Multiple enhancements

- Minimum cut weight & edges are computed to identify edge(s) that need to be removed to decompose class cycle
- Duplicate cycles are excluded from output
- Self-referencing cycles are skipped (cycles that have only one vertex and one edge)

Author: jimbethancourt

circular-reference-detector/src/main/java/com/ideacrest/app/CircularReferenceDetectorApp.java

@@ -3,9 +3,13 @@
 import com.ideacrest.cycledetector.CircularReferenceChecker;
 import com.ideacrest.parser.JavaProjectParser;
 import java.io.IOException;
+import java.util.HashMap;
 import java.util.Map;
+import java.util.Set;
 import org.jgrapht.Graph;
+import org.jgrapht.alg.flow.GusfieldGomoryHuCutTree;
 import org.jgrapht.graph.AsSubgraph;
+import org.jgrapht.graph.AsUndirectedGraph;
 import org.jgrapht.graph.DefaultEdge;
 
 /**
@@ -17,6 +21,8 @@
  */
 public class CircularReferenceDetectorApp {
 
+    private Map<String, AsSubgraph> renderedSubGraphs = new HashMap<>();
+
     public static void main(String[] args) {
         CircularReferenceDetectorApp circularReferenceDetectorApp = new CircularReferenceDetectorApp();
         circularReferenceDetectorApp.launchApp(args);
@@ -49,16 +55,47 @@ private void detectAndStoreCyclesInDirectory(
             String outputDirectoryPath, Graph<String, DefaultEdge> classReferencesGraph) {
         CircularReferenceChecker circularReferenceChecker = new CircularReferenceChecker();
         Map<String, AsSubgraph<String, DefaultEdge>> cyclesForEveryVertexMap =
-                circularReferenceChecker.detectCyles(classReferencesGraph);
+                circularReferenceChecker.detectCycles(classReferencesGraph);
         cyclesForEveryVertexMap.forEach((vertex, subGraph) -> {
             try {
-                circularReferenceChecker.createImage(outputDirectoryPath, subGraph, vertex);
+                int vertexCount = subGraph.vertexSet().size();
+                int edgeCount = subGraph.edgeSet().size();
+                if (vertexCount > 1 && edgeCount > 1 && !isDuplicateSubGraph(subGraph, vertex)) {
+                    circularReferenceChecker.createImage(outputDirectoryPath, subGraph, vertex);
+                    renderedSubGraphs.put(vertex, subGraph);
+                    System.out.println(
+                            "Vertex: " + vertex + " vertex count: " + vertexCount + " edge count: " + edgeCount);
+                    GusfieldGomoryHuCutTree<String, DefaultEdge> gusfieldGomoryHuCutTree =
+                            new GusfieldGomoryHuCutTree<>(new AsUndirectedGraph<>(subGraph));
+                    double minCut = gusfieldGomoryHuCutTree.calculateMinCut();
+                    System.out.println("Min cut weight: " + minCut);
+                    Set<DefaultEdge> minCutEdges = gusfieldGomoryHuCutTree.getCutEdges();
+                    System.out.println("Minimum Cut Edges:");
+                    for (DefaultEdge minCutEdge : minCutEdges) {
+                        System.out.println(minCutEdge);
+                    }
+                }
             } catch (IOException e) {
                 e.printStackTrace();
             }
         });
     }
 
+    private boolean isDuplicateSubGraph(AsSubgraph<String, DefaultEdge> subGraph, String vertex) {
+        if (!renderedSubGraphs.isEmpty()) {
+            for (AsSubgraph renderedSubGraph : renderedSubGraphs.values()) {
+                if (renderedSubGraph.vertexSet().size() == subGraph.vertexSet().size()
+                        && renderedSubGraph.edgeSet().size()
+                                == subGraph.edgeSet().size()
+                        && renderedSubGraph.vertexSet().contains(vertex)) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
     private boolean validateArgs(String[] args) {
         return args.length == 2;
     }

circular-reference-detector/src/main/java/com/ideacrest/cycledetector/CircularReferenceChecker.java

@@ -25,7 +25,7 @@ public class CircularReferenceChecker {
      * @param classReferencesGraph
      * @return a Map of Class and its Cycle Graph
      */
-    public Map<String, AsSubgraph<String, DefaultEdge>> detectCyles(Graph<String, DefaultEdge> classReferencesGraph) {
+    public Map<String, AsSubgraph<String, DefaultEdge>> detectCycles(Graph<String, DefaultEdge> classReferencesGraph) {
         Map<String, AsSubgraph<String, DefaultEdge>> cyclesForEveryVertexMap = new HashMap<>();
         CycleDetector<String, DefaultEdge> cycleDetector = new CycleDetector<>(classReferencesGraph);
         cycleDetector.findCycles().forEach(v -> {

circular-reference-detector/src/test/java/com/ideacrest/cycledetector/CircularReferenceCheckerTests.java

@@ -28,7 +28,7 @@ public void detectCyclesTest() {
         classReferencesGraph.addEdge("B", "C");
         classReferencesGraph.addEdge("C", "A");
         Map<String, AsSubgraph<String, DefaultEdge>> cyclesForEveryVertexMap =
-                sutCircularReferenceChecker.detectCyles(classReferencesGraph);
+                sutCircularReferenceChecker.detectCycles(classReferencesGraph);
         assertEquals(3, cyclesForEveryVertexMap.size());
     }