package org.apache.maven.plugin.gpg;

 /*

  * 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.util.ArrayList;

 import java.util.HashMap;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Map;

 import org.apache.maven.artifact.Artifact;

 import org.apache.maven.artifact.handler.ArtifactHandler;

 import org.apache.maven.artifact.handler.DefaultArtifactHandler;

 import org.apache.maven.artifact.handler.manager.ArtifactHandlerManager;

 import org.apache.maven.plugin.MojoExecutionException;

 import org.apache.maven.plugin.MojoFailureException;

 import org.apache.maven.project.MavenProject;

 import org.apache.maven.project.MavenProjectHelper;

 import org.codehaus.plexus.util.FileUtils;

 import org.codehaus.plexus.util.SelectorUtils;

 /**

  * Sign project artifact, the POM, and attached artifacts with GnuPG for deployment.

  * 

  * @author Jason van Zyl

  * @author Jason Dillon

  * @author Daniel Kulp

  * @goal sign

  * @phase verify

  */

 public class GpgSignAttachedMojo

     extends AbstractGpgMojo

 {

     private static final String DEFAULT_EXCLUDES[] = new String[] { "**/*.md5", "**/*.sha1", "**/*.asc" };

     /**

      * Skip doing the gpg signing.

      * 

      * @parameter expression="${gpg.skip}" default-value="false"

      */

     private boolean skip;

     /**

      * A list of files to exclude from being signed. Can contain Ant-style wildcards and double wildcards. The default

      * excludes are <code>**&#47;*.md5   **&#47;*.sha1    **&#47;*.asc</code>.

      * 

      * @parameter

      * @since 1.0-alpha-4

      */

     private String[] excludes;

     /**

      * The directory where to store signature files.

      * 

      * @parameter default-value="${project.build.directory}/gpg" alias="outputDirectory"

      * @since 1.0-alpha-4

      */

     private File ascDirectory;

     /**

      * The maven project.

      * 

      * @parameter default-value="${project}"

      * @required

      * @readonly

      */

     protected MavenProject project;

     /**

      * Maven ProjectHelper

      * 

      * @component

      * @required

      * @readonly

      */

     private MavenProjectHelper projectHelper;

     /**

      * Maven ArtifactHandlerManager

      * 

      * @component

      * @required

      * @readonly

      */

     private ArtifactHandlerManager artifactHandlerManager;

     public void execute()

         throws MojoExecutionException, MojoFailureException

     {

         if ( skip )

         {

             // We're skipping the signing stuff

             return;

         }

         if ( excludes == null || excludes.length == 0 )

         {

             excludes = DEFAULT_EXCLUDES;

         }

         String newExcludes[] = new String[excludes.length];

         for ( int i = 0; i < excludes.length; i++ )

         {

             String pattern;

             pattern = excludes[i].trim().replace( '/', File.separatorChar ).replace( '\\', File.separatorChar );

             if ( pattern.endsWith( File.separator ) )

             {

                 pattern += "**";

             }

             newExcludes[i] = pattern;

         }

         excludes = newExcludes;

         GpgSigner signer = newSigner( project );

         // ----------------------------------------------------------------------------

         // What we need to generateSignatureForArtifact here

         // ----------------------------------------------------------------------------

         signer.setOutputDirectory( ascDirectory );

         signer.setBuildDirectory( new File( project.getBuild().getDirectory() ) );

         signer.setBaseDirectory( project.getBasedir() );

         List signingBundles = new ArrayList();

         if ( !"pom".equals( project.getPackaging() ) )

         {

             // ----------------------------------------------------------------------------

             // Project artifact

             // ----------------------------------------------------------------------------

             File projectArtifact = project.getArtifact().getFile();

             if ( projectArtifact == null )

             {

                 throw new MojoFailureException( "The project artifact has not been assembled yet. "

                     + "Please do not invoke this goal before the lifecycle phase \"package\"." );

             }

             File projectArtifactSignature = signer.generateSignatureForArtifact( projectArtifact );

             if ( projectArtifactSignature != null )

             {

                 signingBundles.add( new SigningBundle( project.getArtifact().getType(), projectArtifactSignature ) );

             }

         }

         // ----------------------------------------------------------------------------

         // POM

         // ----------------------------------------------------------------------------

         File pomToSign = new File( project.getBuild().getDirectory(), project.getBuild().getFinalName() + ".pom" );

         try

         {

             FileUtils.copyFile( project.getFile(), pomToSign );

         }

         catch ( IOException e )

         {

             throw new MojoExecutionException( "Error copying POM for signing.", e );

         }

         File pomSignature = signer.generateSignatureForArtifact( pomToSign );

         if ( pomSignature != null )

         {

             signingBundles.add( new SigningBundle( "pom", pomSignature ) );

         }

         // ----------------------------------------------------------------------------

         // Attached artifacts

         // ----------------------------------------------------------------------------

         for ( Iterator i = project.getAttachedArtifacts().iterator(); i.hasNext(); )

         {

             Artifact artifact = (Artifact) i.next();

             File file = artifact.getFile();

             File signature = signer.generateSignatureForArtifact( file );

             if ( signature != null )

             {

                 signingBundles.add( new SigningBundle( artifact.getType(), artifact.getClassifier(), signature ) );

             }

         }

         // ----------------------------------------------------------------------------

         // Attach all the signatures

         // ----------------------------------------------------------------------------

         ArtifactHandler handler = new DefaultArtifactHandler( "asc" );

         Map map = new HashMap();

         map.put( "asc", handler );

         artifactHandlerManager.addHandlers( map );

         for ( Iterator i = signingBundles.iterator(); i.hasNext(); )

         {

             SigningBundle bundle = (SigningBundle) i.next();

             ArtifactHandler ah = artifactHandlerManager.getArtifactHandler( bundle.getArtifactType() );

             if ( bundle.getClassifier() != null && !"".equals( bundle.getClassifier() ) )

             {

                 projectHelper.attachArtifact( project, "asc", bundle.getClassifier() + "." + ah.getExtension(),

                                               bundle.getSignature() );

             }

             else

             {

                 projectHelper.attachArtifact( project, ah.getExtension() + ".asc", null, bundle.getSignature() );

             }

         }

     }

     /**

      * Tests whether or not a name matches against at least one exclude pattern.

      * 

      * @param name The name to match. Must not be <code>null</code>.

      * @return <code>true</code> when the name matches against at least one exclude pattern, or <code>false</code>

      *         otherwise.

      */

     protected boolean isExcluded( String name )

     {

         for ( int i = 0; i < excludes.length; i++ )

         {

             if ( SelectorUtils.matchPath( excludes[i], name ) )

             {

                 return true;

             }

         }

         return false;

     }

 }