Rewrite rendering using dedicated classes for each coverage type.

Replace all if/else blocks with proper subclassing. This provides the
possibility to enhance the source code tooltips for mutation results
with additional details for the mutations.

Author: uhafner

plugin/pom.xml

@@ -32,7 +32,7 @@
     <testcontainers.version>1.18.0</testcontainers.version>
     <job-dsl.version>1.83</job-dsl.version>
 
-    <coverage-model.version>0.24.0-rc428.9a_7f3f8f7729</coverage-model.version>
+    <coverage-model.version>0.24.0</coverage-model.version>
     <git-forensics.version>2.0.0</git-forensics.version>
     <prism-api.version>1.29.0-4</prism-api.version>
     <pull-request-monitoring.version>1.7.8</pull-request-monitoring.version>

plugin/src/main/java/io/jenkins/plugins/coverage/metrics/source/CoverageSourcePrinter.java

@@ -0,0 +1,133 @@
+package io.jenkins.plugins.coverage.metrics.source;
+
+import java.io.Serializable;
+import java.util.Arrays;
+
+import org.apache.commons.lang3.StringUtils;
+
+import edu.hm.hafner.coverage.FileNode;
+
+import io.jenkins.plugins.prism.Sanitizer;
+
+import static j2html.TagCreator.*;
+
+/**
+ * Provides all required information for a {@link FileNode} so that its source code can be rendered together with the
+ * line and branch coverage in HTML.
+ */
+class CoverageSourcePrinter implements Serializable {
+    private static final long serialVersionUID = -6044649044983631852L;
+    private static final Sanitizer SANITIZER = new Sanitizer();
+
+    static final String UNDEFINED = "noCover";
+    static final String NO_COVERAGE = "coverNone";
+    static final String FULL_COVERAGE = "coverFull";
+    static final String PARTIAL_COVERAGE = "coverPart";
+    private static final String NBSP = " ";
+
+    private final String path;
+    private final int[] linesToPaint;
+    private final int[] coveredPerLine;
+
+    private final int[] missedPerLine;
+
+    CoverageSourcePrinter(final FileNode file) {
+        path = file.getRelativePath();
+
+        linesToPaint = file.getLinesWithCoverage().stream().mapToInt(i -> i).toArray();
+        coveredPerLine = file.getCoveredCounters();
+        missedPerLine = file.getMissedCounters();
+    }
+
+    public String renderLine(final int line, final String sourceCode) {
+        var isPainted = isPainted(line);
+        return tr()
+                .withClass(isPainted ? getColorClass(line) : CoverageSourcePrinter.UNDEFINED)
+                .condAttr(isPainted, "data-html-tooltip", isPainted ? getTooltip(line) : StringUtils.EMPTY)
+                .with(
+                        td().withClass("line")
+                                .with(a().withName(String.valueOf(line)).withText(String.valueOf(line))),
+                        td().withClass("hits")
+                                .with(isPainted ? text(getSummaryColumn(line)) : text(StringUtils.EMPTY)),
+                        td().withClass("code")
+                                .with(rawHtml(SANITIZER.render(cleanupCode(sourceCode)))))
+                .render();
+    }
+
+    private String cleanupCode(final String content) {
+        return content.replace("\n", StringUtils.EMPTY)
+                .replace("\r", StringUtils.EMPTY)
+                .replace(" ", NBSP)
+                .replace("\t", NBSP.repeat(8));
+    }
+
+    int size() {
+        return linesToPaint.length;
+    }
+
+    public String getColorClass(final int line) {
+        if (getCovered(line) == 0) {
+            return NO_COVERAGE;
+        }
+        else if (getMissed(line) == 0) {
+            return FULL_COVERAGE;
+        }
+        else {
+            return PARTIAL_COVERAGE;
+        }
+    }
+
+    public String getTooltip(final int line) {
+        var covered = getCovered(line);
+        var missed = getMissed(line);
+        if (covered + missed > 1) {
+            if (missed == 0) {
+                return "All branches covered";
+            }
+            return String.format("Partially covered, branch coverage: %d/%d", covered, covered + missed);
+        }
+        else if (covered == 1) {
+            return "Covered at least once";
+        }
+        else {
+            return "Not covered";
+        }
+    }
+
+    public String getSummaryColumn(final int line) {
+        var covered = getCovered(line);
+        var missed = getMissed(line);
+        if (covered + missed > 1) {
+            return String.format("%d/%d", covered, covered + missed);
+        }
+        return String.valueOf(covered);
+    }
+
+    public String getPath() {
+        return path;
+    }
+
+    public boolean isPainted(final int line) {
+        return findIndexOfLine(line) >= 0;
+    }
+
+    int findIndexOfLine(final int line) {
+        return Arrays.binarySearch(linesToPaint, line);
+    }
+
+    public int getCovered(final int line) {
+        return getCounter(line, coveredPerLine);
+    }
+
+    public int getMissed(final int line) {
+        return getCounter(line, missedPerLine);
+    }
+
+    int getCounter(final int line, final int... counters) {
+        var index = findIndexOfLine(line);
+        if (index >= 0) {
+            return counters[index];
+        }
+        return 0;
+    }
+}

plugin/src/main/java/io/jenkins/plugins/coverage/metrics/source/FileWithBranchCoverage.java

@@ -18,18 +18,17 @@
 import static j2html.TagCreator.*;
 
 /**
- * A file with line and mutation coverage information.
- *
- * @author Ullrich Hafner
+ * Provides all required information for a {@link FileNode} so that its source code can be rendered together with the
+ * line and mutation coverage in HTML.
  */
-class FileWithMutationCoverage extends FileWithBranchCoverage {
+class MutationSourcePrinter extends CoverageSourcePrinter {
     private static final long serialVersionUID = -2215657894423024907L;
 
     private final int[] survivedPerLine;
     private final int[] killedPerLine;
     private final String[] tooltipPerLine;
 
-    FileWithMutationCoverage(final FileNode file) {
+    MutationSourcePrinter(final FileNode file) {
         super(file);
 
         survivedPerLine = new int[size()];
@@ -62,7 +61,9 @@ private String createInfo(final List<Mutation> allMutations) {
                 Mutation::isKilled, "Killed Mutations:");
         ContainerTag survivedContainer = listMutations(allMutations,
                 Mutation::hasSurvived, "Survived Mutations:");
-
+        if (killedContainer.getNumChildren() == 0 && survivedContainer.getNumChildren() == 0) {
+            return "Not covered";
+        }
         return div().with(killedContainer, survivedContainer).render();
     }
 

plugin/src/main/java/io/jenkins/plugins/coverage/metrics/source/FileWithMutationCoverage.java renamed to plugin/src/main/java/io/jenkins/plugins/coverage/metrics/source/MutationSourcePrinter.java

@@ -88,16 +88,16 @@ public void processSourceCodePainting(final Node rootNode, final List<FileNode>
         sourceCodeRetention.cleanup(build, sourceCodeFacade.getCoverageSourcesDirectory(), log);
     }
 
-    private FileWithBranchCoverage createFileModel(final Node rootNode, final FileNode fileNode) {
+    private CoverageSourcePrinter createFileModel(final Node rootNode, final FileNode fileNode) {
         if (rootNode.getValue(Metric.MUTATION).isPresent()) {
-            return new FileWithMutationCoverage(fileNode);
+            return new MutationSourcePrinter(fileNode);
         }
         else {
-            return new FileWithBranchCoverage(fileNode);
+            return new CoverageSourcePrinter(fileNode);
         }
     }
 
-    private void paintFilesOnAgent(final List<? extends PaintedNode> paintedFiles,
+    private void paintFilesOnAgent(final List<? extends CoverageSourcePrinter> paintedFiles,
             final String sourceCodeEncoding, final FilteredLog log) throws InterruptedException {
         try {
             var painter = new AgentCoveragePainter(paintedFiles, sourceCodeEncoding, id);
@@ -117,25 +117,25 @@ private void paintFilesOnAgent(final List<? extends PaintedNode> paintedFiles,
     static class AgentCoveragePainter extends MasterToSlaveFileCallable<FilteredLog> {
         private static final long serialVersionUID = 3966282357309568323L;
 
-        private final List<? extends PaintedNode> paintedFiles;
+        private final List<? extends CoverageSourcePrinter> paintedFiles;
         private final String sourceCodeEncoding;
         private final String directory;
 
         /**
          * Creates a new instance of {@link AgentCoveragePainter}.
          *
-         * @param paintedFiles
-         *         the model for the file painting for each coverage node
+         * @param files
+         *         the pretty printers for the files to create the HTML reports for
          * @param sourceCodeEncoding
          *         the encoding of the source code files
          * @param directory
          *         the subdirectory where the source files will be stored in
          */
-        AgentCoveragePainter(final List<? extends PaintedNode> paintedFiles, final String sourceCodeEncoding,
+        AgentCoveragePainter(final List<? extends CoverageSourcePrinter> files, final String sourceCodeEncoding,
                 final String directory) {
             super();
 
-            this.paintedFiles = paintedFiles;
+            this.paintedFiles = files;
             this.sourceCodeEncoding = sourceCodeEncoding;
             this.directory = directory;
         }
@@ -185,7 +185,7 @@ private Charset getCharset() {
             return new ValidationUtilities().getCharset(sourceCodeEncoding);
         }
 
-        private int paintSource(final PaintedNode fileNode, final FilePath workspace,
+        private int paintSource(final CoverageSourcePrinter fileNode, final FilePath workspace,
                 final Path temporaryFolder, final FilteredLog log) {
             String relativePathIdentifier = fileNode.getPath();
             FilePath paintedFilesDirectory = workspace.child(directory);
@@ -195,7 +195,7 @@ paintedFilesDirectory, temporaryFolder, getCharset(), log))
                     .orElse(0);
         }
 
-        private int paint(final PaintedNode paint, final String relativePathIdentifier,
+        private int paint(final CoverageSourcePrinter paint, final String relativePathIdentifier,
                 final FilePath resolvedPath, final FilePath paintedFilesDirectory,
                 final Path temporaryFolder, final Charset charset, final FilteredLog log) {
             String sanitizedFileName = SourceCodeFacade.sanitizeFilename(relativePathIdentifier);
@@ -206,7 +206,9 @@ private int paint(final PaintedNode paint, final String relativePathIdentifier,
                 Path fullSourcePath = paintedFilesFolder.resolve(sanitizedFileName);
                 try (BufferedWriter output = Files.newBufferedWriter(fullSourcePath)) {
                     List<String> lines = Files.readAllLines(Paths.get(resolvedPath.getRemote()), charset);
-                    new SourceToHtml().paintSourceCodeWithCoverageInformation(paint, output, lines);
+                    for (int line = 0; line < lines.size(); line++) {
+                        output.write(paint.renderLine(line + 1, lines.get(line)));
+                    }
                 }
                 new FilePath(fullSourcePath.toFile()).zip(zipOutputPath);
                 FileUtils.deleteDirectory(paintedFilesFolder.toFile());