AbstractPluginMojo.java

package org.codehaus.mojo.minijar;

/*
 * Copyright 2005 The Apache Software Foundation.
 * 
 * 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
 * 
 *      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.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import org.apache.maven.artifact.Artifact;
import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.project.MavenProject;
import org.vafer.dependency.Clazzpath;
import org.vafer.dependency.ClazzpathUnit;

/**
 * Common class for the minijar mojos 
 */
public abstract class AbstractPluginMojo
    extends AbstractMojo
{
    /**
     * @parameter expression="${project}"
     * @required
     * @readonly
     */
    private MavenProject project;

    
    
    /**
     * @parameter expression="${project.build.directory}"
     * @required
     * @readonly
     */
    protected File buildDirectory;

    
    
    /**
     * If provided the default is to relocate no dependencies
     * but the ones specified. This parameter is mutual
     * exclusive to excludeDependenciesInRelocation.
     * 
     * @parameter expression="${includeDependenciesInRelocation}"
     */
    protected HashSet includeDependenciesInRelocation = null;

    /**
     * If provided the default is to relocate all dependencies
     * but exclude the ones specified. This parameter is mutual
     * exclusive to includeDependenciesInRelocation.
	 *
     * @parameter expression="${excludeDependenciesInRelocation}"
     */
    protected HashSet excludeDependenciesInRelocation = null;


    
    /**
     * If provided the default is to include no dependencies
     * but the ones specified. This parameter is mutual
     * exclusive to excludeDependencies.
     * 
     * @parameter expression="${includeDependencies}"
     */
    protected HashSet includeDependencies = null;

    /**
     * If provided the default is to include all dependencies
     * but remove the ones specified. This parameter is mutual
     * exclusive to includeDependencies.
	 *
     * @parameter expression="${excludeDependencies}"
     */
    protected HashSet excludeDependencies = null;
        
    
    
    /**
     * By default minijar will analyse the class dependencies and remove
     * classes that are not required for the execution of the project.
     * See the "keep.." parameters to explicitly override the behaviour
     * for classes or resource that only loaded via reflection or set
     * this parameter to false to turn off the magic.
     * 
     * @parameter expression="${stripUnusedClasses}" default-value="true"
     */
    protected boolean stripUnusedClasses;

    
    /**
     * Explicitly mark all classes from the specified artifacts to be
     * kept - no matter whether the analysis of minijar would suggest
     * to remove (some of) them.
     *  
     * @parameter expression="${keepUnusedClassesFromArtifacts}"
     */
    protected HashSet keepUnusedClassesFromArtifacts = new HashSet();
    
    /**
     * Explicitly mark classes matching the given patterns to be
     * kept - no matter whether the analysis of minijar suggests
     * otherwise.
     * 
     * @parameter expression="${keepUnusedClasses}"
     */
    protected HashSet keepUnusedClasses = new HashSet();

    
    protected MavenProject getProject()
    {
        if ( project.getExecutionProject() != null )
        {
            return project.getExecutionProject();
        }
        else
        {
            return project;
        }
    }
    
    /**
     * Substitute the variables in the given expression with the
     * values from the Map.
     * 
     * @param pVariables
     * @param pExpression
     * @return
     */
    protected String replaceVariables( final Map pVariables, final String pExpression )
    {
    	
    	final char[] s = pExpression.toCharArray();
    	
    	final char[] open = "[".toCharArray();
    	final char[] close = "]".toCharArray();
    	
    	final StringBuffer out = new StringBuffer();
    	StringBuffer sb = new StringBuffer();
    	char[] watch = open;
    	int w = 0;
    	for (int i = 0; i < s.length; i++)
    	{
			char c = s[i];
			
			if ( c == watch[w] )
			{
				w++;
				if (watch.length == w)
				{					
					if(watch == open)
					{
						// found open
						out.append( sb );						
						sb = new StringBuffer();
						watch = close;
					}
					else if ( watch == close )
					{
						// found close
						final String variable = (String) pVariables.get( sb.toString() ); 
						if ( variable != null )
						{
							out.append( variable );
						}
						else
						{
							getLog().error( "Unknown variable " + sb );
						}
						sb = new StringBuffer();
						watch = open;
					}					
					w = 0;
				}
			}
			else
			{				
				if  (w > 0 )
				{
					sb.append( watch, 0, w );
				}

				sb.append( c );
				
				w = 0;
			}
		}
    	
    	if ( watch == open )
    	{
    		out.append( sb );
    	}

    	return out.toString();    	
    }


    public boolean isInKeepUnusedClassesFromArtifacts( final Artifact artifact ) {
    	
    	final String id = artifact.getGroupId() + ":" + artifact.getArtifactId();

    	return keepUnusedClassesFromArtifacts.contains(id);
    }

    public boolean isInKeepUnusedClasses( final String clazzname ) {

    	// FIXME: do matching
    	
    	return keepUnusedClasses.contains(clazzname);
    }

    /**
     * Converts a Set of artifact id's into a Set of artifacts
     * @param artifacts
     * @param ids
     * @return null if no ids were given otherwise the Set of artifacts
     */
    private Set getArtifactsFromIds( final Set artifacts, final Set ids )
    {
    	if ( ids == null )
    	{
    		return null;
    	}
    	
    	final Set result = new HashSet();
    	
    	for ( Iterator it = artifacts.iterator(); it.hasNext(); )
    	{
			final Artifact artifact = (Artifact) it.next();
			
			final String id = artifact.getGroupId() + ":" + artifact.getArtifactId();
			
			if ( ids.contains( id ) )
			{
				result.add( artifact );
			}
		}
    	
    	return result;
    }
    
    
    private Set combine( final Set all, final Set included, final Set excluded, final Set defaults )
    {
    	final Set result = new HashSet();
    	
    	if ( excluded != null )
    	{
    		result.addAll(all);
    		result.removeAll(excluded);
    	}

    	if ( included != null )
    	{
    		result.addAll(included);
    	}

    	if ( excluded == null && included == null)
    	{
    		result.addAll(defaults);
    	}
    	
    	return result;
    }
    
    
    public abstract void execute( final Set removable, final Set dependencies, final Set relocateDependencies )
		throws MojoExecutionException;


    /**
     * Main entry point
     * @throws MojoExecutionException on error
     */
    public void execute()
        throws MojoExecutionException
    {
        final Set removable = new HashSet();

        /** START - THIS SHOULD NOT BE REQUIRED **/
        if ( excludeDependencies != null && excludeDependencies.size() == 0 )
        {
        	excludeDependencies = null;
        }
        if ( includeDependencies != null && includeDependencies.size() == 0 )
        {
        	includeDependencies = null;
        }
        if ( excludeDependenciesInRelocation != null && excludeDependenciesInRelocation.size() == 0 )
        {
        	excludeDependenciesInRelocation = null;
        }
        if ( includeDependenciesInRelocation != null && includeDependenciesInRelocation.size() == 0 )
        {
        	includeDependenciesInRelocation = null;
        }
        /** STOP - THIS SHOULD NOT BE REQUIRED **/
        
        if ( excludeDependencies != null && includeDependencies != null ) {
        	throw new MojoExecutionException( "Both parameters excludeDependencies and includeDependencies are mutual exclusive" );
        }

        if ( excludeDependenciesInRelocation != null && includeDependenciesInRelocation != null ) {
        	throw new MojoExecutionException( "Both parameters excludeDependenciesInRelocation and includeDependenciesInRelocation are mutual exclusive" );
        }

        final Set projectArtifacts = getProject().getArtifacts(); 
        
        final Set dependencies = combine(
        		projectArtifacts,
        		getArtifactsFromIds( projectArtifacts, includeDependencies ),
        		getArtifactsFromIds( projectArtifacts, excludeDependencies ),
        		projectArtifacts
        		);
        
        final Set relocateDependencies = combine(
        		projectArtifacts,
        		getArtifactsFromIds( projectArtifacts, includeDependenciesInRelocation ),
        		getArtifactsFromIds( projectArtifacts, excludeDependenciesInRelocation ),
        		projectArtifacts
        		);

        getLog().debug( "dependencies: " + dependencies );
        getLog().debug( "relocateDependencies: " + relocateDependencies );
        
        if ( stripUnusedClasses )
        {
            getLog().info( "Calculating transitive hull of class dependencies." );

            try
            {
                final Artifact projectArtifact = getProject().getArtifact();
                
                if ( projectArtifact == null )
                {
                    throw new MojoExecutionException( "No project artifact" );
                }
                
                final File projectArtifactFile = projectArtifact.getFile();
                
                if ( projectArtifactFile == null )
                {
                    throw new MojoExecutionException( "No project artifact file" );
                }
                
            	final Clazzpath clazzpath = new Clazzpath();
                final ClazzpathUnit jar = new ClazzpathUnit( clazzpath, projectArtifactFile.getAbsolutePath() );
            
                for ( Iterator i = project.getArtifacts().iterator(); i.hasNext(); )
                {
                    final Artifact dependency = (Artifact) i.next();
                    
                    if ( !dependencies.contains( dependency ) )
                    {
                    	getLog().info( "Ignoring " + dependency );
                    	continue;
                    }                    

                    new ClazzpathUnit( clazzpath, dependency.getFile().getAbsolutePath() );                    	
                }
            
                removable.addAll( clazzpath.getClazzes() );
                
                final int total = removable.size();
                
                removable.removeAll( jar.getClazzes() );
                removable.removeAll( jar.getTransitiveDependencies() );
                
                getLog().info( "Can remove " + removable.size() + " of " + total + " classes (" + (int) ( 100 * removable.size() / total ) + "%)." );                                

                //getLog().debug( "Can remove " + removable );                                

            }
            catch ( IOException e )
            {
                throw new MojoExecutionException( "Could not analyse classpath dependencies", e );
            }
        }

        execute( removable, dependencies, relocateDependencies );
    }

}