#111 newClass processing now works

circular-reference-detector/src/main/java/org/hjug/parser/visitor/JavaClassDeclarationVisitor.java

@@ -1,6 +1,7 @@
 package org.hjug.parser.visitor;
 
 import java.util.List;
+
 import lombok.Getter;
 import org.jgrapht.Graph;
 import org.jgrapht.graph.DefaultWeightedEdge;
@@ -14,6 +15,7 @@
 public class JavaClassDeclarationVisitor<P> extends JavaIsoVisitor<P> implements TypeProcessor {
 
     private final JavaMethodInvocationVisitor methodInvocationVisitor;
+    private final JavaNewClassVisitor newClassVisitor;
 
     @Getter
     private Graph<String, DefaultWeightedEdge> classReferencesGraph =
@@ -25,6 +27,7 @@ public class JavaClassDeclarationVisitor<P> extends JavaIsoVisitor<P> implements
 
     public JavaClassDeclarationVisitor() {
         methodInvocationVisitor = new JavaMethodInvocationVisitor(classReferencesGraph, packageReferencesGraph);
+        newClassVisitor = new JavaNewClassVisitor(classReferencesGraph, packageReferencesGraph);
     }
 
     public JavaClassDeclarationVisitor(
@@ -33,6 +36,7 @@ public JavaClassDeclarationVisitor(
         this.classReferencesGraph = classReferencesGraph;
         this.packageReferencesGraph = packageReferencesGraph;
         methodInvocationVisitor = new JavaMethodInvocationVisitor(classReferencesGraph, packageReferencesGraph);
+        newClassVisitor = new JavaNewClassVisitor(classReferencesGraph, packageReferencesGraph);
     }
 
     @Override
@@ -95,10 +99,12 @@ private void processBlock(J.Block block, String owningFqn) {
                 if (statementInBlock instanceof J.MethodInvocation) {
                     J.MethodInvocation methodInvocation = (J.MethodInvocation) statementInBlock;
                     methodInvocationVisitor.visitMethodInvocation(owningFqn, methodInvocation);
-                }
-                else if (statementInBlock instanceof J.Lambda) {
+                } else if (statementInBlock instanceof J.Lambda) {
                     J.Lambda lambda = (J.Lambda) statementInBlock;
                     processType(owningFqn, lambda.getType());
+                } else if (statementInBlock instanceof J.NewClass) {
+                    J.NewClass newClass = (J.NewClass) statementInBlock;
+                    newClassVisitor.visitNewClass(owningFqn, newClass);
                 }
             }
         }

circular-reference-detector/src/main/java/org/hjug/parser/visitor/JavaNewClassVisitor.java

@@ -1,14 +1,30 @@
 package org.hjug.parser.visitor;
 
 import lombok.Getter;
+import lombok.RequiredArgsConstructor;
 import org.jgrapht.Graph;
 import org.jgrapht.graph.DefaultWeightedEdge;
-import org.jgrapht.graph.SimpleDirectedWeightedGraph;
-import org.openrewrite.java.JavaIsoVisitor;
 import org.openrewrite.java.tree.Expression;
 import org.openrewrite.java.tree.J;
 
-public class JavaNewClassVisitor {//<P> extends JavaIsoVisitor<P> implements TypeProcessor {
+@RequiredArgsConstructor
+@Getter
+public class JavaNewClassVisitor implements TypeProcessor {
 
-    // figure out later
+    private final Graph<String, DefaultWeightedEdge> classReferencesGraph;
+    private final Graph<String, DefaultWeightedEdge> packageReferencesGraph;
+
+    public J.NewClass visitNewClass(String invokingFqn, J.NewClass newClass) {
+
+        // getDeclaringType() returns the type that declared the method being invoked
+        processType(invokingFqn, newClass.getType());
+
+        for (Expression argument : newClass.getArguments()) {
+            processType(invokingFqn, argument.getType());
+        }
+
+        // TASK: process initializer block
+
+        return newClass;
+    }
 }

circular-reference-detector/src/main/java/org/hjug/parser/visitor/JavaVariableTypeVisitor.java

@@ -1,6 +1,7 @@
 package org.hjug.parser.visitor;
 
 import java.util.List;
+
 import lombok.Getter;
 import lombok.extern.slf4j.Slf4j;
 import org.jgrapht.Graph;
@@ -20,12 +21,17 @@ public class JavaVariableTypeVisitor<P> extends JavaIsoVisitor<P> implements Typ
     private Graph<String, DefaultWeightedEdge> packageReferencesGraph =
             new SimpleDirectedWeightedGraph<>(DefaultWeightedEdge.class);
 
-    public JavaVariableTypeVisitor() {}
+    private final JavaNewClassVisitor newClassVisitor;
+
+    public JavaVariableTypeVisitor() {
+        newClassVisitor = new JavaNewClassVisitor(classReferencesGraph, packageReferencesGraph);
+    }
 
     public JavaVariableTypeVisitor(Graph<String, DefaultWeightedEdge> classReferencesGraph,
                                    Graph<String, DefaultWeightedEdge> packageReferencesGraph) {
         this.classReferencesGraph = classReferencesGraph;
         this.packageReferencesGraph = packageReferencesGraph;
+        newClassVisitor = new JavaNewClassVisitor(classReferencesGraph, packageReferencesGraph);
     }
 
     @Override
@@ -84,6 +90,15 @@ public J.VariableDeclarations visitVariableDeclarations(J.VariableDeclarations m
 
         processType(ownerFqn, javaType);
 
+        // process variable instantiation if present
+        Expression initializer = variables.get(0).getInitializer();
+        if (null != initializer && null != initializer.getType()
+                && initializer instanceof J.NewClass) {
+            J.NewClass newClassType = (J.NewClass) initializer;
+            newClassVisitor.visitNewClass(ownerFqn, newClassType);
+        }
+
+
         return variableDeclarations;
     }
 }

circular-reference-detector/src/main/java/org/hjug/parser/visitor/TypeProcessor.java

@@ -135,4 +135,6 @@ default void addType(String ownerFqn, String typeFqn) {
             classReferencesGraph.setEdgeWeight(edge, classReferencesGraph.getEdgeWeight(edge) + 1);
         }
     }
+
+    // TODO: process packages
 }

circular-reference-detector/src/test/java/org/hjug/parser/visitor/JavaNewClassVisitorTest.java

@@ -18,23 +18,32 @@
 
 public class JavaNewClassVisitorTest {
 
-    //@Test
+    @Test
     void visitNewClass() throws IOException {
 
         File srcDirectory = new File("src/test/java/org/hjug/parser/visitor/testclasses/newClass");
 
         JavaParser javaParser = JavaParser.fromJavaVersion().build();
         ExecutionContext ctx = new InMemoryExecutionContext(Throwable::printStackTrace);
 
-        JavaNewClassVisitor classDeclarationVisitor = new JavaNewClassVisitor();
+        JavaClassDeclarationVisitor classDeclarationVisitor = new JavaClassDeclarationVisitor();
+        JavaVariableTypeVisitor variableTypeVisitor = new JavaVariableTypeVisitor();
 
-//        List<Path> list = Files.walk(Paths.get(srcDirectory.getAbsolutePath())).collect(Collectors.toList());
-//        javaParser.parse(list, Paths.get(srcDirectory.getAbsolutePath()), ctx).forEach(cu -> {
-//            classDeclarationVisitor.visit(cu, ctx);
-//        });
-//
-//        Graph<String, DefaultWeightedEdge> graph = classDeclarationVisitor.getClassReferencesGraph();
-//        Assertions.assertTrue(graph.containsVertex("org.hjug.parser.visitor.testclasses.newClass.A"));
+        List<Path> list = Files.walk(Paths.get(srcDirectory.getAbsolutePath())).collect(Collectors.toList());
+        javaParser.parse(list, Paths.get(srcDirectory.getAbsolutePath()), ctx).forEach(cu -> {
+            classDeclarationVisitor.visit(cu, ctx);
+            variableTypeVisitor.visit(cu, ctx);
+        });
+
+        Graph<String, DefaultWeightedEdge> assignmentGraph = variableTypeVisitor.getClassReferencesGraph();
+        Assertions.assertTrue(assignmentGraph.containsVertex("org.hjug.parser.visitor.testclasses.newClass.A"));
+        Assertions.assertTrue(assignmentGraph.containsVertex("org.hjug.parser.visitor.testclasses.newClass.B"));
+        Assertions.assertTrue(assignmentGraph.containsVertex("org.hjug.parser.visitor.testclasses.newClass.C"));
+        Assertions.assertTrue(assignmentGraph.containsVertex("org.hjug.parser.visitor.testclasses.newClass.D"));
+
+        Graph<String, DefaultWeightedEdge> newInstanceGraph = classDeclarationVisitor.getClassReferencesGraph();
+        Assertions.assertTrue(newInstanceGraph.containsVertex("org.hjug.parser.visitor.testclasses.newClass.A"));
+        Assertions.assertTrue(newInstanceGraph.containsVertex("org.hjug.parser.visitor.testclasses.newClass.D"));
 
     }
 

circular-reference-detector/src/test/java/org/hjug/parser/visitor/testclasses/newClass/A.java

@@ -0,0 +1,11 @@
+package org.hjug.parser.visitor.testclasses.newClass;
+
+public class A {
+
+    B newClassMethod() {
+        D d = null;
+        new D();
+        C c = new C();
+        return new B(c, d);
+    }
+}

circular-reference-detector/src/test/java/org/hjug/parser/visitor/testclasses/newClass/B.java

@@ -0,0 +1,7 @@
+package org.hjug.parser.visitor.testclasses.newClass;
+
+public class B {
+
+    public B(C c, D d) {}
+
+}

circular-reference-detector/src/test/java/org/hjug/parser/visitor/testclasses/newClass/C.java

@@ -0,0 +1,4 @@
+package org.hjug.parser.visitor.testclasses.newClass;
+
+public class C {
+}

circular-reference-detector/src/test/java/org/hjug/parser/visitor/testclasses/newClass/D.java

@@ -0,0 +1,4 @@
+package org.hjug.parser.visitor.testclasses.newClass;
+
+public class D {
+}