package org.apache.maven.tools.plugin.extractor.ant;

 /*

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

 import java.util.HashMap;

 import java.util.List;

 import java.util.Map;

 import java.util.Set;

 import org.apache.maven.plugin.descriptor.InvalidPluginDescriptorException;

 import org.apache.maven.plugin.descriptor.MojoDescriptor;

 import org.apache.maven.plugin.descriptor.Parameter;

 import org.apache.maven.plugin.tools.model.PluginMetadataParseException;

 import org.apache.maven.plugin.tools.model.PluginMetadataParser;

 import org.apache.maven.project.MavenProject;

 import org.apache.maven.project.path.PathTranslator;

 import org.apache.maven.tools.plugin.PluginToolsRequest;

 import org.apache.maven.tools.plugin.extractor.AbstractScriptedMojoDescriptorExtractor;

 import org.apache.maven.tools.plugin.extractor.ExtractionException;

 import org.apache.maven.tools.plugin.extractor.MojoDescriptorExtractor;

 import org.codehaus.plexus.component.annotations.Component;

 import org.codehaus.plexus.component.repository.ComponentRequirement;

 import org.codehaus.plexus.util.StringUtils;

 /**

  * Extracts Mojo descriptors from <a href="http://ant.apache.org">Ant</a> sources.

  *

  * @version $Id: AntMojoDescriptorExtractor.java 1343107 2012-05-27 21:35:40Z hboutemy $

  */

 @Component( role = MojoDescriptorExtractor.class, hint = "ant" )

 public class AntMojoDescriptorExtractor

     extends AbstractScriptedMojoDescriptorExtractor

     implements MojoDescriptorExtractor

 {

     /** Default metadata file extension */

     private static final String METADATA_FILE_EXTENSION = ".mojos.xml";

     /** Default Ant build file extension */

     private static final String SCRIPT_FILE_EXTENSION = ".build.xml";

     /** {@inheritDoc} */

     protected List<MojoDescriptor> extractMojoDescriptorsFromMetadata( Map<String, Set<File>> metadataFilesKeyedByBasedir,

                                                                        PluginToolsRequest request )

         throws ExtractionException, InvalidPluginDescriptorException

     {

         List<MojoDescriptor> descriptors = new ArrayList<MojoDescriptor>();

         PluginMetadataParser parser = new PluginMetadataParser();

         for ( Map.Entry<String, Set<File>> entry : metadataFilesKeyedByBasedir.entrySet() )

         {

             String basedir = entry.getKey();

             Set<File> metadataFiles = entry.getValue();

             for ( File metadataFile : metadataFiles )

             {

                 String basename = metadataFile.getName();

                 basename = basename.substring( 0, basename.length() - METADATA_FILE_EXTENSION.length() );

                 File scriptFile = new File( metadataFile.getParentFile(), basename + SCRIPT_FILE_EXTENSION );

                 if ( !scriptFile.exists() )

                 {

                     throw new InvalidPluginDescriptorException(

                         "Found orphaned plugin metadata file: " + metadataFile );

                 }

                 String relativePath = scriptFile.getPath().substring( basedir.length() ).replace( '\\', '/' );

                 if ( relativePath.startsWith( "/" ) )

                 {

                     relativePath = relativePath.substring( 1 );

                 }

                 try

                 {

                     Set<MojoDescriptor> mojoDescriptors = parser.parseMojoDescriptors( metadataFile );

                     for ( MojoDescriptor descriptor : mojoDescriptors )

                     {

                         @SuppressWarnings( "unchecked" )

                         Map<String, ?> paramMap = descriptor.getParameterMap();

                         if ( !paramMap.containsKey( "basedir" ) )

                         {

                             Parameter param = new Parameter();

                             param.setName( "basedir" );

                             param.setAlias( "ant.basedir" );

                             param.setExpression( "${antBasedir}" );

                             param.setDefaultValue( "${basedir}" );

                             param.setType( "java.io.File" );

                             param.setDescription( "The base directory from which to execute the Ant script." );

                             param.setEditable( true );

                             param.setRequired( true );

                             descriptor.addParameter( param );

                         }

                         if ( !paramMap.containsKey( "antMessageLevel" ) )

                         {

                             Parameter param = new Parameter();

                             param.setName( "messageLevel" );

                             param.setAlias( "ant.messageLevel" );

                             param.setExpression( "${antMessageLevel}" );

                             param.setDefaultValue( "info" );

                             param.setType( "java.lang.String" );

                             param.setDescription( "The message-level used to tune the verbosity of Ant logging." );

                             param.setEditable( true );

                             param.setRequired( false );

                             descriptor.addParameter( param );

                         }

                         if ( !paramMap.containsKey( "project" ) )

                         {

                             Parameter param = new Parameter();

                             param.setName( "project" );

                             param.setDefaultValue( "${project}" );

                             param.setType( MavenProject.class.getName() );

                             param.setDescription( "The current MavenProject instance, which contains classpath elements." );

                             param.setEditable( false );

                             param.setRequired( true );

                             descriptor.addParameter( param );

                         }

                         if ( !paramMap.containsKey( "session" ) )

                         {

                             Parameter param = new Parameter();

                             param.setName( "session" );

                             param.setDefaultValue( "${session}" );

                             param.setType( "org.apache.maven.execution.MavenSession" );

                             param.setDescription( "The current MavenSession instance, which is used for plugin-style expression resolution." );

                             param.setEditable( false );

                             param.setRequired( true );

                             descriptor.addParameter( param );

                         }

                         if ( !paramMap.containsKey( "mojoExecution" ) )

                         {

                             Parameter param = new Parameter();

                             param.setName( "mojoExecution" );

                             param.setDefaultValue( "${mojoExecution}" );

                             param.setType( "org.apache.maven.plugin.MojoExecution" );

                             param.setDescription( "The current Maven MojoExecution instance, which contains information about the mojo currently executing." );

                             param.setEditable( false );

                             param.setRequired( true );

                             descriptor.addParameter( param );

                         }

                         @SuppressWarnings( "unchecked" )

                         List<ComponentRequirement> requirements = descriptor.getRequirements();

                         Map<String, ComponentRequirement> reqMap = new HashMap<String, ComponentRequirement>();

                         if ( requirements != null )

                         {

                             for ( ComponentRequirement req : requirements )

                             {

                                 reqMap.put( req.getRole(), req );

                             }

                         }

                         if ( !reqMap.containsKey( PathTranslator.class.getName() ) )

                         {

                             ComponentRequirement req = new ComponentRequirement();

                             req.setRole( PathTranslator.class.getName() );

                             descriptor.addRequirement( req );

                         }

                         String implementation = relativePath;

                         String dImpl = descriptor.getImplementation();

                         if ( StringUtils.isNotEmpty( dImpl ) )

                         {

                             if ( PluginMetadataParser.IMPL_BASE_PLACEHOLDER.equals( dImpl ) )

                             {

                                 implementation = relativePath;

                             }

                             else

                             {

                                 implementation =

                                     relativePath + dImpl.substring( PluginMetadataParser.IMPL_BASE_PLACEHOLDER.length() );

                             }

                         }

                         descriptor.setImplementation( implementation );

                         descriptor.setLanguage( "ant-mojo" );

                         descriptor.setComponentComposer( "map-oriented" );

                         descriptor.setComponentConfigurator( "map-oriented" );

                         descriptor.setPluginDescriptor( request.getPluginDescriptor() );

                         descriptors.add( descriptor );

                     }

                 }

                 catch ( PluginMetadataParseException e )

                 {

                     throw new ExtractionException( "Error extracting mojo descriptor from script: " + metadataFile, e );

                 }

             }

         }

         return descriptors;

     }

     /** {@inheritDoc} */

     protected String getScriptFileExtension( PluginToolsRequest request )

     {

         return SCRIPT_FILE_EXTENSION;

     }

     /** {@inheritDoc} */

     protected String getMetadataFileExtension( PluginToolsRequest request )

     {

         return METADATA_FILE_EXTENSION;

     }

 }