fix: sonar exclusions (#52)

svaningelgem · web-flow · commit 8a83a170101b · 2025-07-10T11:12:31.000+02:00
* introducing sonar exclusions

* Adding configuration parameter to be able to skip including sonar patterns

* Fixing tests

* `SonarExclusions` fully under test now

* Trying to improve the test

* remove the debug log entries
diff --git a/jacoco-console-reporter/src/main/java/io/github/svaningelgem/JacocoConsoleReporterMojo.java b/jacoco-console-reporter/src/main/java/io/github/svaningelgem/JacocoConsoleReporterMojo.java
@@ -25,11 +25,7 @@
  * This plugin provides a simple way to view coverage metrics directly in the console
  * without needing to generate HTML or XML reports.
  */
-@Mojo(
-        name = "report",
-        defaultPhase = LifecyclePhase.VERIFY,
-        threadSafe = true
-)
+@Mojo(name = "report", defaultPhase = LifecyclePhase.VERIFY, threadSafe = true)
 public class JacocoConsoleReporterMojo extends AbstractMojo {
     private final Pattern PACKAGE_PATTERN = Pattern.compile("(?:^|\\*/)\\s*package\\s+([^;]+);", Pattern.DOTALL | Pattern.MULTILINE);
 
@@ -105,6 +101,12 @@ public class JacocoConsoleReporterMojo extends AbstractMojo {
     @Parameter(defaultValue = "true", property = "ignoreFilesInBuildDirectory")
     boolean ignoreFilesInBuildDirectory;
 
+    /**
+     * When true, ignore the files in the build directory. 99.9% of the time these are automatically generated files.
+     */
+    @Parameter(defaultValue = "true", property = "interpretSonarIgnorePatterns")
+    boolean interpretSonarIgnorePatterns;
+
     /**
      * Base directory for compiled output.
      */
@@ -139,6 +141,7 @@ public class JacocoConsoleReporterMojo extends AbstractMojo {
     static final Set<File> collectedExecFilePaths = new HashSet<>();
     static final Set<File> collectedClassesPaths = new HashSet<>();
     static final Set<Pattern> collectedExcludePatterns = new HashSet<>();
+    static final Set<SonarExclusionPattern> collectedSonarExcludePatterns = new HashSet<>();
 
     FileReader fileReader = new FileReader();
 
@@ -172,6 +175,7 @@ public void execute() throws MojoExecutionException {
     void loadExclusionPatterns() {
         addBuildDirExclusion();
         addJacocoExclusions();
+        addSonarExclusions();
     }
 
     /**
@@ -230,6 +234,46 @@ void addJacocoExclusions() {
         });
     }
 
+    /**
+     * Extracts exclusion patterns from Sonar properties
+     */
+    void addSonarExclusions() {
+        if (!interpretSonarIgnorePatterns) return;
+
+        // Check for Sonar exclusions in project properties
+        Properties projectProperties = project.getProperties();
+
+        // Handle sonar.exclusions (file-based patterns)
+        String sonarExclusions = projectProperties.getProperty("sonar.exclusions");
+        if (sonarExclusions != null && !sonarExclusions.trim().isEmpty()) {
+            addSonarFileExclusions(sonarExclusions);
+        }
+
+        // Handle sonar.coverage.exclusions (file-based patterns)
+        String sonarCoverageExclusions = projectProperties.getProperty("sonar.coverage.exclusions");
+        if (sonarCoverageExclusions != null && !sonarCoverageExclusions.trim().isEmpty()) {
+            addSonarFileExclusions(sonarCoverageExclusions);
+        }
+    }
+
+    /**
+     * Processes Sonar file-based exclusions and stores them for later evaluation
+     */
+    void addSonarFileExclusions(@NotNull String exclusions) {
+        String[] patterns = exclusions.split(",");
+        for (String pattern : patterns) {
+            pattern = pattern.trim();
+            if (pattern.isEmpty()) {
+                continue;
+            }
+
+            // Store the original pattern with project context for later evaluation
+            SonarExclusionPattern sonarPattern = new SonarExclusionPattern(pattern, project);
+            collectedSonarExcludePatterns.add(sonarPattern);
+            getLog().debug("Added Sonar file exclusion pattern: " + pattern);
+        }
+    }
+
     /**
      * Converts a JaCoCo exclude pattern to a Java regex Pattern
      * <p/>
@@ -247,17 +291,13 @@ Pattern convertExclusionToPattern(@NotNull String jacocoPattern) {
         }
 
         // Use temporary placeholders to avoid interference between replacements
-        String regex = jacocoPattern
-                .replace("**/", "__DOUBLE_STAR__") // Any directory
+        String regex = jacocoPattern.replace("**/", "__DOUBLE_STAR__") // Any directory
                 .replace("**", "__DOUBLE_STAR__") // Any directory
                 .replace("*", "__STAR__") // Any character (but not a directory)
                 .replace(".", "__DOT__");
 
         // Now perform the actual replacements
-        regex = regex
-                .replace("__DOUBLE_STAR__", "(?:[^/]*/)*")
-                .replace("__STAR__", "[^/]*")
-                .replace("__DOT__", "\\.");
+        regex = regex.replace("__DOUBLE_STAR__", "(?:[^/]*/)*").replace("__STAR__", "[^/]*").replace("__DOT__", "\\.");
 
         regex = "^" + regex + "$";
 
@@ -272,14 +312,34 @@ void addExclusion(@NotNull String jacocoPattern) {
     }
 
     /**
-     * Checks if a class should be excluded based on its name
+     * Checks if a class should be excluded based on its name and file path
      */
     boolean isExcluded(String className) {
-        if (collectedExcludePatterns.isEmpty()) {
-            return false;
+        return isExcluded(className, null);
+    }
+
+    /**
+     * Checks if a class should be excluded based on its name and optional file path
+     */
+    boolean isExcluded(String className, String filePath) {
+        // Check JaCoCo-style package exclusions
+        if (!collectedExcludePatterns.isEmpty()) {
+            if (collectedExcludePatterns.stream().anyMatch(p -> p.matcher(className).matches())) {
+                return true;
+            }
+        }
+
+        // Check Sonar-style file exclusions if we have a file path
+        if (filePath != null && !collectedSonarExcludePatterns.isEmpty()) {
+            for (SonarExclusionPattern sonarPattern : collectedSonarExcludePatterns) {
+                if (sonarPattern.matches(filePath, project)) {
+                    getLog().debug("Excluded by Sonar pattern '" + sonarPattern.getOriginalPattern() + "': " + filePath);
+                    return true;
+                }
+            }
         }
 
-        return collectedExcludePatterns.stream().anyMatch(p -> p.matcher(className).matches());
+        return false;
     }
 
     void generateReport() throws MojoExecutionException {
@@ -546,13 +606,21 @@ void printTree(@NotNull DirectoryNode root) {
     void buildDirectoryTreeAddNode(DirectoryNode root, @NotNull IPackageCoverage packageCoverage, @NotNull ISourceFileCoverage sourceFileCoverage) {
         String filename = sourceFileCoverage.getName();
         String className = filename.substring(0, filename.lastIndexOf('.'));
+        String packageName = packageCoverage.getName();
+        String classPath = packageName + "/" + className;
 
-        String p = packageCoverage.getName() + "/" + className;
-        if (isExcluded(p)) {
+        // Construct potential file paths for Sonar pattern matching
+        String javaFilePath = packageName.replace("/", "/") + "/" + filename;
+        String srcMainJavaPath = "src/main/java/" + javaFilePath;
+        String srcTestJavaPath = "src/test/java/" + javaFilePath;
+
+        // Check exclusions with both package-style and file-style paths
+        if (isExcluded(classPath) || isExcluded(classPath, javaFilePath) || isExcluded(classPath, srcMainJavaPath) || isExcluded(classPath, srcTestJavaPath)) {
+            getLog().debug("Excluded source file: " + javaFilePath);
             return;
         }
 
-        String[] pathComponents = packageCoverage.getName().split("/");
+        String[] pathComponents = packageName.split("/");
         DirectoryNode current = root;
         for (String component : pathComponents) {
             current = current.getSubdirectories().computeIfAbsent(component, DirectoryNode::new);
@@ -577,7 +645,6 @@ void buildDirectoryTreeAddNode(DirectoryNode root, @NotNull IPackageCoverage pac
         metrics.setCoveredBranches(sourceFileCoverage.getBranchCounter().getCoveredCount());
 
         current.getSourceFiles().add(new SourceFileNode(sourceFileName, metrics));
-
     }
 
     void buildDirectoryTreeAddNode(DirectoryNode root, @NotNull IPackageCoverage packageCoverage) {
diff --git a/jacoco-console-reporter/src/main/java/io/github/svaningelgem/SonarExclusionPattern.java b/jacoco-console-reporter/src/main/java/io/github/svaningelgem/SonarExclusionPattern.java
@@ -0,0 +1,119 @@
+package io.github.svaningelgem;
+
+import lombok.Data;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.maven.project.MavenProject;
+import org.jetbrains.annotations.NotNull;
+
+import java.io.File;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.regex.Pattern;
+
+/**
+ * Represents a Sonar exclusion pattern with its source project context
+ */
+@Data
+@RequiredArgsConstructor
+public class SonarExclusionPattern {
+    /**
+     * The original Sonar pattern (file-based)
+     */
+    private final String originalPattern;
+
+    /**
+     * The project this pattern was found in
+     */
+    private final MavenProject sourceProject;
+
+    /**
+     * Compiled regex pattern for matching
+     */
+    private Pattern compiledPattern;
+
+    /**
+     * Checks if a file path (relative to the source project) matches this exclusion pattern
+     */
+    public boolean matches(@NotNull String filePath, @NotNull MavenProject currentProject) {
+        if (compiledPattern == null) {
+            compiledPattern = compilePattern();
+        }
+
+        // Convert the file path to be relative to the source project if needed
+        String relativePath = getRelativePath(filePath, currentProject);
+
+        return compiledPattern.matcher(relativePath).matches();
+    }
+
+    /**
+     * Gets the file path relative to the source project
+     */
+    @NotNull String getRelativePath(@NotNull String filePath, @NotNull MavenProject currentProject) {
+        if (currentProject.equals(sourceProject)) {
+            return filePath;
+        }
+
+        try {
+            File sourceBaseDir = sourceProject.getBasedir();
+            File currentBaseDir = currentProject.getBasedir();
+
+            if (sourceBaseDir != null && currentBaseDir != null) {
+                Path sourcePath = sourceBaseDir.toPath();
+                Path currentPath = currentBaseDir.toPath();
+                Path relativePath = sourcePath.relativize(currentPath);
+
+                return relativePath.resolve(filePath).toString().replace('\\', '/');
+            }
+        } catch (Exception e) {
+            // Fall back to original path if relativization fails
+        }
+
+        return filePath;
+    }
+
+    /**
+     * Compiles the Sonar pattern into a regex Pattern
+     */
+    @NotNull Pattern compilePattern() {
+        String pattern = originalPattern.replace("\\", "/");
+
+        // Escape regex special characters except for our wildcards
+        pattern = pattern
+                .replace(".", "\\.")
+                .replace("(", "\\(")
+                .replace(")", "\\)")
+                .replace("[", "\\[")
+                .replace("]", "\\]")
+                .replace("{", "\\{")
+                .replace("}", "\\}")
+                .replace("^", "\\^")
+                .replace("$", "\\$")
+                .replace("+", "\\+")
+                .replace("|", "\\|");
+
+        // Handle wildcards with proper precedence - use placeholders to avoid interference
+        // First handle **/ (directory wildcard)
+        pattern = pattern.replace("**/", "__DOUBLE_STAR_SLASH__");
+
+        // Then handle trailing ** (matches everything remaining)
+        pattern = pattern.replaceAll("\\*\\*$", "__TRAILING_DOUBLE_STAR__");
+
+        // Handle remaining ** in the middle (treat as directory wildcard)
+        pattern = pattern.replace("**", "__DOUBLE_STAR_SLASH__");
+
+        // Handle single * (filename wildcard)
+        pattern = pattern.replace("*", "__STAR__");
+
+        // Convert placeholders to regex
+        pattern = pattern
+                .replace("__DOUBLE_STAR_SLASH__", "(?:[^/]*/)*")
+                .replace("__TRAILING_DOUBLE_STAR__", "(?:[^/]*/)*(?:[^/]*)")
+                .replace("__STAR__", "[^/]*");
+
+        // Anchor the pattern
+        pattern = "^" + pattern + "$";
+
+        return Pattern.compile(pattern);
+    }
+}
diff --git a/jacoco-console-reporter/src/test/java/io/github/svaningelgem/BaseTestClass.java b/jacoco-console-reporter/src/test/java/io/github/svaningelgem/BaseTestClass.java
@@ -93,6 +93,7 @@ public void setUp() throws Exception {
         mojo.weightBranchCoverage = 0.4;
         mojo.weightLineCoverage = 0.4;
         mojo.ignoreFilesInBuildDirectory = true;
+        mojo.interpretSonarIgnorePatterns = true;
         mojo.targetDir = new File(project.getBuild().getDirectory()).getCanonicalFile();
         mojo.baseDir = project.getBasedir();
 
@@ -105,6 +106,7 @@ public void tearDown() {
         JacocoConsoleReporterMojo.collectedClassesPaths.clear();
         JacocoConsoleReporterMojo.collectedExecFilePaths.clear();
         JacocoConsoleReporterMojo.collectedExcludePatterns.clear();
+        JacocoConsoleReporterMojo.collectedSonarExcludePatterns.clear();
     }
 
     private static int nextInt(int bound) {
@@ -129,6 +131,15 @@ private static int nextInt(int bound) {
         return cm;
     }
 
+    protected void assertLogNotContains(@NotNull String @NotNull [] expected) {
+        try {
+            assertLogContains(expected);
+        } catch (AssertionError e) {
+            return; // Good!
+        }
+
+        failLog(expected, "Expected log to NOT contain:");
+    }
     protected void assertLogContains(@NotNull String @NotNull [] expected) {
         assertTrue("Wrong test: we need SOMETHING to check!", expected.length > 0);
 
@@ -157,8 +168,12 @@ protected void assertLogContains(@NotNull String @NotNull [] expected) {
     }
 
     protected void failLog(String @NotNull [] expected) {
+        failLog(expected, "Expected log to contain:");
+    }
+
+    protected void failLog(String @NotNull [] expected, String message) {
         StringBuilder builder = new StringBuilder();
-        builder.append("Expected log to contain:\n");
+        builder.append(message).append('\n');
         for (String line : expected) {
             builder.append(line).append("\n");
         }
diff --git a/jacoco-console-reporter/src/test/java/io/github/svaningelgem/BuildDirectoryTreeExclusionTest.java b/jacoco-console-reporter/src/test/java/io/github/svaningelgem/BuildDirectoryTreeExclusionTest.java
@@ -71,14 +71,12 @@ public void testBuildDirectoryTreeWithExcludedFiles() throws Exception {
                 "[info] com.example        ",
                 "[info] └─IncludedClass.java"
         };
+        String[] notExpected = {
+                "[info] └─ExcludedClass.java"
+        };
 
         assertLogContains(expected);
-
-        // Verify that the excluded file is not in the log
-        for (String line : log.writtenData) {
-            assertFalse("Log should not contain ExcludedClass",
-                    line.contains("ExcludedClass") && !line.contains("Converted pattern"));
-        }
+        assertLogNotContains(notExpected);
     }
 
     /**
diff --git a/jacoco-console-reporter/src/test/java/io/github/svaningelgem/SonarExclusionsTest.java b/jacoco-console-reporter/src/test/java/io/github/svaningelgem/SonarExclusionsTest.java
