def cache_file(input_filename, instruction_file, output_filename, tree_callback=None): """ Takes the input filename (not a folder) and runs the instructions on it. :param tree_callback: A callback that accepts three arguments: the tree of the input_file, the input filename and the output filename. Use this to apply any modifications before the file is written out. Note that by this point the caching has been applied. """ # Parse input file parser = Parser() tree = parser.parse_file(input_filename) # Run all instructions. package = "" if tree.package_declaration is not None: package = tree.package_declaration.name.value + "." cached = [] for type_decl in tree.type_declarations: if isinstance(type_decl, ClassDeclaration): name = package + type_decl.name.value cached += instruction_file.rewrite_class_decl(name, type_decl) if tree_callback is not None: tree_callback(tree, input_filename, output_filename) # Write tree to output. with open(output_filename, "w") as f: f.write(tree.serialize()) return cached
def test_print_empty_class(self): parser = Parser() tree = parser.parse_string('public class Foo extends Bar {}') printer = JavaPrinter() tree.accept(printer) self.assertEqual(''' public class Foo extends Bar { } '''.strip(), printer.result)
def test_print_empty_class(self): parser = Parser() tree = parser.parse_string('public class Foo extends Bar {}') printer = JavaPrinter() tree.accept(printer) self.assertEqual( ''' public class Foo extends Bar { } '''.strip(), printer.result)
def get_tree(self): """ Parse a .java file and get its declarations, then initialise the references """ with open(path.join(path.dirname(__file__), './', 'app.java')) as j_file: parser = Parser() tree = parser.parse_file(j_file) initial_classes = tree.type_declarations self.initialise_references(initial_classes)
def __init__(self, iterations, fitness_method, probabilities, exp_condition, add_state, logging, initial_classes=None): """ :param initial_classes: assuming these classes has no method calls to or inheritances from each other :return: None """ # params self.iterations = iterations self.fitness_method = fitness_method self.probabilities = probabilities self.exp_condition = exp_condition self.add_state = add_state if initial_classes is None: with open(path.join(path.dirname(__file__), '..', 'App.java')) as java_file: parser = Parser() tree = parser.parse_file(java_file) initial_classes = tree.type_declarations self.p_create_class = 0.1 self.p_no_inherit = 0.2 self.code_modifier = CodeModifier() self.inheritance_graph = DiGraph() self.reference_graph = DiGraph() self.fitness = [] self.step_n = 0 for c in initial_classes: self.inheritance_graph.add_node(c.name, {'class': c}) for m in c.body: if isinstance(m, MethodDeclaration): self.reference_graph.add_node(m.name, { 'method': m, 'class': c, 'fitness': random(), 'lines': 0 }) # Analysis lists self.list_fmin = [] self.list_action = [] self.list_fitnesses = [] self.list_fit_stats = [] self.total_code_size = [] self.changes = []
def test_print_statement(self): parser = Parser() tree = parser.parse_string('''public class Foo{ static void bar() { Math.random(); } }''') printer = JavaPrinter() tree.accept(printer) self.assertEqual(''' public class Foo { static void bar() { Math.random(); } } '''.strip(), printer.result)
def test_print_statement(self): parser = Parser() tree = parser.parse_string('''public class Foo{ static void bar() { Math.random(); } }''') printer = JavaPrinter() tree.accept(printer) self.assertEqual( ''' public class Foo { static void bar() { Math.random(); } } '''.strip(), printer.result)
def __init__(self): self.counter = 0 self._revisions = [] with open(path.join(path.dirname(__file__), '..', 'App.java')) as java_file: parser = Parser() tree = parser.parse_file(java_file) initial_classes = tree.type_declarations self._inheritance_graph = DiGraph() self._method_call_graph = DiGraph() for c in initial_classes: self._inheritance_graph.add_node(c.name, {'class': c}) for m in c.body: if isinstance(m, MethodDeclaration): self._method_call_graph.add_node(m.name, {'method': m, 'class_name': c.name, 'fitness': random() })
def test_print_method_with_argument(self): parser = Parser() tree = parser.parse_string(''' public class Foo { static void main(String[] args) { System.out.println(args); System.out.println(3); } } ''') printer = JavaPrinter() tree.accept(printer) self.assertEqual(''' public class Foo { static void main(String[] args) { System.out.println(args); System.out.println(3); } } '''.strip(), printer.result)
def go(in_f, out_f): parser = JavaParser() print("Parsing...") if in_f is not None: with open(in_f, "r") as f: contents = f.read() else: contents = sys.stdin.read() ast = parser.parse_string(contents) # print(ast) print("Finding 'generate' function...") clazz = ast.type_declarations[0] decls_to_keep = [] stm = None for decl in clazz.body: if isinstance(decl, MethodDeclaration) and decl.name == "generate": if stm is not None: die("found duplicate generate() method") generated_type = decl.return_type args = decl.parameters stm = Block(decl.body) else: decls_to_keep.append(decl) if stm is None: die("found no generate() method") print("Extracting declarations...") decls = [] stm = extract_declarations(stm, decls.append) # print(decls) print("Numbering yield statements...") stm.accept(YieldNumberer()) print("Constructing iterator...") _hn = FieldDeclaration(modifiers=["private"], type="boolean", variable_declarators=[ VariableDeclarator(Variable(fresh_name()), Literal("false")) ]) _next = FieldDeclaration(modifiers=["private"], type=generated_type, variable_declarators=[ VariableDeclarator(Variable(fresh_name()), Literal("null")) ]) _state = FieldDeclaration(modifiers=["private"], type="int", variable_declarators=[ VariableDeclarator(Variable(fresh_name()), Literal("0")) ]) _hn_var = Name(_hn.variable_declarators[0].variable.name) _next_var = Name(_next.variable_declarators[0].variable.name) conts = list(enumerate_conts(stm)) _state_var = Name(_state.variable_declarators[0].variable.name ) if len(conts) > 1 else None init = ConstructorDeclaration( clazz.name, modifiers=["public"], parameters=args, block=[ Assignment(operator="=", lhs=FieldAccess(target="this", name=a.variable.name), rhs=Name(a.variable.name)) for a in args ] + run_to_first_yield(stm, _hn_var, _next_var, _state_var)) has_next = MethodDeclaration( "hasNext", modifiers=["public"], parameters=[], return_type="boolean", body=[Return(Name(_hn.variable_declarators[0].variable.name))]) _tmpnext = VariableDeclarator( Variable(fresh_name()), Name(_next.variable_declarators[0].variable.name)) get_next = MethodDeclaration("next", modifiers=["public"], parameters=[], return_type=generated_type, body=[ VariableDeclaration( generated_type, [_tmpnext]), MethodInvocation("advance", []), Return(Name(_tmpnext.variable.name)) ]) advance = MethodDeclaration( "advance", modifiers=["private"], parameters=[], return_type="void", body=[ Assignment(operator="=", lhs=_hn_var, rhs=Literal("false")), Switch(_state_var, [ SwitchCase([Literal(str(i))], run_to_first_yield( k, _hn_var, _next_var, _state_var, k=Break())) for (i, k) in conts ]) if _state_var else Block( run_to_first_yield(conts[0][1], _hn_var, _next_var, _state_var)) if conts else Empty() ]) it = CompilationUnit( package_declaration=ast.package_declaration, import_declarations=ast.import_declarations, type_declarations=[ ClassDeclaration( clazz.name, modifiers=clazz.modifiers, type_parameters=clazz.type_parameters, extends=clazz.extends, implements=clazz.implements, body=decls_to_keep + [ FieldDeclaration(a.type, [VariableDeclarator(a.variable)], modifiers=["private"]) for a in args ] + [ FieldDeclaration(d.type, [ VariableDeclarator(v.variable) for v in d.variable_declarators ], ["private"] + d.modifiers) for d in decls ] + [_hn, _next] + ([_state] if _state_var else []) + [init, has_next, get_next, advance]) ]) # print(it) print("Writing output...") if out_f is not None: with open(out_f, "w") as f: dump(it, f.write) else: dump(it, sys.stdout.write) print("Done.")
def __parse_file(self, file_path): parser = Parser() tree = parser.parse_file(file_path) self.errors += [PlyjSyntaxError(file_path, e) for e in parser.errors()] return tree
def setUp(self): self.parser = Parser()
class TestCaseWithParser(TestCase): def setUp(self): self.parser = Parser() def parse(self, text): return self.parser.parse_string(text)