package org.apache.maven.plugins.help;
   
   /*
    * 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.IOException;
  import java.lang.reflect.InvocationTargetException;
  import java.lang.reflect.Method;
  import java.util.Collections;
  import java.util.Comparator;
  import java.util.Iterator;
  import java.util.List;
  import java.util.StringTokenizer;
  
  import org.apache.maven.artifact.Artifact;
  import org.apache.maven.artifact.factory.ArtifactFactory;
  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.versioning.InvalidVersionSpecificationException;
  import org.apache.maven.artifact.versioning.VersionRange;
  import org.apache.maven.execution.MavenSession;
  import org.apache.maven.lifecycle.DefaultLifecycleExecutor;
  import org.apache.maven.lifecycle.Lifecycle;
  import org.apache.maven.lifecycle.LifecycleExecutionException;
  import org.apache.maven.lifecycle.LifecycleExecutor;
  import org.apache.maven.lifecycle.mapping.LifecycleMapping;
  import org.apache.maven.model.Plugin;
  import org.apache.maven.plugin.InvalidPluginException;
  import org.apache.maven.plugin.MojoExecutionException;
  import org.apache.maven.plugin.MojoFailureException;
  import org.apache.maven.plugin.PluginManager;
  import org.apache.maven.plugin.PluginManagerException;
  import org.apache.maven.plugin.PluginNotFoundException;
  import org.apache.maven.plugin.descriptor.MojoDescriptor;
  import org.apache.maven.plugin.descriptor.Parameter;
  import org.apache.maven.plugin.descriptor.PluginDescriptor;
  import org.apache.maven.plugin.version.PluginVersionNotFoundException;
  import org.apache.maven.plugin.version.PluginVersionResolutionException;
  import org.apache.maven.project.MavenProject;
  import org.apache.maven.project.MavenProjectBuilder;
  import org.apache.maven.project.ProjectBuildingException;
  import org.apache.maven.settings.Settings;
  import org.apache.maven.tools.plugin.util.PluginUtils;
  import org.codehaus.plexus.component.repository.exception.ComponentLookupException;
  import org.codehaus.plexus.util.StringUtils;
  
  /**
   * Displays a list of the attributes for a Maven Plugin and/or goals (aka Mojo - Maven plain Old Java Object).
   *
   * @version $Id: DescribeMojo.java 925939 2010-03-22 02:01:33Z brett $
   * @since 2.0
   * @goal describe
   * @requiresProject false
   * @aggregator
   * @see <a href="http://maven.apache.org/general.html#What_is_a_Mojo">What is a Mojo?</a>
   */
  public class DescribeMojo
      extends AbstractHelpMojo
  {
      /** The default indent size when writing description's Mojo. */
      private static final int INDENT_SIZE = 2;
  
      /** For unknown values */
      private static final String UNKNOWN = "Unknown";
  
      /** For not defined values */
      private static final String NOT_DEFINED = "Not defined";
  
      /** For deprecated values */
      private static final String NO_REASON = "No reason given";
  
      // ----------------------------------------------------------------------
      // Mojo components
      // ----------------------------------------------------------------------
  
      /**
       * Maven Artifact Factory component.
       *
       * @component
       * @since 2.1
       */
      private ArtifactFactory artifactFactory;
 
     /**
      * The Plugin manager instance used to resolve Plugin descriptors.
      *
      * @component role="org.apache.maven.plugin.PluginManager"
      */
     private PluginManager pluginManager;
 
     /**
      * The project builder instance used to retrieve the super-project instance
      * in the event there is no current MavenProject instance. Some MavenProject
      * instance has to be present to use in the plugin manager APIs.
      *
      * @component role="org.apache.maven.project.MavenProjectBuilder"
      */
     private MavenProjectBuilder projectBuilder;
 
     // ----------------------------------------------------------------------
     // Mojo parameters
     // ----------------------------------------------------------------------
 
     /**
      * The current project, if there is one. This is listed as optional, since
      * the help plugin should be able to function on its own. If this
      * parameter is empty at execution time, this Mojo will instead use the
      * super-project.
      *
      * @parameter expression="${project}"
      * @readonly
      */
     private MavenProject project;
 
     /**
      * The current user system settings for use in Maven. This is used for
      * plugin manager API calls.
      *
      * @parameter expression="${settings}"
      * @required
      * @readonly
      */
     private Settings settings;
 
     /**
      * The current build session instance. This is used for
      * plugin manager API calls.
      *
      * @parameter expression="${session}"
      * @required
      * @readonly
      */
     private MavenSession session;
 
     /**
      * The local repository ArtifactRepository instance. This is used
      * for plugin manager API calls.
      *
      * @parameter expression="${localRepository}"
      * @required
      * @readonly
      */
     private ArtifactRepository localRepository;
 
     /**
      * Remote repositories used for the project.
      *
      * @since 2.1
      * @parameter expression="${project.remoteArtifactRepositories}"
      * @required
      * @readonly
      */
     private List remoteRepositories;
 
     /**
      * The Maven Plugin to describe. This must be specified in one of three ways:
      * <br/>
      * <ol>
      * <li>plugin-prefix, i.e. 'help'</li>
      * <li>groupId:artifactId, i.e. 'org.apache.maven.plugins:maven-help-plugin'</li>
      * <li>groupId:artifactId:version, i.e. 'org.apache.maven.plugins:maven-help-plugin:2.0'</li>
      * </ol>
      *
      * @parameter expression="${plugin}" alias="prefix"
      */
     private String plugin;
 
     /**
      * The Maven Plugin <code>groupId</code> to describe.
      * <br/>
      * <b>Note</b>: Should be used with <code>artifactId</code> parameter.
      *
      * @parameter expression="${groupId}"
      */
     private String groupId;
 
     /**
      * The Maven Plugin <code>artifactId</code> to describe.
      * <br/>
      * <b>Note</b>: Should be used with <code>groupId</code> parameter.
      *
      * @parameter expression="${artifactId}"
      */
     private String artifactId;
 
     /**
      * The Maven Plugin <code>version</code> to describe.
      * <br/>
      * <b>Note</b>: Should be used with <code>groupId/artifactId</code> parameters.
      *
      * @parameter expression="${version}"
      */
     private String version;
 
     /**
      * The goal name of a Mojo to describe within the specified Maven Plugin.
      * If this parameter is specified, only the corresponding goal (Mojo) will be described,
      * rather than the whole Plugin.
      *
      * @parameter expression="${goal}" alias="mojo"
      * @since 2.1, was <code>mojo</code> in 2.0.x
      */
     private String goal;
 
     /**
      * This flag specifies that a detailed (verbose) list of goal (Mojo) information should be given.
      *
      * @parameter expression="${detail}" default-value="false" alias="full"
      * @since 2.1, was <code>full</code> in 2.0.x
      */
     private boolean detail;
 
     /**
      * This flag specifies that a medium list of goal (Mojo) information should be given.
      *
      * @parameter expression="${medium}" default-value="true"
      * @since 2.0.2
      */
     private boolean medium;
 
     /**
      * This flag specifies that a minimal list of goal (Mojo) information should be given.
      *
      * @parameter expression="${minimal}" default-value="false"
      * @since 2.1
      */
     private boolean minimal;
 
     /**
      * A Maven command like a single goal or a single phase following the Maven command line:
      * <br/>
      * <code>mvn [options] [&lt;goal(s)&gt;] [&lt;phase(s)&gt;]</code>
      *
      * @parameter expression="${cmd}"
      * @since 2.1
      */
     private String cmd;
 
     // ----------------------------------------------------------------------
     // Public methods
     // ----------------------------------------------------------------------
 
     /** {@inheritDoc} */
     public void execute()
         throws MojoExecutionException, MojoFailureException
     {
         validateParameters();
 
         if ( project == null )
         {
             try
             {
                 project = projectBuilder.buildStandaloneSuperProject( localRepository );
             }
             catch ( ProjectBuildingException e )
             {
                 throw new MojoExecutionException( "Error while retrieving the super-project.", e );
             }
         }
 
         StringBuffer descriptionBuffer = new StringBuffer();
 
         boolean describePlugin = true;
         if ( StringUtils.isNotEmpty( cmd ) )
         {
             describePlugin = describeCommand( descriptionBuffer );
         }
 
         if ( describePlugin )
         {
             PluginInfo pi = new PluginInfo();
 
             parsePluginLookupInfo( pi );
 
             PluginDescriptor descriptor = lookupPluginDescriptor( pi );
 
             if ( StringUtils.isNotEmpty( goal ) )
             {
                 MojoDescriptor mojo = descriptor.getMojo( goal );
                 if ( mojo == null )
                 {
                     throw new MojoFailureException(
                         "The mojo '" + goal + "' does not exist in the plugin '" + pi.getPrefix() + "'" );
                 }
 
                 describeMojo( mojo, descriptionBuffer );
             }
             else
             {
                 describePlugin( descriptor, descriptionBuffer );
             }
         }
 
         writeDescription( descriptionBuffer );
     }
 
     // ----------------------------------------------------------------------
     // Private methods
     // ----------------------------------------------------------------------
 
     /**
      * Validate parameters
      */
     private void validateParameters()
     {
         // support legacy parameters "mojo" and "full"
         if ( goal == null && session.getExecutionProperties().get( "mojo" ) != null )
         {
             goal = session.getExecutionProperties().getProperty( "mojo" );
         }
 
         if ( !detail && session.getExecutionProperties().get( "full" ) != null )
         {
             String full = session.getExecutionProperties().getProperty( "full" );
             detail = new Boolean( full ).booleanValue();
         }
 
         if ( detail || minimal )
         {
             medium = false;
         }
     }
 
     /**
      * Method to write the Mojo description into the output file
      *
      * @param descriptionBuffer contains the description to be written to the file
      * @throws MojoExecutionException if any
      */
     private void writeDescription( StringBuffer descriptionBuffer )
         throws MojoExecutionException
     {
         if ( output != null )
         {
             try
             {
                 writeFile( output, descriptionBuffer );
             }
             catch ( IOException e )
             {
                 throw new MojoExecutionException( "Cannot write plugin/mojo description to output: " + output, e );
             }
 
             if ( getLog().isInfoEnabled() )
             {
                 getLog().info( "Wrote descriptions to: " + output );
             }
         }
         else
         {
             if ( getLog().isInfoEnabled() )
             {
                 getLog().info( descriptionBuffer.toString() );
             }
         }
     }
 
     /**
      * Method for retrieving the description of the plugin
      *
      * @param pi holds information of the plugin whose description is to be retrieved
      * @return  a PluginDescriptor where the plugin description is to be retrieved
      * @throws MojoExecutionException if the plugin could not be verify
      * @throws MojoFailureException if groupId or artifactId is empty
      */
     private PluginDescriptor lookupPluginDescriptor( PluginInfo pi )
         throws MojoExecutionException, MojoFailureException
     {
         PluginDescriptor descriptor = null;
 
         Plugin forLookup = null;
 
         if ( StringUtils.isNotEmpty( pi.getPrefix() ) )
         {
             descriptor = pluginManager.getPluginDescriptorForPrefix( pi.getPrefix() );
             if ( descriptor == null )
             {
                 forLookup = pluginManager.getPluginDefinitionForPrefix( pi.getPrefix(), session, project );
             }
         }
         else if ( StringUtils.isNotEmpty( pi.getGroupId() ) && StringUtils.isNotEmpty( pi.getArtifactId() ) )
         {
             forLookup = new Plugin();
 
             forLookup.setGroupId( pi.getGroupId() );
             forLookup.setArtifactId( pi.getArtifactId() );
 
             if ( StringUtils.isNotEmpty( pi.getVersion() ) )
             {
                 forLookup.setVersion( pi.getVersion() );
             }
         }
         else
         {
             StringBuffer msg = new StringBuffer();
             msg.append( "You must specify either: both 'groupId' and 'artifactId' parameters OR a 'plugin' parameter"
                 + " OR a 'cmd' parameter. For instance:\n" );
             msg.append( "  # mvn help:describe -Dcmd=install\n" );
             msg.append( "or\n" );
             msg.append( "  # mvn help:describe -Dcmd=help:describe\n" );
             msg.append( "or\n" );
             msg.append( "  # mvn help:describe -Dplugin=org.apache.maven.plugins:maven-help-plugin\n" );
             msg.append( "or\n" );
             msg.append( "  # mvn help:describe -DgroupId=org.apache.maven.plugins -DartifactId=maven-help-plugin\n\n" );
             msg.append( "Try 'mvn help:help -Ddetail=true' for more information." );
 
             throw new MojoFailureException( msg.toString() );
         }
 
         if ( descriptor == null && forLookup != null )
         {
             try
             {
                 descriptor = pluginManager.verifyPlugin( forLookup, project, settings, localRepository );
             }
             catch ( ArtifactResolutionException e )
             {
                 throw new MojoExecutionException( "Error retrieving plugin descriptor for:\n\ngroupId: '"
                     + groupId + "'\nartifactId: '" + artifactId + "'\nversion: '" + version + "'\n\n", e );
             }
             catch ( PluginManagerException e )
             {
                 throw new MojoExecutionException( "Error retrieving plugin descriptor for:\n\ngroupId: '"
                     + groupId + "'\nartifactId: '" + artifactId + "'\nversion: '" + version + "'\n\n", e );
             }
             catch ( PluginVersionResolutionException e )
             {
                 throw new MojoExecutionException( "Error retrieving plugin descriptor for:\n\ngroupId: '"
                     + groupId + "'\nartifactId: '" + artifactId + "'\nversion: '" + version + "'\n\n", e );
             }
             catch ( ArtifactNotFoundException e )
             {
                 throw new MojoExecutionException( "Plugin dependency does not exist: " + e.getMessage(), e );
             }
             catch ( InvalidVersionSpecificationException e )
             {
                 throw new MojoExecutionException( "Error retrieving plugin descriptor for:\n\ngroupId: '"
                     + groupId + "'\nartifactId: '" + artifactId + "'\nversion: '" + version + "'\n\n", e );
             }
             catch ( InvalidPluginException e )
             {
                 throw new MojoExecutionException( "Error retrieving plugin descriptor for:\n\ngroupId: '"
                     + groupId + "'\nartifactId: '" + artifactId + "'\nversion: '" + version + "'\n\n", e );
             }
             catch ( PluginNotFoundException e )
             {
                 if ( getLog().isDebugEnabled() )
                 {
                     getLog().debug( "Unable to find plugin", e );
                 }
                 throw new MojoFailureException( "Plugin does not exist: " + e.getMessage() );
             }
             catch ( PluginVersionNotFoundException e )
             {
                 if ( getLog().isDebugEnabled() )
                 {
                     getLog().debug( "Unable to find plugin version", e );
                 }
                 throw new MojoFailureException( e.getMessage() );
             }
         }
 
         if ( descriptor == null )
         {
             throw new MojoFailureException( "Plugin could not be found. If you believe it is correct,"
                 + " check your pluginGroups setting, and run with -U to update the remote configuration" );
         }
 
         return descriptor;
     }
 
     /**
      * Method for parsing the plugin parameter
      *
      * @param pi contains information about the plugin whose description is to be retrieved
      * @throws MojoFailureException if <code>plugin<*code> parameter is not conform to
      * <code>groupId:artifactId[:version]</code>
      */
     private void parsePluginLookupInfo( PluginInfo pi )
         throws MojoFailureException
     {
         if ( StringUtils.isNotEmpty( plugin ) )
         {
             if ( plugin.indexOf( ":" ) > -1 )
             {
                 String[] pluginParts = plugin.split( ":" );
 
                 switch ( pluginParts.length )
                 {
                     case ( 1 ):
                         pi.setPrefix( pluginParts[0] );
                         break;
                     case ( 2 ):
                         pi.setGroupId( pluginParts[0] );
                         pi.setArtifactId( pluginParts[1] );
                         break;
                     case ( 3 ):
                         pi.setGroupId( pluginParts[0] );
                         pi.setArtifactId( pluginParts[1] );
                         pi.setVersion( pluginParts[2] );
                         break;
                     default:
                         throw new MojoFailureException( "plugin parameter must be a plugin prefix,"
                             + " or conform to: 'groupId:artifactId[:version]'." );
                 }
             }
             else
             {
                 pi.setPrefix( plugin );
             }
         }
         else
         {
             pi.setGroupId( groupId );
             pi.setArtifactId( artifactId );
             pi.setVersion( version );
         }
     }
 
     /**
      * Method for retrieving the plugin description
      *
      * @param pd contains the plugin description
      * @param buffer contains the information to be displayed or printed
      * @throws MojoFailureException if any reflection exceptions occur.
      * @throws MojoExecutionException if any
      */
     private void describePlugin( PluginDescriptor pd, StringBuffer buffer )
         throws MojoFailureException, MojoExecutionException
     {
         append( buffer, pd.getId(), 0 );
         buffer.append( "\n" );
 
         String name = pd.getName();
         if ( name == null )
         {
             // Always null see MPLUGIN-137
             // TODO remove when maven-plugin-tools-api:2.4.4
             try
             {
                 Artifact artifact =
                     artifactFactory.createPluginArtifact( pd.getGroupId(), pd.getArtifactId(),
                                                           VersionRange.createFromVersion( pd.getVersion() ) );
                 MavenProject pluginProject =
                     projectBuilder.buildFromRepository( artifact, remoteRepositories, localRepository );
 
                 name = pluginProject.getName();
             }
             catch ( ProjectBuildingException e )
             {
                 // oh well, we tried our best.
                 name = pd.getId();
             }
         }
         append( buffer, "Name", name, 0 );
         appendAsParagraph( buffer, "Description", toDescription( pd.getDescription() ), 0 );
         append( buffer, "Group Id", pd.getGroupId(), 0 );
         append( buffer, "Artifact Id", pd.getArtifactId(), 0 );
         append( buffer, "Version", pd.getVersion(), 0 );
         append( buffer, "Goal Prefix", pd.getGoalPrefix(), 0 );
         buffer.append( "\n" );
 
         List mojos = pd.getMojos();
 
         if ( mojos == null )
         {
             append( buffer, "This plugin has no goals.", 0 );
             return;
         }
 
         if ( ( detail || medium ) && !minimal )
         {
             append( buffer, "This plugin has " + pd.getMojos().size() + " goal"
                 + ( pd.getMojos().size() > 1 ? "s" : "" ) + ":", 0 );
             buffer.append( "\n" );
 
             PluginUtils.sortMojos( mojos );
 
             for ( Iterator it = mojos.iterator(); it.hasNext(); )
             {
                 MojoDescriptor md = (MojoDescriptor) it.next();
 
                 if ( detail )
                 {
                     describeMojoGuts( md, buffer, true );
                 }
                 else
                 {
                     describeMojoGuts( md, buffer, false );
                 }
 
                 buffer.append( "\n" );
             }
         }
 
         if ( !detail )
         {
             buffer.append( "For more information, run 'mvn help:describe [...] -Ddetail'" );
             buffer.append( "\n" );
         }
     }
 
     /**
      * Displays information about the Plugin Mojo
      *
      * @param md contains the description of the Plugin Mojo
      * @param buffer the displayed output
      * @throws MojoFailureException if any reflection exceptions occur.
      * @throws MojoExecutionException if any
      */
     private void describeMojo( MojoDescriptor md, StringBuffer buffer )
         throws MojoFailureException, MojoExecutionException
     {
         buffer.append( "Mojo: '" ).append( md.getFullGoalName() ).append( "'" );
         buffer.append( '\n' );
 
         describeMojoGuts( md, buffer, detail );
         buffer.append( "\n" );
 
         if ( !detail )
         {
             buffer.append( "For more information, run 'mvn help:describe [...] -Ddetail'" );
             buffer.append( "\n" );
         }
     }
 
     /**
      * Displays detailed information about the Plugin Mojo
      *
      * @param md contains the description of the Plugin Mojo
      * @param buffer contains information to be printed or displayed
      * @param fullDescription specifies whether all the details about the Plugin Mojo is to  be displayed
      * @throws MojoFailureException if any reflection exceptions occur.
      * @throws MojoExecutionException if any
      */
     private void describeMojoGuts( MojoDescriptor md, StringBuffer buffer, boolean fullDescription )
         throws MojoFailureException, MojoExecutionException
     {
         append( buffer, md.getFullGoalName(), 0 );
 
         // indent 1
         appendAsParagraph( buffer, "Description", toDescription( md.getDescription() ), 1 );
 
         String deprecation = md.getDeprecated();
         if ( deprecation != null && deprecation.length() <= 0 )
         {
             deprecation = NO_REASON;
         }
 
         if ( StringUtils.isNotEmpty( deprecation ) )
         {
             append( buffer, "Deprecated. " + deprecation, 1 );
         }
 
         if ( !fullDescription )
         {
             return;
         }
 
         append( buffer, "Implementation", md.getImplementation(), 1 );
         append( buffer, "Language", md.getLanguage(), 1 );
 
         String phase = md.getPhase();
         if ( StringUtils.isNotEmpty( phase ) )
         {
             append( buffer, "Bound to phase", phase, 1 );
         }
 
         String eGoal = md.getExecuteGoal();
         String eLife = md.getExecuteLifecycle();
         String ePhase = md.getExecutePhase();
 
         if ( StringUtils.isNotEmpty( eGoal ) || StringUtils.isNotEmpty( ePhase ) )
         {
             append( buffer, "Before this mojo executes, it will call:", 1 );
 
             if ( StringUtils.isNotEmpty( eGoal ) )
             {
                 append( buffer, "Single mojo", "'" + eGoal + "'", 2 );
             }
 
             if ( StringUtils.isNotEmpty( ePhase ) )
             {
                 String s = "Phase: '" + ePhase + "'";
 
                 if ( StringUtils.isNotEmpty( eLife ) )
                 {
                     s += " in Lifecycle Overlay: '" + eLife + "'";
                 }
 
                 append( buffer, s, 2 );
             }
         }
 
         buffer.append( "\n" );
 
         describeMojoParameters( md, buffer );
     }
 
     /**
      * Displays parameter information of the Plugin Mojo
      *
      * @param md contains the description of the Plugin Mojo
      * @param buffer contains information to be printed or displayed
      * @throws MojoFailureException if any reflection exceptions occur.
      * @throws MojoExecutionException if any
      */
     private void describeMojoParameters( MojoDescriptor md, StringBuffer buffer )
         throws MojoFailureException, MojoExecutionException
     {
         List params = md.getParameters();
 
         if ( params == null || params.isEmpty() )
         {
             append( buffer, "This mojo doesn't use any parameters.", 1 );
             return;
         }
 
         // TODO remove when maven-plugin-tools-api:2.4.4 is out see PluginUtils.sortMojoParameters()
         Collections.sort( params, new Comparator()
         {
             /** {@inheritDoc} */
             public int compare( Object o1, Object o2 )
             {
                 Parameter parameter1 = (Parameter) o1;
                 Parameter parameter2 = (Parameter) o2;
 
                 return parameter1.getName().compareToIgnoreCase( parameter2.getName() );
             }
         } );
 
         append( buffer, "Available parameters:", 1 );
 
         // indent 2
         for ( Iterator it = params.iterator(); it.hasNext(); )
         {
             Parameter parameter = (Parameter) it.next();
             if ( !parameter.isEditable() )
             {
                 continue;
             }
 
             buffer.append( "\n" );
 
             // DGF wouldn't it be nice if this worked?
             String defaultVal = parameter.getDefaultValue();
             if ( defaultVal == null )
             {
                 // defaultVal is ALWAYS null, this is a bug in PluginDescriptorBuilder
                 defaultVal =
                     md.getMojoConfiguration().getChild( parameter.getName() ).getAttribute( "default-value", null );
             }
 
             if ( StringUtils.isNotEmpty( defaultVal ) )
             {
                 defaultVal = " (Default: " + defaultVal + ")";
             }
             else
             {
                 defaultVal = "";
             }
             append( buffer, parameter.getName() + defaultVal, 2 );
 
             String expression = parameter.getExpression();
             if ( StringUtils.isNotEmpty( expression ) )
             {
                 append( buffer, "Expression", expression, 3 );
             }
 
             append( buffer, toDescription( parameter.getDescription() ), 3 );
 
             String deprecation = parameter.getDeprecated();
             if ( deprecation != null && deprecation.length() <= 0 )
             {
                 deprecation = NO_REASON;
             }
 
             if ( StringUtils.isNotEmpty( deprecation ) )
             {
                 append( buffer, "Deprecated. " + deprecation, 3 );
             }
         }
     }
 
     /**
      * Describe the <code>cmd</code> parameter
      *
      * @param descriptionBuffer not null
      * @return <code>true</code> if it implies to describe a plugin, <code>false</code> otherwise.
      * @throws MojoFailureException if any reflection exceptions occur or missing components.
      * @throws MojoExecutionException if any
      */
     private boolean describeCommand( StringBuffer descriptionBuffer )
         throws MojoFailureException, MojoExecutionException
     {
         if ( cmd.indexOf( ":" ) == -1 )
         {
             // phase
             try
             {
                 DefaultLifecycleExecutor lifecycleExecutor =
                     (DefaultLifecycleExecutor) session.lookup( LifecycleExecutor.ROLE );
 
                 Lifecycle lifecycle = (Lifecycle) lifecycleExecutor.getPhaseToLifecycleMap().get( cmd );
                 if ( lifecycle == null )
                 {
                     throw new MojoExecutionException( "The given phase '" + cmd + "' is an unknown phase." );
                 }
 
                 LifecycleMapping lifecycleMapping =
                     (LifecycleMapping) session.lookup( LifecycleMapping.ROLE, project.getPackaging() );
                 if ( lifecycle.getDefaultPhases() == null )
                 {
                     descriptionBuffer.append( "'" + cmd + "' is a phase corresponding to this plugin:\n" );
                     for ( Iterator it = lifecycle.getPhases().iterator(); it.hasNext(); )
                     {
                         String key = (String) it.next();
 
                         if ( !key.equals( cmd ) )
                         {
                             continue;
                         }
 
                         if ( lifecycleMapping.getPhases( "default" ).get( key ) != null )
                         {
                             descriptionBuffer.append( lifecycleMapping.getPhases( "default" ).get( key ) );
                             descriptionBuffer.append( "\n" );
                         }
                     }
 
                     descriptionBuffer.append( "\n" );
                     descriptionBuffer.append( "It is a part of the lifecycle for the POM packaging '"
                         + project.getPackaging() + "'. This lifecycle includes the following phases:" );
                     descriptionBuffer.append( "\n" );
                     for ( Iterator it = lifecycle.getPhases().iterator(); it.hasNext(); )
                     {
                         String key = (String) it.next();
 
                         descriptionBuffer.append( "* " + key + ": " );
                         String value = (String) lifecycleMapping.getPhases( "default" ).get( key );
                         if ( StringUtils.isNotEmpty( value ) )
                         {
                             for ( StringTokenizer tok = new StringTokenizer( value, "," ); tok.hasMoreTokens(); )
                             {
                                 descriptionBuffer.append( tok.nextToken().trim() );
 
                                 if ( !tok.hasMoreTokens() )
                                 {
                                     descriptionBuffer.append( "\n" );
                                 }
                                 else
                                 {
                                     descriptionBuffer.append( ", " );
                                 }
                             }
                         }
                         else
                         {
                             descriptionBuffer.append( NOT_DEFINED ).append( "\n" );
                         }
                     }
                 }
                 else
                 {
                     descriptionBuffer.append( "'" + cmd + "' is a lifecycle with the following phases: " );
                     descriptionBuffer.append( "\n" );
 
                     for ( Iterator it = lifecycle.getPhases().iterator(); it.hasNext(); )
                     {
                         String key = (String) it.next();
 
                         descriptionBuffer.append( "* " + key + ": " );
                         if ( lifecycle.getDefaultPhases().get( key ) != null )
                         {
                             descriptionBuffer.append( lifecycle.getDefaultPhases().get( key ) ).append( "\n" );
                         }
                         else
                         {
                             descriptionBuffer.append( NOT_DEFINED ).append( "\n" );
                         }
                     }
                 }
             }
             catch ( ComponentLookupException e )
             {
                 throw new MojoFailureException( "ComponentLookupException: " + e.getMessage() );
             }
             catch ( LifecycleExecutionException e )
             {
                 throw new MojoFailureException( "LifecycleExecutionException: " + e.getMessage() );
             }
 
             return false;
         }
 
         // goals
         MojoDescriptor mojoDescriptor = HelpUtil.getMojoDescriptor( cmd, session, project, cmd, true, false );
 
         descriptionBuffer.append( "'" + cmd + "' is a plugin goal (aka mojo)" ).append( ".\n" );
         plugin = mojoDescriptor.getPluginDescriptor().getId();
         goal = mojoDescriptor.getGoal();
 
         return true;
     }
 
     /**
      * Invoke the following private method
      * <code>HelpMojo#toLines(String, int, int, int)</code>
      *
      * @param text The text to split into lines, must not be <code>null</code>.
      * @param indent The base indentation level of each line, must not be negative.
      * @param indentSize The size of each indentation, must not be negative.
      * @param lineLength The length of the line, must not be negative.
      * @return The sequence of display lines, never <code>null</code>.
      * @throws MojoFailureException if any can not invoke the method
      * @throws MojoExecutionException if no line was found for <code>text</code>
      * @see HelpMojo#toLines(String, int, int, int)
      */
     private static List toLines( String text, int indent, int indentSize, int lineLength )
         throws MojoFailureException, MojoExecutionException
     {
         try
         {
             Method m =
                 HelpMojo.class.getDeclaredMethod( "toLines", new Class[] { String.class, Integer.TYPE,
                     Integer.TYPE, Integer.TYPE } );
             m.setAccessible( true );
             List output =
                 (List) m.invoke( HelpMojo.class, new Object[] { text, new Integer( indent ),
                     new Integer( indentSize ), new Integer( lineLength ) } );
 
             if ( output == null )
             {
                 throw new MojoExecutionException( "No output was specified." );
             }
 
             return output;
         }
         catch ( SecurityException e )
         {
             throw new MojoFailureException( "SecurityException: " + e.getMessage() );
         }
         catch ( IllegalArgumentException e )
         {
             throw new MojoFailureException( "IllegalArgumentException: " + e.getMessage() );
         }
         catch ( NoSuchMethodException e )
         {
             throw new MojoFailureException( "NoSuchMethodException: " + e.getMessage() );
         }
         catch ( IllegalAccessException e )
         {
             throw new MojoFailureException( "IllegalAccessException: " + e.getMessage() );
         }
         catch ( InvocationTargetException e )
         {
             Throwable cause = e.getCause();
 
             if ( cause instanceof NegativeArraySizeException )
             {
                 throw new MojoFailureException( "NegativeArraySizeException: " + cause.getMessage() );
             }
 
             throw new MojoFailureException( "InvocationTargetException: " + e.getMessage() );
         }
     }
 
     /**
      * Append a description to the buffer by respecting the indentSize and lineLength parameters.
      * <b>Note</b>: The last character is always a new line.
      *
      * @param sb The buffer to append the description, not <code>null</code>.
      * @param description The description, not <code>null</code>.
      * @param indent The base indentation level of each line, must not be negative.
      * @throws MojoFailureException if any reflection exceptions occur.
      * @throws MojoExecutionException if any
      * @see #toLines(String, int, int, int)
      */
     private static void append( StringBuffer sb, String description, int indent )
         throws MojoFailureException, MojoExecutionException
     {
         if ( StringUtils.isEmpty( description ) )
         {
             sb.append( UNKNOWN ).append( '\n' );
             return;
         }
 
         for ( Iterator it = toLines( description, indent, INDENT_SIZE, LINE_LENGTH ).iterator(); it.hasNext(); )
         {
             sb.append( it.next().toString() ).append( '\n' );
         }
     }
 
     /**
      * Append a description to the buffer by respecting the indentSize and lineLength parameters.
      * <b>Note</b>: The last character is always a new line.
      *
      * @param sb The buffer to append the description, not <code>null</code>.
      * @param key The key, not <code>null</code>.
      * @param value The value associated to the key, could be <code>null</code>.
      * @param indent The base indentation level of each line, must not be negative.
      * @throws MojoFailureException if any reflection exceptions occur.
      * @throws MojoExecutionException if any
      * @see #toLines(String, int, int, int)
      */
     private static void append( StringBuffer sb, String key, String value, int indent )
         throws MojoFailureException, MojoExecutionException
     {
         if ( StringUtils.isEmpty( key ) )
         {
             throw new IllegalArgumentException( "Key is required!" );
         }
 
         if ( StringUtils.isEmpty( value ) )
         {
             value = UNKNOWN;
         }
 
         String description = key + ": " + value;
         for ( Iterator it = toLines( description, indent, INDENT_SIZE, LINE_LENGTH ).iterator(); it.hasNext(); )
         {
             sb.append( it.next().toString() ).append( '\n' );
         }
     }
 
     /**
      * Append a description to the buffer by respecting the indentSize and lineLength parameters for the first line,
      * and append the next lines with <code>indent + 1</code> like a paragraph.
      * <b>Note</b>: The last character is always a new line.
      *
      * @param sb The buffer to append the description, not <code>null</code>.
      * @param key The key, not <code>null</code>.
      * @param value The value, could be <code>null</code>.
      * @param indent The base indentation level of each line, must not be negative.
      * @throws MojoFailureException if any reflection exceptions occur.
      * @throws MojoExecutionException if any
      * @see #toLines(String, int, int, int)
      */
     private static void appendAsParagraph( StringBuffer sb, String key, String value, int indent )
         throws MojoFailureException, MojoExecutionException
     {
         if ( StringUtils.isEmpty( value ) )
         {
             value = UNKNOWN;
         }
 
         String description;
         if ( key == null )
         {
             description = value;
         }
         else
         {
             description = key + ": " + value;
         }
 
         List l1 = toLines( description, indent, INDENT_SIZE, LINE_LENGTH - INDENT_SIZE );
         List l2 = toLines( description, indent + 1, INDENT_SIZE, LINE_LENGTH );
         l2.set( 0, l1.get( 0 ) );
         for ( Iterator it = l2.iterator(); it.hasNext(); )
         {
             sb.append( it.next().toString() ).append( '\n' );
         }
     }
 
     /**
      * Gets the effective string to use for the plugin/mojo/parameter description.
      *
      * @param description The description of the element, may be <code>null</code>.
      * @return The effective description string, never <code>null</code>.
      */
     private static String toDescription( String description )
     {
         if ( StringUtils.isNotEmpty( description ) )
         {
             return PluginUtils.toText( description );
         }
 
         return "(no description available)";
     }
 
     /**
      * Class to wrap Plugin information.
      */
     static class PluginInfo
     {
         private String prefix;
 
         private String groupId;
 
         private String artifactId;
 
         private String version;
 
         private String mojo;
 
         private Plugin plugin;
 
         private PluginDescriptor pluginDescriptor;
 
         /**
          * @return the prefix
          */
         public String getPrefix()
         {
             return prefix;
         }
 
         /**
          * @param prefix the prefix to set
          */
         public void setPrefix( String prefix )
         {
             this.prefix = prefix;
         }
 
         /**
          * @return the groupId
          */
         public String getGroupId()
         {
             return groupId;
         }
 
         /**
          * @param groupId the groupId to set
          */
         public void setGroupId( String groupId )
         {
             this.groupId = groupId;
         }
 
         /**
          * @return the artifactId
          */
         public String getArtifactId()
         {
             return artifactId;
         }
 
         /**
          * @param artifactId the artifactId to set
          */
         public void setArtifactId( String artifactId )
         {
             this.artifactId = artifactId;
         }
 
         /**
          * @return the version
          */
         public String getVersion()
         {
             return version;
         }
 
         /**
          * @param version the version to set
          */
         public void setVersion( String version )
         {
             this.version = version;
         }
 
         /**
          * @return the mojo
          */
         public String getMojo()
         {
             return mojo;
         }
 
         /**
          * @param mojo the mojo to set
          */
         public void setMojo( String mojo )
         {
             this.mojo = mojo;
         }
 
         /**
          * @return the plugin
          */
         public Plugin getPlugin()
         {
             return plugin;
         }
 
         /**
          * @param plugin the plugin to set
          */
         public void setPlugin( Plugin plugin )
         {
             this.plugin = plugin;
         }
 
         /**
          * @return the pluginDescriptor
          */
         public PluginDescriptor getPluginDescriptor()
         {
             return pluginDescriptor;
         }
 
         /**
          * @param pluginDescriptor the pluginDescriptor to set
          */
         public void setPluginDescriptor( PluginDescriptor pluginDescriptor )
         {
             this.pluginDescriptor = pluginDescriptor;
         }
     }
 }