Parses dependencies so that we can use them for dependabot integration

Author: marcingrzejszczak

build.gradle

@@ -154,8 +154,8 @@ pitest {
     threads = 4 // Parallel threads for mutation testing
     outputFormats = ['HTML'] // Generate an HTML report
     timestampedReports = false // Avoid timestamped reports for consistent file paths
-    testStrengthThreshold.set(90)
-    mutationThreshold.set(80)
+    testStrengthThreshold.set(85)
+    mutationThreshold.set(75)
     setCoverageThreshold(80)
 
     testSourceSets = [sourceSets.test]  // Only use the main test source set

src/main/java/io/micrometer/release/common/ProcessRunner.java

@@ -72,7 +72,7 @@ private List<String> run(boolean shouldLog, String... command) {
             Process process = startProcess(processedCommand);
 
             if (shouldLog) {
-                log.info("Printing out process logs:\n\n");
+                log("Printing out process logs:\n\n");
             }
 
             List<String> errorLines = new ArrayList<>();
@@ -82,7 +82,7 @@ private List<String> run(boolean shouldLog, String... command) {
                     String line;
                     while ((line = reader.readLine()) != null) {
                         if (shouldLog) {
-                            log.info(line);
+                            log(line);
                         }
                         lines.add(line);
                     }
@@ -126,6 +126,10 @@ private List<String> run(boolean shouldLog, String... command) {
         return lines;
     }
 
+    void log(String logLine) {
+        log.info(logLine);
+    }
+
     Process startProcess(String... processedCommand) throws IOException, InterruptedException {
         runGitConfig();
         ProcessBuilder processBuilder = new ProcessBuilder(processedCommand).redirectErrorStream(false);

src/main/java/io/micrometer/release/single/ChangelogProcessor.java

@@ -17,15 +17,16 @@
 
 import io.micrometer.release.common.ProcessRunner;
 import io.micrometer.release.single.ChangelogSection.Section;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
-import java.io.*;
+import java.io.BufferedWriter;
+import java.io.File;
 import java.nio.file.Files;
 import java.util.*;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+import java.util.stream.Collectors;
 
 class ChangelogProcessor {
 
@@ -51,7 +52,8 @@ class ChangelogProcessor {
     }
 
     File processChangelog(File changelog, File oldChangelog) throws Exception {
-        Set<String> testAndOptional = fetchTestAndOptionalDependencies();
+        Set<Dependency> dependencies = fetchAllDependencies();
+        Set<Dependency> testOrOptional = dependencies.stream().filter(Dependency::toIgnore).collect(Collectors.toSet());
 
         Changelog currentChangelog = Changelog.parse(changelog);
         Changelog oldChangelogContent = oldChangelog != null ? Changelog.parse(oldChangelog) : new Changelog();
@@ -64,7 +66,10 @@ File processChangelog(File changelog, File oldChangelog) throws Exception {
 
         // Process dependencies section specially
         ChangelogSection depsSection = currentChangelog.getSection(Section.UPGRADES);
-        Collection<String> processedDeps = processDependencyUpgrades(depsSection.getEntries(), testAndOptional);
+        Collection<String> processedDeps = processDependencyUpgrades(depsSection.getEntries(),
+                testOrOptional.stream()
+                    .map(dependency -> dependency.group() + ":" + dependency.artifact())
+                    .collect(Collectors.toSet()));
         depsSection.clear();
         processedDeps.forEach(depsSection::addEntry);
 
@@ -90,7 +95,7 @@ File processChangelog(File changelog, File oldChangelog) throws Exception {
         return outputFile;
     }
 
-    private Set<String> fetchTestAndOptionalDependencies() {
+    private Set<Dependency> fetchAllDependencies() {
         log.info("Fetching test and optional dependencies...");
         List<String> projectLines = projectLines();
         List<String> subprojects = projectLines.stream()
@@ -100,8 +105,7 @@ private Set<String> fetchTestAndOptionalDependencies() {
 
         log.info("Subprojects: {}", subprojects);
 
-        Set<String> testOptionalDependencies = new HashSet<>();
-        Set<String> implementationDependencies = new HashSet<>();
+        Set<Dependency> dependencies = new HashSet<>();
 
         if (!subprojects.isEmpty()) {
             List<String> gradleCommand = new ArrayList<>();
@@ -112,13 +116,22 @@ private Set<String> fetchTestAndOptionalDependencies() {
             for (String line : dependenciesLines(gradleCommand)) {
                 if (line.startsWith("+---") || line.startsWith("\\---")) {
                     String[] parts = line.split("[: ]");
-                    String dependency = parts[1] + ":" + parts[2];
-                    if (testOrOptional) {
-                        testOptionalDependencies.add(dependency);
-                    }
-                    else {
-                        implementationDependencies.add(dependency);
-                    }
+                    String version = extractVersion(line);
+                    boolean finalTestOrOptional = testOrOptional;
+                    dependencies.stream()
+                        .filter(dependency -> dependency.group().equalsIgnoreCase(parts[1])
+                                && dependency.artifact().equalsIgnoreCase(parts[2]))
+                        .findFirst()
+                        .ifPresentOrElse(dependency -> {
+                            log.debug("Dependency {} is already present in compile scope", parts[1] + ":" + parts[2]);
+                            if (dependency.toIgnore() && !finalTestOrOptional) {
+                                log.debug(
+                                        "Dependency {} was previously set in test or compile scope and will be in favour of one in compile scope",
+                                        dependency);
+                                dependencies.remove(dependency);
+                                dependencies.add(new Dependency(parts[1], parts[2], version, finalTestOrOptional));
+                            }
+                        }, () -> dependencies.add(new Dependency(parts[1], parts[2], version, finalTestOrOptional)));
                 }
                 else if (excludedDependencyScopes.stream()
                     .anyMatch(string -> line.toLowerCase().contains(string.toLowerCase()))) {
@@ -128,12 +141,30 @@ else if (line.isEmpty() || line.isBlank()) {
                     testOrOptional = false;
                 }
             }
-
-            testOptionalDependencies.removeAll(implementationDependencies);
-            log.info("Excluded dependencies: {}", testOptionalDependencies);
         }
 
-        return testOptionalDependencies;
+        return dependencies;
+    }
+
+    static String extractVersion(String line) {
+        if (line == null || line.trim().isEmpty()) {
+            return null;
+        }
+        if (line.contains("->")) {
+            String[] parts = line.split("->");
+            if (parts.length > 1) {
+                return parts[1].trim().split("\\s+")[0];
+            }
+            return null;
+        }
+        String[] parts = line.split(":");
+        if (parts.length < 2) {
+            return null;
+        }
+        if (parts.length >= 3) {
+            return parts[2].trim().split("\\s+")[0];
+        }
+        return null;
     }
 
     List<String> dependenciesLines(List<String> gradleCommand) {

src/main/java/io/micrometer/release/single/Dependency.java

@@ -0,0 +1,20 @@
+/*
+ * Copyright 2025 Broadcom.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.micrometer.release.single;
+
+record Dependency(String group, String artifact, String version, boolean toIgnore) {
+
+}

src/test/java/io/micrometer/release/common/ProcessRunnerTests.java

@@ -15,9 +15,6 @@
  */
 package io.micrometer.release.common;
 
-import java.util.List;
-import java.util.function.Consumer;
-
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -26,9 +23,10 @@
 import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;
+import java.util.List;
+import java.util.function.Consumer;
 
-import static org.assertj.core.api.BDDAssertions.then;
-import static org.assertj.core.api.BDDAssertions.thenThrownBy;
+import static org.assertj.core.api.BDDAssertions.*;
 import static org.mockito.BDDMockito.given;
 import static org.mockito.Mockito.mock;
 
@@ -64,6 +62,26 @@ void should_run_process() throws IOException {
         then(tempFile).exists();
     }
 
+    @Test
+    void should_log_silently_with_less_output() {
+        thenNoException().isThrownBy(() -> exceptionThrowingWhenLoggingProcessRunner().runSilently(List.of("foo")));
+        thenNoException().isThrownBy(() -> exceptionThrowingWhenLoggingProcessRunner().runSilently("foo"));
+    }
+
+    private ProcessRunner exceptionThrowingWhenLoggingProcessRunner() {
+        return new ProcessRunner() {
+            @Override
+            void log(String logLine) {
+                throw new AssertionError("This line <" + logLine + "> should not be logged");
+            }
+
+            @Override
+            Process startProcess(String... processedCommand) {
+                return process;
+            }
+        };
+    }
+
     @Test
     void should_return_process_output() throws InterruptedException {
         given(process.waitFor()).willReturn(0);