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(): 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(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(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(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 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(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 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()
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())
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 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 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 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 main(args): # Step 1: Load input source into stream begin_time = time() stream = FileStream(args.file, encoding='utf8') # 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 = StrategyPatternRefactoringListener( common_token_stream=token_stream, method_identifier='execute') # method_identifier='read') # method_identifier='write') walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener) print('Compiler result:') print(my_listener.token_stream_rewriter.getDefaultText()) with open('StrategyExample0.refactored.java', mode='w', newline='') as f: # with open('StrategyExample1.refactored.java', mode='w', newline='') as f: # with open('StrategyExample2.refactored.java', mode='w', newline='') as f: f.write(my_listener.token_stream_rewriter.getDefaultText()) end_time = time() print("execute time : ", end_time - begin_time)
def main(udb_path: str, children_classes: list, method_name: str, *args, **kwargs): """ """ if len(children_classes) <= 1: logger.error("len(children_classes) should be gte 2") return False # Initialize with understand destination_class = "" fileslist_to_be_rafeactored = set() fileslist_to_be_propagate = set() propagation_classes = set() db = und.open(udb_path) try: method_ents = [ db.lookup(i + "." + method_name, "method")[0] for i in children_classes ] except IndexError: # print([db.lookup(i + "." + method_name, "method") for i in children_classes]) logger.error( f"Method {method_name} does not exists in all children_classes.") db.close() return False # Get method text method_text = method_ents[0].contents().strip() for method_ent in method_ents: if method_ent.contents().strip() != method_text: logger.error("Method content is different.") db.close() return False for ref in method_ent.refs("Use,Call"): if ref.ent().parent() is not None: if ref.ent().parent().simplename() in children_classes: logger.error("Method has internal dependencies.") db.close() return False for mth in db.ents("Java Method"): for child in children_classes: if mth.longname().endswith(child + "." + method_name): fileslist_to_be_rafeactored.add( mth.parent().parent().longname()) for fth in mth.parent().refs("Extend"): destination_class = fth.ent().longname() fileslist_to_be_rafeactored.add( fth.ent().parent().longname()) for ref in mth.refs("Java Callby"): propagation_classes.add(ref.ent().parent().longname()) fileslist_to_be_propagate.add( ref.ent().parent().parent().longname()) db.close() # print("=========================================") # print("fileslist_to_be_propagate :", fileslist_to_be_propagate) # print("propagation_classes : ", propagation_classes) # print("fileslist_to_be_rafeactored :", fileslist_to_be_rafeactored) # print("father class :", destination_class) fileslist_to_be_rafeactored = list(fileslist_to_be_rafeactored) fileslist_to_be_propagate = list(fileslist_to_be_propagate) propagation_class = list(propagation_classes) # refactored start for file in fileslist_to_be_rafeactored: try: stream = FileStream(file, encoding='utf-8', errors='ignore') except: continue lexer = JavaLexer(stream) token_stream = CommonTokenStream(lexer) parser = JavaParserLabeled(token_stream) parser.getTokenStream() parse_tree = parser.compilationUnit() my_listener_refactor = PullUpMethodRefactoringListener( common_token_stream=token_stream, destination_class=destination_class, children_class=children_classes, moved_methods=method_name, method_text=method_text) walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener_refactor) with open(file, mode='w', encoding='utf-8', newline='') as f: f.write( my_listener_refactor.token_stream_rewriter.getDefaultText()) # end refactoring # beginning of propagate for file in fileslist_to_be_propagate: if not os.path.exists(file): continue stream = FileStream(file, encoding='utf-8', errors='ignore') lexer = JavaLexer(stream) token_stream = CommonTokenStream(lexer) parser = JavaParserLabeled(token_stream) parser.getTokenStream() parse_tree = parser.compilationUnit() my_listener_propagate = PropagationPullUpMethodRefactoringListener( token_stream_rewriter=token_stream, old_class_name=children_classes, new_class_name=destination_class, propagated_class_name=propagation_class) walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener_propagate) with open(file, mode='w', encoding='utf8', errors='ignore', newline='') as f: f.write( my_listener_propagate.token_stream_rewriter.getDefaultText()) # end of propagate return True
def main(udb_path, source_package, source_class, method_name, target_classes: list, *args, **kwargs): """ The main API for the push-down method refactoring operation """ target_package = source_package source_method = method_name main_file = None source_method_entity = None is_static = False propagation_files = [] propagation_classes = [] propagation_lines = [] children_classes = [] children_files = [] # Initialize with understand db = und.open(udb_path) methods = db.ents("Java Method") for mth in methods: if mth.longname( ) == source_package + "." + source_class + "." + source_method: source_method_entity = mth for child_ref in mth.parent().refs("Extendby"): child_ref = child_ref.ent() if child_ref.simplename() in target_classes: children_classes.append(child_ref.simplename()) children_files.append(child_ref.parent().longname()) # print("mainfile : ", mth.parent().parent().longname()) is_static = mth.kind().check("static") main_file = mth.parent().parent().longname() for ref in mth.refs("Callby"): propagation_files.append( ref.ent().parent().parent().longname()) propagation_classes.append(ref.ent().parent().simplename()) propagation_lines.append(ref.line()) # Check pre-condition if not len(target_classes) == 1: logger.error(f"len(target_classes) is not 1.") db.close() return False if not len(children_classes) == 1: logger.error(f"len(children_classes) is not 1.") db.close() return False if not len(children_files) == 1: logger.error(f"len(children_files) is not 1.") db.close() return False for mth in methods: if mth.simplename() == source_method: if mth.parent().simplename() in target_classes: if mth.type() == source_method_entity.type(): if mth.kind() == source_method_entity.kind(): if mth.parameters() == source_method_entity.parameters( ): logger.error("Duplicated method") db.close() return False for ref in source_method_entity.refs("use, call"): ref_ent = ref.ent() is_public = ref_ent.kind().check("public") if not is_public: logger.error("Has internal dependencies.") db.close() return False # get text method_text = source_method_entity.contents() db.close() # Delete source method 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 = DeleteSourceListener(common_token_stream=token_stream, source_method=source_method) walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener) # print(my_listener.token_stream_rewriter.getDefaultText()) with open(main_file, mode='w', encoding='utf-8', newline='') as f: f.write(my_listener.token_stream_rewriter.getDefaultText()) # Do the push down for child_file, child_class in zip(children_files, children_classes): stream = FileStream(child_file, encoding='utf8', errors='ignore') lexer = JavaLexer(stream) token_stream = CommonTokenStream(lexer) parser = JavaParserLabeled(token_stream) parser.getTokenStream() parse_tree = parser.compilationUnit() my_listener = PushDownMethodRefactoringListener( common_token_stream=token_stream, source_class=child_class, source_method_text=method_text) walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener) # print(my_listener.token_stream_rewriter.getDefaultText()) with open(child_file, mode='w', encoding='utf8', newline='') as f: f.write(my_listener.token_stream_rewriter.getDefaultText()) # Propagation for file, _class, line in zip(propagation_files, propagation_classes, propagation_lines): stream = FileStream(file, encoding='utf8', errors='ignore') lexer = JavaLexer(stream) token_stream = CommonTokenStream(lexer) parser = JavaParserLabeled(token_stream) parser.getTokenStream() parse_tree = parser.compilationUnit() if is_static: my_listener = PropagationStaticListener( common_token_stream=token_stream, source_class=source_class, child_class=children_classes[0], class_name=_class, method_name=source_method, ref_line=line, target_package=target_package) else: my_listener = PropagationNonStaticListener( common_token_stream=token_stream, source_class=source_class, child_class=children_classes[0], class_name=_class, method_name=source_method, ref_line=line, target_package=target_package) walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener) # print(my_listener.token_stream_rewriter.getDefaultText()) with open(file, mode='w', encoding='utf8', errors='ignore', newline='') as f: f.write(my_listener.token_stream_rewriter.getDefaultText()) return True
def main(args): files = get_file_dirs(args.dir) create_new_project_dir('JavaProjectRefactored', files) ref = input(" choose your refactoring :") for file in files: # Step 1: Load input source into stream m = re.search(r'^.*\.java$', file) if m is None: continue print(file) stream = FileStream(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() # Step 5: Create parse tree parse_tree = parser.compilationUnit() # Step 6: Create an instance of AssignmentStListener # my_listener = RenameClassRefactoringListener(common_token_stream=token_stream, class_new_name='Z', # class_identifier='A', package_identifier="Dummy") if ref == "Rename": print("Rename class =>") my_listener = RenameClassRefactoringListener(common_token_stream=token_stream, class_new_name='Z', class_identifier='ReflectiveXmlRpcMetaDataHandler', package_identifier="org.apache.xmlrpc.metadata") elif ref == "Static": print("Make field static =>") my_listener = MakeFieldStaticRefactoringListener(common_token_stream=token_stream, field_identifier='methodHelp', class_identifier='ReflectiveXmlRpcMetaDataHandler', package_identifier="org.apache.xmlrpc.metadata") elif ref == "Non-Static": print("Make field Non static =>") my_listener = MakeFieldNonStaticRefactoringListener(common_token_stream=token_stream, field_identifier='log', class_identifier='XmlRpcErrorLogger', package_identifier="org.apache.xmlrpc.server") else: print("Not Valid") break walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener) if ref == "Non Static" and my_listener.canceled: rewrite_project(files, 'JavaProjectRefactored') break if ref == "Rename" and my_listener.in_selected_class: splited_dir = file.split('/') splited_dir[0] = 'JavaProjectRefactored' if os.path.exists("/".join(splited_dir)): os.remove("/".join(splited_dir)) splited_dir[-1] = my_listener.class_new_name + ".java" with open("/".join(splited_dir), mode='w', newline='') as f: f.write(my_listener.token_stream_rewriter.getDefaultText()) else: splited_dir = file.split('/') splited_dir[0] = 'JavaProjectRefactored' with open("/".join(splited_dir), mode='w', newline='') as f: f.write(my_listener.token_stream_rewriter.getDefaultText())
def main(udb, child, parent): # initialize with understand udb_path = "/home/ali/Desktop/code/TestProject/TestProject.udb" child_path_file = "" father_path_file = "" file_list_to_be_propagate = set() propagate_classes = set() # db = und.open(udb) # for cls in db.ents("class"): # if cls.simplename() == child: # child_path_file = cls.parent().longname() # for ref in cls.refs("Coupleby"): # propagate_classes.add(ref.ent().longname()) # file_list_to_be_propagate.add(ref.ent().parent().longname()) # if cls.simplename() == parent: # father_path_file = cls.parent().longname() file_list_to_be_propagate = list(file_list_to_be_propagate) propagate_classes = list(propagate_classes) stream = FileStream(child_path_file, encoding='utf8', errors='ignore') lexer = JavaLexer(stream) token_stream = CommonTokenStream(lexer) parser = JavaParserLabeled(token_stream) parser.getTokenStream() parse_tree = parser.compilationUnit() my_listener_field_text = CollapseHierarchyRefactoringGetFieldTextListener( common_token_stream=token_stream, child_class=child) walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener_field_text) field_code = my_listener_field_text.fieldcode my_listener_method_text = CollapseHierarchyRefactoringGetMethodTextListener( common_token_stream=token_stream, child_class=child) walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener_method_text) methods_code = my_listener_method_text.methodcode # Remove child class my_listener_remove_child_class = RemoveClassRefactoringListener( common_token_stream=token_stream, class_name=child) walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener_remove_child_class) with open(child_path_file, mode='w', newline='') as f: f.write(my_listener_remove_child_class.token_stream_rewriter. getDefaultText()) # Refactor stream = FileStream(father_path_file, encoding='utf8', errors='ignore') lexer = JavaLexer(stream) token_stream = CommonTokenStream(lexer) parser = JavaParserLabeled(token_stream) parser.getTokenStream() parse_tree = parser.compilationUnit() my_listener_refactor_action = CollapseHierarchyRefactoringListener( common_token_stream=token_stream, parent_class=parent, child_class=child, field_text=field_code, method_text=methods_code) walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener_refactor_action) with open(father_path_file, mode='w', newline='') as f: f.write( my_listener_refactor_action.token_stream_rewriter.getDefaultText()) # Propagate for file in file_list_to_be_propagate: stream = FileStream(file, encoding='utf8', errors='ignore') lexer = JavaLexer(stream) token_stream = CommonTokenStream(lexer) parser = JavaParserLabeled(token_stream) parser.getTokenStream() parse_tree = parser.compilationUnit() my_listener_propagate = PropagationCollapseHierarchyListener( token_stream_rewriter=token_stream, old_class_name=child, new_class_name=parent, propagated_class_name=propagate_classes) walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener_propagate) with open(file, mode='w', newline='') as f: f.write( my_listener_propagate.token_stream_rewriter.getDefaultText())
index=ctx.start.tokenIndex, text=self.object + '.', program_name=self.token_stream_rewriter. DEFAULT_PROGRAM_NAME) if __name__ == '__main__': udb_path = "/home/ali/Desktop/code/TestProject/TestProject.udb" source_class = "Shape" # 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', errors='ignore') lexer = JavaLexer(stream) token_stream = CommonTokenStream(lexer) parser = JavaParserLabeled(token_stream) parser.getTokenStream() parse_tree = parser.compilationUnit() my_listener = MakeConcreteClassRefactoringListener( common_token_stream=token_stream, class_name=source_class) 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(): """ it builds the parse tree and walk its corresponding walker so that our overridden methods run. """ # 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" # moved_methods = ['getValue', 'rowToJSONArray', 'getVal', ] # moved_fields = ['number_2', 'number_1', ] source_class = "GodClass" moved_methods = ['method1', 'method3'] moved_fields = ['field1', 'field2'] father_path_file = "/data/Dev/JavaSample/src/GodClass.java" father_path_directory = "/data/Dev/JavaSample/src" path_to_refactor = "/data/Dev/JavaSample/src" new_class_file = "/data/Dev/JavaSample/src/GodSubClass.java" # source_class = "TaskNode" # moved_methods = ['getUserObject'] # moved_fields = [] # father_path_file = "C:\\Users\\asus\\Desktop\\benchmark_projects\\ganttproject\\ganttproject\\src\\main\\java\\net\\sourceforge\\ganttproject\\task\\TaskNode.java" # father_path_directory = "C:\\Users\\asus\\Desktop\\benchmark_projects\\ganttproject\\ganttproject\\src\\main\\java\\net\\sourceforge\\ganttproject\\task" # path_to_refactor = "C:\\Users\\asus\\Desktop\\benchmark_projects\\ganttproject" # new_class_file = "C:\\Users\\asus\\Desktop\\benchmark_projects\\ganttproject\\ganttproject\\src\\main\\java\\net\\sourceforge\\ganttproject\\task\\TaskNodeextracted.java" # source_class = "SecuritySupport" # moved_methods = ['getSystemProperty'] # moved_fields = [] # father_path_file = "C:\\Users\\asus\\Desktop\\benchmark_projects\\xerces2-j\\src\\org\\apache\\html\\dom\\SecuritySupport.java" # father_path_directory = "C:\\Users\\asus\\Desktop\\benchmark_projects\\xerces2-j\\src\\org\\apache\\html\\dom" # path_to_refactor = "C:\\Users\\asus\\Desktop\\benchmark_projects\\xerces2-j" # new_class_file = "C:\\Users\\asus\\Desktop\\benchmark_projects\\xerces2-j\\src\\org\\apache\\html\\dom\\SecuritySupportextracted.java" # source_class = "BaseMarkupSerializer" # moved_methods = ['setOutputCharStream'] # moved_fields = [] # father_path_file = "C:\\Users\\asus\\Desktop\\benchmark_projects\\xerces2-j\\src\\org\\apache\\xml\\serialize\\BaseMarkupSerializer.java" # father_path_directory = "C:\\Users\\asus\\Desktop\\benchmark_projects\\xerces2-j\\src\\org\\apache\\xml\\serialize" # path_to_refactor = "C:\\Users\\asus\\Desktop\\benchmark_projects\\xerces2-j" # new_class_file = "C:\\Users\\asus\\Desktop\\benchmark_projects\\xerces2-j\\src\\org\\apache\\xml\\serialize\\BaseMarkupSerializerextracted.java" # source_class = "Piece" # moved_methods = ['setX'] # moved_fields = [] # father_path_file = "C:\\Users\\asus\\Desktop\\benchmark_projects\\Chess_master\\src\\game\\Piece.java" # father_path_directory = "C:\\Users\\asus\\Desktop\\benchmark_projects\\Chess_master\\src\\game" # path_to_refactor = "C:\\Users\\asus\\Desktop\\benchmark_projects\\Chess_master" # new_class_file = "C:\\Users\\asus\\Desktop\\benchmark_projects\\Chess_master\\src\\game\\Pieceextracted.java" 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()) extractJavaFilesAndProcess(path_to_refactor, father_path_file, new_class_file) for file in files_to_refactor: stream = FileStream(file, encoding='utf8') lexer = JavaLexer(stream) token_stream = CommonTokenStream(lexer) parser = JavaParserLabeled(token_stream) parser.getTokenStream() parse_tree = parser.compilationUnit() my_listener = FindUsagesListener(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) # output_path=father_path_directory) walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener) tmp_aul = my_listener.aul with open(file, mode='w', newline='') as f: f.write(my_listener.token_stream_rewriter.getDefaultText()) # after find usages try: stream = FileStream(file, encoding='utf8') lexer = JavaLexer(stream) token_stream = CommonTokenStream(lexer) parser = JavaParserLabeled(token_stream) parser.getTokenStream() parse_tree = parser.compilationUnit() my_listener = PropagationListener( 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, aul=tmp_aul) walker = ParseTreeWalker() walker.walk(t=parse_tree, listener=my_listener) with open(file, mode='w', newline='') as f: f.write(my_listener.token_stream_rewriter.getDefaultText()) except: print("not utf8")
def main(args): global f_iteration_flag # 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 AssignmentStListener if f_iteration_flag: my_listener = MoveClassRefactoringListener( common_token_stream=token_stream, source_package=source_package, target_package=target_package, class_identifier=class_identifier, filename=args.file, dirname=directory) 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().replace( "\r", "")) else: has_import = False has_exact_import = False file_to_check = open(file=args.file, mode='r') for line in file_to_check.readlines(): text_line = line.replace('\n', '').replace('\r', '').strip() if text_line.startswith('import') and text_line.endswith( source_package + '.' + class_identifier + ';'): has_import = True break if text_line.startswith('import') and text_line.endswith( target_package + '.' + class_identifier + ';'): has_exact_import = True break if not has_exact_import: print( f"Start checking file \"{file_to_check.name}\" *** {file_counter}/100" ) my_listener = ReplaceDependentObjectsListener( common_token_stream=token_stream, source_package=source_package, target_package=target_package, class_identifier=class_identifier, filename=args.file, has_import=has_import) 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().replace( "\r", "")) print( f"Finish checking file \"{file_to_check.name}\" *** {file_counter}/100" )