DependencyCollector.java

package com.simpligility.maven.plugins.android.common;

import org.apache.maven.artifact.Artifact;
import org.apache.maven.shared.dependency.graph.DependencyNode;
import org.codehaus.plexus.logging.Logger;

import java.util.Collections;
import java.util.HashSet;
import java.util.Set;

/**
 * Filters a graph of Artifacts and transforms it into a Set.
 */
final class DependencyCollector
{
    private final Logger log;
    private final Set<Artifact> dependencies = new HashSet<Artifact>();
    private final Artifact target;

    /**
     * @param logger    Logger on which to output and messages.
     * @param target    Artifact from which we will start collecting.
     */
    DependencyCollector( Logger logger, Artifact target )
    {
        this.log = logger;
        this.target = target;
    }

    /**
     * Visits all nodes from the given node and collects dependencies.
     *
     * @param node          DependencyNode from which to search.
     * @param collecting    Whether we are currently collecting artifacts.
     */
    public void visit( DependencyNode node, boolean collecting )
    {
        if ( collecting )
        {
            dependencies.add( node.getArtifact() );
        }

        if ( matchesTarget( node.getArtifact() ) )
        {
            collecting = true;
            log.debug( "Found target. Collecting dependencies after " + node.getArtifact() );
        }

        for ( final DependencyNode child : node.getChildren() )
        {
            visit( child, collecting );
        }
    }

    public Set<Artifact> getDependencies()
    {
        return Collections.unmodifiableSet( dependencies );
    }

    private boolean matchesTarget( Artifact found )
    {
        return found.getGroupId().equals( target.getGroupId() )
                && found.getArtifactId().equals( target.getArtifactId() )
                && found.getVersion().equals( target.getVersion() )
                && found.getType().equals( target.getType() )
                && classifierMatch( found.getClassifier(), target.getClassifier() )
                ;
    }

    private boolean classifierMatch( String classifierA, String classifierB )
    {
        final boolean hasClassifierA = !isNullOrEmpty( classifierA );
        final boolean hasClassifierB = !isNullOrEmpty( classifierB );
        if ( !hasClassifierA && !hasClassifierB )
        {
            return true;
        }
        else if ( hasClassifierA && hasClassifierB )
        {
            return classifierA.equals( classifierB );
        }
        return false;
    }

    private boolean isNullOrEmpty( String string )
    {
        return ( string == null ) || string.isEmpty();
    }
}