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(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(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 __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): 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 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(): 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 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 __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 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 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(): # 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 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 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 __init__(self, file_path, target_class, target_method, target_parameters): self.file_path = file_path self.new_file_path = file_path self.target_class = target_class self.target_method = target_method self.target_parameters = target_parameters 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()
def __init__(self, file_path, target_class, target_method, target_parameters): self.file_path = file_path self.new_file_path = \ "C:\\Users\\asus\\Desktop\\desk\\projects\\Workspace\\Workspace\\src\\com\\amirh\\CodART_Test_result.java" self.target_class = target_class self.target_method = target_method self.target_parameters = target_parameters 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()
def main(): Path = "../tests/rename_tests/benchmark" Package_name = "org.json" class_identifier = "CDL" new_class_name = "test" FolderPath = os.listdir(Path) testsPath = os.listdir(Path + "/refactoredFiles/") # 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 =\ RenameClassRefactoringListener(TokenStream, Package_name, class_identifier, new_class_name) Walker = ParseTreeWalker() Walker.walk(ListenerForReRenameClass, Tree) Refactored.write(ListenerForReRenameClass.token_stream_rewriter. getDefaultText()) print("changing public class files name... ") for i in range(len(old_names)): os.rename( Path + "/refactoredFiles/" + old_names[i] + "_Refactored.java", Path + "/refactoredFiles/" + new_names[i] + "_Refactored.java") print(" %%%%%%%%%%%%%" + " all files finished " + "****************")
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 __init__(self, file_path, target_class, target_method, target_parameters): self.file_path = file_path self.new_file_path = \ "../tests/replace_parameter_with_quey_test/java_refactored.java" self.target_class = target_class self.target_method = target_method self.target_parameters = target_parameters 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()
class RemoveFlagArgument: """Refactoring API that can be used to to do remove flag argument """ 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 do_refactor(self): """removes flag argument logic and replace it by two method call of the new method generated from extracted login in if else block """ walker = ParseTreeWalker() walker.walk(t=self.parse_tree, listener=self.my_listener) # self.my_listener.body_1 with open(self.main_file, 'w') as f: f.write(self.my_listener.token_stream_rewriter.getDefaultText())
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())
class ReplaceParameterWithQueryAPI: def __init__(self, file_path, target_class, target_method, target_parameters): self.file_path = file_path self.new_file_path = file_path self.target_class = target_class self.target_method = target_method self.target_parameters = target_parameters self.stream = FileStream(self.file_path, encoding="utf8", errors='ignore') 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() def do_refactor(self): listener = ReplaceParameterWithQueryRefactoringListener( common_token_stream=self.token_stream, target_class=self.target_class, target_method=self.target_method, target_parameters=self.target_parameters) self.walker.walk(listener=listener, t=self.tree) print(listener.add_to_top_of_target_method) print(listener.token_stream_rewriter.getDefaultText()) print(type(self.new_file_path)) with open(self.new_file_path, mode="w", newline="") as f: f.write(listener.token_stream_rewriter.getDefaultText())
class ReplaceParameterWithQueryAPI: def __init__(self, file_path, target_class, target_method, target_parameters): self.file_path = file_path self.new_file_path = \ "../tests/replace_parameter_with_quey_test/java_refactored.java" self.target_class = target_class self.target_method = target_method self.target_parameters = target_parameters 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() def do_refactor(self): listener = ReplaceParameterWithQueryListener( common_token_stream=self.token_stream, target_class=self.target_class, target_method=self.target_method, target_parameters=self.target_parameters) self.walker.walk(listener=listener, t=self.tree) with open(self.new_file_path, mode="w", newline="") as f: f.write(listener.token_stream_rewriter.getDefaultText())
class ReplaceParameterWithQueryAPI: def __init__(self, file_path, target_class, target_method, target_parameters): self.file_path = file_path self.new_file_path = \ "C:\\Users\\asus\\Desktop\\desk\\projects\\Workspace\\Workspace\\src\\com\\amirh\\CodART_Test_result.java" self.target_class = target_class self.target_method = target_method self.target_parameters = target_parameters 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() def do_refactor(self): listener = ReplaceParameterWithQueryRefactoringListener( common_token_stream=self.token_stream, target_class=self.target_class, target_method=self.target_method, target_parameters=self.target_parameters ) self.walker.walk( listener=listener, t=self.tree ) print(listener.add_to_top_of_target_method) print(listener.token_stream_rewriter.getDefaultText()) with open(self.new_file_path, mode="w", newline="") as f: f.write(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 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 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 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)