package org.apache.maven.tools.plugin.generator;
/*
* 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.plugin.descriptor.DuplicateMojoDescriptorException;
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.descriptor.Requirement;
import org.apache.maven.project.MavenProject;
import org.apache.maven.tools.plugin.ExtendedMojoDescriptor;
import org.apache.maven.tools.plugin.PluginToolsRequest;
import org.apache.maven.tools.plugin.util.PluginUtils;
import org.codehaus.plexus.util.IOUtil;
import org.codehaus.plexus.util.PropertyUtils;
import org.codehaus.plexus.util.StringUtils;
import org.codehaus.plexus.util.xml.PrettyPrintXMLWriter;
import org.codehaus.plexus.util.xml.XMLWriter;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.ClassVisitor;
import org.objectweb.asm.ClassWriter;
import org.objectweb.asm.commons.RemappingClassAdapter;
import org.objectweb.asm.commons.SimpleRemapper;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
/**
* Generate a <a href="/ref/current/maven-plugin-api/plugin.html">Maven Plugin Descriptor XML file</a> and
* corresponding help content.
*
* @version $Id: PluginDescriptorGenerator.java 1343173 2012-05-28 09:30:23Z hboutemy $
* @todo add example usage tag that can be shown in the doco
* @todo need to add validation directives so that systems embedding maven2 can
* get validation directives to help users in IDEs.
*/
public class PluginDescriptorGenerator
implements Generator
{
/**
* {@inheritDoc}
*/
public void execute( File destinationDirectory, PluginToolsRequest request )
throws GeneratorException
{
File tmpPropertiesFile =
new File( request.getProject().getBuild().getDirectory(), "maven-plugin-help.properties" );
if ( tmpPropertiesFile.exists() )
{
Properties properties = PropertyUtils.loadProperties( tmpPropertiesFile );
String helpPackageName = properties.getProperty( "helpPackageName" );
// if helpPackageName property is empty we have to rewrite the class with a better package name than empty
if ( StringUtils.isEmpty( helpPackageName ) )
{
String helpMojoImplementation = rewriteHelpClassToMojoPackage( request );
if ( helpMojoImplementation != null )
{
// rewrite plugin descriptor with new HelpMojo implementation class
rewriteDescriptor( request.getPluginDescriptor(), helpMojoImplementation );
}
}
}
try
{
// write complete plugin.xml descriptor
File f = new File( destinationDirectory, "plugin.xml" );
writeDescriptor( f, request, false );
// write plugin-help.xml help-descriptor
MavenProject mavenProject = request.getProject();
String pluginHelpFilePath =
"META-INF/maven/" + mavenProject.getGroupId() + "/" + mavenProject.getArtifactId()
+ "/plugin-help.xml";
f = new File( request.getProject().getBuild().getOutputDirectory(), pluginHelpFilePath );
writeDescriptor( f, request, true );
}
catch ( IOException e )
{
throw new GeneratorException( e.getMessage(), e );
}
catch ( DuplicateMojoDescriptorException e )
{
throw new GeneratorException( e.getMessage(), e );
}
}
private String getVersion()
{
Package p = this.getClass().getPackage();
String version = ( p == null ) ? null : p.getSpecificationVersion();
return ( version == null ) ? "SNAPSHOT" : version;
}
public void writeDescriptor( File destinationFile, PluginToolsRequest request, boolean helpDescriptor )
throws IOException, DuplicateMojoDescriptorException
{
PluginDescriptor pluginDescriptor = request.getPluginDescriptor();
if ( destinationFile.exists() )
{
destinationFile.delete();
}
else
{
if ( !destinationFile.getParentFile().exists() )
{
destinationFile.getParentFile().mkdirs();
}
}
String encoding = "UTF-8";
Writer writer = null;
try
{
writer = new OutputStreamWriter( new FileOutputStream( destinationFile ), encoding );
XMLWriter w = new PrettyPrintXMLWriter( writer, encoding, null );
w.writeMarkup( "\n<!-- Generated by maven-plugin-tools " + getVersion() + " on "
+ new SimpleDateFormat( "yyyy-MM-dd" ).format( new Date() ) + " -->\n\n" );
w.startElement( "plugin" );
GeneratorUtils.element( w, "name", pluginDescriptor.getName() );
GeneratorUtils.element( w, "description", pluginDescriptor.getDescription(), helpDescriptor );
GeneratorUtils.element( w, "groupId", pluginDescriptor.getGroupId() );
GeneratorUtils.element( w, "artifactId", pluginDescriptor.getArtifactId() );
GeneratorUtils.element( w, "version", pluginDescriptor.getVersion() );
GeneratorUtils.element( w, "goalPrefix", pluginDescriptor.getGoalPrefix() );
if ( !helpDescriptor )
{
GeneratorUtils.element( w, "isolatedRealm", String.valueOf( pluginDescriptor.isIsolatedRealm() ) );
GeneratorUtils.element( w, "inheritedByDefault", String.valueOf( pluginDescriptor.isInheritedByDefault() ) );
}
w.startElement( "mojos" );
if ( pluginDescriptor.getMojos() != null )
{
@SuppressWarnings( "unchecked" ) List<MojoDescriptor> descriptors = pluginDescriptor.getMojos();
if ( helpDescriptor )
{
PluginUtils.sortMojos( descriptors );
}
for ( MojoDescriptor descriptor : descriptors )
{
processMojoDescriptor( descriptor, w, helpDescriptor );
}
}
w.endElement();
if ( !helpDescriptor )
{
GeneratorUtils.writeDependencies( w, pluginDescriptor );
}
w.endElement();
writer.flush();
}
finally
{
IOUtil.close( writer );
}
}
protected void processMojoDescriptor( MojoDescriptor mojoDescriptor, XMLWriter w )
{
processMojoDescriptor( mojoDescriptor, w, false );
}
/**
* @param mojoDescriptor not null
* @param w not null
* @param helpDescriptor will clean html content from description fields
*/
protected void processMojoDescriptor( MojoDescriptor mojoDescriptor, XMLWriter w, boolean helpDescriptor )
{
w.startElement( "mojo" );
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
w.startElement( "goal" );
w.writeText( mojoDescriptor.getGoal() );
w.endElement();
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
String description = mojoDescriptor.getDescription();
if ( description != null )
{
w.startElement( "description" );
if ( helpDescriptor )
{
w.writeText( GeneratorUtils.toText( mojoDescriptor.getDescription() ) );
}
else
{
w.writeText( mojoDescriptor.getDescription() );
}
w.endElement();
}
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
if ( mojoDescriptor.isDependencyResolutionRequired() != null )
{
GeneratorUtils.element( w, "requiresDependencyResolution", mojoDescriptor.isDependencyResolutionRequired() );
}
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
GeneratorUtils.element( w, "requiresDirectInvocation", String.valueOf( mojoDescriptor.isDirectInvocationOnly() ) );
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
GeneratorUtils.element( w, "requiresProject", String.valueOf( mojoDescriptor.isProjectRequired() ) );
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
GeneratorUtils.element( w, "requiresReports", String.valueOf( mojoDescriptor.isRequiresReports() ) );
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
GeneratorUtils.element( w, "aggregator", String.valueOf( mojoDescriptor.isAggregator() ) );
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
GeneratorUtils.element( w, "requiresOnline", String.valueOf( mojoDescriptor.isOnlineRequired() ) );
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
GeneratorUtils.element( w, "inheritedByDefault", String.valueOf( mojoDescriptor.isInheritedByDefault() ) );
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
if ( mojoDescriptor.getPhase() != null )
{
GeneratorUtils.element( w, "phase", mojoDescriptor.getPhase() );
}
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
if ( mojoDescriptor.getExecutePhase() != null )
{
GeneratorUtils.element( w, "executePhase", mojoDescriptor.getExecutePhase() );
}
if ( mojoDescriptor.getExecuteGoal() != null )
{
GeneratorUtils.element( w, "executeGoal", mojoDescriptor.getExecuteGoal() );
}
if ( mojoDescriptor.getExecuteLifecycle() != null )
{
GeneratorUtils.element( w, "executeLifecycle", mojoDescriptor.getExecuteLifecycle() );
}
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
w.startElement( "implementation" );
w.writeText( mojoDescriptor.getImplementation() );
w.endElement();
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
w.startElement( "language" );
w.writeText( mojoDescriptor.getLanguage() );
w.endElement();
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
if ( mojoDescriptor.getComponentConfigurator() != null )
{
w.startElement( "configurator" );
w.writeText( mojoDescriptor.getComponentConfigurator() );
w.endElement();
}
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
if ( mojoDescriptor.getComponentComposer() != null )
{
w.startElement( "composer" );
w.writeText( mojoDescriptor.getComponentComposer() );
w.endElement();
}
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
w.startElement( "instantiationStrategy" );
w.writeText( mojoDescriptor.getInstantiationStrategy() );
w.endElement();
// ----------------------------------------------------------------------
// Strategy for handling repeated reference to mojo in
// the calculated (decorated, resolved) execution stack
// ----------------------------------------------------------------------
w.startElement( "executionStrategy" );
w.writeText( mojoDescriptor.getExecutionStrategy() );
w.endElement();
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
if ( mojoDescriptor.getSince() != null )
{
w.startElement( "since" );
if ( StringUtils.isEmpty( mojoDescriptor.getSince() ) )
{
w.writeText( "No version given" );
}
else
{
w.writeText( mojoDescriptor.getSince() );
}
w.endElement();
}
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
if ( mojoDescriptor.getDeprecated() != null )
{
w.startElement( "deprecated" );
if ( StringUtils.isEmpty( mojoDescriptor.getDeprecated() ) )
{
w.writeText( "No reason given" );
}
else
{
w.writeText( mojoDescriptor.getDeprecated() );
}
w.endElement();
}
// ----------------------------------------------------------------------
// Extended (3.0) descriptor
// ----------------------------------------------------------------------
if ( mojoDescriptor instanceof ExtendedMojoDescriptor )
{
ExtendedMojoDescriptor extendedMojoDescriptor = (ExtendedMojoDescriptor) mojoDescriptor;
if ( extendedMojoDescriptor.getDependencyCollectionRequired() != null )
{
GeneratorUtils.element( w, "requiresDependencyCollection",
extendedMojoDescriptor.getDependencyCollectionRequired() );
}
GeneratorUtils.element( w, "threadSafe", String.valueOf( extendedMojoDescriptor.isThreadSafe() ) );
}
// ----------------------------------------------------------------------
// Parameters
// ----------------------------------------------------------------------
@SuppressWarnings( "unchecked" ) List<Parameter> parameters = mojoDescriptor.getParameters();
w.startElement( "parameters" );
Map<String, Requirement> requirements = new LinkedHashMap<String, Requirement>();
Set<Parameter> configuration = new LinkedHashSet<Parameter>();
if ( parameters != null )
{
if ( helpDescriptor )
{
PluginUtils.sortMojoParameters( parameters );
}
for ( Parameter parameter : parameters )
{
String expression = getExpression( parameter );
if ( StringUtils.isNotEmpty( expression ) && expression.startsWith( "${component." ) )
{
// treat it as a component...a requirement, in other words.
// remove "component." plus expression delimiters
String role = expression.substring( "${component.".length(), expression.length() - 1 );
String roleHint = null;
int posRoleHintSeparator = role.indexOf( "#" );
if ( posRoleHintSeparator > 0 )
{
roleHint = role.substring( posRoleHintSeparator + 1 );
role = role.substring( 0, posRoleHintSeparator );
}
// TODO: remove deprecated expression
requirements.put( parameter.getName(), new Requirement( role, roleHint ) );
}
else if ( parameter.getRequirement() != null )
{
requirements.put( parameter.getName(), parameter.getRequirement() );
}
else if ( !helpDescriptor || parameter.isEditable() ) // don't show readonly parameters in help
{
// treat it as a normal parameter.
w.startElement( "parameter" );
GeneratorUtils.element( w, "name", parameter.getName() );
if ( parameter.getAlias() != null )
{
GeneratorUtils.element( w, "alias", parameter.getAlias() );
}
GeneratorUtils.element( w, "type", parameter.getType() );
if ( parameter.getSince() != null )
{
w.startElement( "since" );
if ( StringUtils.isEmpty( parameter.getSince() ) )
{
w.writeText( "No version given" );
}
else
{
w.writeText( parameter.getSince() );
}
w.endElement();
}
if ( parameter.getDeprecated() != null )
{
if ( StringUtils.isEmpty( parameter.getDeprecated() ) )
{
GeneratorUtils.element( w, "deprecated", "No reason given" );
}
else
{
GeneratorUtils.element( w, "deprecated", parameter.getDeprecated() );
}
}
if ( parameter.getImplementation() != null )
{
GeneratorUtils.element( w, "implementation", parameter.getImplementation() );
}
GeneratorUtils.element( w, "required", Boolean.toString( parameter.isRequired() ) );
GeneratorUtils.element( w, "editable", Boolean.toString( parameter.isEditable() ) );
GeneratorUtils.element( w, "description", parameter.getDescription(), helpDescriptor );
if ( StringUtils.isNotEmpty( parameter.getDefaultValue() )
|| StringUtils.isNotEmpty( parameter.getExpression() ) )
{
configuration.add( parameter );
}
w.endElement();
}
}
}
w.endElement();
// ----------------------------------------------------------------------
// Configuration
// ----------------------------------------------------------------------
if ( !configuration.isEmpty() )
{
w.startElement( "configuration" );
for ( Parameter parameter : configuration )
{
if ( helpDescriptor && !parameter.isEditable() )
{
// don't show readonly parameters in help
continue;
}
w.startElement( parameter.getName() );
String type = parameter.getType();
if ( type != null )
{
w.addAttribute( "implementation", type );
}
if ( parameter.getDefaultValue() != null )
{
w.addAttribute( "default-value", parameter.getDefaultValue() );
}
if ( parameter.getExpression() != null )
{
w.writeText( parameter.getExpression() );
}
w.endElement();
}
w.endElement();
}
// ----------------------------------------------------------------------
// Requirements
// ----------------------------------------------------------------------
if ( !requirements.isEmpty() && !helpDescriptor )
{
w.startElement( "requirements" );
for ( Map.Entry<String, Requirement> entry : requirements.entrySet() )
{
String key = entry.getKey();
Requirement requirement = entry.getValue();
w.startElement( "requirement" );
GeneratorUtils.element( w, "role", requirement.getRole() );
if ( requirement.getRoleHint() != null )
{
GeneratorUtils.element( w, "role-hint", requirement.getRoleHint() );
}
GeneratorUtils.element( w, "field-name", key );
w.endElement();
}
w.endElement();
}
w.endElement();
}
/**
* Get the expression value, eventually surrounding it with <code>${ }</code>.
*
* @param parameter the parameter
* @return the expression value
*/
private String getExpression( Parameter parameter )
{
String expression = parameter.getExpression();
if ( StringUtils.isNotBlank( expression ) && !expression.contains( "${" ) )
{
expression = "${" + expression.trim() + "}";
parameter.setExpression( expression );
}
return expression;
}
protected String rewriteHelpClassToMojoPackage( PluginToolsRequest request )
throws GeneratorException
{
String destinationPackage = GeneratorUtils.discoverPackageName( request.getPluginDescriptor() );
if ( StringUtils.isEmpty( destinationPackage ) )
{
return null;
}
File helpClassFile = new File( request.getProject().getBuild().getOutputDirectory(), "HelpMojo.class" );
if ( !helpClassFile.exists() )
{
return null;
}
File rewriteHelpClassFile = new File(
request.getProject().getBuild().getOutputDirectory() + "/" + StringUtils.replace( destinationPackage, ".",
"/" ), "HelpMojo.class" );
if ( !rewriteHelpClassFile.getParentFile().exists() )
{
rewriteHelpClassFile.getParentFile().mkdirs();
}
ClassReader cr = null;
try
{
cr = new ClassReader( new FileInputStream( helpClassFile ) );
}
catch ( IOException e )
{
throw new GeneratorException( e.getMessage(), e );
}
ClassWriter cw = new ClassWriter( 0 );
ClassVisitor cv = new RemappingClassAdapter( cw, new SimpleRemapper( "HelpMojo",
StringUtils.replace( destinationPackage,
".", "/" )
+ "/HelpMojo" ) );
try
{
cr.accept( cv, ClassReader.EXPAND_FRAMES );
}
catch ( Throwable e )
{
throw new GeneratorException( "ASM issue processing classFile " + helpClassFile.getPath(), e );
}
byte[] renamedClass = cw.toByteArray();
FileOutputStream fos = null;
try
{
fos = new FileOutputStream( rewriteHelpClassFile );
fos.write( renamedClass );
}
catch ( IOException e )
{
throw new GeneratorException( "Error rewriting help class: " + e.getMessage(), e );
}
finally
{
IOUtil.close( fos );
}
helpClassFile.delete();
return destinationPackage + ".HelpMojo";
}
private void rewriteDescriptor( PluginDescriptor pluginDescriptor, String helpMojoImplementation )
{
MojoDescriptor mojoDescriptor = pluginDescriptor.getMojo( "help" );
if ( mojoDescriptor != null )
{
mojoDescriptor.setImplementation( helpMojoImplementation );
}
}
}