package org.apache.maven.plugin.dependency;

 /*

  * 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 org.apache.maven.artifact.Artifact;

 import org.apache.maven.artifact.ArtifactUtils;

 import org.apache.maven.artifact.factory.ArtifactFactory;

 import org.apache.maven.artifact.metadata.ArtifactMetadataSource;

 import org.apache.maven.artifact.repository.ArtifactRepository;

 import org.apache.maven.artifact.resolver.ArtifactNotFoundException;

 import org.apache.maven.artifact.resolver.ArtifactResolutionException;

 import org.apache.maven.artifact.resolver.ArtifactResolutionResult;

 import org.apache.maven.artifact.resolver.ArtifactResolver;

 import org.apache.maven.artifact.resolver.filter.ArtifactFilter;

 import org.apache.maven.artifact.versioning.VersionRange;

 import org.apache.maven.model.Dependency;

 import org.apache.maven.plugin.AbstractMojo;

 import org.apache.maven.plugin.MojoExecutionException;

 import org.apache.maven.plugin.MojoFailureException;

 import org.apache.maven.plugins.annotations.Component;

 import org.apache.maven.plugins.annotations.Mojo;

 import org.apache.maven.plugins.annotations.Parameter;

 import org.apache.maven.project.MavenProject;

 import org.codehaus.plexus.util.FileUtils;

 import java.io.File;

 import java.io.IOException;

 import java.util.ArrayList;

 import java.util.Arrays;

 import java.util.Collections;

 import java.util.HashMap;

 import java.util.HashSet;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Map;

 import java.util.Set;

 /**

  * Remove the project dependencies from the local repository, and optionally

  * re-resolve them.

  *

  * @author jdcasey

  * @version $Id: PurgeLocalRepositoryMojo.java 1357251 2012-07-04 13:28:33Z olamy $

  * @since 2.0

  */

 @Mojo( name = "purge-local-repository", aggregator = true )

 public class PurgeLocalRepositoryMojo

     extends AbstractMojo

 {

     public static final String FILE_FUZZINESS = "file";

     public static final String VERSION_FUZZINESS = "version";

     public static final String ARTIFACT_ID_FUZZINESS = "artifactId";

     public static final String GROUP_ID_FUZZINESS = "groupId";

     /**

      * The projects in the current build. Each of these is subject to

      * refreshing.

      */

     @Parameter( defaultValue = "${reactorProjects}", readonly = true, required = true )

     private List<MavenProject> projects;

     /**

      * The list of dependencies in the form of groupId:artifactId which should

      * NOT be deleted/refreshed. This is useful for third-party artifacts.

      */

     @Parameter

     private List<String> excludes;

     /**

      * Comma-separated list of groupId:artifactId entries, which should be used

      * to exclude artifacts from deletion/refresh. This is a command-line

      * alternative to the <code>excludes</code> parameter, since List

      * parameters are not currently compatible with CLI specification.

      */

     @Parameter( property = "exclude" )

     private String exclude;

     /**

      * Whether to re-resolve the artifacts once they have been deleted from the

      * local repository. If you are running this mojo from the command-line, you

      * may want to disable this. By default, artifacts will be re-resolved.

      */

     @Parameter( property = "reResolve", defaultValue = "true" )

     private boolean reResolve;

     /**

      * The local repository, from which to delete artifacts.

      */

     @Parameter( defaultValue = "${localRepository}", readonly = true, required = true )

     private ArtifactRepository localRepository;

     /**

      * The artifact resolver used to re-resolve dependencies, if that option is

      * enabled.

      */

     @Component

     private ArtifactResolver resolver;

     /**

      * The artifact metadata source used to resolve dependencies

      */

     @Component

     private ArtifactMetadataSource source;

     /**

      * Determines how liberally the plugin will delete an artifact from the

      * local repository. Values are: <br/>

      * <ul>

      * <li><b>file</b> <i>(default)</i> - Eliminate only the artifact's file.</li>

      * <li><b>version</b> - Eliminate all files associated with the artifact's

      * version.</li>

      * <li><b>artifactId</b> - Eliminate all files associated with the

      * artifact's artifactId.</li>

      * <li><b>groupId</b> - Eliminate all files associated with the artifact's

      * groupId.</li>

      * </ul>

      */

     @Parameter( property = "resolutionFuzziness", defaultValue = "file" )

     private String resolutionFuzziness;

     /**

      * Whether this mojo should act on all transitive dependencies. Default

      * value is true.

      */

     @Parameter( property = "actTransitively", defaultValue = "true" )

     private boolean actTransitively;

     /**

      * Used to construct artifacts for deletion/resolution...

      */

     @Component

     private ArtifactFactory factory;

     /**

      * Whether this plugin should output verbose messages. Default is false.

      */

     @Parameter( property = "verbose", defaultValue = "false" )

     private boolean verbose;

     /**

      * Whether to purge only snapshot artifacts.

      *

      * @since 2.4

      */

     @Parameter( property = "snapshotsOnly", defaultValue = "false" )

     private boolean snapshotsOnly;

     public void execute()

         throws MojoExecutionException, MojoFailureException

     {

         List<String> exclusionPatterns = buildExclusionPatternsList();

         for ( MavenProject project : projects )

         {

             try

             {

                 refreshDependenciesForProject( project, exclusionPatterns );

             }

             catch ( ArtifactResolutionException e )

             {

                 MojoFailureException failure =

                     new MojoFailureException( this, "Failed to refresh project dependencies for: " + project.getId(),

                                               "Artifact resolution failed for project: " + project.getId() );

                 failure.initCause( e );

                 throw failure;

             }

         }

     }

     private List<String> buildExclusionPatternsList()

     {

         List<String> patterns = new ArrayList<String>();

         if ( exclude != null )

         {

             String[] elements = exclude.split( " ?, ?" );

             patterns.addAll( Arrays.asList( elements ) );

         }

         else if ( excludes != null && !excludes.isEmpty() )

         {

             patterns.addAll( excludes );

         }

         return patterns;

     }

     private Map<String, Artifact> createArtifactMap( MavenProject project )

     {

         Map<String, Artifact> artifactMap = Collections.emptyMap();

         @SuppressWarnings( "unchecked" ) List<Dependency> dependencies = project.getDependencies();

         List<ArtifactRepository> remoteRepositories = Collections.emptyList();

         Set<Artifact> dependencyArtifacts = new HashSet<Artifact>();

         for ( Dependency dependency : dependencies )

         {

             VersionRange vr = VersionRange.createFromVersion( dependency.getVersion() );

             Artifact artifact =

                 factory.createDependencyArtifact( dependency.getGroupId(), dependency.getArtifactId(), vr,

                                                   dependency.getType(), dependency.getClassifier(),

                                                   dependency.getScope() );

             if ( snapshotsOnly && !artifact.isSnapshot() )

             {

                 continue;

             }

             dependencyArtifacts.add( artifact );

         }

         if ( actTransitively )

         {

             try

             {

                 ArtifactResolutionResult result;

                 if ( snapshotsOnly )

                 {

                     result = resolver.resolveTransitively( dependencyArtifacts, project.getArtifact(), localRepository,

                                                            remoteRepositories, source, new ArtifactFilter()

                     {

                         public boolean include( Artifact artifact )

                         {

                             return artifact.isSnapshot();

                         }

                     } );

                 }

                 else

                 {

                     result =

                         resolver.resolveTransitively( dependencyArtifacts, project.getArtifact(), remoteRepositories,

                                                       localRepository, source );

                 }

                 artifactMap = ArtifactUtils.artifactMapByVersionlessId( result.getArtifacts() );

             }

             catch ( ArtifactResolutionException e )

             {

                 verbose( "Skipping: " + e.getArtifactId() + ". It cannot be resolved." );

             }

             catch ( ArtifactNotFoundException e )

             {

                 verbose( "Skipping: " + e.getArtifactId() + ". It cannot be resolved." );

             }

         }

         else

         {

             artifactMap = new HashMap<String, Artifact>();

             for ( Artifact artifact : dependencyArtifacts )

             {

                 try

                 {

                     resolver.resolve( artifact, remoteRepositories, localRepository );

                     artifactMap.put( ArtifactUtils.versionlessKey( artifact ), artifact );

                 }

                 catch ( ArtifactResolutionException e )

                 {

                     verbose( "Skipping: " + e.getArtifactId() + ". It cannot be resolved." );

                 }

                 catch ( ArtifactNotFoundException e )

                 {

                     verbose( "Skipping: " + e.getArtifactId() + ". It cannot be resolved." );

                 }

             }

         }

         return artifactMap;

     }

     private void verbose( String message )

     {

         if ( verbose || getLog().isDebugEnabled() )

         {

             getLog().info( message );

         }

     }

     private void refreshDependenciesForProject( MavenProject project, List<String> exclusionPatterns )

         throws ArtifactResolutionException, MojoFailureException

     {

         Map<String, Artifact> deps = createArtifactMap( project );

         if ( deps.isEmpty() )

         {

             getLog().info( "Nothing to do for project: " + project.getId() );

             return;

         }

         if ( !exclusionPatterns.isEmpty() )

         {

             for ( String excludedKey : exclusionPatterns )

             {

                 if ( GROUP_ID_FUZZINESS.equals( resolutionFuzziness ) )

                 {

                     verbose( "Excluding groupId: " + excludedKey + " from refresh operation for project: "

                                  + project.getId() );

                     for ( Iterator<Map.Entry<String, Artifact>> deps_it = deps.entrySet().iterator();

                           deps_it.hasNext(); )

                     {

                         Map.Entry<String, Artifact> dependency = deps_it.next();

                         Artifact artifact = dependency.getValue();

                         if ( artifact.getGroupId().equals( excludedKey ) )

                         {

                             deps_it.remove();

                         }

                     }

                 }

                 else

                 {

                     verbose( "Excluding: " + excludedKey + " from refresh operation for project: " + project.getId() );

                     deps.remove( excludedKey );

                 }

             }

         }

         verbose( "Processing dependencies for project: " + project.getId() );

         List<Artifact> missingArtifacts = new ArrayList<Artifact>();

         for ( Map.Entry<String, Artifact> entry : deps.entrySet() )

         {

             Artifact artifact = entry.getValue();

             verbose( "Processing artifact: " + artifact.getId() );

             File deleteTarget = findDeleteTarget( artifact );

             verbose( "Deleting: " + deleteTarget );

             if ( deleteTarget.isDirectory() )

             {

                 try

                 {

                     FileUtils.deleteDirectory( deleteTarget );

                 }

                 catch ( IOException e )

                 {

                     throw new MojoFailureException( this, "Cannot delete dependency from the local repository: "

                         + artifact.getId(), "Failed to delete: " + deleteTarget );

                 }

             }

             else

             {

                 deleteTarget.delete();

             }

             if ( reResolve )

             {

                 verbose( "Re-resolving." );

                 artifact.setResolved( false );

                 try

                 {

                     resolver.resolveAlways( artifact, project.getRemoteArtifactRepositories(), localRepository );

                 }

                 catch ( ArtifactResolutionException e )

                 {

                     getLog().debug( e.getMessage() );

                     missingArtifacts.add( artifact );

                 }

                 catch ( ArtifactNotFoundException e )

                 {

                     getLog().debug( e.getMessage() );

                     missingArtifacts.add( artifact );

                 }

             }

         }

         if ( missingArtifacts.size() > 0 )

         {

             String message = "required artifacts missing:\n";

             for ( Artifact missingArtifact : missingArtifacts )

             {

                 message += "  " + missingArtifact.getId() + "\n";

             }

             message += "\nfor the artifact:";

             throw new ArtifactResolutionException( message, project.getArtifact(),

                                                    project.getRemoteArtifactRepositories() );

         }

     }

     private File findDeleteTarget( Artifact artifact )

     {

         File deleteTarget = artifact.getFile();

         if ( GROUP_ID_FUZZINESS.equals( resolutionFuzziness ) )

         {

             // get the artifactId dir.

             deleteTarget = deleteTarget.getParentFile().getParentFile();

             // get the first groupId dir.

             deleteTarget = deleteTarget.getParentFile();

             String[] path = localRepository.pathOf( artifact ).split( "\\/" );

             // subtract the artifact filename, version dir, artifactId dir, and

             // the first groupId

             // dir, since we've accounted for those above.

             int groupParts = path.length - 4;

             File parent = deleteTarget.getParentFile();

             int count = 0;

             while ( count++ < groupParts )

             {

                 // prune empty dirs back to the beginning of the groupId, if

                 // possible.

                 // if the parent dir only has the one child file, then it's okay

                 // to prune.

                 if ( parent.list().length < 2 )

                 {

                     deleteTarget = parent;

                     // check the parent of this newly checked dir

                     parent = deleteTarget.getParentFile();

                 }

                 else

                 {

                     // if there are more files than the one that we're

                     // interested in killing, stop.

                     break;

                 }

             }

         }

         else if ( ARTIFACT_ID_FUZZINESS.equals( resolutionFuzziness ) )

         {

             // get the artifactId dir.

             deleteTarget = deleteTarget.getParentFile().getParentFile();

         }

         else if ( VERSION_FUZZINESS.equals( resolutionFuzziness ) )

         {

             // get the version dir.

             deleteTarget = deleteTarget.getParentFile();

         }

         // else it's file fuzziness.

         return deleteTarget;

     }

 }