org.apache.maven.shared.dependency.analyzer.DefaultProjectDependencyAnalyzer Maven / Gradle / Ivy
package org.apache.maven.shared.dependency.analyzer;
/*
* 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.
*/
import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Set;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.project.MavenProject;
import org.codehaus.plexus.component.annotations.Component;
import org.codehaus.plexus.component.annotations.Requirement;
/**
* @author Mark Hobson
* @version $Id$
*/
@Component( role = ProjectDependencyAnalyzer.class )
public class DefaultProjectDependencyAnalyzer
implements ProjectDependencyAnalyzer
{
// fields -----------------------------------------------------------------
/**
* ClassAnalyzer
*/
@Requirement
private ClassAnalyzer classAnalyzer;
/**
* DependencyAnalyzer
*/
@Requirement
private DependencyAnalyzer dependencyAnalyzer;
// ProjectDependencyAnalyzer methods --------------------------------------
/*
* @see org.apache.maven.shared.dependency.analyzer.ProjectDependencyAnalyzer#analyze(org.apache.maven.project.MavenProject)
*/
public ProjectDependencyAnalysis analyze( MavenProject project )
throws ProjectDependencyAnalyzerException
{
try
{
Map> artifactClassMap = buildArtifactClassMap( project );
Set dependencyClasses = buildDependencyClasses( project );
Set testOnlyDependencyClasses = buildTestDependencyClasses( project );
Set declaredArtifacts = buildDeclaredArtifacts( project );
Set usedArtifacts = buildUsedArtifacts( artifactClassMap, dependencyClasses );
Set testOnlyArtifacts = buildUsedArtifacts( artifactClassMap, testOnlyDependencyClasses );
Set usedDeclaredArtifacts = new LinkedHashSet( declaredArtifacts );
usedDeclaredArtifacts.retainAll( usedArtifacts );
Set usedUndeclaredArtifacts = new LinkedHashSet( usedArtifacts );
usedUndeclaredArtifacts = removeAll( usedUndeclaredArtifacts, declaredArtifacts );
Set unusedDeclaredArtifacts = new LinkedHashSet( declaredArtifacts );
unusedDeclaredArtifacts = removeAll( unusedDeclaredArtifacts, usedArtifacts );
Set testArtifactsWithNonTestScope = getTestArtifactsWithNonTestScope( testOnlyArtifacts );
return new ProjectDependencyAnalysis( usedDeclaredArtifacts, usedUndeclaredArtifacts,
unusedDeclaredArtifacts, testArtifactsWithNonTestScope );
}
catch ( IOException exception )
{
throw new ProjectDependencyAnalyzerException( "Cannot analyze dependencies", exception );
}
}
/**
* This method defines a new way to remove the artifacts by using the conflict id. We don't care about the version
* here because there can be only 1 for a given artifact anyway.
*
* @param start initial set
* @param remove set to exclude
* @return set with remove excluded
*/
private Set removeAll( Set start, Set remove )
{
Set results = new LinkedHashSet( start.size() );
for ( Artifact artifact : start )
{
boolean found = false;
for ( Artifact artifact2 : remove )
{
if ( artifact.getDependencyConflictId().equals( artifact2.getDependencyConflictId() ) )
{
found = true;
break;
}
}
if ( !found )
{
results.add( artifact );
}
}
return results;
}
private Set getTestArtifactsWithNonTestScope( Set testOnlyArtifacts )
{
Set nonTestScopeArtifacts = new LinkedHashSet();
for ( Artifact artifact : testOnlyArtifacts )
{
if ( !artifact.getScope().equals( "test" ) )
{
nonTestScopeArtifacts.add( artifact );
}
}
return nonTestScopeArtifacts;
}
private Map> buildArtifactClassMap( MavenProject project )
throws IOException
{
Map> artifactClassMap = new LinkedHashMap>();
@SuppressWarnings( "unchecked" )
Set dependencyArtifacts = project.getArtifacts();
for ( Artifact artifact : dependencyArtifacts )
{
File file = artifact.getFile();
if ( file != null && file.getName().endsWith( ".jar" ) )
{
// optimized solution for the jar case
JarFile jarFile = new JarFile( file );
try
{
Enumeration jarEntries = jarFile.entries();
Set classes = new HashSet();
while ( jarEntries.hasMoreElements() )
{
String entry = jarEntries.nextElement().getName();
if ( entry.endsWith( ".class" ) )
{
String className = entry.replace( '/', '.' );
className = className.substring( 0, className.length() - ".class".length() );
classes.add( className );
}
}
artifactClassMap.put( artifact, classes );
}
finally
{
try
{
jarFile.close();
}
catch ( IOException ignore )
{
// ingore
}
}
}
else if ( file != null && file.isDirectory() )
{
URL url = file.toURI().toURL();
Set classes = classAnalyzer.analyze( url );
artifactClassMap.put( artifact, classes );
}
}
return artifactClassMap;
}
private Set buildTestDependencyClasses( MavenProject project ) throws IOException
{
Set nonTestDependencyClasses = new HashSet<>();
Set testDependencyClasses = new HashSet<>();
Set testOnlyDependencyClasses = new HashSet<>();
String outputDirectory = project.getBuild().getOutputDirectory();
nonTestDependencyClasses.addAll( buildDependencyClasses( outputDirectory ) );
String testOutputDirectory = project.getBuild().getTestOutputDirectory();
testDependencyClasses.addAll( buildDependencyClasses( testOutputDirectory ) );
for ( String testString : testDependencyClasses )
{
if ( !nonTestDependencyClasses.contains( testString ) )
{
testOnlyDependencyClasses.add( testString );
}
}
return testOnlyDependencyClasses;
}
private Set buildDependencyClasses( MavenProject project )
throws IOException
{
Set dependencyClasses = new HashSet();
String outputDirectory = project.getBuild().getOutputDirectory();
dependencyClasses.addAll( buildDependencyClasses( outputDirectory ) );
String testOutputDirectory = project.getBuild().getTestOutputDirectory();
dependencyClasses.addAll( buildDependencyClasses( testOutputDirectory ) );
return dependencyClasses;
}
private Set buildDependencyClasses( String path )
throws IOException
{
URL url = new File( path ).toURI().toURL();
return dependencyAnalyzer.analyze( url );
}
private Set buildDeclaredArtifacts( MavenProject project )
{
@SuppressWarnings( "unchecked" )
Set declaredArtifacts = project.getDependencyArtifacts();
if ( declaredArtifacts == null )
{
declaredArtifacts = Collections.emptySet();
}
return declaredArtifacts;
}
private Set buildUsedArtifacts( Map> artifactClassMap,
Set dependencyClasses )
{
Set usedArtifacts = new HashSet();
for ( String className : dependencyClasses )
{
Artifact artifact = findArtifactForClassName( artifactClassMap, className );
if ( artifact != null )
{
usedArtifacts.add( artifact );
}
}
return usedArtifacts;
}
private Artifact findArtifactForClassName( Map> artifactClassMap, String className )
{
for ( Map.Entry> entry : artifactClassMap.entrySet() )
{
if ( entry.getValue().contains( className ) )
{
return entry.getKey();
}
}
return null;
}
}