Create a new step to record coverage results

plugin/pom.xml

@@ -19,10 +19,18 @@
   <url>https://github.com/jenkinsci/code-coverage-api-plugin</url>
 
   <properties>
-    <revision>3.3.0</revision>
+    <revision>4.0.0</revision>
     <changelist>-SNAPSHOT</changelist>
     <gitHubRepo>jenkinsci/code-coverage-api-plugin</gitHubRepo>
 
+    <jenkins.baseline>2.361</jenkins.baseline>
+    <jenkins.version>2.361.2</jenkins.version>
+    <jdk>11</jdk>
+    <maven.compiler.source>11</maven.compiler.source>
+    <maven.compiler.target>11</maven.compiler.target>
+    <maven.compiler.release>11</maven.compiler.release>
+    <maven.compiler.testRelease>11</maven.compiler.testRelease>
+
     <trove4j.version>3.0.3</trove4j.version>
     <saxon-he.version>11.4</saxon-he.version>
 
@@ -58,6 +66,11 @@
   </licenses>
 
   <dependencies>
+    <dependency>
+      <groupId>edu.hm.hafner</groupId>
+      <artifactId>coverage-model</artifactId>
+      <version>0.1.0</version>
+    </dependency>
     <dependency>
       <groupId>io.jenkins.plugins</groupId>
       <artifactId>ionicons-api</artifactId>
@@ -142,6 +155,10 @@
       <artifactId>prism-api</artifactId>
       <version>${prism-api.version}</version>
     </dependency>
+    <dependency>
+      <groupId>org.jenkins-ci.plugins.workflow</groupId>
+      <artifactId>workflow-api</artifactId>
+    </dependency>
     <dependency>
       <groupId>org.jsoup</groupId>
       <artifactId>jsoup</artifactId>
@@ -199,11 +216,6 @@
       <artifactId>workflow-durable-task-step</artifactId>
       <scope>test</scope>
     </dependency>
-    <dependency>
-      <groupId>org.jenkins-ci.plugins.workflow</groupId>
-      <artifactId>workflow-api</artifactId>
-      <scope>test</scope>
-    </dependency>
     <dependency>
       <groupId>org.jenkins-ci.plugins.workflow</groupId>
       <artifactId>workflow-support</artifactId>
@@ -302,6 +314,7 @@
         <artifactId>assertj-assertions-generator-maven-plugin</artifactId>
         <configuration>
           <packages combine.children="append">
+            <package>io.jenkins.plugins.coverage.metrics</package>
             <package>io.jenkins.plugins.coverage.model</package>
           </packages>
           <excludes combine.children="append">
@@ -316,6 +329,14 @@
           <skip>true</skip>
         </configuration>
       </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <configuration>
+          <source>10</source>
+          <target>10</target>
+        </configuration>
+      </plugin>
     </plugins>
   </build>
 

plugin/src/main/java/io/jenkins/plugins/coverage/CoverageAction.java

@@ -5,9 +5,10 @@
 import java.util.Collection;
 import java.util.Collections;
 
+import org.apache.commons.lang.StringUtils;
+
 import edu.umd.cs.findbugs.annotations.CheckForNull;
 
-import org.apache.commons.lang.StringUtils;
 import org.kohsuke.stapler.StaplerProxy;
 import hudson.model.Action;
 import hudson.model.HealthReport;
@@ -16,7 +17,7 @@
 import jenkins.model.RunAction2;
 import jenkins.tasks.SimpleBuildStep;
 
-import io.jenkins.plugins.coverage.model.CoverageBuildAction;
+import io.jenkins.plugins.coverage.metrics.CoverageBuildAction;
 import io.jenkins.plugins.coverage.targets.CoverageResult;
 
 public class CoverageAction implements StaplerProxy, SimpleBuildStep.LastBuildAction, RunAction2, HealthReportingAction {

plugin/src/main/java/io/jenkins/plugins/coverage/CoverageProcessor.java

@@ -44,7 +44,6 @@
 import io.jenkins.plugins.coverage.detector.Detectable;
 import io.jenkins.plugins.coverage.detector.ReportDetector;
 import io.jenkins.plugins.coverage.exception.CoverageException;
-import io.jenkins.plugins.coverage.model.CoverageReporter;
 import io.jenkins.plugins.coverage.source.SourceFileResolver;
 import io.jenkins.plugins.coverage.source.SourceFileResolver.SourceFileResolverLevel;
 import io.jenkins.plugins.coverage.targets.CoverageElement;
@@ -128,14 +127,16 @@ public void performCoverageReport(final List<CoverageReportAdapter> reportAdapte
         HealthReport healthReport = processThresholds(results, globalThresholds, action);
         action.setHealthReport(healthReport);
 
-        // Transform the old model to the new model
+        // FIXME: Transform the old model to the new model
+        /*
         CoverageReporter coverageReporter = new CoverageReporter();
         coverageReporter.run(coverageReport.getRoot(), run, workspace, listener, healthReport, scm,
                 sourceDirectories, sourceCodeEncoding, mapSourceCodeRetention());
 
         if (failBuildIfCoverageDecreasedInChangeRequest) {
             failBuildIfChangeRequestDecreasedCoverage(coverageReport, action);
         }
+        */
     }
 
     private SourceCodeRetention mapSourceCodeRetention() {

plugin/src/main/java/io/jenkins/plugins/coverage/metrics/AggregatedResult.java

@@ -0,0 +1,36 @@
+package io.jenkins.plugins.coverage.metrics;
+
+import java.io.Serializable;
+
+import edu.hm.hafner.metric.Node;
+import edu.hm.hafner.util.FilteredLog;
+
+/**
+ * Combines the root node of a coverage tree with the log that contains useful information gathered during parsing on an
+ * agent.
+ *
+ * @author Ullrich Hafner
+ */
+class AggregatedResult implements Serializable {
+    private static final long serialVersionUID = 2122230867938547733L;
+
+    private final FilteredLog log;
+    private final Node root;
+
+    AggregatedResult(final FilteredLog log, final Node root) {
+        this.log = log;
+        this.root = root;
+    }
+
+    public FilteredLog getLog() {
+        return log;
+    }
+
+    public Node getRoot() {
+        return root;
+    }
+
+    public boolean hasErrors() {
+        return !getLog().getErrorMessages().isEmpty();
+    }
+}

plugin/src/main/java/io/jenkins/plugins/coverage/model/ChangeCoverageTableModel.java → plugin/src/main/java/io/jenkins/plugins/coverage/metrics/ChangeCoverageTableModel.java

@@ -1,15 +1,18 @@
-package io.jenkins.plugins.coverage.model;
+package io.jenkins.plugins.coverage.metrics;
 
 import java.util.List;
 import java.util.Locale;
-import java.util.Optional;
+import java.util.SortedSet;
 import java.util.stream.Collectors;
 
-import org.apache.commons.lang3.math.Fraction;
+import edu.hm.hafner.metric.Coverage;
+import edu.hm.hafner.metric.FileNode;
+import edu.hm.hafner.metric.Metric;
+import edu.hm.hafner.metric.Node;
 
 import hudson.Functions;
 
-import io.jenkins.plugins.coverage.model.visualization.colorization.ColorProvider;
+import io.jenkins.plugins.coverage.metrics.visualization.colorization.ColorProvider;
 import io.jenkins.plugins.datatables.DetailedCell;
 import io.jenkins.plugins.datatables.TableConfiguration;
 import io.jenkins.plugins.datatables.TableConfiguration.SelectStyle;
@@ -20,7 +23,7 @@
  * @since 3.0.0
  */
 class ChangeCoverageTableModel extends CoverageTableModel {
-    private final CoverageNode changeRoot;
+    private final Node changeRoot;
 
     /**
      * Creates a change coverage table model.
@@ -36,7 +39,7 @@ class ChangeCoverageTableModel extends CoverageTableModel {
      * @param colorProvider
      *         The {@link ColorProvider} which provides the used colors
      */
-    ChangeCoverageTableModel(final String id, final CoverageNode root, final CoverageNode changeRoot,
+    ChangeCoverageTableModel(final String id, final Node root, final Node changeRoot,
             final RowRenderer renderer, final ColorProvider colorProvider) {
         super(id, root, renderer, colorProvider);
 
@@ -51,18 +54,18 @@ public TableConfiguration getTableConfiguration() {
     @Override
     public List<Object> getRows() {
         Locale browserLocale = Functions.getCurrentLocale();
-        return changeRoot.getAllFileCoverageNodes().stream()
+        return changeRoot.getAllFileNodes().stream()
                 .map(file -> new ChangeCoverageRow(
                         getOriginalNode(file), file, browserLocale, getRenderer(), getColorProvider()))
                 .collect(Collectors.toList());
     }
 
-    private FileCoverageNode getOriginalNode(final FileCoverageNode fileNode) {
-        Optional<FileCoverageNode> reference = getRoot().getAllFileCoverageNodes().stream()
+    private FileNode getOriginalNode(final FileNode fileNode) {
+        return getRoot().getAllFileNodes().stream()
                 .filter(node -> node.getPath().equals(fileNode.getPath())
                         && node.getName().equals(fileNode.getName()))
-                .findFirst();
-        return reference.orElse(fileNode); // return this as fallback to prevent exceptions
+                .findFirst()
+                .orElse(fileNode); // return this as fallback to prevent exceptions
     }
 
     /**
@@ -71,51 +74,36 @@ private FileCoverageNode getOriginalNode(final FileCoverageNode fileNode) {
      * @since 3.0.0
      */
     private static class ChangeCoverageRow extends CoverageRow {
-        private final FileCoverageNode changedFileNode;
+        private final FileNode originalFile;
 
-        ChangeCoverageRow(final FileCoverageNode root, final FileCoverageNode changedFileNode,
+        ChangeCoverageRow(final FileNode originalFile, final FileNode changedFileNode,
                 final Locale browserLocale, final RowRenderer renderer, final ColorProvider colorProvider) {
-            super(root, browserLocale, renderer, colorProvider);
+            super(changedFileNode, browserLocale, renderer, colorProvider);
 
-            this.changedFileNode = changedFileNode;
-        }
-
-        @Override
-        public DetailedCell<?> getLineCoverage() {
-            Coverage coverage = changedFileNode.getCoverage(CoverageMetric.LINE);
-            return createColoredCoverageColumn(coverage, "The line change coverage");
-        }
-
-        @Override
-        public DetailedCell<?> getBranchCoverage() {
-            Coverage coverage = changedFileNode.getCoverage(CoverageMetric.BRANCH);
-            return createColoredCoverageColumn(coverage, "The branch change coverage");
+            this.originalFile = originalFile;
         }
 
         @Override
         public DetailedCell<?> getLineCoverageDelta() {
-            return createColoredChangeCoverageDeltaColumn(CoverageMetric.LINE);
+            return createColoredChangeCoverageDeltaColumn(Metric.LINE);
         }
 
         @Override
         public DetailedCell<?> getBranchCoverageDelta() {
-            return createColoredChangeCoverageDeltaColumn(CoverageMetric.BRANCH);
+            return createColoredChangeCoverageDeltaColumn(Metric.BRANCH);
         }
 
         @Override
         public int getLoc() {
-            return (int) changedFileNode.getChangedCodeLines().stream()
-                    .filter(line -> changedFileNode.getCoveragePerLine().containsKey(line))
-                    .count();
+            SortedSet<Integer> coveredDelta = getFile().getCoveredLinesOfChangeSet();
+            return coveredDelta.size();
         }
 
-        private DetailedCell<?> createColoredChangeCoverageDeltaColumn(final CoverageMetric coverageMetric) {
-            Coverage changeCoverage = changedFileNode.getCoverage(coverageMetric);
+        private DetailedCell<?> createColoredChangeCoverageDeltaColumn(final Metric metric) {
+            Coverage changeCoverage = getFile().getTypedValue(metric, Coverage.nullObject(metric));
             if (changeCoverage.isSet()) {
-                Fraction delta = changeCoverage.getCoveredFraction()
-                        .subtract(getRoot().getCoverage(coverageMetric).getCoveredFraction());
-                return createColoredCoverageDeltaColumn(CoveragePercentage.valueOf(delta),
-                        "The change coverage within the file against the total file coverage");
+                return createColoredCoverageDeltaColumn(metric,
+                        changeCoverage.delta(originalFile.getTypedValue(metric, Coverage.nullObject(metric))));
             }
             return NO_COVERAGE;
         }

plugin/src/main/java/io/jenkins/plugins/coverage/model/CodeDeltaCalculator.java → plugin/src/main/java/io/jenkins/plugins/coverage/metrics/CodeDeltaCalculator.java

@@ -1,4 +1,4 @@
-package io.jenkins.plugins.coverage.model;
+package io.jenkins.plugins.coverage.metrics;
 
 import java.util.Collection;
 import java.util.Comparator;
@@ -12,6 +12,7 @@
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
+import edu.hm.hafner.metric.Node;
 import edu.hm.hafner.util.FilteredLog;
 
 import one.util.streamex.StreamEx;
@@ -20,7 +21,6 @@
 import hudson.model.Run;
 import hudson.model.TaskListener;
 
-import io.jenkins.plugins.coverage.model.exception.CodeDeltaException;
 import io.jenkins.plugins.forensics.delta.DeltaCalculatorFactory;
 import io.jenkins.plugins.forensics.delta.model.Delta;
 import io.jenkins.plugins.forensics.delta.model.FileChanges;
@@ -32,7 +32,6 @@
  * @author Florian Orendi
  */
 public class CodeDeltaCalculator {
-
     static final String AMBIGUOUS_PATHS_ERROR =
             "Failed to map SCM paths with coverage report paths due to ambiguous fully qualified names";
     static final String AMBIGUOUS_OLD_PATHS_ERROR =
@@ -108,24 +107,20 @@ public Set<FileChanges> getCoverageRelevantChanges(final Delta delta) {
      * the coverage reporting tools - usually the fully qualified name of the file.
      *
      * @param changes
-     *         The code changes
+     *         the code changes
      * @param root
-     *         The root of the coverage tree
+     *         the root of the coverage tree
      * @param log
-     *         The log
+     *         logger
      *
-     * @return the create code changes mapping
+     * @return the created mapping of code changes
      * @throws CodeDeltaException
      *         when creating the mapping failed due to ambiguous paths
      */
     public Map<String, FileChanges> mapScmChangesToReportPaths(
-            final Set<FileChanges> changes, final CoverageNode root, final FilteredLog log) throws CodeDeltaException {
-        Set<String> reportPaths = root.getAllFileCoverageNodes().stream()
-                .map(FileCoverageNode::getPath)
-                .collect(Collectors.toSet());
-        Set<String> scmPaths = changes.stream()
-                .map(FileChanges::getFileName)
-                .collect(Collectors.toSet());
+            final Set<FileChanges> changes, final Node root, final FilteredLog log) throws CodeDeltaException {
+        Set<String> reportPaths = new HashSet<>(root.getFiles());
+        Set<String> scmPaths = changes.stream().map(FileChanges::getFileName).collect(Collectors.toSet());
 
         Map<String, String> pathMapping = getScmToReportPathMapping(scmPaths, reportPaths);
         verifyScmToReportPathMapping(pathMapping, log);
@@ -157,19 +152,17 @@ public Map<String, FileChanges> mapScmChangesToReportPaths(
      * @throws CodeDeltaException
      *         if the SCM path mapping is ambiguous
      */
-    public Map<String, String> createOldPathMapping(final CoverageNode root, final CoverageNode referenceRoot,
+    public Map<String, String> createOldPathMapping(final Node root, final Node referenceRoot,
             final Map<String, FileChanges> changes, final FilteredLog log)
             throws CodeDeltaException {
-        Set<String> oldReportPaths = referenceRoot.getAllFileCoverageNodes().stream()
-                .map(FileCoverageNode::getPath)
-                .collect(Collectors.toSet());
+        Set<String> oldReportPaths = new HashSet<>(referenceRoot.getFiles());
         // mapping between reference and current file paths which initially contains the SCM paths with renamings
         Map<String, String> oldPathMapping = changes.entrySet().stream()
                 .filter(entry -> FileEditType.RENAME.equals(entry.getValue().getFileEditType()))
                 .collect(Collectors.toMap(Entry::getKey, entry -> entry.getValue().getOldFileName()));
         // the SCM paths and the coverage report paths from the reference
-        Map<String, String> oldScmToOldReportPathMapping =
-                getScmToReportPathMapping(oldPathMapping.values(), oldReportPaths);
+        Map<String, String> oldScmToOldReportPathMapping
+                = getScmToReportPathMapping(oldPathMapping.values(), oldReportPaths);
 
         // replacing the old SCM paths with the old report paths
         Set<String> newReportPathsWithRename = oldPathMapping.keySet();
@@ -182,10 +175,9 @@ public Map<String, String> createOldPathMapping(final CoverageNode root, final C
         }
 
         // adding the paths, which exist in both trees and contain no changes, to the mapping
-        root.getAllFileCoverageNodes().stream()
-                .filter(node -> !oldPathMapping.containsKey(node.getPath()) && oldReportPaths.contains(
-                        node.getPath()))
-                .forEach(node -> oldPathMapping.put(node.getPath(), node.getPath()));
+        root.getFiles().stream()
+                .filter(file -> !oldPathMapping.containsKey(file) && oldReportPaths.contains(file))
+                .forEach(file -> oldPathMapping.put(file, file));
 
         removeMissingReferences(oldPathMapping, log);
         verifyOldPathMapping(oldPathMapping, log);

plugin/src/main/java/io/jenkins/plugins/coverage/model/exception/CodeDeltaException.java → plugin/src/main/java/io/jenkins/plugins/coverage/metrics/CodeDeltaException.java

@@ -1,4 +1,4 @@
-package io.jenkins.plugins.coverage.model.exception;
+package io.jenkins.plugins.coverage.metrics;
 
 /**
  * Exception which is thrown when preprocessing the code delta failed.