Remote API to connect additional code review tools

README.md

@@ -184,12 +184,12 @@ Examples:
 
 ## Remote API
 
-We provide a remote API to retrieve coverage data, using the following URL: `https://[jenkins-url]/job/[job-name]/[build-number]/coverage/api/json?pretty=true`. 
+We provide a remote API to retrieve a coverage overview, using the following URL: `https://[jenkins-url]/job/[job-name]/[build-number]/coverage/api/json?pretty=true`. 
 
 Example output:
 ```json
 {
-  "_class" : "io.jenkins.plugins.coverage.metrics.steps.CoverageApi",
+  "_class" : "io.jenkins.plugins.coverage.metrics.restapi.CoverageApi",
   "modifiedFilesDelta" : {
     "branch" : "+1.72%",
     "class" : "-3.54%",
@@ -278,3 +278,34 @@ Example output:
   "referenceBuild" : "<a href=\"http://localhost:8080/job/coverage-model-history/10/\" class=\"model-link inside\">coverage-model-history #10</a>"
 }
 ```
+
+More concrete, the line coverage for modified code lines is provided per modified file, using the following URL: `https://[jenkins-url]/job/[job-name]/[build-number]/coverage/modified/api/json?pretty=true`.
+
+Example output:
+```json
+{
+  "_class": "io.jenkins.plugins.coverage.metrics.restapi.ModifiedLinesCoverageApi",
+  "files": [
+    {
+      "fullyQualifiedFileName": "io/jenkins/plugins/coverage/metrics/restapi/ModifiedLinesCoverageApi.java",
+      "modifiedLinesBlocks": [
+        {
+          "startLine": 30,
+          "endLine": 35,
+          "type": "MISSED"
+        }
+      ]
+    },
+    {
+      "fullyQualifiedFileName": "io/jenkins/plugins/coverage/metrics/restapi/ModifiedLinesBlocks.java",
+      "modifiedLinesBlocks": [
+        {
+          "startLine": 80,
+          "endLine": 81,
+          "type": "COVERED"
+        }
+      ]
+    }
+  ]
+}
+```

plugin/src/main/java/io/jenkins/plugins/coverage/metrics/steps/CoverageApi.java → plugin/src/main/java/io/jenkins/plugins/coverage/metrics/restapi/CoverageApi.java

@@ -1,4 +1,4 @@
-package io.jenkins.plugins.coverage.metrics.steps;
+package io.jenkins.plugins.coverage.metrics.restapi;
 
 import java.util.Collection;
 import java.util.Locale;
@@ -30,7 +30,17 @@ public class CoverageApi {
     private final QualityGateResult qualityGateResult;
     private final String referenceBuild;
 
-    CoverageApi(final CoverageStatistics statistics, final QualityGateResult qualityGateResult,
+    /**
+     * Creates a new instance of {@link CoverageApi}.
+     *
+     * @param statistics
+     *         the coverage statistics of the build.
+     * @param qualityGateResult
+     *         the quality gate result of the build.
+     * @param referenceBuild
+     *         the build referenced for comparison purposes.
+     */
+    public CoverageApi(final CoverageStatistics statistics, final QualityGateResult qualityGateResult,
             final String referenceBuild) {
         this.statistics = statistics;
         this.qualityGateResult = qualityGateResult;
@@ -136,7 +146,10 @@ public Result getOverallResult() {
 
         @Exported(inline = true)
         public Collection<QualityGateItemApi> getResultItems() {
-            return qualityGateResult.getResultItems().stream().map(QualityGateItemApi::new).collect(Collectors.toList());
+            return qualityGateResult.getResultItems()
+                    .stream()
+                    .map(QualityGateItemApi::new)
+                    .collect(Collectors.toList());
         }
     }
 

plugin/src/main/java/io/jenkins/plugins/coverage/metrics/restapi/FileWithModifiedLines.java

@@ -0,0 +1,51 @@
+package io.jenkins.plugins.coverage.metrics.restapi;
+
+import java.util.Objects;
+import java.util.SortedSet;
+
+import org.kohsuke.stapler.export.Exported;
+import org.kohsuke.stapler.export.ExportedBean;
+
+/**
+ * Model class that describes the {@link LineCoverageType coverage} for modified code lines of a file. The file is
+ * described by its fully qualified name.
+ */
+@ExportedBean
+class FileWithModifiedLines {
+    private final String fullyQualifiedFileName;
+    private final SortedSet<ModifiedLinesBlock> modifiedLinesBlocks;
+
+    FileWithModifiedLines(final String fullyQualifiedFileName,
+            final SortedSet<ModifiedLinesBlock> modifiedLinesBlocks) {
+        this.fullyQualifiedFileName = fullyQualifiedFileName;
+        this.modifiedLinesBlocks = modifiedLinesBlocks;
+    }
+
+    @Exported(inline = true)
+    public String getFullyQualifiedFileName() {
+        return fullyQualifiedFileName;
+    }
+
+    @Exported(inline = true)
+    public SortedSet<ModifiedLinesBlock> getModifiedLinesBlocks() {
+        return modifiedLinesBlocks;
+    }
+
+    @Override
+    public boolean equals(final Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        FileWithModifiedLines file = (FileWithModifiedLines) o;
+        return Objects.equals(this.getFullyQualifiedFileName(), file.getFullyQualifiedFileName())
+                && Objects.equals(this.getModifiedLinesBlocks(), file.getModifiedLinesBlocks());
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(getFullyQualifiedFileName(), getModifiedLinesBlocks());
+    }
+}

plugin/src/main/java/io/jenkins/plugins/coverage/metrics/restapi/LineCoverageType.java

@@ -0,0 +1,10 @@
+package io.jenkins.plugins.coverage.metrics.restapi;
+
+/**
+ * Defines the type of line coverage.
+ */
+enum LineCoverageType {
+    COVERED,
+    MISSED,
+    PARTIALLY_COVERED
+}

plugin/src/main/java/io/jenkins/plugins/coverage/metrics/restapi/ModifiedLinesBlock.java

@@ -0,0 +1,63 @@
+package io.jenkins.plugins.coverage.metrics.restapi;
+
+import java.util.Objects;
+
+import org.kohsuke.stapler.export.Exported;
+import org.kohsuke.stapler.export.ExportedBean;
+
+/**
+ * Model class containing data pertaining to consecutive lines of modified code. Each object possesses a starting and
+ * ending line number and the type of coverage of the block. Each object is associated with a
+ * {@link FileWithModifiedLines} object. The class implements {@link Comparable} and is ordered by the start line. Empty
+ * lines and comments are also included in blocks.
+ */
+@ExportedBean
+class ModifiedLinesBlock implements Comparable<ModifiedLinesBlock> {
+    private final int startLine;
+    private final int endLine;
+    private final LineCoverageType type;
+
+    ModifiedLinesBlock(final int startLine, final int endLine, final LineCoverageType type) {
+        this.startLine = startLine;
+        this.endLine = endLine;
+        this.type = type;
+    }
+
+    @Exported
+    public int getStartLine() {
+        return startLine;
+    }
+
+    @Exported
+    public int getEndLine() {
+        return endLine;
+    }
+
+    @Exported
+    public LineCoverageType getType() {
+        return type;
+    }
+
+    @Override
+    public int compareTo(final ModifiedLinesBlock other) {
+        return this.startLine - other.startLine;
+    }
+
+    @Override
+    public boolean equals(final Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        ModifiedLinesBlock that = (ModifiedLinesBlock) o;
+        return getStartLine() == that.getStartLine() && getEndLine() == that.getEndLine()
+                && getType() == that.getType();
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(getStartLine(), getEndLine(), getType());
+    }
+}

plugin/src/main/java/io/jenkins/plugins/coverage/metrics/restapi/ModifiedLinesCoverageApi.java

@@ -0,0 +1,147 @@
+package io.jenkins.plugins.coverage.metrics.restapi;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.TreeSet;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+import edu.hm.hafner.coverage.FileNode;
+import edu.hm.hafner.coverage.Node;
+
+import org.kohsuke.stapler.export.Exported;
+import org.kohsuke.stapler.export.ExportedBean;
+
+/**
+ * Remote API to list the details of modified line coverage results.
+ */
+@ExportedBean
+class ModifiedLinesCoverageApi {
+    private final List<FileWithModifiedLines> filesWithModifiedLines;
+
+    ModifiedLinesCoverageApi(final Node node) {
+        this.filesWithModifiedLines = createListOfFilesWithModifiedLines(node);
+    }
+
+    @Exported(inline = true, name = "files")
+    public List<FileWithModifiedLines> getFilesWithModifiedLines() {
+        return filesWithModifiedLines;
+    }
+
+    /**
+     * Finds all files with modified lines of code in a passed {@link Node} object.
+     *
+     * @param node
+     *         containing the file tree.
+     *
+     * @return a list of {@link FileWithModifiedLines} objects.
+     */
+    private List<FileWithModifiedLines> createListOfFilesWithModifiedLines(final Node node) {
+        var result = new ArrayList<FileWithModifiedLines>();
+
+        for (FileNode fileNode : node.filterByModifiedLines().getAllFileNodes()) {
+            var modifiedLines = new ArrayList<>(fileNode.getModifiedLines());
+            var modifiedLinesWithoutCoverage = modifiedLines.stream()
+                    .filter(line -> !fileNode.getLinesWithCoverage().contains(line))
+                    .collect(Collectors.toList());
+
+            var missedLines = filterByModifiedLines(modifiedLines, fileNode.getMissedLines());
+            var partiallyCoveredLines =
+                    filterByModifiedLines(modifiedLines, fileNode.getPartiallyCoveredLines().keySet());
+            var coveredLines = fileNode.getLinesWithCoverage().stream()
+                    .filter(line -> fileNode.getMissedOfLine(line) == 0)
+                    .filter(modifiedLines::contains)
+                    .collect(Collectors.toList());
+
+            var modifiedLinesBlocks = new TreeSet<ModifiedLinesBlock>();
+
+            modifiedLinesBlocks.addAll(
+                    calculateModifiedLineBlocks(coveredLines, modifiedLinesWithoutCoverage, LineCoverageType.COVERED));
+            modifiedLinesBlocks.addAll(
+                    calculateModifiedLineBlocks(missedLines, modifiedLinesWithoutCoverage, LineCoverageType.MISSED));
+            modifiedLinesBlocks.addAll(calculateModifiedLineBlocks(partiallyCoveredLines, modifiedLinesWithoutCoverage,
+                    LineCoverageType.PARTIALLY_COVERED));
+
+            var changedFile = new FileWithModifiedLines(fileNode.getRelativePath(), modifiedLinesBlocks);
+            result.add(changedFile);
+        }
+
+        return result;
+    }
+
+    /**
+     * Filters the given lines to only contain the given modified lines.
+     *
+     * @param modifiedLines
+     *         the lines that have been modified
+     * @param lines
+     *         the lines that should be filtered for modified lines only
+     *
+     * @return the filtered lines
+     */
+    private List<Integer> filterByModifiedLines(final Collection<Integer> modifiedLines,
+            final Collection<Integer> lines) {
+        return lines.stream().filter(modifiedLines::contains).collect(Collectors.toList());
+    }
+
+    /**
+     * This method parses over the modified lines of a file and combines consecutive line numbers with the same coverage
+     * type into a {@link ModifiedLinesBlock} object. If there are empty lines without coverage information between
+     * lines with the same type, they will be included in the block. The result is sorted by the starting line number.
+     *
+     * @param modifiedLines
+     *         list containing the integer numbers of modified lines.
+     * @param modifiedLinesWithoutCoverage
+     *         lines that have been modified but have no coverage information
+     * @param type
+     *         type of coverage pertaining to each line of code ({@link LineCoverageType#COVERED},
+     *         {@link LineCoverageType#MISSED}, or {@link LineCoverageType#PARTIALLY_COVERED})
+     *
+     * @return the list of {@link ModifiedLinesBlock}
+     */
+    private List<ModifiedLinesBlock> calculateModifiedLineBlocks(final List<Integer> modifiedLines,
+            final List<Integer> modifiedLinesWithoutCoverage, final LineCoverageType type) {
+        var modifiedLinesBlocks = new ArrayList<ModifiedLinesBlock>();
+        if (modifiedLines.isEmpty()) {
+            return modifiedLinesBlocks;
+        }
+
+        int start = modifiedLines.get(0);
+        int last = start;
+        if (modifiedLines.size() > 1) {
+            for (int line : modifiedLines.subList(1, modifiedLines.size())) {
+                if (line > last + 1
+                        && hasAnyLinesWithCoverageBetween(last, line, modifiedLinesWithoutCoverage)) {
+                    var modifiedLinesBlock = new ModifiedLinesBlock(start, last, type);
+                    modifiedLinesBlocks.add(modifiedLinesBlock);
+                    start = line;
+                }
+                last = line;
+            }
+        }
+        var modifiedLinesBlock = new ModifiedLinesBlock(start, last, type);
+        modifiedLinesBlocks.add(modifiedLinesBlock);
+
+        return modifiedLinesBlocks;
+    }
+
+    /**
+     * Checks whether the range between the first and the second given line contains any lines with coverage
+     * information.
+     *
+     * @param start
+     *         the first line number
+     * @param end
+     *         the second line number (must be greater than the first)
+     * @param modifiedLinesWithoutCoverage
+     *         the modified lines without coverage information
+     *
+     * @return {@code true} whether there are any lines within the given line range that contains coverage information,
+     *         else {@code false}
+     */
+    private boolean hasAnyLinesWithCoverageBetween(final int start, final int end,
+            final List<Integer> modifiedLinesWithoutCoverage) {
+        return IntStream.range(start + 1, end).anyMatch(line -> !modifiedLinesWithoutCoverage.contains(line));
+    }
+}