This is an automated email from the ASF dual-hosted git repository.
slachiewicz pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/maven-dependency-analyzer.git
The following commit(s) were added to refs/heads/master by this push:
new 1cabc68 Expose used dependency classes and candidate artifacts for
duplicate-class cases (#280) (#320)
1cabc68 is described below
commit 1cabc68aa316f52f19611490e1defc88fa3163b3
Author: Sylwester Lachiewicz <[email protected]>
AuthorDate: Tue Nov 10 19:43:40 2026 +0100
Expose used dependency classes and candidate artifacts for duplicate-class
cases (#280) (#320)
* Add proposal for duplicate-class visibility (#280)
Propose exposing raw used classes and candidate artifacts alongside
current single-artifact mapping, preserving existing analysis behavior.
* Expose used dependency classes and candidate artifacts (#280)
Record referenced dependency class names, all providing artifacts per
used class, and the selected artifact in ProjectDependencyAnalysis while
keeping existing used/unused artifact results unchanged.
* Move design notes from docs/ into PR description
---
.../analyzer/DefaultProjectDependencyAnalyzer.java | 50 +++++++-
.../analyzer/ProjectDependencyAnalysis.java | 142 ++++++++++++++++++++-
.../DefaultProjectDependencyAnalyzerTest.java | 34 +++++
.../analyzer/ProjectDependencyAnalysisTest.java | 50 ++++++++
4 files changed, 272 insertions(+), 4 deletions(-)
diff --git
a/src/main/java/org/apache/maven/shared/dependency/analyzer/DefaultProjectDependencyAnalyzer.java
b/src/main/java/org/apache/maven/shared/dependency/analyzer/DefaultProjectDependencyAnalyzer.java
index e903b52..f381112 100644
---
a/src/main/java/org/apache/maven/shared/dependency/analyzer/DefaultProjectDependencyAnalyzer.java
+++
b/src/main/java/org/apache/maven/shared/dependency/analyzer/DefaultProjectDependencyAnalyzer.java
@@ -170,9 +170,20 @@ public class DefaultProjectDependencyAnalyzer implements
ProjectDependencyAnalyz
Set<Artifact> testArtifactsWithNonTestScope =
getTestArtifactsWithNonTestScope(project, testOnlyArtifacts);
+ Set<String> usedDependencyClasses =
buildUsedDependencyClasses(dependencyClasses);
+ Map<String, Set<Artifact>> candidateArtifactsByUsedClass =
+ buildCandidateArtifactsByUsedClass(artifactClassMap,
usedDependencyClasses);
+ Map<String, Artifact> selectedArtifactByUsedClass =
+ buildSelectedArtifactByUsedClass(classToArtifactMap,
usedDependencyClasses);
+
return new ProjectDependencyAnalysis(
- usedDeclaredArtifactsWithClasses,
usedUndeclaredArtifactsWithClasses,
- unusedDeclaredArtifacts, testArtifactsWithNonTestScope);
+ usedDeclaredArtifactsWithClasses,
+ usedUndeclaredArtifactsWithClasses,
+ unusedDeclaredArtifacts,
+ testArtifactsWithNonTestScope,
+ usedDependencyClasses,
+ candidateArtifactsByUsedClass,
+ selectedArtifactByUsedClass);
} catch (IOException exception) {
throw new ProjectDependencyAnalyzerException("Cannot analyze
dependencies", exception);
}
@@ -472,6 +483,41 @@ public class DefaultProjectDependencyAnalyzer implements
ProjectDependencyAnalyz
return usedArtifacts;
}
+ static Set<String> buildUsedDependencyClasses(Set<DependencyUsage>
dependencyClasses) {
+ Set<String> usedDependencyClasses = new LinkedHashSet<>();
+ for (DependencyUsage usage : dependencyClasses) {
+ usedDependencyClasses.add(usage.getDependencyClass());
+ }
+ return usedDependencyClasses;
+ }
+
+ static Map<String, Set<Artifact>> buildCandidateArtifactsByUsedClass(
+ Map<Artifact, Set<String>> artifactClassMap, Set<String>
usedDependencyClasses) {
+ Map<String, Set<Artifact>> candidatesByClass = new LinkedHashMap<>();
+ for (String className : usedDependencyClasses) {
+ Set<Artifact> candidates = new LinkedHashSet<>();
+ for (Map.Entry<Artifact, Set<String>> entry :
artifactClassMap.entrySet()) {
+ if (entry.getValue().contains(className)) {
+ candidates.add(entry.getKey());
+ }
+ }
+ candidatesByClass.put(className, candidates);
+ }
+ return candidatesByClass;
+ }
+
+ static Map<String, Artifact> buildSelectedArtifactByUsedClass(
+ Map<String, Artifact> classToArtifactMap, Set<String>
usedDependencyClasses) {
+ Map<String, Artifact> selectedByClass = new LinkedHashMap<>();
+ for (String className : usedDependencyClasses) {
+ Artifact artifact = classToArtifactMap.get(className);
+ if (artifact != null) {
+ selectedByClass.put(className, artifact);
+ }
+ }
+ return selectedByClass;
+ }
+
/**
* Treats a declared artifact without classes of its own (for example
{@code junit-jupiter}, which only carries
* {@code module-info.class}) as used when one of the artifacts it brings
in directly is used. The used artifacts
diff --git
a/src/main/java/org/apache/maven/shared/dependency/analyzer/ProjectDependencyAnalysis.java
b/src/main/java/org/apache/maven/shared/dependency/analyzer/ProjectDependencyAnalysis.java
index 2132c3b..2579d31 100644
---
a/src/main/java/org/apache/maven/shared/dependency/analyzer/ProjectDependencyAnalysis.java
+++
b/src/main/java/org/apache/maven/shared/dependency/analyzer/ProjectDependencyAnalysis.java
@@ -47,6 +47,12 @@ public class ProjectDependencyAnalysis {
private final Set<Artifact> testArtifactsWithNonTestScope;
+ private final Set<String> usedDependencyClasses;
+
+ private final Map<String, Set<Artifact>> candidateArtifactsByUsedClass;
+
+ private final Map<String, Artifact> selectedArtifactByUsedClass;
+
/**
* <p>Constructor for ProjectDependencyAnalysis.</p>
*/
@@ -101,10 +107,43 @@ public class ProjectDependencyAnalysis {
Map<Artifact, Set<DependencyUsage>> usedUndeclaredArtifacts,
Set<Artifact> unusedDeclaredArtifacts,
Set<Artifact> testArtifactsWithNonTestScope) {
+ this(
+ usedDeclaredArtifacts,
+ usedUndeclaredArtifacts,
+ unusedDeclaredArtifacts,
+ testArtifactsWithNonTestScope,
+ null,
+ null,
+ null);
+ }
+
+ /**
+ * Creates an analysis result with usage details, raw used classes and
candidate artifacts.
+ *
+ * @param usedDeclaredArtifacts artifacts both used and declared
+ * @param usedUndeclaredArtifacts artifacts used but not declared
+ * @param unusedDeclaredArtifacts artifacts declared but not used
+ * @param testArtifactsWithNonTestScope artifacts only used in tests but
not declared with test scope
+ * @param usedDependencyClasses dependency class names referenced by the
analyzed bytecode
+ * @param candidateArtifactsByUsedClass candidate artifacts that provide
each used dependency class
+ * @param selectedArtifactByUsedClass artifact selected for each used
dependency class
+ * @since 1.18.0
+ */
+ public ProjectDependencyAnalysis(
+ Map<Artifact, Set<DependencyUsage>> usedDeclaredArtifacts,
+ Map<Artifact, Set<DependencyUsage>> usedUndeclaredArtifacts,
+ Set<Artifact> unusedDeclaredArtifacts,
+ Set<Artifact> testArtifactsWithNonTestScope,
+ Set<String> usedDependencyClasses,
+ Map<String, Set<Artifact>> candidateArtifactsByUsedClass,
+ Map<String, Artifact> selectedArtifactByUsedClass) {
this.usedDeclaredArtifacts = safeCopy(usedDeclaredArtifacts);
this.usedUndeclaredArtifacts = safeCopy(usedUndeclaredArtifacts);
this.unusedDeclaredArtifacts = safeCopy(unusedDeclaredArtifacts);
this.testArtifactsWithNonTestScope =
safeCopy(testArtifactsWithNonTestScope);
+ this.usedDependencyClasses = safeCopyStrings(usedDependencyClasses);
+ this.candidateArtifactsByUsedClass =
safeCopyStringArtifactSetMap(candidateArtifactsByUsedClass);
+ this.selectedArtifactByUsedClass =
safeCopyStringArtifactMap(selectedArtifactByUsedClass);
}
/**
@@ -180,6 +219,70 @@ public class ProjectDependencyAnalysis {
return safeCopy(testArtifactsWithNonTestScope);
}
+ /**
+ * Returns dependency class names referenced by the analyzed bytecode.
+ *
+ * @return dependency class names referenced by the analyzed bytecode
+ * @since 1.18.0
+ */
+ public Set<String> getUsedDependencyClasses() {
+ return safeCopyStrings(usedDependencyClasses);
+ }
+
+ /**
+ * Returns the artifacts that provide each referenced dependency class.
+ *
+ * @return candidate artifacts per referenced dependency class
+ * @since 1.18.0
+ */
+ public Map<String, Set<Artifact>> getCandidateArtifactsByUsedClass() {
+ return safeCopyStringArtifactSetMap(candidateArtifactsByUsedClass);
+ }
+
+ /**
+ * Returns the artifact selected for each referenced dependency class.
+ *
+ * @return selected artifact per referenced dependency class
+ * @since 1.18.0
+ */
+ public Map<String, Artifact> getSelectedArtifactByUsedClass() {
+ return safeCopyStringArtifactMap(selectedArtifactByUsedClass);
+ }
+
+ /**
+ * Returns referenced dependency classes provided by more than one
artifact.
+ *
+ * @return ambiguous referenced dependency classes
+ * @since 1.18.0
+ */
+ public Set<String> getAmbiguousUsedDependencyClasses() {
+ Set<String> ambiguous = new LinkedHashSet<>();
+ for (Map.Entry<String, Set<Artifact>> entry :
candidateArtifactsByUsedClass.entrySet()) {
+ if (entry.getValue().size() > 1) {
+ ambiguous.add(entry.getKey());
+ }
+ }
+ return Collections.unmodifiableSet(ambiguous);
+ }
+
+ /**
+ * Returns referenced dependency classes that could not be mapped to any
dependency artifact.
+ *
+ * @return unmapped referenced dependency classes
+ * @since 1.18.0
+ */
+ public Set<String> getUnmappedUsedDependencyClasses() {
+ Set<String> unmapped = new LinkedHashSet<>();
+ for (String className : usedDependencyClasses) {
+ if (candidateArtifactsByUsedClass
+ .getOrDefault(className, Collections.emptySet())
+ .isEmpty()) {
+ unmapped.add(className);
+ }
+ }
+ return Collections.unmodifiableSet(unmapped);
+ }
+
/**
* Filter non-compile scoped artifacts from unused declared.
*
@@ -191,7 +294,13 @@ public class ProjectDependencyAnalysis {
filteredUnusedDeclared.removeIf(artifact ->
!artifact.getScope().equals(Artifact.SCOPE_COMPILE));
return new ProjectDependencyAnalysis(
- usedDeclaredArtifacts, usedUndeclaredArtifacts,
filteredUnusedDeclared, testArtifactsWithNonTestScope);
+ usedDeclaredArtifacts,
+ usedUndeclaredArtifacts,
+ filteredUnusedDeclared,
+ testArtifactsWithNonTestScope,
+ usedDependencyClasses,
+ candidateArtifactsByUsedClass,
+ selectedArtifactByUsedClass);
}
/**
@@ -250,7 +359,10 @@ public class ProjectDependencyAnalysis {
mapWithKeys(forcedUsedDeclared),
usedUndeclaredArtifacts,
forcedUnusedDeclared,
- testArtifactsWithNonTestScope);
+ testArtifactsWithNonTestScope,
+ usedDependencyClasses,
+ candidateArtifactsByUsedClass,
+ selectedArtifactByUsedClass);
}
/**
@@ -334,6 +446,10 @@ public class ProjectDependencyAnalysis {
return (set == null) ? Collections.emptySet() :
Collections.unmodifiableSet(new LinkedHashSet<>(set));
}
+ private static Set<String> safeCopyStrings(Set<String> set) {
+ return (set == null) ? Collections.emptySet() :
Collections.unmodifiableSet(new LinkedHashSet<>(set));
+ }
+
private static Map<Artifact, Set<DependencyUsage>> safeCopy(Map<Artifact,
Set<DependencyUsage>> origMap) {
if (origMap == null) {
return Collections.emptyMap();
@@ -348,6 +464,28 @@ public class ProjectDependencyAnalysis {
return map;
}
+ private static Map<String, Set<Artifact>>
safeCopyStringArtifactSetMap(Map<String, Set<Artifact>> origMap) {
+ if (origMap == null) {
+ return Collections.emptyMap();
+ }
+
+ Map<String, Set<Artifact>> map = new LinkedHashMap<>();
+
+ for (Map.Entry<String, Set<Artifact>> e : origMap.entrySet()) {
+ map.put(e.getKey(), Collections.unmodifiableSet(new
LinkedHashSet<>(e.getValue())));
+ }
+
+ return map;
+ }
+
+ private static Map<String, Artifact> safeCopyStringArtifactMap(Map<String,
Artifact> origMap) {
+ if (origMap == null) {
+ return Collections.emptyMap();
+ }
+
+ return Collections.unmodifiableMap(new LinkedHashMap<>(origMap));
+ }
+
private static Map<Artifact, Set<DependencyUsage>>
mapWithKeys(Set<Artifact> keys) {
if (keys == null) {
return Collections.emptyMap();
diff --git
a/src/test/java/org/apache/maven/shared/dependency/analyzer/DefaultProjectDependencyAnalyzerTest.java
b/src/test/java/org/apache/maven/shared/dependency/analyzer/DefaultProjectDependencyAnalyzerTest.java
index d9c5f22..c56730a 100644
---
a/src/test/java/org/apache/maven/shared/dependency/analyzer/DefaultProjectDependencyAnalyzerTest.java
+++
b/src/test/java/org/apache/maven/shared/dependency/analyzer/DefaultProjectDependencyAnalyzerTest.java
@@ -498,4 +498,38 @@ class DefaultProjectDependencyAnalyzerTest {
private Artifact aTestArtifact(String groupId, String artifactId, String
scope) {
return new DefaultArtifact(groupId, artifactId,
VersionRange.createFromVersion("1.0"), scope, "jar", "", null);
}
+
+ @Test
+ void buildCandidateArtifactsByUsedClassShouldReturnAllProviders() {
+ Artifact first = aTestArtifact("first");
+ Artifact second = aTestArtifact("second");
+
+ Map<Artifact, Set<String>> artifactClassMap = new LinkedHashMap<>();
+ artifactClassMap.put(first, Collections.singleton("com.example.Cls"));
+ artifactClassMap.put(second, Collections.singleton("com.example.Cls"));
+
+ Set<String> used = Collections.singleton("com.example.Cls");
+ Map<String, Set<Artifact>> candidates =
+
DefaultProjectDependencyAnalyzer.buildCandidateArtifactsByUsedClass(artifactClassMap,
used);
+
+ assertThat(candidates.get("com.example.Cls")).containsExactly(first,
second);
+ }
+
+ @Test
+ void buildSelectedArtifactByUsedClassShouldKeepSelectedProvider() {
+ Artifact first = aTestArtifact("first");
+ Artifact second = aTestArtifact("second");
+
+ Map<Artifact, Set<String>> artifactClassMap = new LinkedHashMap<>();
+ artifactClassMap.put(first, Collections.singleton("com.example.Cls"));
+ artifactClassMap.put(second, Collections.singleton("com.example.Cls"));
+
+ Set<String> used = Collections.singleton("com.example.Cls");
+ Map<String, Artifact> classToArtifactMap =
+
DefaultProjectDependencyAnalyzer.buildClassToArtifactMap(artifactClassMap);
+ Map<String, Artifact> selected =
+
DefaultProjectDependencyAnalyzer.buildSelectedArtifactByUsedClass(classToArtifactMap,
used);
+
+ assertThat(selected.get("com.example.Cls")).isEqualTo(first);
+ }
}
diff --git
a/src/test/java/org/apache/maven/shared/dependency/analyzer/ProjectDependencyAnalysisTest.java
b/src/test/java/org/apache/maven/shared/dependency/analyzer/ProjectDependencyAnalysisTest.java
index d0f9b18..d8deacd 100644
---
a/src/test/java/org/apache/maven/shared/dependency/analyzer/ProjectDependencyAnalysisTest.java
+++
b/src/test/java/org/apache/maven/shared/dependency/analyzer/ProjectDependencyAnalysisTest.java
@@ -19,7 +19,10 @@
package org.apache.maven.shared.dependency.analyzer;
import java.util.Arrays;
+import java.util.Collections;
import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.Map;
import java.util.Set;
import org.apache.maven.artifact.Artifact;
@@ -75,6 +78,53 @@ class ProjectDependencyAnalysisTest {
assertThat(compileOnlyAnalysis.getTestArtifactsWithNonTestScope()).hasSize(3);
}
+ @Test
+ void shouldExposeUsedClassesAndCandidateArtifacts() {
+ Artifact declared = aTestArtifact("declared", Artifact.SCOPE_COMPILE);
+ Artifact other = aTestArtifact("other", Artifact.SCOPE_COMPILE);
+ Set<String> used = new HashSet<>(Arrays.asList("a.B", "c.D"));
+ Map<String, Set<Artifact>> candidates = new
java.util.LinkedHashMap<>();
+ candidates.put("a.B", new LinkedHashSet<>(Arrays.asList(declared,
other)));
+ candidates.put("c.D", new
LinkedHashSet<>(Collections.singleton(declared)));
+ Map<String, Artifact> selected = new java.util.LinkedHashMap<>();
+ selected.put("a.B", declared);
+ selected.put("c.D", declared);
+
+ ProjectDependencyAnalysis analysis = new ProjectDependencyAnalysis(
+ Collections.emptyMap(),
+ Collections.emptyMap(),
+ Collections.emptySet(),
+ Collections.emptySet(),
+ used,
+ candidates,
+ selected);
+
+
assertThat(analysis.getUsedDependencyClasses()).containsExactlyInAnyOrder("a.B",
"c.D");
+
assertThat(analysis.getCandidateArtifactsByUsedClass().get("a.B")).containsExactly(declared,
other);
+
assertThat(analysis.getSelectedArtifactByUsedClass().get("a.B")).isEqualTo(declared);
+
assertThat(analysis.getAmbiguousUsedDependencyClasses()).containsExactly("a.B");
+ assertThat(analysis.getUnmappedUsedDependencyClasses()).isEmpty();
+ }
+
+ @Test
+ void shouldReportUnmappedUsedDependencyClasses() {
+ Set<String> used = new HashSet<>(Collections.singletonList("a.B"));
+ Map<String, Set<Artifact>> candidates = new
java.util.LinkedHashMap<>();
+ candidates.put("a.B", Collections.emptySet());
+
+ ProjectDependencyAnalysis analysis = new ProjectDependencyAnalysis(
+ Collections.emptyMap(),
+ Collections.emptyMap(),
+ Collections.emptySet(),
+ Collections.emptySet(),
+ used,
+ candidates,
+ Collections.emptyMap());
+
+
assertThat(analysis.getUnmappedUsedDependencyClasses()).containsExactly("a.B");
+
assertThat(analysis.getSelectedArtifactByUsedClass()).doesNotContainKey("a.B");
+ }
+
private <T> Set<T> asSet(T... items) {
return new HashSet<>(Arrays.asList(items));
}