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-rc427.d5fd580c7466</coverage-model.version>
+    <coverage-model.version>0.24.0-rc428.9a_7f3f8f7729</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/FileWithBranchCoverage.java

@@ -0,0 +1,57 @@
+package io.jenkins.plugins.coverage.metrics.source;
+
+import edu.hm.hafner.coverage.FileNode;
+
+/**
+ * A file with line and branch coverage information.
+ *
+ * @author Ullrich Hafner
+ */
+class FileWithBranchCoverage extends PaintedNode {
+    private static final long serialVersionUID = -2703496036007699731L;
+
+    FileWithBranchCoverage(final FileNode file) {
+        super(file);
+    }
+
+    @Override
+    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;
+        }
+    }
+
+    @Override
+    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";
+        }
+    }
+
+    @Override
+    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);
+    }
+}

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

@@ -0,0 +1,123 @@
+package io.jenkins.plugins.coverage.metrics.source;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map.Entry;
+import java.util.NavigableMap;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+
+import org.apache.commons.lang3.StringUtils;
+
+import edu.hm.hafner.coverage.FileNode;
+import edu.hm.hafner.coverage.Mutation;
+
+import j2html.tags.ContainerTag;
+import j2html.tags.UnescapedText;
+
+import static j2html.TagCreator.*;
+
+/**
+ * A file with line and mutation coverage information.
+ *
+ * @author Ullrich Hafner
+ */
+class FileWithMutationCoverage extends FileWithBranchCoverage {
+    private static final long serialVersionUID = -2215657894423024907L;
+
+    private final int[] survivedPerLine;
+    private final int[] killedPerLine;
+    private final String[] tooltipPerLine;
+
+    FileWithMutationCoverage(final FileNode file) {
+        super(file);
+
+        survivedPerLine = new int[size()];
+        killedPerLine = new int[size()];
+        tooltipPerLine = new String[size()];
+        Arrays.fill(tooltipPerLine, StringUtils.EMPTY);
+
+        extractMutationDetails(file.getMutationsPerLine());
+
+        for (Mutation mutation : file.getMutations()) {
+            if (mutation.hasSurvived()) {
+                survivedPerLine[findIndexOfLine(mutation.getLine())]++;
+            }
+            else if (mutation.isKilled()) {
+                killedPerLine[findIndexOfLine(mutation.getLine())]++;
+            }
+        }
+    }
+
+    private void extractMutationDetails(final NavigableMap<Integer, List<Mutation>> mutationsPerLine) {
+        for (Entry<Integer, List<Mutation>> entry : mutationsPerLine.entrySet()) {
+            var indexOfLine = findIndexOfLine(entry.getKey());
+
+            tooltipPerLine[indexOfLine] = createInfo(entry.getValue());
+        }
+    }
+
+    private String createInfo(final List<Mutation> allMutations) {
+        ContainerTag killedContainer = listMutations(allMutations,
+                Mutation::isKilled, "Killed Mutations:");
+        ContainerTag survivedContainer = listMutations(allMutations,
+                Mutation::hasSurvived, "Survived Mutations:");
+
+        return div().with(killedContainer, survivedContainer).render();
+    }
+
+    private ContainerTag listMutations(final List<Mutation> allMutations,
+            final Predicate<Mutation> predicate, final String title) {
+        var filtered = div();
+        var killed = asBulletPoints(allMutations, predicate);
+        if (!killed.isEmpty()) {
+            filtered.with(div().with(new UnescapedText(title), ul().with(killed)));
+        }
+        return filtered;
+    }
+
+    private List<ContainerTag> asBulletPoints(final List<Mutation> mutations, final Predicate<Mutation> predicate) {
+        return mutations.stream().filter(predicate).map(mutation ->
+                li().withText(String.format("%s (%s)", mutation.getDescription(), mutation.getMutator())))
+                .collect(Collectors.toList());
+    }
+
+    public int getSurvived(final int line) {
+        return getCounter(line, survivedPerLine);
+    }
+
+    public int getKilled(final int line) {
+        return getCounter(line, killedPerLine);
+    }
+
+    @Override
+    public String getColorClass(final int line) {
+        if (getCovered(line) == 0) {
+            return NO_COVERAGE;
+        }
+        if (getKilled(line) == 0) {
+            return NO_COVERAGE;
+        }
+        else if (getSurvived(line) == 0) {
+            return FULL_COVERAGE;
+        }
+        else {
+            return PARTIAL_COVERAGE;
+        }
+    }
+
+    @Override
+    public String getTooltip(final int line) {
+        return StringUtils.defaultIfBlank(tooltipPerLine[findIndexOfLine(line)], super.getTooltip(line));
+    }
+
+    @Override
+    public String getSummaryColumn(final int line) {
+        var killed = getKilled(line);
+        var survived = getSurvived(line);
+        if (survived + killed > 0) {
+            return String.format("%d/%d", killed, survived + killed);
+        }
+        return String.valueOf(killed);
+    }
+}

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

@@ -0,0 +1,69 @@
+package io.jenkins.plugins.coverage.metrics.source;
+
+import java.io.Serializable;
+import java.util.Arrays;
+
+import edu.hm.hafner.coverage.FileNode;
+
+/**
+ * Provides all required information for a {@link FileNode} so that its source code can be rendered in HTML.
+ */
+abstract class PaintedNode implements Serializable {
+    private static final long serialVersionUID = -6044649044983631852L;
+
+    static final String NO_COVERAGE = "coverNone";
+    static final String FULL_COVERAGE = "coverFull";
+    static final String PARTIAL_COVERAGE = "coverPart";
+
+    private final String path;
+    private final int[] linesToPaint;
+    private final int[] coveredPerLine;
+
+    private final int[] missedPerLine;
+
+    PaintedNode(final FileNode file) {
+        path = file.getRelativePath();
+
+        linesToPaint = file.getLinesWithCoverage().stream().mapToInt(i -> i).toArray();
+        coveredPerLine = file.getCoveredCounters();
+        missedPerLine = file.getMissedCounters();
+    }
+
+    int size() {
+        return linesToPaint.length;
+    }
+
+    abstract String getColorClass(int line);
+
+    abstract String getTooltip(int line);
+
+    abstract String getSummaryColumn(int line);
+
+    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;
+    }
+}