[MSHARED-1407] Track dependency usage by referencing classes (#125)

Author: jaredstehler

src/main/java/org/apache/maven/shared/dependency/analyzer/DefaultProjectDependencyAnalyzer.java

@@ -36,6 +36,7 @@
 import java.util.Set;
 import java.util.jar.JarEntry;
 import java.util.jar.JarFile;
+import java.util.stream.Collectors;
 
 import org.apache.maven.artifact.Artifact;
 import org.apache.maven.project.MavenProject;
@@ -68,17 +69,17 @@ public ProjectDependencyAnalysis analyze(MavenProject project, Collection<String
             ClassesPatterns excludedClassesPatterns = new ClassesPatterns(excludedClasses);
             Map<Artifact, Set<String>> artifactClassMap = buildArtifactClassMap(project, excludedClassesPatterns);
 
-            Set<String> mainDependencyClasses = buildMainDependencyClasses(project, excludedClassesPatterns);
-            Set<String> testDependencyClasses = buildTestDependencyClasses(project, excludedClassesPatterns);
+            Set<DependencyUsage> mainDependencyClasses = buildMainDependencyClasses(project, excludedClassesPatterns);
+            Set<DependencyUsage> testDependencyClasses = buildTestDependencyClasses(project, excludedClassesPatterns);
 
-            Set<String> dependencyClasses = new HashSet<>();
+            Set<DependencyUsage> dependencyClasses = new HashSet<>();
             dependencyClasses.addAll(mainDependencyClasses);
             dependencyClasses.addAll(testDependencyClasses);
 
-            Set<String> testOnlyDependencyClasses =
+            Set<DependencyUsage> testOnlyDependencyClasses =
                     buildTestOnlyDependencyClasses(mainDependencyClasses, testDependencyClasses);
 
-            Map<Artifact, Set<String>> usedArtifacts = buildUsedArtifacts(artifactClassMap, dependencyClasses);
+            Map<Artifact, Set<DependencyUsage>> usedArtifacts = buildUsedArtifacts(artifactClassMap, dependencyClasses);
             Set<Artifact> mainUsedArtifacts =
                     buildUsedArtifacts(artifactClassMap, mainDependencyClasses).keySet();
 
@@ -90,7 +91,7 @@ public ProjectDependencyAnalysis analyze(MavenProject project, Collection<String
             Set<Artifact> usedDeclaredArtifacts = new LinkedHashSet<>(declaredArtifacts);
             usedDeclaredArtifacts.retainAll(usedArtifacts.keySet());
 
-            Map<Artifact, Set<String>> usedUndeclaredArtifactsWithClasses = new LinkedHashMap<>(usedArtifacts);
+            Map<Artifact, Set<DependencyUsage>> usedUndeclaredArtifactsWithClasses = new LinkedHashMap<>(usedArtifacts);
             Set<Artifact> usedUndeclaredArtifacts =
                     removeAll(usedUndeclaredArtifactsWithClasses.keySet(), declaredArtifacts);
             usedUndeclaredArtifactsWithClasses.keySet().retainAll(usedUndeclaredArtifacts);
@@ -190,29 +191,33 @@ private Map<Artifact, Set<String>> buildArtifactClassMap(MavenProject project, C
         return artifactClassMap;
     }
 
-    private static Set<String> buildTestOnlyDependencyClasses(
-            Set<String> mainDependencyClasses, Set<String> testDependencyClasses) {
-        Set<String> testOnlyDependencyClasses = new HashSet<>(testDependencyClasses);
-        testOnlyDependencyClasses.removeAll(mainDependencyClasses);
+    private static Set<DependencyUsage> buildTestOnlyDependencyClasses(
+            Set<DependencyUsage> mainDependencyClasses, Set<DependencyUsage> testDependencyClasses) {
+        Set<DependencyUsage> testOnlyDependencyClasses = new HashSet<>(testDependencyClasses);
+        Set<String> mainDepClassNames = mainDependencyClasses.stream()
+                .map(DependencyUsage::getDependencyClass)
+                .collect(Collectors.toSet());
+        testOnlyDependencyClasses.removeIf(u -> mainDepClassNames.contains(u.getDependencyClass()));
         return testOnlyDependencyClasses;
     }
 
-    private Set<String> buildMainDependencyClasses(MavenProject project, ClassesPatterns excludedClasses)
+    private Set<DependencyUsage> buildMainDependencyClasses(MavenProject project, ClassesPatterns excludedClasses)
             throws IOException {
         String outputDirectory = project.getBuild().getOutputDirectory();
         return buildDependencyClasses(outputDirectory, excludedClasses);
     }
 
-    private Set<String> buildTestDependencyClasses(MavenProject project, ClassesPatterns excludedClasses)
+    private Set<DependencyUsage> buildTestDependencyClasses(MavenProject project, ClassesPatterns excludedClasses)
             throws IOException {
         String testOutputDirectory = project.getBuild().getTestOutputDirectory();
         return buildDependencyClasses(testOutputDirectory, excludedClasses);
     }
 
-    private Set<String> buildDependencyClasses(String path, ClassesPatterns excludedClasses) throws IOException {
+    private Set<DependencyUsage> buildDependencyClasses(String path, ClassesPatterns excludedClasses)
+            throws IOException {
         URL url = new File(path).toURI().toURL();
 
-        return dependencyAnalyzer.analyze(url, excludedClasses);
+        return dependencyAnalyzer.analyzeUsages(url, excludedClasses);
     }
 
     private static Set<Artifact> buildDeclaredArtifacts(MavenProject project) {
@@ -225,20 +230,20 @@ private static Set<Artifact> buildDeclaredArtifacts(MavenProject project) {
         return declaredArtifacts;
     }
 
-    private static Map<Artifact, Set<String>> buildUsedArtifacts(
-            Map<Artifact, Set<String>> artifactClassMap, Set<String> dependencyClasses) {
-        Map<Artifact, Set<String>> usedArtifacts = new HashMap<>();
+    private static Map<Artifact, Set<DependencyUsage>> buildUsedArtifacts(
+            Map<Artifact, Set<String>> artifactClassMap, Set<DependencyUsage> dependencyClasses) {
+        Map<Artifact, Set<DependencyUsage>> usedArtifacts = new HashMap<>();
 
-        for (String className : dependencyClasses) {
-            Artifact artifact = findArtifactForClassName(artifactClassMap, className);
+        for (DependencyUsage classUsage : dependencyClasses) {
+            Artifact artifact = findArtifactForClassName(artifactClassMap, classUsage.getDependencyClass());
 
             if (artifact != null) {
-                Set<String> classesFromArtifact = usedArtifacts.get(artifact);
+                Set<DependencyUsage> classesFromArtifact = usedArtifacts.get(artifact);
                 if (classesFromArtifact == null) {
                     classesFromArtifact = new HashSet<>();
                     usedArtifacts.put(artifact, classesFromArtifact);
                 }
-                classesFromArtifact.add(className);
+                classesFromArtifact.add(classUsage);
             }
         }
 

src/main/java/org/apache/maven/shared/dependency/analyzer/DependencyAnalyzer.java

@@ -21,6 +21,7 @@
 import java.io.IOException;
 import java.net.URL;
 import java.util.Set;
+import java.util.stream.Collectors;
 
 /**
  * Gets the set of classes referenced by a library given either as a jar file or an exploded directory.
@@ -48,5 +49,19 @@ default Set<String> analyze(URL url) throws IOException {
      * @return the set of class names referenced by the library
      * @throws IOException if an error occurs reading a JAR or .class file
      */
-    Set<String> analyze(URL url, ClassesPatterns excludeClasses) throws IOException;
+    default Set<String> analyze(URL url, ClassesPatterns excludeClasses) throws IOException {
+        return analyzeUsages(url, excludeClasses).stream()
+                .map(DependencyUsage::getDependencyClass)
+                .collect(Collectors.toSet());
+    }
+
+    /**
+     * <p>analyzeUsages.</p>
+     *
+     * @param url the JAR file or directory to analyze
+     * @return the set of class names referenced by the library, paired with the
+     * classes declaring those references.
+     * @throws IOException if an error occurs reading a JAR or .class file
+     */
+    Set<DependencyUsage> analyzeUsages(URL url, ClassesPatterns excludeClasses) throws IOException;
 }

src/main/java/org/apache/maven/shared/dependency/analyzer/DependencyUsage.java

@@ -0,0 +1,92 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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
+ *
+ *   http://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 org.apache.maven.shared.dependency.analyzer;
+
+/**
+ * Usage of a dependency class by a project class.
+ *
+ * @author <a href="mailto:[email protected]">Jonathan Haber</a>
+ */
+public class DependencyUsage {
+
+    private final String dependencyClass;
+
+    private final String usedBy;
+
+    public DependencyUsage(String dependencyClass, String usedBy) {
+        this.dependencyClass = dependencyClass;
+        this.usedBy = usedBy;
+    }
+
+    /**
+     * @return the dependency class used by the project class
+     */
+    public String getDependencyClass() {
+        return dependencyClass;
+    }
+
+    /**
+     * @return the project class using the dependency class
+     */
+    public String getUsedBy() {
+        return usedBy;
+    }
+
+    /*
+     * @see java.lang.Object#hashCode()
+     */
+    public int hashCode() {
+        int hashCode = dependencyClass.hashCode();
+        hashCode = (hashCode * 37) + usedBy.hashCode();
+
+        return hashCode;
+    }
+
+    /*
+     * @see java.lang.Object#equals(java.lang.Object)
+     */
+    public boolean equals(Object object) {
+        if (object instanceof DependencyUsage) {
+            DependencyUsage usage = (DependencyUsage) object;
+
+            return getDependencyClass().equals(usage.getDependencyClass())
+                    && getUsedBy().equals(usage.getUsedBy());
+        }
+
+        return false;
+    }
+
+    /*
+     * @see java.lang.Object#toString()
+     */
+    public String toString() {
+        StringBuilder buffer = new StringBuilder();
+
+        buffer.append("dependencyClass=").append(getDependencyClass());
+        buffer.append(",");
+        buffer.append("usedBy=").append(getUsedBy());
+
+        buffer.insert(0, "[");
+        buffer.insert(0, getClass().getName());
+
+        buffer.append("]");
+
+        return buffer.toString();
+    }
+}

src/main/java/org/apache/maven/shared/dependency/analyzer/ProjectDependencyAnalysis.java

@@ -26,6 +26,7 @@
 import java.util.LinkedHashSet;
 import java.util.Map;
 import java.util.Set;
+import java.util.stream.Collectors;
 
 import org.apache.maven.artifact.Artifact;
 
@@ -39,7 +40,7 @@ public class ProjectDependencyAnalysis {
 
     private final Set<Artifact> usedDeclaredArtifacts;
 
-    private final Map<Artifact, Set<String>> usedUndeclaredArtifacts;
+    private final Map<Artifact, Set<DependencyUsage>> usedUndeclaredArtifacts;
 
     private final Set<Artifact> unusedDeclaredArtifacts;
 
@@ -49,7 +50,7 @@ public class ProjectDependencyAnalysis {
      * <p>Constructor for ProjectDependencyAnalysis.</p>
      */
     public ProjectDependencyAnalysis() {
-        this(null, (Map<Artifact, Set<String>>) null, null, null);
+        this(null, (Map<Artifact, Set<DependencyUsage>>) null, null, null);
     }
 
     /**
@@ -88,7 +89,7 @@ public ProjectDependencyAnalysis(
 
     public ProjectDependencyAnalysis(
             Set<Artifact> usedDeclaredArtifacts,
-            Map<Artifact, Set<String>> usedUndeclaredArtifacts,
+            Map<Artifact, Set<DependencyUsage>> usedUndeclaredArtifacts,
             Set<Artifact> unusedDeclaredArtifacts,
             Set<Artifact> testArtifactsWithNonTestScope) {
         this.usedDeclaredArtifacts = safeCopy(usedDeclaredArtifacts);
@@ -121,6 +122,20 @@ public Set<Artifact> getUsedUndeclaredArtifacts() {
      * @return artifacts used but not declared
      */
     public Map<Artifact, Set<String>> getUsedUndeclaredArtifactsWithClasses() {
+        Map<Artifact, Set<String>> usedUndeclaredArtifactsWithClasses = new HashMap<>();
+
+        for (Map.Entry<Artifact, Set<DependencyUsage>> entry : usedUndeclaredArtifacts.entrySet()) {
+            usedUndeclaredArtifactsWithClasses.put(
+                    entry.getKey(),
+                    entry.getValue().stream()
+                            .map(DependencyUsage::getDependencyClass)
+                            .collect(Collectors.toSet()));
+        }
+
+        return usedUndeclaredArtifactsWithClasses;
+    }
+
+    public Map<Artifact, Set<DependencyUsage>> getUsedUndeclaredArtifactsWithUsages() {
         return safeCopy(usedUndeclaredArtifacts);
     }
 
@@ -294,29 +309,29 @@ private Set<Artifact> safeCopy(Set<Artifact> set) {
         return (set == null) ? Collections.emptySet() : Collections.unmodifiableSet(new LinkedHashSet<>(set));
     }
 
-    private static Map<Artifact, Set<String>> safeCopy(Map<Artifact, Set<String>> origMap) {
+    private static Map<Artifact, Set<DependencyUsage>> safeCopy(Map<Artifact, Set<DependencyUsage>> origMap) {
         if (origMap == null) {
             return Collections.emptyMap();
         }
 
-        Map<Artifact, Set<String>> map = new HashMap<>();
+        Map<Artifact, Set<DependencyUsage>> map = new HashMap<>();
 
-        for (Map.Entry<Artifact, Set<String>> e : origMap.entrySet()) {
+        for (Map.Entry<Artifact, Set<DependencyUsage>> e : origMap.entrySet()) {
             map.put(e.getKey(), Collections.unmodifiableSet(new LinkedHashSet<>(e.getValue())));
         }
 
         return map;
     }
 
-    private static Map<Artifact, Set<String>> mapWithKeys(Set<Artifact> keys) {
+    private static Map<Artifact, Set<DependencyUsage>> mapWithKeys(Set<Artifact> keys) {
         if (keys == null) {
             return Collections.emptyMap();
         }
 
-        Map<Artifact, Set<String>> map = new HashMap<>();
+        Map<Artifact, Set<DependencyUsage>> map = new HashMap<>();
 
         for (Artifact k : keys) {
-            map.put(k, Collections.<String>emptySet());
+            map.put(k, Collections.<DependencyUsage>emptySet());
         }
 
         return map;

src/main/java/org/apache/maven/shared/dependency/analyzer/asm/ASMDependencyAnalyzer.java

@@ -28,6 +28,7 @@
 import org.apache.maven.shared.dependency.analyzer.ClassFileVisitorUtils;
 import org.apache.maven.shared.dependency.analyzer.ClassesPatterns;
 import org.apache.maven.shared.dependency.analyzer.DependencyAnalyzer;
+import org.apache.maven.shared.dependency.analyzer.DependencyUsage;
 
 /**
  * ASMDependencyAnalyzer
@@ -39,11 +40,11 @@
 public class ASMDependencyAnalyzer implements DependencyAnalyzer {
 
     @Override
-    public Set<String> analyze(URL url, ClassesPatterns excludeClasses) throws IOException {
+    public Set<DependencyUsage> analyzeUsages(URL url, ClassesPatterns excludeClasses) throws IOException {
         DependencyClassFileVisitor visitor = new DependencyClassFileVisitor(excludeClasses);
 
         ClassFileVisitorUtils.accept(url, visitor);
 
-        return visitor.getDependencies();
+        return visitor.getDependencyUsages();
     }
 }

src/main/java/org/apache/maven/shared/dependency/analyzer/asm/DefaultAnnotationVisitor.java

@@ -31,34 +31,37 @@
 public class DefaultAnnotationVisitor extends AnnotationVisitor {
     private final ResultCollector resultCollector;
 
+    private final String usedByClass;
+
     /**
      * <p>Constructor for DefaultAnnotationVisitor.</p>
      *
      * @param resultCollector a {@link org.apache.maven.shared.dependency.analyzer.asm.ResultCollector} object.
      */
-    public DefaultAnnotationVisitor(ResultCollector resultCollector) {
+    public DefaultAnnotationVisitor(ResultCollector resultCollector, String usedByClass) {
         super(Opcodes.ASM9);
         this.resultCollector = resultCollector;
+        this.usedByClass = usedByClass;
     }
 
     /** {@inheritDoc} */
     @Override
     public void visit(final String name, final Object value) {
         if (value instanceof Type) {
-            resultCollector.addType((Type) value);
+            resultCollector.addType(usedByClass, (Type) value);
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public void visitEnum(final String name, final String desc, final String value) {
-        resultCollector.addDesc(desc);
+        resultCollector.addDesc(usedByClass, desc);
     }
 
     /** {@inheritDoc} */
     @Override
     public AnnotationVisitor visitAnnotation(final String name, final String desc) {
-        resultCollector.addDesc(desc);
+        resultCollector.addDesc(usedByClass, desc);
 
         return this;
     }