def main():
Path = "../tests/rename_tests/benchmark"
package_identifier = "json"
new_package_name = "test"
FolderPath = os.listdir(Path)
testsPath = os.listdir(Path + "/refactoredFiles/")
for File in FolderPath:
# We have all of the java files in this folder now
if File.endswith('.java'):
EachFilePath = Path + "\\" + File
EachFile = FileStream(str(EachFilePath))
Lexer = JavaLexer(EachFile)
TokenStream = CommonTokenStream(Lexer)
Parser = JavaParserLabeled(TokenStream)
Tree = Parser.compilationUnit()
find_packages = FindPackages(TokenStream)
Walker = ParseTreeWalker()
Walker.walk(find_packages, Tree)
# delete last refactored files
for t in testsPath:
os.remove(os.path.join(Path + "/refactoredFiles/", t))
for File in FolderPath:
# We have all of the java files in this folder now
if File.endswith('.java'):
EachFilePath = Path + "/" + File
print(" ****************" + " in file : " + File + " ****************")
EachFile = FileStream(str(EachFilePath))
FileName = File.split(".")[0]
Refactored = open(Path + "/refactoredFiles/" + FileName + "_Refactored.java", 'w', newline='')
Lexer = JavaLexer(EachFile)
TokenStream = CommonTokenStream(Lexer)
Parser = JavaParserLabeled(TokenStream)
Tree = Parser.compilationUnit()
ListenerForReRenameClass = \
RenamePackageRefactoringListener(TokenStream, package_identifier, new_package_name,
packages)
Walker = ParseTreeWalker()
Walker.walk(ListenerForReRenameClass, Tree)
Refactored.write(ListenerForReRenameClass.token_stream_rewriter.getDefaultText())
print(" %%%%%%%%%%%%%" + " all files finished " + "****************")
def main():
Path = "../tests/rename_tests/"
FolderPath = os.listdir(Path)
for File in FolderPath:
# We have all of the java files in this folder now
if File.endswith('.java'):
EachFilePath = Path + "\\" + File
EachFile = FileStream(str(EachFilePath))
Lexer = JavaLexer(EachFile)
TokenStream = CommonTokenStream(Lexer)
Parser = JavaParserLabeled(TokenStream)
Tree = Parser.compilationUnit()
find_packages = FindPackages(TokenStream)
Walker = ParseTreeWalker()
Walker.walk(find_packages, Tree)
rename_method_test_file = FileStream(str(Path +
"rename_package_test.java"))
print("file opened")
Refactored = open(os.path.join(Path,
"rename_package_test_Refactored.java"),
'w',
newline='')
Lexer = JavaLexer(rename_method_test_file)
TokenStream = CommonTokenStream(Lexer)
Parser = JavaParserLabeled(TokenStream)
Tree = Parser.compilationUnit()
ListenerForReRename = RenamePackageRefactoringListener(
TokenStream, "jsoniter", "jsoniter_new", find_packages.packages)
Walker = ParseTreeWalker()
Walker.walk(ListenerForReRename, Tree)
Refactored.write(
ListenerForReRename.token_stream_rewriter.getDefaultText())
print("tamam shod")
def main(args, i):
# Step 1: Load input source into stream
stream = FileStream(args.file, encoding='utf8')
# Step 2: Create an instance of AssignmentStLexer
lexer = JavaLexer(stream)
# Step 3: Convert the input source into a list of tokens
token_stream = CommonTokenStream(lexer)
# Step 4: Create an instance of the AssignmentStParser
parser = JavaParserLabeled(token_stream)
parser.getTokenStream()
# Step 5: Create parse tree
parse_tree = parser.compilationUnit()
# Step 6: Create an instance of the refactoringListener, and send as a parameter the list of tokens to the class
# my_listener = EncapsulateFiledRefactoringListener(common_token_stream=token_stream, class_identifier='A')
my_listener = SingletonRefactoringListener(
common_token_stream=token_stream, class_identifier='GeneralPurposeBit')
walker = ParseTreeWalker()
walker.walk(t=parse_tree, listener=my_listener)
newpath = "Refactored" + args.file
if not os.path.exists(os.path.dirname(newpath)):
try:
os.makedirs(os.path.dirname(newpath))
except OSError as exc: # Guard against race condition
pass
with open(newpath, mode='w', newline='') as f:
f.write(my_listener.token_stream_rewriter.getDefaultText())
def main(class_path):
"""
Args:
class_path (str): The java file path containing the public class
"""
# Precondition 1: The interface should not be already exist.
interface_path = os.path.join(
os.path.dirname(class_path),
f'I{os.path.splitext(os.path.basename(class_path))[0]}.java')
if os.path.exists(interface_path):
return False
stream = FileStream(class_path, encoding='utf-8', errors='ignore')
lexer = JavaLexer(stream)
tokens = CommonTokenStream(lexer)
parser = JavaParserLabeled(tokens)
tree = parser.compilationUnit()
listener = InterfaceInfoListener()
walker = ParseTreeWalker()
walker.walk(listener=listener, t=tree)
interface_info_ = listener.get_interface_info()
interface_info_['name'] = 'I' + interface_info_['name']
interface_info_['path'] = os.path.dirname(class_path)
ic = InterfaceCreator(interface_info_, class_path)
ic.add_implement_statement_to_class()
ic.save()
return True
def main():
udb_path = "/home/ali/Desktop/code/TestProject/TestProject.udb"
source_class = "App"
method_name = "testMethod"
# initialize with understand
main_file = ""
db = und.open(udb_path)
for cls in db.ents("class"):
if cls.simplename() == source_class:
main_file = cls.parent().longname()
stream = FileStream(main_file, encoding='utf8')
lexer = JavaLexer(stream)
token_stream = CommonTokenStream(lexer)
parser = JavaParserLabeled(token_stream)
parser.getTokenStream()
parse_tree = parser.compilationUnit()
my_listener = IncreaseMethodVisibilityRefactoringListener(
common_token_stream=token_stream,
source_class=source_class,
method_name=method_name)
walker = ParseTreeWalker()
walker.walk(t=parse_tree, listener=my_listener)
with open(main_file, mode='w', newline='') as f:
f.write(my_listener.token_stream_rewriter.getDefaultText())
def main():
Path = "../tests/rename_tests/"
rename_method_test_file = FileStream(str(Path + "rename_method_test.java"))
print("file opened")
Refactored = open(os.path.join(Path, "rename_method_test_Refactored.java"),
'w',
newline='')
Lexer = JavaLexer(rename_method_test_file)
TokenStream = CommonTokenStream(Lexer)
Parser = JavaParserLabeled(TokenStream)
Tree = Parser.compilationUnit()
ListenerForReRename = RenameMethodRefactoringListener(
TokenStream, "SuggestedRoomsByFollowingsListViewAdapter", "RoomModel",
"RoomModel_changed")
Walker = ParseTreeWalker()
Walker.walk(ListenerForReRename, Tree)
Refactored.write(
ListenerForReRename.token_stream_rewriter.getDefaultText())
print("tamam shod")
def __init__(self,
udb_path,
file_path,
source_class,
new_class,
moved_fields,
moved_methods,
new_file_path=None):
self.file_path = file_path
self.udb_path = udb_path
self.new_file_path = new_file_path
self.source_class = source_class
self.new_class = new_class
self.moved_fields = moved_fields
self.moved_methods = moved_methods
self.stream = FileStream(self.file_path, encoding="utf8")
self.lexer = JavaLexer(self.stream)
self.token_stream = CommonTokenStream(self.lexer)
self.parser = JavaParserLabeled(self.token_stream)
self.tree = self.parser.compilationUnit()
self.walker = ParseTreeWalker()
self.method_usage_map = {}
self.pass_this = False
self.TAB = "\t"
self.object_name = ""
def main(udb_path, source_class, field_name, *args, **kwargs):
main_file = None
db = und.open(udb_path)
for cls in db.ents("class"):
if cls.simplename() == source_class:
main_file = cls.parent().longname(True)
if not os.path.isfile(main_file):
continue
if main_file is None:
db.close()
return
stream = FileStream(main_file, encoding='utf8')
lexer = JavaLexer(stream)
token_stream = CommonTokenStream(lexer)
parser = JavaParserLabeled(token_stream)
parser.getTokenStream()
parse_tree = parser.compilationUnit()
my_listener = MakeFieldNonStaticRefactoringListener(common_token_stream=token_stream, source_class=source_class,
field_name=field_name)
walker = ParseTreeWalker()
walker.walk(t=parse_tree, listener=my_listener)
with open(main_file, mode='w', newline='') as f:
f.write(my_listener.token_stream_rewriter.getDefaultText())
db.close()
def main():
print("Decrease Field Visibility")
udb_path = "/home/ali/Documents/compiler/Research/xerces2-j/xerces2-j.udb"
class_name = "AttributesImpl"
field_name = "length"
mainfile = ""
db = und.open(udb_path)
for cls in db.ents("class"):
if (cls.simplename() == class_name):
if cls.kindname() != "Unknown Class":
mainfile = cls.parent().longname()
stream = FileStream(mainfile, encoding='utf8')
# Step 2: Create an instance of AssignmentStLexer
lexer = JavaLexer(stream)
# Step 3: Convert the input source into a list of tokens
token_stream = CommonTokenStream(lexer)
# Step 4: Create an instance of the AssignmentStParser
parser = JavaParser(token_stream)
parser.getTokenStream()
parse_tree = parser.compilationUnit()
my_listener = DecreaseFieldVisibilityRefactoringListener(
common_token_stream=token_stream,
source_class=class_name,
field_name=field_name)
walker = ParseTreeWalker()
walker.walk(t=parse_tree, listener=my_listener)
with open(mainfile, mode='w', newline='') as f:
f.write(my_listener.token_stream_rewriter.getDefaultText())
def main(args):
# Step 1: Load input source into stream
stream = FileStream(args.file, encoding='utf8')
# input_stream = StdinStream()
# Step 2: Create an instance of AssignmentStLexer
lexer = JavaLexer(stream)
# Step 3: Convert the input source into a list of tokens
token_stream = CommonTokenStream(lexer)
# Step 4: Create an instance of the AssignmentStParser
parser = JavaParserLabeled(token_stream)
parser.getTokenStream()
print("=====Enter Create ParseTree=====")
# Step 5: Create parse tree
parse_tree = parser.compilationUnit()
print("=====Create ParseTree Finished=====")
# Step 6: Create an instance of AssignmentStListener
my_listener = RemoveFieldRefactoringListener(common_token_stream=token_stream, class_identifier='User',
fieldname='test_var', filename=args.file)
# return
walker = ParseTreeWalker()
walker.walk(t=parse_tree, listener=my_listener)
with open(args.file, mode='w', newline='') as f:
f.write(my_listener.token_stream_rewriter.getDefaultText())
def main(directory_path, package_name, source_class, field_name):
for root, dirs, files in os.walk(directory_path):
for file in files:
if file.endswith('.java'):
stream = FileStream(os.path.join(root, file),
encoding='utf8',
errors='ignore')
lexer = JavaLexer(stream)
token_stream = CommonTokenStream(lexer)
parser = JavaParserLabeled(token_stream)
ef_listener = EncapsulateFiledRefactoringListener(
token_stream, package_name, source_class, field_name)
tree = parser.compilationUnit()
walker = ParseTreeWalker()
walker.walk(t=tree, listener=ef_listener)
ip_listener = InstancePropagationEncapsulateFieldListener(
ef_listener.token_stream_rewriter, package_name,
source_class, field_name)
walker.walk(t=tree, listener=ip_listener)
refactored = open(os.path.join(root, file), 'w', newline='')
refactored.write(
ip_listener.token_stream_rewriter.getDefaultText())
refactored.close()
return True
def main():
# folder_path = "..\\benchmark_projects\\JSON\\src\\main\\java\\org\\json"
folder_path = "..\\tests\\replace_constructor_with_factory_function_tests"
path = os.listdir(folder_path)
# target_class = "CDL"
target_class = "Employee"
for file in path:
if file.endswith('.java') and not file.endswith('_refactored.java'):
each = folder_path + "\\" + file
stream = FileStream(str(each))
lexer = JavaLexer(stream)
tokens = CommonTokenStream(lexer)
parser = JavaParserLabeled(tokens)
tree = parser.compilationUnit()
new_file = open(os.path.join(folder_path,
file + "_refactored.java"),
mode='w',
newline='')
listener = ReplaceConstructorWithFactoryFunctionRefactoringListener(
common_token_stream=tokens, target_class=target_class)
walker = ParseTreeWalker()
walker.walk(listener=listener, t=tree)
new_code = str(listener.codeRewrite.getDefaultText())
new_file.write(new_code)
def main():
# folder_path = "..\\benchmark_projects\\JSON\\src\\main\\java\\org\\json"
folder_path = "/data/Dev/JavaSample/"
path = get_filenames_in_dir(folder_path)
print(path)
# target_class = "CDL"
target_class = "ReplaceConstructorWithFactoryMethod"
for file in path:
if file.endswith('.java') and not file.endswith('_refactored.java'):
stream = FileStream(file)
lexer = JavaLexer(stream)
tokens = CommonTokenStream(lexer)
parser = JavaParserLabeled(tokens)
tree = parser.compilationUnit()
new_file = open(file, mode='w', newline='')
listener = ReplaceConstructorWithFactoryFunctionRefactoringListener(common_token_stream=tokens,
target_class=target_class)
walker = ParseTreeWalker()
walker.walk(
listener=listener,
t=tree
)
new_code = str(listener.codeRewrite.getDefaultText())
new_file.write(new_code)
def __init__(self,
source_class="Playground",
source_method="DeliveryDate",
argument_name="b",
main_file="playground.java"):
"""create a removeflagargument refactor
Args:
source_class (str): class name contaminated by code smell.
source_mathod (str): method name contaminated.
argument_name (str): boolean argument in method.
main_file (str): path of main file containing source class.
"""
self.source_class = source_class
self.source_method = source_method
self.arguemnt_name = argument_name
self.main_file = main_file
self.stream = FileStream(self.main_file,
encoding='utf8',
errors='ignore')
self.lexer = JavaLexer(self.stream)
self.token_stream = CommonTokenStream(self.lexer)
self.parser = JavaParserLabeled(self.token_stream)
self.parser.getTokenStream()
self.parse_tree = self.parser.compilationUnit()
self.my_listener = RemoveFlagArgumentListener(
common_token_stream=self.token_stream,
source_class=self.source_class,
source_method=self.source_method,
argument_name=self.arguemnt_name)
def extract_subclass(self):
# udb_path = "/home/ali/Desktop/code/TestProject/TestProject.udb"
# udb_path=create_understand_database("C:\\Users\\asus\\Desktop\\test_project")
# source_class = "GodClass"
# moved_methods = ['method1', 'method3', ]
# moved_fields = ['field1', 'field2', ]
udb_path = "C:\\Users\\asus\\Desktop\\test_project\\test_project.udb"
source_class = "CDL"
moved_methods = [
'getValue',
'rowToJSONArray',
'getVal',
]
moved_fields = [
'number',
'number_2',
'number_1',
]
# initialize with understand
father_path_file = ""
file_list_to_be_propagate = set()
propagate_classes = set()
db = und.open(udb_path)
# db=open(udb_path)
for cls in db.ents("class"):
if (cls.simplename() == source_class):
father_path_file = cls.parent().longname()
for ref in cls.refs("Coupleby"):
# print(ref.ent().longname())
propagate_classes.add(ref.ent().longname())
# print(ref.ent().parent().relname())
# file_list_to_be_propagate.add(ref.ent().parent().relname())
# if(cls.longname()==fatherclass):
# print(cls.parent().relname())
# father_path_file=cls.parent().relname()
father_path_file = "C:\\Users\\asus\\Desktop\\test_project\\CDL.java"
father_path_directory = "C:\\Users\\asus\\Desktop\\test_project"
stream = FileStream(father_path_file, encoding='utf8')
lexer = JavaLexer(stream)
token_stream = CommonTokenStream(lexer)
parser = JavaParserLabeled(token_stream)
parser.getTokenStream()
parse_tree = parser.compilationUnit()
my_listener = ExtractSubClassRefactoringListener(
common_token_stream=token_stream,
source_class=source_class,
new_class=source_class + "extracted",
moved_fields=moved_fields,
moved_methods=moved_methods,
output_path=father_path_directory)
walker = ParseTreeWalker()
walker.walk(t=parse_tree, listener=my_listener)
with open(father_path_file, mode='w', newline='') as f:
f.write(my_listener.token_stream_rewriter.getDefaultText())
def main(args):
# Step 1: Load input source into stream
stream = FileStream(args.file, encoding='utf8', errors='ignore')
# input_stream = StdinStream()
# Step 2: Create an instance of AssignmentStLexer
lexer = JavaLexer(stream)
# Step 3: Convert the input source into a list of tokens
token_stream = CommonTokenStream(lexer)
# Step 4: Create an instance of the AssignmentStParser
parser = JavaParserLabeled(token_stream)
parser.getTokenStream()
# Step 5: Create parse tree
parse_tree = parser.compilationUnit()
# Step 6: Create an instance of the refactoringListener, and send as a parameter the list of tokens to the class
my_listener = FactoryMethodRefactoringListener(
common_token_stream=token_stream,
creator_identifier='FactoryMethod',
products_identifier=['JpegReader', 'GifReader'])
walker = ParseTreeWalker()
walker.walk(t=parse_tree, listener=my_listener)
with open('../tests/factory1/FactoryExample.refactored.java',
mode='w',
newline='') as f:
f.write(my_listener.token_stream_rewriter.getDefaultText())
def main(udb_path, source_class, field_name):
udb_path = "/home/ali/Desktop/code/TestProject/TestProject.udb"
source_class = "Website"
field_name = "HELLO_FROM_STUDENT_WEBSITE"
print("Make Field Static")
main_file = ""
db = und.open(udb_path)
for cls in db.ents("class"):
if cls.simplename() == source_class:
main_file = cls.parent().longname(True)
if not os.path.isfile(main_file):
continue
if main_file is None:
return
stream = FileStream(main_file, encoding='utf8')
lexer = JavaLexer(stream)
token_stream = CommonTokenStream(lexer)
parser = JavaParserLabeled(token_stream)
parser.getTokenStream()
parse_tree = parser.compilationUnit()
my_listener = MakeFieldStaticRefactoringListener(common_token_stream=token_stream, source_class=source_class,
field_name=field_name)
walker = ParseTreeWalker()
walker.walk(t=parse_tree, listener=my_listener)
with open(main_file, mode='w', newline='') as f:
f.write(my_listener.token_stream_rewriter.getDefaultText())
def do_refactor(self):
db = und.open(self.udb_path)
self.get_source_class_map(db=db)
listener = ExtractClassRefactoringListener(
common_token_stream=self.token_stream,
new_class=self.new_class,
source_class=self.source_class,
moved_fields=self.moved_fields,
moved_methods=self.moved_methods,
method_map=self.method_usage_map)
self.object_name = listener.object_name
self.walker.walk(listener=listener, t=self.tree)
# Find Field and Method Usages
field_usages = []
for field in self.moved_fields:
for ent in db.lookup(f"{self.source_class}.{field}"):
# print(ent.name(), " [", ent.kindname(), "]", sep="", end="\n")
for ref in ent.refs("useBy, setBy, modifyBy"):
if Path(ref.file().longname()) == Path(self.file_path):
continue
field_usage = {
'field_name': field,
'file_path': ref.file().longname()
}
if field_usage not in field_usages:
field_usages.append(field_usage)
# print(listener.token_stream_rewriter.getDefaultText())
# print("=" * 25)
# print(listener.code)
stream = InputStream(listener.code)
lexer = JavaLexer(stream)
token_stream = CommonTokenStream(lexer)
parser = JavaParserLabeled(token_stream)
parser.getTokenStream()
parse_tree = parser.compilationUnit()
my_listener = NewClassPropagation(common_token_stream=token_stream,
method_map=self.method_usage_map,
source_class=self.source_class,
moved_fields=self.moved_fields)
walker = ParseTreeWalker()
walker.walk(t=parse_tree, listener=my_listener)
# print(my_listener.token_stream_rewriter.getDefaultText())
# Write Changes
with open(self.file_path, 'w') as f:
f.write(listener.token_stream_rewriter.getDefaultText())
with open(self.new_file_path, 'w') as f:
f.write(my_listener.token_stream_rewriter.getDefaultText())
# Propagate and reformat
self.propagate_fields(field_usages)
self.reformat(self.file_path)
self.reformat(self.new_file_path)
db.close()
def extract_method(conf):
stream = FileStream(conf['target_file'], encoding="utf-8")
lexer = JavaLexer(stream)
tokens = CommonTokenStream(lexer)
parser = JavaParserLabeled(tokens)
tree = parser.compilationUnit()
# TODO : too many params for ExtractMethodRefactoring constructor
listener = ExtractMethodRefactoring(conf['target_package'],
conf['target_class'],
conf['target_method'], conf['lines'])
walker = ParseTreeWalker()
walker.walk(listener=listener, t=tree)
# print(parser.getTokenStream())
# print(listener.variable_info)
output = []
file1 = open(conf['target_file'], 'r', encoding="utf-8")
lines = file1.readlines()
line_num = 1
# func_added = False
func = []
print('extracting following lines:')
for line in lines:
if listener.lines.__contains__(line_num):
print(line, end='')
if line_num == min(listener.lines):
output.append('\t\t' + conf['new_method_name'] +
get_args(listener.used_variables))
if listener.remain_lines.__contains__(line_num):
output.append(line)
func.append(line)
elif line_num == listener.method_stop_line:
output.append(line)
output.append(
'\tpublic void ' + conf['new_method_name'] +
get_args_with_type(listener.used_variables,
listener.variable_info['variables']) + '\n')
output.append('\t{\n')
output = output + func
output.append('\t}\n')
else:
output.append(line)
line_num += 1
file1.close()
print('--------------------')
file2 = open(conf['output_file'], 'w', encoding="utf-8")
for item in output:
file2.write(item)
file2.close()
def main():
udb_path = "/home/ali/Desktop/code/TestProject/TestProject.udb"
source_class = "GodClass"
moved_methods = [
'method1',
'method3',
]
moved_fields = [
'field1',
'field2',
]
# initialize with understand
father_path_file = ""
file_list_to_be_propagate = set()
propagate_classes = set()
db = und.open(udb_path)
for cls in db.ents("class"):
if (cls.simplename() == source_class):
father_path_file = cls.parent().longname()
for ref in cls.refs("Coupleby"):
# print(ref.ent().longname())
propagate_classes.add(ref.ent().longname())
# print(ref.ent().parent().relname())
# file_list_to_be_propagate.add(ref.ent().parent().relname())
# if(cls.longname()==fatherclass):
# print(cls.parent().relname())
# father_path_file=cls.parent().relname()
stream = FileStream(father_path_file, encoding='utf8')
lexer = JavaLexer(stream)
token_stream = CommonTokenStream(lexer)
parser = JavaParserLabeled(token_stream)
parser.getTokenStream()
parse_tree = parser.compilationUnit()
my_listener = ExtractSubClassRefactoringListener(
common_token_stream=token_stream,
source_class=source_class,
new_class=source_class + "extracted",
moved_fields=moved_fields,
moved_methods=moved_methods)
walker = ParseTreeWalker()
walker.walk(t=parse_tree, listener=my_listener)
with open(father_path_file, mode='w', newline='') as f:
f.write(my_listener.token_stream_rewriter.getDefaultText())
def propagate_fields(self, usages):
for usage in usages:
file_path = usage.pop('file_path')
stream = FileStream(file_path, encoding='utf-8', errors='ignore')
lexer = JavaLexer(stream)
token_stream = CommonTokenStream(lexer)
parser = JavaParserLabeled(token_stream)
parse_tree = parser.compilationUnit()
my_listener = PropagateFieldUsageListener(common_token_stream=token_stream, object_name=self.object_name,
**usage)
walker = ParseTreeWalker()
walker.walk(t=parse_tree, listener=my_listener)
# print(my_listener.token_stream_rewriter.getDefaultText())
with open(file_path, mode='w', encoding='utf-8', errors='ignore') as f:
f.write(my_listener.token_stream_rewriter.getDefaultText())
self.reformat(file_path)
def main(udb_path, source_class, method_name, *args, **kwargs):
"""
"""
main_file = None
db = und.open(udb_path)
classes = db.ents("Class")
for cls in classes:
if cls.simplename() == source_class:
if cls.parent() is not None:
temp_file = str(cls.parent().longname(True))
if os.path.isfile(temp_file):
main_file = temp_file
break
if main_file is None:
db.close()
return False
db.close()
stream = FileStream(main_file, encoding='utf8', errors='ignore')
lexer = JavaLexer(stream)
token_stream = CommonTokenStream(lexer)
parser = JavaParserLabeled(token_stream)
parser.getTokenStream()
parse_tree = parser.compilationUnit()
my_listener = MakeMethodStaticRefactoringListener(
common_token_stream=token_stream,
source_class=source_class,
method_name=method_name)
walker = ParseTreeWalker()
walker.walk(t=parse_tree, listener=my_listener)
with open(main_file,
mode='w',
encoding='utf8',
errors='ignore',
newline='') as f:
f.write(my_listener.token_stream_rewriter.getDefaultText())
return True
def get_parse_tree_token_stream(args):
"""
returns parse tree and token stream base on the file stream
:param args: file arguments
"""
# Step 1: Load input source into stream
stream = FileStream(args.file, encoding='utf8')
# Step 2: Create an instance of AssignmentStLexer
lexer = JavaLexer(stream)
# Step 3: Convert the input source into a list of tokens
token_stream = CommonTokenStream(lexer)
# Step 4: Create an instance of the AssignmentStParser
parser = JavaParserLabeled(token_stream)
parser.getTokenStream()
# Step 5: Create parse tree
parse_tree = parser.compilationUnit()
return parse_tree, token_stream
def find_usages(self, new_code):
stream = InputStream(new_code)
lexer = JavaLexer(stream)
token_stream = CommonTokenStream(lexer)
parser = JavaParserLabeled(token_stream)
tree = parser.compilationUnit()
find_listener = FindClassUsagesListener(
source_class=self.source_class,
new_class=self.new_class,
)
self.walker.walk(listener=find_listener, t=tree)
change_listener = ChangeClassUsagesListener(
common_token_stream=token_stream,
source_class=self.source_class,
new_class=self.new_class,
moved_fields=self.moved_fields,
moved_methods=self.moved_methods,
usages=find_listener.usages)
self.walker.walk(listener=change_listener, t=tree)
def main(args):
# Step 1: Load input source into stream
begin_time = time()
stream = FileStream(args.file, encoding='utf8', errors='ignore')
# input_stream = StdinStream()
print('Input stream:')
print(stream)
# Step 2: Create an instance of AssignmentStLexer
lexer = JavaLexer(stream)
# Step 3: Convert the input source into a list of tokens
token_stream = CommonTokenStream(lexer)
# Step 4: Create an instance of the AssignmentStParser
parser = JavaParserLabeled(token_stream)
parser.getTokenStream()
# Step 5: Create parse tree
parse_tree = parser.compilationUnit()
# Step 6: Create an instance of the refactoringListener, and send as a parameter the list of tokens to the class
my_listener = VisitorPatternRefactoringListener(
common_token_stream=token_stream,
SuperClass_identifier='SC',
SubClass_identifier=['CC1', 'CC2', 'CC3'])
# SuperClass_identifier='ComputerPart',
# SubClass_identifier=['Keyboard', 'Monitor', 'Mouse', 'Computer'])
# SuperClass_identifier='Shape',
# SubClass_identifier=['Polygon', 'Rectangle','Arrow'])
walker = ParseTreeWalker()
walker.walk(t=parse_tree, listener=my_listener)
print('Compiler result:')
print(my_listener.token_stream_rewriter.getDefaultText())
with open('../tests/visitor1/VisitorExample0.refactored.java',
mode='w',
newline='') as f:
# with open('VisitorExample1.refactored.java', mode='w', newline='') as f:
# with open('VisitorExample2.refactored.java', mode='w', newline='') as f:
f.write(my_listener.token_stream_rewriter.getDefaultText())
end_time = time()
print("time execution : ", end_time - begin_time)
def get_objects(source_files: str) -> FileInfo:
objects = {}
for filename in source_files:
stream = FileStream(filename, encoding='utf8')
lexer = JavaLexer(stream)
token_stream = CommonTokenStream(lexer)
parser = JavaParser(token_stream)
tree = parser.compilationUnit()
listener = UtilsListener(filename)
walker = ParseTreeWalker()
walker.walk(listener, tree)
if not listener.package.name in objects:
objects[listener.package.name] = listener.objects_declaration
else:
for class_name in listener.objects_declaration:
objects[listener.package.name][
class_name] = listener.objects_declaration[class_name]
return objects
def add_implement_statement_to_class(self, ):
stream = FileStream(self.class_path, encoding='utf8', errors='ignore')
lexer = JavaLexer(stream)
token_stream = CommonTokenStream(lexer)
parser = JavaParserLabeled(token_stream)
parser.getTokenStream()
parse_tree = parser.compilationUnit()
listener = AddingImplementStatementToClass(
common_token_stream=token_stream,
class_name=os.path.splitext(os.path.basename(self.class_path))[0],
interface_package=self.interface_info['package'],
interface_name=self.interface_info['name'])
walker = ParseTreeWalker()
walker.walk(t=parse_tree, listener=listener)
with open(self.class_path,
encoding='utf8',
errors='ignore',
mode='w',
newline='') as f:
f.write(listener.token_stream_rewriter.getDefaultText())
def rename_method(java_file_path,
scope_class_name,
target_method_name,
new_name,
reference=None):
"""Main Entry Point to the Listener and Tree Walker
Args:
java_file_path(str): Address path to the test/source file
scope_class_name(str): Name of the class in which the refactoring has to be done
target_method_name(str): Name of the method in which the refactoring has to be done
new_name(str): The new name of the refactored method
reference(str): Keeping track for all of the method references in the project scope
Returns:
No Returns
"""
stream = FileStream(java_file_path)
lexer = JavaLexer(stream)
tokens = CommonTokenStream(lexer)
parser = JavaParserLabeled(tokens)
tree = parser.compilationUnit()
listener = RenameMethodListener(java_file_path=java_file_path,
common_token_stream=tokens,
scope_class_name=scope_class_name,
target_method_name=target_method_name,
new_name=new_name,
reference=reference)
walker = ParseTreeWalker()
walker.walk(listener, tree)
if listener.changed:
print(java_file_path)
new_file = open(file=java_file_path, mode='w')
new_file.write(listener.token_stream_rewriter.getDefaultText().replace(
'\r', ''))
def main(udb_path, target_class, target_methods):
main_file = ""
db = understand.open(udb_path)
for cls in db.ents("class"):
if cls.simplename() == target_class:
main_file = cls.parent().longname()
stream = FileStream(main_file, encoding='utf8')
lexer = JavaLexer(stream)
token_stream = CommonTokenStream(lexer)
parser = JavaParserLabeled(token_stream)
parser.getTokenStream()
parse_tree = parser.compilationUnit()
my_listener = MakeMethodNonStaticRefactoringListener(
common_token_stream=token_stream,
target_class=target_class,
target_methods=target_methods)
walker = ParseTreeWalker()
walker.walk(t=parse_tree, listener=my_listener)
with open(main_file, mode='w', newline='') as f:
f.write(my_listener.token_stream_rewriter.getDefaultText())
def __init__(self,
project_dir,
file_path,
source_class,
new_class,
moved_fields,
moved_methods,
new_file_path=None):
self.project_dir = project_dir
self.file_path = file_path
self.new_file_path = new_file_path or "/home/ali/Documents/dev/CodART/input.refactored.java"
self.source_class = source_class
self.new_class = new_class
self.moved_fields = moved_fields
self.moved_methods = moved_methods
self.stream = FileStream(self.file_path, encoding="utf8")
self.lexer = JavaLexer(self.stream)
self.token_stream = CommonTokenStream(self.lexer)
self.parser = JavaParserLabeled(self.token_stream)
self.tree = self.parser.compilationUnit()
self.walker = ParseTreeWalker()
self.checked = False
