Generating Cycle summary data

Generating cycle summary data

Author: jimbethancourt

circular-reference-detector/pom.xml

@@ -13,10 +13,7 @@
 	<artifactId>circular-reference-detector</artifactId>
 
 	<description>Tool to help detecting circular references by parsing a java project.</description>
-	<properties>
-		<maven.compiler.target>11</maven.compiler.target>
-		<maven.compiler.source>11</maven.compiler.source>
-	</properties>
+
 	<dependencies>
 		<dependency>
 			<groupId>org.jgrapht</groupId>

…st/app/CircularReferenceDetectorApp.java …ug/app/CircularReferenceDetectorApp.javacircular-reference-detector/src/main/java/com/ideacrest/app/CircularReferenceDetectorApp.java renamed to circular-reference-detector/src/main/java/org/hjug/app/CircularReferenceDetectorApp.java circular-reference-detector/src/main/java/com/ideacrest/app/CircularReferenceDetectorApp.java renamed to circular-reference-detector/src/main/java/org/hjug/app/CircularReferenceDetectorApp.java

@@ -1,11 +1,11 @@
-package com.ideacrest.app;
+package org.hjug.app;
 
-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.hjug.cycledetector.CircularReferenceChecker;
+import org.hjug.parser.JavaProjectParser;
 import org.jgrapht.Graph;
 import org.jgrapht.alg.flow.GusfieldGomoryHuCutTree;
 import org.jgrapht.graph.AsSubgraph;
@@ -17,7 +17,6 @@
  * Takes two arguments : source folder of java project, directory to store images of the circular reference graphs.
  *
  * @author nikhil_pereira
- *
  */
 public class CircularReferenceDetectorApp {
 

…ledetector/CircularReferenceChecker.java …ledetector/CircularReferenceChecker.javacircular-reference-detector/src/main/java/com/ideacrest/cycledetector/CircularReferenceChecker.java renamed to circular-reference-detector/src/main/java/org/hjug/cycledetector/CircularReferenceChecker.java circular-reference-detector/src/main/java/com/ideacrest/cycledetector/CircularReferenceChecker.java renamed to circular-reference-detector/src/main/java/org/hjug/cycledetector/CircularReferenceChecker.java

@@ -1,4 +1,4 @@
-package com.ideacrest.cycledetector;
+package org.hjug.cycledetector;
 
 import com.mxgraph.layout.mxCircleLayout;
 import com.mxgraph.layout.mxIGraphLayout;

…/ideacrest/parser/JavaProjectParser.java …a/org/hjug/parser/JavaProjectParser.javacircular-reference-detector/src/main/java/com/ideacrest/parser/JavaProjectParser.java renamed to circular-reference-detector/src/main/java/org/hjug/parser/JavaProjectParser.java circular-reference-detector/src/main/java/com/ideacrest/parser/JavaProjectParser.java renamed to circular-reference-detector/src/main/java/org/hjug/parser/JavaProjectParser.java

@@ -1,4 +1,4 @@
-package com.ideacrest.parser;
+package org.hjug.parser;
 
 import com.github.javaparser.StaticJavaParser;
 import com.github.javaparser.ast.CompilationUnit;
@@ -11,9 +11,7 @@
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
+import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 import org.jgrapht.Graph;

…ector/CircularReferenceCheckerTests.java …ector/CircularReferenceCheckerTests.javacircular-reference-detector/src/test/java/com/ideacrest/cycledetector/CircularReferenceCheckerTests.java renamed to circular-reference-detector/src/test/java/org/hjug/cycledetector/CircularReferenceCheckerTests.java circular-reference-detector/src/test/java/com/ideacrest/cycledetector/CircularReferenceCheckerTests.java renamed to circular-reference-detector/src/test/java/org/hjug/cycledetector/CircularReferenceCheckerTests.java

@@ -1,4 +1,4 @@
-package com.ideacrest.cycledetector;
+package org.hjug.cycledetector;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertTrue;

…crest/parser/JavaProjectParserTests.java …/hjug/parser/JavaProjectParserTests.javacircular-reference-detector/src/test/java/com/ideacrest/parser/JavaProjectParserTests.java renamed to circular-reference-detector/src/test/java/org/hjug/parser/JavaProjectParserTests.java circular-reference-detector/src/test/java/com/ideacrest/parser/JavaProjectParserTests.java renamed to circular-reference-detector/src/test/java/org/hjug/parser/JavaProjectParserTests.java

@@ -1,4 +1,4 @@
-package com.ideacrest.parser;
+package org.hjug.parser;
 
 import static org.junit.jupiter.api.Assertions.*;
 

cost-benefit-calculator/pom.xml

@@ -29,6 +29,11 @@
             <artifactId>effort-ranker</artifactId>
         </dependency>
 
+        <dependency>
+            <groupId>org.hjug.refactorfirst.circularreferencedetector</groupId>
+            <artifactId>circular-reference-detector</artifactId>
+        </dependency>
+
         <dependency>
             <groupId>org.hjug.refactorfirst.testresources</groupId>
             <artifactId>test-resources</artifactId>

cost-benefit-calculator/src/main/java/org/hjug/cbc/CostBenefitCalculator.java

@@ -16,20 +16,30 @@
 import net.sourceforge.pmd.lang.LanguageRegistry;
 import org.eclipse.jgit.api.errors.GitAPIException;
 import org.eclipse.jgit.lib.Repository;
+import org.hjug.cycledetector.CircularReferenceChecker;
 import org.hjug.git.ChangePronenessRanker;
 import org.hjug.git.GitLogReader;
 import org.hjug.git.ScmLogInfo;
 import org.hjug.metrics.*;
 import org.hjug.metrics.rules.CBORule;
+import org.hjug.parser.JavaProjectParser;
+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;
 
 @Slf4j
 public class CostBenefitCalculator {
 
+    private final Map<String, AsSubgraph> renderedSubGraphs = new HashMap<>();
+
     private Report report;
     private String repositoryPath;
     private final GitLogReader gitLogReader = new GitLogReader();
     private Repository repository = null;
     private final ChangePronenessRanker changePronenessRanker;
+    private final JavaProjectParser javaProjectParser = new JavaProjectParser();
 
     public CostBenefitCalculator(String repositoryPath) {
         this.repositoryPath = repositoryPath;
@@ -48,6 +58,100 @@ public CostBenefitCalculator(String repositoryPath) {
         changePronenessRanker = new ChangePronenessRanker(repository, gitLogReader);
     }
 
+    public List<RankedCycle> runCycleAnalysis() {
+        List<RankedCycle> rankedCycles = new ArrayList<>();
+        try {
+            Map<String, String> classNamesAndPaths = getClassNamesAndPaths();
+            Graph<String, DefaultEdge> classReferencesGraph = javaProjectParser.getClassReferences(repositoryPath);
+            CircularReferenceChecker circularReferenceChecker = new CircularReferenceChecker();
+            Map<String, AsSubgraph<String, DefaultEdge>> cyclesForEveryVertexMap =
+                    circularReferenceChecker.detectCycles(classReferencesGraph);
+            cyclesForEveryVertexMap.forEach((vertex, subGraph) -> {
+                int vertexCount = subGraph.vertexSet().size();
+                int edgeCount = subGraph.edgeSet().size();
+                double minCut = 0;
+                Set<DefaultEdge> minCutEdges = null;
+                if (vertexCount > 1 && edgeCount > 1 && !isDuplicateSubGraph(subGraph, vertex)) {
+                    // circularReferenceChecker.createImage(outputDirectoryPath, subGraph, vertex);
+                    renderedSubGraphs.put(vertex, subGraph);
+                    log.info("Vertex: " + vertex + " vertex count: " + vertexCount + " edge count: " + edgeCount);
+                    GusfieldGomoryHuCutTree<String, DefaultEdge> gusfieldGomoryHuCutTree =
+                            new GusfieldGomoryHuCutTree<>(new AsUndirectedGraph<>(subGraph));
+                    minCut = gusfieldGomoryHuCutTree.calculateMinCut();
+                    log.info("Min cut weight: " + minCut);
+                    minCutEdges = gusfieldGomoryHuCutTree.getCutEdges();
+
+                    log.info("Minimum Cut Edges:");
+                    for (DefaultEdge minCutEdge : minCutEdges) {
+                        log.info(minCutEdge.toString());
+                    }
+                }
+
+                List<CycleNode> cycleNodes = subGraph.vertexSet().stream()
+                        .map(classInCycle -> new CycleNode(classInCycle, classNamesAndPaths.get(classInCycle)))
+                        .collect(Collectors.toList());
+                List<ScmLogInfo> changeRanks = getRankedChangeProneness(cycleNodes);
+
+                Map<String, CycleNode> cycleNodeMap = new HashMap<>();
+
+                for (CycleNode cycleNode : cycleNodes) {
+                    cycleNodeMap.put(cycleNode.getFileName(), cycleNode);
+                }
+
+                for (ScmLogInfo changeRank : changeRanks) {
+                    CycleNode cn = cycleNodeMap.get(changeRank.getPath());
+                    cn.setScmLogInfo(changeRank);
+                }
+
+                // sum change proneness ranks
+                int changePronenessRankSum = changeRanks.stream()
+                        .mapToInt(ScmLogInfo::getChangePronenessRank)
+                        .sum();
+                rankedCycles.add(new RankedCycle(
+                        vertex,
+                        changePronenessRankSum,
+                        subGraph.vertexSet(),
+                        subGraph.edgeSet(),
+                        minCut,
+                        minCutEdges,
+                        cycleNodes));
+            });
+
+            rankedCycles.sort(Comparator.comparing(RankedCycle::getAverageChangeProneness));
+            int cpr = 1;
+            for (RankedCycle rankedCycle : rankedCycles) {
+                rankedCycle.setChangePronenessRank(cpr++);
+            }
+
+            rankedCycles.sort(Comparator.comparing(RankedCycle::getRawPriority).reversed());
+
+            int priority = 1;
+            for (RankedCycle rankedCycle : rankedCycles) {
+                rankedCycle.setPriority(priority++);
+            }
+
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+
+        return rankedCycles;
+    }
+
+    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;
+    }
+
     // copied from PMD's PmdTaskImpl.java and modified
     public void runPmdAnalysis() throws IOException {
         PMDConfiguration configuration = new PMDConfiguration();
@@ -186,4 +290,31 @@ private List<CBOClass> getCBOClasses() {
     private String getFileName(RuleViolation violation) {
         return violation.getFileId().getUriString().replace("file:///" + repositoryPath.replace("\\", "/") + "/", "");
     }
+
+    public Map<String, String> getClassNamesAndPaths() throws IOException {
+
+        Map<String, String> fileNamePaths = new HashMap<>();
+
+        Files.walk(Paths.get(repositoryPath)).forEach(path -> {
+            String filename = path.getFileName().toString();
+            if (filename.endsWith(".java")) {
+                fileNamePaths.put(
+                        getClassName(filename),
+                        path.toUri().toString().replace("file:///" + repositoryPath.replace("\\", "/") + "/", ""));
+            }
+        });
+
+        return fileNamePaths;
+    }
+
+    /**
+     * Extract class name from java file name
+     * Example : MyJavaClass.java becomes MyJavaClass
+     *
+     * @param javaFileName
+     * @return
+     */
+    private String getClassName(String javaFileName) {
+        return javaFileName.substring(0, javaFileName.indexOf('.'));
+    }
 }

cost-benefit-calculator/src/main/java/org/hjug/cbc/CycleNode.java

@@ -0,0 +1,24 @@
+package org.hjug.cbc;
+
+import java.time.Instant;
+import lombok.Data;
+import org.hjug.git.ScmLogInfo;
+import org.hjug.metrics.Disharmony;
+
+@Data
+public class CycleNode implements Disharmony {
+
+    private final String className;
+    private final String fileName;
+    private Integer changePronenessRank;
+
+    private Instant firstCommitTime;
+    private Instant mostRecentCommitTime;
+    private Integer commitCount;
+
+    public void setScmLogInfo(ScmLogInfo scmLogInfo) {
+        firstCommitTime = Instant.ofEpochSecond(scmLogInfo.getEarliestCommit());
+        mostRecentCommitTime = Instant.ofEpochSecond(scmLogInfo.getMostRecentCommit());
+        commitCount = scmLogInfo.getCommitCount();
+    }
+}

cost-benefit-calculator/src/main/java/org/hjug/cbc/RankedCycle.java

@@ -0,0 +1,59 @@
+package org.hjug.cbc;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import lombok.Data;
+import lombok.extern.slf4j.Slf4j;
+import org.jgrapht.graph.DefaultEdge;
+
+@Data
+@Slf4j
+public class RankedCycle {
+
+    private final String cycleName;
+    private final Integer changePronenessRankSum;
+
+    private final Set<String> vertexSet;
+    private final Set<DefaultEdge> edgeSet;
+    private final double minCutCount;
+    private final Set<DefaultEdge> minCutEdges;
+    private final List<CycleNode> cycleNodes;
+
+    private float rawPriority;
+    private Integer priority = 0;
+    private float averageChangeProneness;
+    private Integer changePronenessRank;
+    private float impact;
+
+    public RankedCycle(
+            String cycleName,
+            Integer changePronenessRankSum,
+            Set<String> vertexSet,
+            Set<DefaultEdge> edgeSet,
+            double minCutCount,
+            Set<DefaultEdge> minCutEdges,
+            List<CycleNode> cycleNodes) {
+        this.cycleNodes = cycleNodes;
+        this.cycleName = cycleName;
+        this.changePronenessRankSum = changePronenessRankSum;
+        this.vertexSet = vertexSet;
+        this.edgeSet = edgeSet;
+        this.minCutCount = minCutCount;
+
+        if (null == minCutEdges) {
+            this.minCutEdges = new HashSet<>();
+        } else {
+            this.minCutEdges = minCutEdges;
+        }
+
+        if (minCutCount == 0.0) {
+            this.impact = (float) (vertexSet.size());
+        } else {
+            this.impact = (float) (vertexSet.size() / minCutCount);
+        }
+
+        this.averageChangeProneness = (float) changePronenessRankSum / vertexSet.size();
+        this.rawPriority = this.impact + averageChangeProneness;
+    }
+}