#152 Add minimum feedback set algorithms

change-proneness-ranker/src/main/java/org/hjug/git/ChangePronenessRanker.java

@@ -8,25 +8,40 @@
 @Slf4j
 public class ChangePronenessRanker {
 
-    private final TreeMap<Integer, Integer> changeCountsByTimeStamps = new TreeMap<>();
+    private final Map<Integer, Integer> changeCountsByTimeStamps = new HashMap<>();
     private final Map<String, ScmLogInfo> cachedScmLogInfos = new HashMap<>();
 
     public ChangePronenessRanker(GitLogReader repositoryLogReader) {
         try {
             log.info("Capturing change count based on commit timestamps");
-            changeCountsByTimeStamps.putAll(repositoryLogReader.captureChangeCountByCommitTimestamp());
+            changeCountsByTimeStamps.putAll(
+                    computeChangeCountsByTimeStamps(repositoryLogReader.captureChangeCountByCommitTimestamp()));
         } catch (IOException | GitAPIException e) {
             log.error("Error reading from repository: {}", e.getMessage());
         }
     }
 
+    private Map<Integer, Integer> computeChangeCountsByTimeStamps(TreeMap<Integer, Integer> commitsWithChangeCounts) {
+        HashMap<Integer, Integer> changeCountsByTimeStamps = new HashMap<>();
+        int runningTotal = 0;
+        for (Map.Entry<Integer, Integer> commitChangeCountEntry :
+                commitsWithChangeCounts.descendingMap().entrySet()) {
+            runningTotal += commitChangeCountEntry.getValue();
+            changeCountsByTimeStamps.put(commitChangeCountEntry.getKey(), runningTotal);
+        }
+
+        return changeCountsByTimeStamps;
+    }
+
     public void rankChangeProneness(List<ScmLogInfo> scmLogInfos) {
         for (ScmLogInfo scmLogInfo : scmLogInfos) {
             if (!cachedScmLogInfos.containsKey(scmLogInfo.getPath())) {
-                int commitsInRepositorySinceCreation =
-                        changeCountsByTimeStamps.tailMap(scmLogInfo.getEarliestCommit()).values().stream()
-                                .mapToInt(i -> i)
-                                .sum();
+                if (scmLogInfo.getEarliestCommit() == 0) {
+                    log.warn("No commits found for {}", scmLogInfo.getPath());
+                    continue;
+                }
+
+                int commitsInRepositorySinceCreation = changeCountsByTimeStamps.get(scmLogInfo.getEarliestCommit());
 
                 scmLogInfo.setChangeProneness((float) scmLogInfo.getCommitCount() / commitsInRepositorySinceCreation);
                 cachedScmLogInfos.put(scmLogInfo.getPath(), scmLogInfo);

change-proneness-ranker/src/main/java/org/hjug/git/GitLogReader.java

@@ -87,7 +87,7 @@ public ScmLogInfo fileLog(String path) throws GitAPIException, IOException {
                 .next()
                 .getCommitTime();
 
-        return new ScmLogInfo(path, earliestCommit, mostRecentCommit, commitCount);
+        return new ScmLogInfo(path, null, earliestCommit, mostRecentCommit, commitCount);
     }
 
     // based on https://stackoverflow.com/questions/27361538/how-to-show-changes-between-commits-with-jgit
@@ -104,28 +104,27 @@ public TreeMap<Integer, Integer> captureChangeCountByCommitTimestamp() throws IO
             RevCommit oldCommit = iterator.next();
 
             int count = 0;
-            if (null == newCommit) {
+            if (null == newCommit && iterator.hasNext()) {
                 newCommit = oldCommit;
                 continue;
+            } else if (!iterator.hasNext()) {
+                // Handle first / initial commit
+                changesByCommitTimestamp.putAll(walkFirstCommit(oldCommit));
             }
 
-            for (DiffEntry entry : getDiffEntries(newCommit, oldCommit)) {
-                if (entry.getNewPath().endsWith(JAVA_FILE_TYPE)
-                        || entry.getOldPath().endsWith(JAVA_FILE_TYPE)) {
-                    count++;
+            if (null != newCommit) {
+                for (DiffEntry entry : getDiffEntries(newCommit, oldCommit)) {
+                    if (entry.getNewPath().endsWith(JAVA_FILE_TYPE)
+                            || entry.getOldPath().endsWith(JAVA_FILE_TYPE)) {
+                        count++;
+                    }
                 }
-            }
-
-            if (count > 0) {
-                changesByCommitTimestamp.put(newCommit.getCommitTime(), count);
-            }
 
-            // Handle first / initial commit
-            if (!iterator.hasNext()) {
-                changesByCommitTimestamp.putAll(walkFirstCommit(oldCommit));
+                if (count > 0) {
+                    changesByCommitTimestamp.put(newCommit.getCommitTime(), count);
+                }
+                newCommit = oldCommit;
             }
-
-            newCommit = oldCommit;
         }
 
         return changesByCommitTimestamp;

change-proneness-ranker/src/main/java/org/hjug/git/ScmLogInfo.java

@@ -6,14 +6,16 @@
 public class ScmLogInfo {
 
     private String path;
+    private String className;
     private int earliestCommit;
     private int mostRecentCommit;
     private int commitCount;
     private float changeProneness;
     private int changePronenessRank;
 
-    public ScmLogInfo(String path, int earliestCommit, int mostRecentCommit, int commitCount) {
+    public ScmLogInfo(String path, String className, int earliestCommit, int mostRecentCommit, int commitCount) {
         this.path = path;
+        this.className = className;
         this.earliestCommit = earliestCommit;
         this.mostRecentCommit = mostRecentCommit;
         this.commitCount = commitCount;

change-proneness-ranker/src/test/java/org/hjug/git/ChangePronenessRankerTest.java

@@ -23,7 +23,7 @@ public void setUp() {
     // TODO: this should probably be a cucumber test
     @Test
     void testChangePronenessCalculation() throws IOException, GitAPIException {
-        ScmLogInfo scmLogInfo = new ScmLogInfo("path", 1595275997, 0, 1);
+        ScmLogInfo scmLogInfo = new ScmLogInfo("path", null, 1595275997, 0, 1);
 
         TreeMap<Integer, Integer> commitsWithChangeCounts = new TreeMap<>();
         commitsWithChangeCounts.put(scmLogInfo.getEarliestCommit(), scmLogInfo.getCommitCount());
@@ -43,30 +43,32 @@ void testChangePronenessCalculation() throws IOException, GitAPIException {
 
     @Test
     void testRankChangeProneness() throws IOException, GitAPIException {
-        ScmLogInfo scmLogInfo = new ScmLogInfo("file1", 1595275997, 0, 1);
+        // more recent commit
+        ScmLogInfo newerCommit = new ScmLogInfo("file1", null, 1595275997, 0, 1);
 
         TreeMap<Integer, Integer> commitsWithChangeCounts = new TreeMap<>();
-        commitsWithChangeCounts.put(scmLogInfo.getEarliestCommit(), scmLogInfo.getCommitCount());
-        commitsWithChangeCounts.put(scmLogInfo.getEarliestCommit() + 5 * 60, 3);
-        commitsWithChangeCounts.put(scmLogInfo.getEarliestCommit() + 10 * 60, 3);
+        commitsWithChangeCounts.put(newerCommit.getEarliestCommit(), newerCommit.getCommitCount());
+        commitsWithChangeCounts.put(newerCommit.getEarliestCommit() + 5 * 60, 3);
+        commitsWithChangeCounts.put(newerCommit.getEarliestCommit() + 10 * 60, 3);
 
-        ScmLogInfo scmLogInfo2 = new ScmLogInfo("file2", 1595175997, 0, 1);
+        // older commit
+        ScmLogInfo olderCommit = new ScmLogInfo("file2", null, 1595175997, 0, 1);
 
-        commitsWithChangeCounts.put(scmLogInfo2.getEarliestCommit(), scmLogInfo2.getCommitCount());
-        commitsWithChangeCounts.put(scmLogInfo2.getEarliestCommit() + 5 * 60, 5);
-        commitsWithChangeCounts.put(scmLogInfo2.getEarliestCommit() + 10 * 60, 5);
+        commitsWithChangeCounts.put(olderCommit.getEarliestCommit(), olderCommit.getCommitCount());
+        commitsWithChangeCounts.put(olderCommit.getEarliestCommit() + 5 * 60, 5);
+        commitsWithChangeCounts.put(olderCommit.getEarliestCommit() + 10 * 60, 5);
 
         when(repositoryLogReader.captureChangeCountByCommitTimestamp()).thenReturn(commitsWithChangeCounts);
         changePronenessRanker = new ChangePronenessRanker(repositoryLogReader);
 
         List<ScmLogInfo> scmLogInfos = new ArrayList<>();
-        scmLogInfos.add(scmLogInfo);
-        scmLogInfos.add(scmLogInfo2);
+        scmLogInfos.add(newerCommit);
+        scmLogInfos.add(olderCommit);
         changePronenessRanker.rankChangeProneness(scmLogInfos);
 
         // ranks higher since fewer commits since initial commit
-        Assertions.assertEquals(2, scmLogInfo.getChangePronenessRank());
+        Assertions.assertEquals(2, newerCommit.getChangePronenessRank());
         // ranks lower since there have been more commits since initial commit
-        Assertions.assertEquals(1, scmLogInfo2.getChangePronenessRank());
+        Assertions.assertEquals(1, olderCommit.getChangePronenessRank());
     }
 }

codebase-graph-builder/src/main/java/org/hjug/graphbuilder/JavaGraphBuilder.java

@@ -23,23 +23,22 @@
 public class JavaGraphBuilder {
 
     /**
-     * Given a java source directory return a graph of class references
+     * Given a java source directory, return a CodebaseGraphDTO
      *
      * @param srcDirectory
-     * @return
+     * @return CodebaseGraphDTO
      * @throws IOException
      */
-    public Graph<String, DefaultWeightedEdge> getClassReferences(
-            String srcDirectory, boolean excludeTests, String testSourceDirectory) throws IOException {
-        Graph<String, DefaultWeightedEdge> classReferencesGraph;
+    public CodebaseGraphDTO getCodebaseGraphDTO(String srcDirectory, boolean excludeTests, String testSourceDirectory)
+            throws IOException {
+        CodebaseGraphDTO codebaseGraphDTO;
         if (srcDirectory == null || srcDirectory.isEmpty()) {
             throw new IllegalArgumentException();
         } else {
-            classReferencesGraph = processWithOpenRewrite(srcDirectory, excludeTests, testSourceDirectory)
-                    .getClassReferencesGraph();
+            codebaseGraphDTO = processWithOpenRewrite(srcDirectory, excludeTests, testSourceDirectory);
         }
 
-        return classReferencesGraph;
+        return codebaseGraphDTO;
     }
 
     private CodebaseGraphDTO processWithOpenRewrite(String srcDir, boolean excludeTests, String testSourceDirectory)

codebase-graph-builder/src/main/java/org/hjug/graphbuilder/visitor/TypeProcessor.java

@@ -50,13 +50,15 @@ private void processType(String ownerFqn, JavaType.Array arrayType) {
     }
 
     private void processType(String ownerFqn, JavaType.GenericTypeVariable typeVariable) {
-        LogHolder.log.debug("Type parameter type name: " + typeVariable.getName());
+        LogHolder.log.debug("Type parameter type name: {}", typeVariable.getName());
 
         for (JavaType bound : typeVariable.getBounds()) {
             if (bound instanceof JavaType.Class) {
-                addType(((JavaType.Class) bound).getFullyQualifiedName(), ownerFqn);
+                addType(ownerFqn, ((JavaType.Class) bound).getFullyQualifiedName());
             } else if (bound instanceof JavaType.Parameterized) {
-                addType(((JavaType.Parameterized) bound).getFullyQualifiedName(), ownerFqn);
+                addType(ownerFqn, ((JavaType.Parameterized) bound).getFullyQualifiedName());
+            } else {
+                LogHolder.log.debug("Unknown type bound: {}", bound);
             }
         }
     }

codebase-graph-builder/src/test/java/org/hjug/graphbuilder/JavaGraphBuilderTest.java

@@ -20,17 +20,17 @@ class JavaGraphBuilderTest {
     @Test
     void parseSourceDirectoryEmptyTest() {
         Assertions.assertThrows(
-                IllegalArgumentException.class, () -> javaGraphBuilder.getClassReferences("", false, ""));
+                IllegalArgumentException.class, () -> javaGraphBuilder.getCodebaseGraphDTO("", false, ""));
         Assertions.assertThrows(
-                IllegalArgumentException.class, () -> javaGraphBuilder.getClassReferences(null, false, ""));
+                IllegalArgumentException.class, () -> javaGraphBuilder.getCodebaseGraphDTO(null, false, ""));
     }
 
     @DisplayName("Given a valid source directory input parameter return a valid graph.")
     @Test
     void parseSourceDirectoryTest() throws IOException {
         File srcDirectory = new File("src/test/resources/javaSrcDirectory");
-        Graph<String, DefaultWeightedEdge> classReferencesGraph =
-                javaGraphBuilder.getClassReferences(srcDirectory.getAbsolutePath(), false, "");
+        CodebaseGraphDTO dto = javaGraphBuilder.getCodebaseGraphDTO(srcDirectory.getAbsolutePath(), false, "");
+        Graph<String, DefaultWeightedEdge> classReferencesGraph = dto.getClassReferencesGraph();
         assertNotNull(classReferencesGraph);
         assertEquals(5, classReferencesGraph.vertexSet().size());
         assertEquals(7, classReferencesGraph.edgeSet().size());
@@ -77,9 +77,8 @@ private static double getEdgeWeight(
     @Test
     void removeClassesNotInCodebase() throws IOException {
         File srcDirectory = new File("src/test/resources/javaSrcDirectory");
-        Graph<String, DefaultWeightedEdge> classReferencesGraph =
-                javaGraphBuilder.getClassReferences(srcDirectory.getAbsolutePath(), false, "");
-
+        CodebaseGraphDTO dto = javaGraphBuilder.getCodebaseGraphDTO(srcDirectory.getAbsolutePath(), false, "");
+        Graph<String, DefaultWeightedEdge> classReferencesGraph = dto.getClassReferencesGraph();
         classReferencesGraph.addVertex("org.favioriteoss.FunClass");
         classReferencesGraph.addVertex("org.favioriteoss.AnotherFunClass");
 

cost-benefit-calculator/pom.xml

@@ -35,7 +35,7 @@
 
         <dependency>
             <groupId>org.hjug.refactorfirst.dsm</groupId>
-            <artifactId>dsm</artifactId>
+            <artifactId>graph-algorithms</artifactId>
         </dependency>
 
         <dependency>