Coverage Report

Coverage Report - org.apache.maven.tools.plugin.generator.PluginDescriptorGenerator

Classes in this File

Line Coverage

Branch Coverage

Complexity

PluginDescriptorGenerator

65 %

130/200

49 %

53/108

10,667

 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.StringUtils;
 import org.codehaus.plexus.util.xml.PrettyPrintXMLWriter;
 import org.codehaus.plexus.util.xml.XMLWriter;
 
 import java.io.File;
 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.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 1354239 2012-06-26 21:19:06Z 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
     {
         // eventually rewrite help mojo class to match actual package name
         PluginHelpGenerator.rewriteHelpMojo( request );
 
         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 ( StringUtils.isNotEmpty( mojoDescriptor.isDependencyResolutionRequired() ) )
         {
             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 ( StringUtils.isNotEmpty( mojoDescriptor.getPhase() ) )
         {
             GeneratorUtils.element( w, "phase", mojoDescriptor.getPhase() );
         }
 
         // ----------------------------------------------------------------------
         //
         // ----------------------------------------------------------------------
 
         if ( StringUtils.isNotEmpty( mojoDescriptor.getExecutePhase() ) )
         {
             GeneratorUtils.element( w, "executePhase", mojoDescriptor.getExecutePhase() );
         }
 
         if ( StringUtils.isNotEmpty( mojoDescriptor.getExecuteGoal() ) )
         {
             GeneratorUtils.element( w, "executeGoal", mojoDescriptor.getExecuteGoal() );
         }
 
         if ( StringUtils.isNotEmpty( mojoDescriptor.getExecuteLifecycle() ) )
         {
             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 ( StringUtils.isNotEmpty( mojoDescriptor.getComponentConfigurator() ) )
         {
             w.startElement( "configurator" );
             w.writeText( mojoDescriptor.getComponentConfigurator() );
             w.endElement();
         }
 
         // ----------------------------------------------------------------------
         //
         // ----------------------------------------------------------------------
 
         if ( StringUtils.isNotEmpty( mojoDescriptor.getComponentComposer() ) )
         {
             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 ( StringUtils.isNotEmpty( type ) )
                 {
                     w.addAttribute( "implementation", type );
                 }
 
                 if ( parameter.getDefaultValue() != null )
                 {
                     w.addAttribute( "default-value", parameter.getDefaultValue() );
                 }
 
                 if ( StringUtils.isNotEmpty( parameter.getExpression() ) )
                 {
                     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 ( StringUtils.isNotEmpty( requirement.getRoleHint() ) )
                 {
                     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;
     }
 }

1		package org.apache.maven.tools.plugin.generator;
2
3		/*
4		* Licensed to the Apache Software Foundation (ASF) under one
5		* or more contributor license agreements. See the NOTICE file
6		* distributed with this work for additional information
7		* regarding copyright ownership. The ASF licenses this file
8		* to you under the Apache License, Version 2.0 (the
9		* "License"); you may not use this file except in compliance
10		* with the License. You may obtain a copy of the License at
11		*
12		* http://www.apache.org/licenses/LICENSE-2.0
13		*
14		* Unless required by applicable law or agreed to in writing,
15		* software distributed under the License is distributed on an
16		* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17		* KIND, either express or implied. See the License for the
18		* specific language governing permissions and limitations
19		* under the License.
20		*/
21
22		import org.apache.maven.plugin.descriptor.DuplicateMojoDescriptorException;
23		import org.apache.maven.plugin.descriptor.MojoDescriptor;
24		import org.apache.maven.plugin.descriptor.Parameter;
25		import org.apache.maven.plugin.descriptor.PluginDescriptor;
26		import org.apache.maven.plugin.descriptor.Requirement;
27		import org.apache.maven.project.MavenProject;
28		import org.apache.maven.tools.plugin.ExtendedMojoDescriptor;
29		import org.apache.maven.tools.plugin.PluginToolsRequest;
30		import org.apache.maven.tools.plugin.util.PluginUtils;
31		import org.codehaus.plexus.util.IOUtil;
32		import org.codehaus.plexus.util.StringUtils;
33		import org.codehaus.plexus.util.xml.PrettyPrintXMLWriter;
34		import org.codehaus.plexus.util.xml.XMLWriter;
35
36		import java.io.File;
37		import java.io.FileOutputStream;
38		import java.io.IOException;
39		import java.io.OutputStreamWriter;
40		import java.io.Writer;
41		import java.text.SimpleDateFormat;
42		import java.util.Date;
43		import java.util.LinkedHashMap;
44		import java.util.LinkedHashSet;
45		import java.util.List;
46		import java.util.Map;
47		import java.util.Set;
48
49		/**
50		* Generate a <a href="/ref/current/maven-plugin-api/plugin.html">Maven Plugin Descriptor XML file</a> and
51		* corresponding help content.
52		*
53		* @version $Id: PluginDescriptorGenerator.java 1354239 2012-06-26 21:19:06Z hboutemy $
54		* @todo add example usage tag that can be shown in the doco
55		* @todo need to add validation directives so that systems embedding maven2 can
56		* get validation directives to help users in IDEs.
57		*/
58	1	public class PluginDescriptorGenerator
59		implements Generator
60		{
61
62		/**
63		* {@inheritDoc}
64		*/
65		public void execute( File destinationDirectory, PluginToolsRequest request )
66		throws GeneratorException
67		{
68		// eventually rewrite help mojo class to match actual package name
69	1	PluginHelpGenerator.rewriteHelpMojo( request );
70
71		try
72		{
73		// write complete plugin.xml descriptor
74	1	File f = new File( destinationDirectory, "plugin.xml" );
75	1	writeDescriptor( f, request, false );
76
77		// write plugin-help.xml help-descriptor
78	1	MavenProject mavenProject = request.getProject();
79	1	String pluginHelpFilePath =
80		"META-INF/maven/" + mavenProject.getGroupId() + "/" + mavenProject.getArtifactId() + "/plugin-help.xml";
81
82	1	f = new File( request.getProject().getBuild().getOutputDirectory(), pluginHelpFilePath );
83	1	writeDescriptor( f, request, true );
84		}
85	0	catch ( IOException e )
86		{
87	0	throw new GeneratorException( e.getMessage(), e );
88		}
89	0	catch ( DuplicateMojoDescriptorException e )
90		{
91	0	throw new GeneratorException( e.getMessage(), e );
92	1	}
93	1	}
94
95		private String getVersion()
96		{
97	2	Package p = this.getClass().getPackage();
98	2	String version = ( p == null ) ? null : p.getSpecificationVersion();
99	2	return ( version == null ) ? "SNAPSHOT" : version;
100		}
101
102		public void writeDescriptor( File destinationFile, PluginToolsRequest request, boolean helpDescriptor )
103		throws IOException, DuplicateMojoDescriptorException
104		{
105	2	PluginDescriptor pluginDescriptor = request.getPluginDescriptor();
106
107	2	if ( destinationFile.exists() )
108		{
109	1	destinationFile.delete();
110		}
111		else
112		{
113	1	if ( !destinationFile.getParentFile().exists() )
114		{
115	0	destinationFile.getParentFile().mkdirs();
116		}
117		}
118
119	2	String encoding = "UTF-8";
120
121	2	Writer writer = null;
122		try
123		{
124	2	writer = new OutputStreamWriter( new FileOutputStream( destinationFile ), encoding );
125
126	2	XMLWriter w = new PrettyPrintXMLWriter( writer, encoding, null );
127
128	2	w.writeMarkup( "\n<!-- Generated by maven-plugin-tools " + getVersion() + " on " + new SimpleDateFormat(
129		"yyyy-MM-dd" ).format( new Date() ) + " -->\n\n" );
130
131	2	w.startElement( "plugin" );
132
133	2	GeneratorUtils.element( w, "name", pluginDescriptor.getName() );
134
135	2	GeneratorUtils.element( w, "description", pluginDescriptor.getDescription(), helpDescriptor );
136
137	2	GeneratorUtils.element( w, "groupId", pluginDescriptor.getGroupId() );
138
139	2	GeneratorUtils.element( w, "artifactId", pluginDescriptor.getArtifactId() );
140
141	2	GeneratorUtils.element( w, "version", pluginDescriptor.getVersion() );
142
143	2	GeneratorUtils.element( w, "goalPrefix", pluginDescriptor.getGoalPrefix() );
144
145	2	if ( !helpDescriptor )
146		{
147	1	GeneratorUtils.element( w, "isolatedRealm", String.valueOf( pluginDescriptor.isIsolatedRealm() ) );
148
149	1	GeneratorUtils.element( w, "inheritedByDefault",
150		String.valueOf( pluginDescriptor.isInheritedByDefault() ) );
151		}
152
153	2	w.startElement( "mojos" );
154
155	2	if ( pluginDescriptor.getMojos() != null )
156		{
157	2	@SuppressWarnings( "unchecked" ) List<MojoDescriptor> descriptors = pluginDescriptor.getMojos();
158
159	2	if ( helpDescriptor )
160		{
161	1	PluginUtils.sortMojos( descriptors );
162		}
163
164	2	for ( MojoDescriptor descriptor : descriptors )
165		{
166	2	processMojoDescriptor( descriptor, w, helpDescriptor );
167		}
168		}
169
170	2	w.endElement();
171
172	2	if ( !helpDescriptor )
173		{
174	1	GeneratorUtils.writeDependencies( w, pluginDescriptor );
175		}
176
177	2	w.endElement();
178
179	2	writer.flush();
180
181		}
182		finally
183		{
184	2	IOUtil.close( writer );
185	2	}
186	2	}
187
188		protected void processMojoDescriptor( MojoDescriptor mojoDescriptor, XMLWriter w )
189		{
190	0	processMojoDescriptor( mojoDescriptor, w, false );
191	0	}
192
193		/**
194		* @param mojoDescriptor not null
195		* @param w not null
196		* @param helpDescriptor will clean html content from description fields
197		*/
198		protected void processMojoDescriptor( MojoDescriptor mojoDescriptor, XMLWriter w, boolean helpDescriptor )
199		{
200	2	w.startElement( "mojo" );
201
202		// ----------------------------------------------------------------------
203		//
204		// ----------------------------------------------------------------------
205
206	2	w.startElement( "goal" );
207	2	w.writeText( mojoDescriptor.getGoal() );
208	2	w.endElement();
209
210		// ----------------------------------------------------------------------
211		//
212		// ----------------------------------------------------------------------
213
214	2	String description = mojoDescriptor.getDescription();
215
216	2	if ( description != null )
217		{
218	0	w.startElement( "description" );
219	0	if ( helpDescriptor )
220		{
221	0	w.writeText( GeneratorUtils.toText( mojoDescriptor.getDescription() ) );
222		}
223		else
224		{
225	0	w.writeText( mojoDescriptor.getDescription() );
226		}
227	0	w.endElement();
228		}
229
230		// ----------------------------------------------------------------------
231		//
232		// ----------------------------------------------------------------------
233
234	2	if ( StringUtils.isNotEmpty( mojoDescriptor.isDependencyResolutionRequired() ) )
235		{
236	2	GeneratorUtils.element( w, "requiresDependencyResolution",
237		mojoDescriptor.isDependencyResolutionRequired() );
238		}
239
240		// ----------------------------------------------------------------------
241		//
242		// ----------------------------------------------------------------------
243
244	2	GeneratorUtils.element( w, "requiresDirectInvocation",
245		String.valueOf( mojoDescriptor.isDirectInvocationOnly() ) );
246
247		// ----------------------------------------------------------------------
248		//
249		// ----------------------------------------------------------------------
250
251	2	GeneratorUtils.element( w, "requiresProject", String.valueOf( mojoDescriptor.isProjectRequired() ) );
252
253		// ----------------------------------------------------------------------
254		//
255		// ----------------------------------------------------------------------
256
257	2	GeneratorUtils.element( w, "requiresReports", String.valueOf( mojoDescriptor.isRequiresReports() ) );
258
259		// ----------------------------------------------------------------------
260		//
261		// ----------------------------------------------------------------------
262
263	2	GeneratorUtils.element( w, "aggregator", String.valueOf( mojoDescriptor.isAggregator() ) );
264
265		// ----------------------------------------------------------------------
266		//
267		// ----------------------------------------------------------------------
268
269	2	GeneratorUtils.element( w, "requiresOnline", String.valueOf( mojoDescriptor.isOnlineRequired() ) );
270
271		// ----------------------------------------------------------------------
272		//
273		// ----------------------------------------------------------------------
274
275	2	GeneratorUtils.element( w, "inheritedByDefault", String.valueOf( mojoDescriptor.isInheritedByDefault() ) );
276
277		// ----------------------------------------------------------------------
278		//
279		// ----------------------------------------------------------------------
280
281	2	if ( StringUtils.isNotEmpty( mojoDescriptor.getPhase() ) )
282		{
283	0	GeneratorUtils.element( w, "phase", mojoDescriptor.getPhase() );
284		}
285
286		// ----------------------------------------------------------------------
287		//
288		// ----------------------------------------------------------------------
289
290	2	if ( StringUtils.isNotEmpty( mojoDescriptor.getExecutePhase() ) )
291		{
292	0	GeneratorUtils.element( w, "executePhase", mojoDescriptor.getExecutePhase() );
293		}
294
295	2	if ( StringUtils.isNotEmpty( mojoDescriptor.getExecuteGoal() ) )
296		{
297	0	GeneratorUtils.element( w, "executeGoal", mojoDescriptor.getExecuteGoal() );
298		}
299
300	2	if ( StringUtils.isNotEmpty( mojoDescriptor.getExecuteLifecycle() ) )
301		{
302	0	GeneratorUtils.element( w, "executeLifecycle", mojoDescriptor.getExecuteLifecycle() );
303		}
304
305		// ----------------------------------------------------------------------
306		//
307		// ----------------------------------------------------------------------
308
309	2	w.startElement( "implementation" );
310	2	w.writeText( mojoDescriptor.getImplementation() );
311	2	w.endElement();
312
313		// ----------------------------------------------------------------------
314		//
315		// ----------------------------------------------------------------------
316
317	2	w.startElement( "language" );
318	2	w.writeText( mojoDescriptor.getLanguage() );
319	2	w.endElement();
320
321		// ----------------------------------------------------------------------
322		//
323		// ----------------------------------------------------------------------
324
325	2	if ( StringUtils.isNotEmpty( mojoDescriptor.getComponentConfigurator() ) )
326		{
327	0	w.startElement( "configurator" );
328	0	w.writeText( mojoDescriptor.getComponentConfigurator() );
329	0	w.endElement();
330		}
331
332		// ----------------------------------------------------------------------
333		//
334		// ----------------------------------------------------------------------
335
336	2	if ( StringUtils.isNotEmpty( mojoDescriptor.getComponentComposer() ) )
337		{
338	0	w.startElement( "composer" );
339	0	w.writeText( mojoDescriptor.getComponentComposer() );
340	0	w.endElement();
341		}
342
343		// ----------------------------------------------------------------------
344		//
345		// ----------------------------------------------------------------------
346
347	2	w.startElement( "instantiationStrategy" );
348	2	w.writeText( mojoDescriptor.getInstantiationStrategy() );
349	2	w.endElement();
350
351		// ----------------------------------------------------------------------
352		// Strategy for handling repeated reference to mojo in
353		// the calculated (decorated, resolved) execution stack
354		// ----------------------------------------------------------------------
355	2	w.startElement( "executionStrategy" );
356	2	w.writeText( mojoDescriptor.getExecutionStrategy() );
357	2	w.endElement();
358
359		// ----------------------------------------------------------------------
360		//
361		// ----------------------------------------------------------------------
362
363	2	if ( mojoDescriptor.getSince() != null )
364		{
365	0	w.startElement( "since" );
366
367	0	if ( StringUtils.isEmpty( mojoDescriptor.getSince() ) )
368		{
369	0	w.writeText( "No version given" );
370		}
371		else
372		{
373	0	w.writeText( mojoDescriptor.getSince() );
374		}
375
376	0	w.endElement();
377		}
378
379		// ----------------------------------------------------------------------
380		//
381		// ----------------------------------------------------------------------
382
383	2	if ( mojoDescriptor.getDeprecated() != null )
384		{
385	0	w.startElement( "deprecated" );
386
387	0	if ( StringUtils.isEmpty( mojoDescriptor.getDeprecated() ) )
388		{
389	0	w.writeText( "No reason given" );
390		}
391		else
392		{
393	0	w.writeText( mojoDescriptor.getDeprecated() );
394		}
395
396	0	w.endElement();
397		}
398
399		// ----------------------------------------------------------------------
400		// Extended (3.0) descriptor
401		// ----------------------------------------------------------------------
402
403	2	if ( mojoDescriptor instanceof ExtendedMojoDescriptor )
404		{
405	0	ExtendedMojoDescriptor extendedMojoDescriptor = (ExtendedMojoDescriptor) mojoDescriptor;
406	0	if ( extendedMojoDescriptor.getDependencyCollectionRequired() != null )
407		{
408	0	GeneratorUtils.element( w, "requiresDependencyCollection",
409		extendedMojoDescriptor.getDependencyCollectionRequired() );
410		}
411
412	0	GeneratorUtils.element( w, "threadSafe", String.valueOf( extendedMojoDescriptor.isThreadSafe() ) );
413		}
414
415		// ----------------------------------------------------------------------
416		// Parameters
417		// ----------------------------------------------------------------------
418
419	2	@SuppressWarnings( "unchecked" ) List<Parameter> parameters = mojoDescriptor.getParameters();
420
421	2	w.startElement( "parameters" );
422
423	2	Map<String, Requirement> requirements = new LinkedHashMap<String, Requirement>();
424
425	2	Set<Parameter> configuration = new LinkedHashSet<Parameter>();
426
427	2	if ( parameters != null )
428		{
429	2	if ( helpDescriptor )
430		{
431	1	PluginUtils.sortMojoParameters( parameters );
432		}
433
434	2	for ( Parameter parameter : parameters )
435		{
436	2	String expression = getExpression( parameter );
437
438	2	if ( StringUtils.isNotEmpty( expression ) && expression.startsWith( "${component." ) )
439		{
440		// treat it as a component...a requirement, in other words.
441
442		// remove "component." plus expression delimiters
443	0	String role = expression.substring( "${component.".length(), expression.length() - 1 );
444
445	0	String roleHint = null;
446
447	0	int posRoleHintSeparator = role.indexOf( "#" );
448	0	if ( posRoleHintSeparator > 0 )
449		{
450	0	roleHint = role.substring( posRoleHintSeparator + 1 );
451
452	0	role = role.substring( 0, posRoleHintSeparator );
453		}
454
455		// TODO: remove deprecated expression
456	0	requirements.put( parameter.getName(), new Requirement( role, roleHint ) );
457	0	}
458	2	else if ( parameter.getRequirement() != null )
459		{
460	0	requirements.put( parameter.getName(), parameter.getRequirement() );
461		}
462	2	else if ( !helpDescriptor \|\| parameter.isEditable() ) // don't show readonly parameters in help
463		{
464		// treat it as a normal parameter.
465
466	2	w.startElement( "parameter" );
467
468	2	GeneratorUtils.element( w, "name", parameter.getName() );
469
470	2	if ( parameter.getAlias() != null )
471		{
472	0	GeneratorUtils.element( w, "alias", parameter.getAlias() );
473		}
474
475	2	GeneratorUtils.element( w, "type", parameter.getType() );
476
477	2	if ( parameter.getSince() != null )
478		{
479	0	w.startElement( "since" );
480
481	0	if ( StringUtils.isEmpty( parameter.getSince() ) )
482		{
483	0	w.writeText( "No version given" );
484		}
485		else
486		{
487	0	w.writeText( parameter.getSince() );
488		}
489
490	0	w.endElement();
491		}
492
493	2	if ( parameter.getDeprecated() != null )
494		{
495	0	if ( StringUtils.isEmpty( parameter.getDeprecated() ) )
496		{
497	0	GeneratorUtils.element( w, "deprecated", "No reason given" );
498		}
499		else
500		{
501	0	GeneratorUtils.element( w, "deprecated", parameter.getDeprecated() );
502		}
503		}
504
505	2	if ( parameter.getImplementation() != null )
506		{
507	0	GeneratorUtils.element( w, "implementation", parameter.getImplementation() );
508		}
509
510	2	GeneratorUtils.element( w, "required", Boolean.toString( parameter.isRequired() ) );
511
512	2	GeneratorUtils.element( w, "editable", Boolean.toString( parameter.isEditable() ) );
513
514	2	GeneratorUtils.element( w, "description", parameter.getDescription(), helpDescriptor );
515
516	2	if ( StringUtils.isNotEmpty( parameter.getDefaultValue() ) \|\| StringUtils.isNotEmpty(
517		parameter.getExpression() ) )
518		{
519	2	configuration.add( parameter );
520		}
521
522	2	w.endElement();
523		}
524
525	2	}
526		}
527
528	2	w.endElement();
529
530		// ----------------------------------------------------------------------
531		// Configuration
532		// ----------------------------------------------------------------------
533
534	2	if ( !configuration.isEmpty() )
535		{
536	2	w.startElement( "configuration" );
537
538	2	for ( Parameter parameter : configuration )
539		{
540	2	if ( helpDescriptor && !parameter.isEditable() )
541		{
542		// don't show readonly parameters in help
543	0	continue;
544		}
545
546	2	w.startElement( parameter.getName() );
547
548	2	String type = parameter.getType();
549	2	if ( StringUtils.isNotEmpty( type ) )
550		{
551	2	w.addAttribute( "implementation", type );
552		}
553
554	2	if ( parameter.getDefaultValue() != null )
555		{
556	2	w.addAttribute( "default-value", parameter.getDefaultValue() );
557		}
558
559	2	if ( StringUtils.isNotEmpty( parameter.getExpression() ) )
560		{
561	2	w.writeText( parameter.getExpression() );
562		}
563
564	2	w.endElement();
565	2	}
566
567	2	w.endElement();
568		}
569
570		// ----------------------------------------------------------------------
571		// Requirements
572		// ----------------------------------------------------------------------
573
574	2	if ( !requirements.isEmpty() && !helpDescriptor )
575		{
576	0	w.startElement( "requirements" );
577
578	0	for ( Map.Entry<String, Requirement> entry : requirements.entrySet() )
579		{
580	0	String key = entry.getKey();
581	0	Requirement requirement = entry.getValue();
582
583	0	w.startElement( "requirement" );
584
585	0	GeneratorUtils.element( w, "role", requirement.getRole() );
586
587	0	if ( StringUtils.isNotEmpty( requirement.getRoleHint() ) )
588		{
589	0	GeneratorUtils.element( w, "role-hint", requirement.getRoleHint() );
590		}
591
592	0	GeneratorUtils.element( w, "field-name", key );
593
594	0	w.endElement();
595	0	}
596
597	0	w.endElement();
598		}
599
600	2	w.endElement();
601	2	}
602
603		/**
604		* Get the expression value, eventually surrounding it with <code>${ }</code>.
605		*
606		* @param parameter the parameter
607		* @return the expression value
608		*/
609		private String getExpression( Parameter parameter )
610		{
611	2	String expression = parameter.getExpression();
612	2	if ( StringUtils.isNotBlank( expression ) && !expression.contains( "${" ) )
613		{
614	0	expression = "${" + expression.trim() + "}";
615	0	parameter.setExpression( expression );
616		}
617	2	return expression;
618		}
619		}