Coverage Report

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

Classes in this File

Line Coverage

Branch Coverage

Complexity

PluginDescriptorGenerator

67%

104/155

44%

31/70

 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.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.tools.plugin.DefaultPluginToolsRequest;
 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.util.Iterator;
 import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 /**
  * @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.
  *
  * @version $Id: PluginDescriptorGenerator.java 1133707 2011-06-09 08:28:59Z stephenc $
  */
 public class PluginDescriptorGenerator
     implements Generator
 {
     /** {@inheritDoc} */
     public void execute( File destinationDirectory, PluginDescriptor pluginDescriptor )
         throws IOException
     {
         execute( destinationDirectory, new DefaultPluginToolsRequest( null, pluginDescriptor ) );
     }
     
     /** {@inheritDoc} */
     public void execute( File destinationDirectory, PluginToolsRequest request )
         throws IOException
     {
         PluginDescriptor pluginDescriptor = request.getPluginDescriptor();
         
         String encoding = "UTF-8";
 
         File f = new File( destinationDirectory, "plugin.xml" );
 
         if ( !f.getParentFile().exists() )
         {
             f.getParentFile().mkdirs();
         }
 
         Writer writer = null;
         try
         {
             writer = new OutputStreamWriter( new FileOutputStream( f ), encoding );
 
             XMLWriter w = new PrettyPrintXMLWriter( writer, encoding, null );
 
             w.startElement( "plugin" );
 
             PluginUtils.element( w, "name", pluginDescriptor.getName() );
 
             PluginUtils.element( w, "description", pluginDescriptor.getDescription() );
 
             PluginUtils.element( w, "groupId", pluginDescriptor.getGroupId() );
 
             PluginUtils.element( w, "artifactId", pluginDescriptor.getArtifactId() );
 
             PluginUtils.element( w, "version", pluginDescriptor.getVersion() );
 
             PluginUtils.element( w, "goalPrefix", pluginDescriptor.getGoalPrefix() );
 
             PluginUtils.element( w, "isolatedRealm", "" + pluginDescriptor.isIsolatedRealm() );
 
             PluginUtils.element( w, "inheritedByDefault", "" + pluginDescriptor.isInheritedByDefault() );
 
             w.startElement( "mojos" );
 
             if ( pluginDescriptor.getMojos() != null )
             {
                 for ( @SuppressWarnings( "unchecked" )
                 Iterator<MojoDescriptor> it = pluginDescriptor.getMojos().iterator(); it.hasNext(); )
                 {
                     MojoDescriptor descriptor = it.next();
                     processMojoDescriptor( descriptor, w );
                 }
             }
 
             w.endElement();
 
             PluginUtils.writeDependencies( w, pluginDescriptor );
 
             w.endElement();
 
             writer.flush();
         }
         finally
         {
             IOUtil.close( writer );
         }
     }
 
     /**
      * @param mojoDescriptor not null
      * @param w not null
      */
     protected void processMojoDescriptor( MojoDescriptor mojoDescriptor, XMLWriter w )
     {
         w.startElement( "mojo" );
 
         // ----------------------------------------------------------------------
         //
         // ----------------------------------------------------------------------
 
         w.startElement( "goal" );
         w.writeText( mojoDescriptor.getGoal() );
         w.endElement();
 
         // ----------------------------------------------------------------------
         //
         // ----------------------------------------------------------------------
 
         String description = mojoDescriptor.getDescription();
 
         if ( description != null )
         {
             w.startElement( "description" );
             w.writeText( mojoDescriptor.getDescription() );
             w.endElement();
         }
 
         // ----------------------------------------------------------------------
         //
         // ----------------------------------------------------------------------
 
         if ( mojoDescriptor.isDependencyResolutionRequired() != null )
         {
             PluginUtils.element( w, "requiresDependencyResolution", mojoDescriptor.isDependencyResolutionRequired() );
         }
 
         // ----------------------------------------------------------------------
         //
         // ----------------------------------------------------------------------
 
         PluginUtils.element( w, "requiresDirectInvocation", "" + mojoDescriptor.isDirectInvocationOnly() );
 
         // ----------------------------------------------------------------------
         //
         // ----------------------------------------------------------------------
 
         PluginUtils.element( w, "requiresProject", "" + mojoDescriptor.isProjectRequired() );
 
         // ----------------------------------------------------------------------
         //
         // ----------------------------------------------------------------------
 
         PluginUtils.element( w, "requiresReports", "" + mojoDescriptor.isRequiresReports() );
 
         // ----------------------------------------------------------------------
         //
         // ----------------------------------------------------------------------
 
         PluginUtils.element( w, "aggregator", "" + mojoDescriptor.isAggregator() );
 
         // ----------------------------------------------------------------------
         //
         // ----------------------------------------------------------------------
 
         PluginUtils.element( w, "requiresOnline", "" + mojoDescriptor.isOnlineRequired() );
 
         // ----------------------------------------------------------------------
         //
         // ----------------------------------------------------------------------
 
         PluginUtils.element( w, "inheritedByDefault", "" + mojoDescriptor.isInheritedByDefault() );
 
         // ----------------------------------------------------------------------
         //
         // ----------------------------------------------------------------------
 
         if ( mojoDescriptor.getPhase() != null )
         {
             PluginUtils.element( w, "phase", mojoDescriptor.getPhase() );
         }
 
         // ----------------------------------------------------------------------
         //
         // ----------------------------------------------------------------------
 
         if ( mojoDescriptor.getExecutePhase() != null )
         {
             PluginUtils.element( w, "executePhase", mojoDescriptor.getExecutePhase() );
         }
 
         if ( mojoDescriptor.getExecuteGoal() != null )
         {
             PluginUtils.element( w, "executeGoal", mojoDescriptor.getExecuteGoal() );
         }
 
         if ( mojoDescriptor.getExecuteLifecycle() != null )
         {
             PluginUtils.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.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 )
             {
                 PluginUtils.element( w, "requiresDependencyCollection",
                                      extendedMojoDescriptor.getDependencyCollectionRequired() );
             }
 
             PluginUtils.element( w, "threadSafe", "" + 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 )
         {
             for ( Parameter parameter : parameters )
             {
                 String expression = parameter.getExpression();
 
                 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
                 {
                     // treat it as a normal parameter.
 
                     w.startElement( "parameter" );
 
                     PluginUtils.element( w, "name", parameter.getName() );
 
                     if ( parameter.getAlias() != null )
                     {
                         PluginUtils.element( w, "alias", parameter.getAlias() );
                     }
 
                     PluginUtils.element( w, "type", parameter.getType() );
 
                     if ( parameter.getDeprecated() != null )
                     {
                         if ( StringUtils.isEmpty( parameter.getDeprecated() ) )
                         {
                             PluginUtils.element( w, "deprecated", "No reason given" );
                         }
                         else
                         {
                             PluginUtils.element( w, "deprecated", parameter.getDeprecated() );
                         }
                     }
 
                     if ( parameter.getImplementation() != null )
                     {
                         PluginUtils.element( w, "implementation", parameter.getImplementation() );
                     }
 
                     PluginUtils.element( w, "required", Boolean.toString( parameter.isRequired() ) );
 
                     PluginUtils.element( w, "editable", Boolean.toString( parameter.isEditable() ) );
 
                     PluginUtils.element( w, "description", parameter.getDescription() );
 
                     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 )
             {
                 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() )
         {
             w.startElement( "requirements" );
 
             for ( Map.Entry<String, Requirement> entry : requirements.entrySet() )
             {
                 String key = entry.getKey();
                 Requirement requirement = entry.getValue();
 
                 w.startElement( "requirement" );
 
                 PluginUtils.element( w, "role", requirement.getRole() );
 
                 if ( requirement.getRoleHint() != null )
                 {
                     PluginUtils.element( w, "role-hint", requirement.getRoleHint() );
                 }
 
                 PluginUtils.element( w, "field-name", key );
 
                 w.endElement();
             }
 
             w.endElement();
         }
 
         w.endElement();
     }
 }

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.MojoDescriptor;
23		import org.apache.maven.plugin.descriptor.Parameter;
24		import org.apache.maven.plugin.descriptor.PluginDescriptor;
25		import org.apache.maven.plugin.descriptor.Requirement;
26		import org.apache.maven.tools.plugin.DefaultPluginToolsRequest;
27		import org.apache.maven.tools.plugin.ExtendedMojoDescriptor;
28		import org.apache.maven.tools.plugin.PluginToolsRequest;
29		import org.apache.maven.tools.plugin.util.PluginUtils;
30		import org.codehaus.plexus.util.IOUtil;
31		import org.codehaus.plexus.util.StringUtils;
32		import org.codehaus.plexus.util.xml.PrettyPrintXMLWriter;
33		import org.codehaus.plexus.util.xml.XMLWriter;
34
35		import java.io.File;
36		import java.io.FileOutputStream;
37		import java.io.IOException;
38		import java.io.OutputStreamWriter;
39		import java.io.Writer;
40		import java.util.Iterator;
41		import java.util.LinkedHashMap;
42		import java.util.LinkedHashSet;
43		import java.util.List;
44		import java.util.Map;
45		import java.util.Set;
46
47		/**
48		* @todo add example usage tag that can be shown in the doco
49		* @todo need to add validation directives so that systems embedding maven2 can
50		* get validation directives to help users in IDEs.
51		*
52		* @version $Id: PluginDescriptorGenerator.java 1133707 2011-06-09 08:28:59Z stephenc $
53		*/
54	1	public class PluginDescriptorGenerator
55		implements Generator
56		{
57		/** {@inheritDoc} */
58		public void execute( File destinationDirectory, PluginDescriptor pluginDescriptor )
59		throws IOException
60		{
61	0	execute( destinationDirectory, new DefaultPluginToolsRequest( null, pluginDescriptor ) );
62	0	}
63
64		/** {@inheritDoc} */
65		public void execute( File destinationDirectory, PluginToolsRequest request )
66		throws IOException
67		{
68	1	PluginDescriptor pluginDescriptor = request.getPluginDescriptor();
69
70	1	String encoding = "UTF-8";
71
72	1	File f = new File( destinationDirectory, "plugin.xml" );
73
74	1	if ( !f.getParentFile().exists() )
75		{
76	0	f.getParentFile().mkdirs();
77		}
78
79	1	Writer writer = null;
80		try
81		{
82	1	writer = new OutputStreamWriter( new FileOutputStream( f ), encoding );
83
84	1	XMLWriter w = new PrettyPrintXMLWriter( writer, encoding, null );
85
86	1	w.startElement( "plugin" );
87
88	1	PluginUtils.element( w, "name", pluginDescriptor.getName() );
89
90	1	PluginUtils.element( w, "description", pluginDescriptor.getDescription() );
91
92	1	PluginUtils.element( w, "groupId", pluginDescriptor.getGroupId() );
93
94	1	PluginUtils.element( w, "artifactId", pluginDescriptor.getArtifactId() );
95
96	1	PluginUtils.element( w, "version", pluginDescriptor.getVersion() );
97
98	1	PluginUtils.element( w, "goalPrefix", pluginDescriptor.getGoalPrefix() );
99
100	1	PluginUtils.element( w, "isolatedRealm", "" + pluginDescriptor.isIsolatedRealm() );
101
102	1	PluginUtils.element( w, "inheritedByDefault", "" + pluginDescriptor.isInheritedByDefault() );
103
104	1	w.startElement( "mojos" );
105
106	1	if ( pluginDescriptor.getMojos() != null )
107		{
108		for ( @SuppressWarnings( "unchecked" )
109	1	Iterator<MojoDescriptor> it = pluginDescriptor.getMojos().iterator(); it.hasNext(); )
110		{
111	1	MojoDescriptor descriptor = it.next();
112	1	processMojoDescriptor( descriptor, w );
113	1	}
114		}
115
116	1	w.endElement();
117
118	1	PluginUtils.writeDependencies( w, pluginDescriptor );
119
120	1	w.endElement();
121
122	1	writer.flush();
123		}
124		finally
125		{
126	1	IOUtil.close( writer );
127	1	}
128	1	}
129
130		/**
131		* @param mojoDescriptor not null
132		* @param w not null
133		*/
134		protected void processMojoDescriptor( MojoDescriptor mojoDescriptor, XMLWriter w )
135		{
136	1	w.startElement( "mojo" );
137
138		// ----------------------------------------------------------------------
139		//
140		// ----------------------------------------------------------------------
141
142	1	w.startElement( "goal" );
143	1	w.writeText( mojoDescriptor.getGoal() );
144	1	w.endElement();
145
146		// ----------------------------------------------------------------------
147		//
148		// ----------------------------------------------------------------------
149
150	1	String description = mojoDescriptor.getDescription();
151
152	1	if ( description != null )
153		{
154	0	w.startElement( "description" );
155	0	w.writeText( mojoDescriptor.getDescription() );
156	0	w.endElement();
157		}
158
159		// ----------------------------------------------------------------------
160		//
161		// ----------------------------------------------------------------------
162
163	1	if ( mojoDescriptor.isDependencyResolutionRequired() != null )
164		{
165	1	PluginUtils.element( w, "requiresDependencyResolution", mojoDescriptor.isDependencyResolutionRequired() );
166		}
167
168		// ----------------------------------------------------------------------
169		//
170		// ----------------------------------------------------------------------
171
172	1	PluginUtils.element( w, "requiresDirectInvocation", "" + mojoDescriptor.isDirectInvocationOnly() );
173
174		// ----------------------------------------------------------------------
175		//
176		// ----------------------------------------------------------------------
177
178	1	PluginUtils.element( w, "requiresProject", "" + mojoDescriptor.isProjectRequired() );
179
180		// ----------------------------------------------------------------------
181		//
182		// ----------------------------------------------------------------------
183
184	1	PluginUtils.element( w, "requiresReports", "" + mojoDescriptor.isRequiresReports() );
185
186		// ----------------------------------------------------------------------
187		//
188		// ----------------------------------------------------------------------
189
190	1	PluginUtils.element( w, "aggregator", "" + mojoDescriptor.isAggregator() );
191
192		// ----------------------------------------------------------------------
193		//
194		// ----------------------------------------------------------------------
195
196	1	PluginUtils.element( w, "requiresOnline", "" + mojoDescriptor.isOnlineRequired() );
197
198		// ----------------------------------------------------------------------
199		//
200		// ----------------------------------------------------------------------
201
202	1	PluginUtils.element( w, "inheritedByDefault", "" + mojoDescriptor.isInheritedByDefault() );
203
204		// ----------------------------------------------------------------------
205		//
206		// ----------------------------------------------------------------------
207
208	1	if ( mojoDescriptor.getPhase() != null )
209		{
210	0	PluginUtils.element( w, "phase", mojoDescriptor.getPhase() );
211		}
212
213		// ----------------------------------------------------------------------
214		//
215		// ----------------------------------------------------------------------
216
217	1	if ( mojoDescriptor.getExecutePhase() != null )
218		{
219	0	PluginUtils.element( w, "executePhase", mojoDescriptor.getExecutePhase() );
220		}
221
222	1	if ( mojoDescriptor.getExecuteGoal() != null )
223		{
224	0	PluginUtils.element( w, "executeGoal", mojoDescriptor.getExecuteGoal() );
225		}
226
227	1	if ( mojoDescriptor.getExecuteLifecycle() != null )
228		{
229	0	PluginUtils.element( w, "executeLifecycle", mojoDescriptor.getExecuteLifecycle() );
230		}
231
232		// ----------------------------------------------------------------------
233		//
234		// ----------------------------------------------------------------------
235
236	1	w.startElement( "implementation" );
237	1	w.writeText( mojoDescriptor.getImplementation() );
238	1	w.endElement();
239
240		// ----------------------------------------------------------------------
241		//
242		// ----------------------------------------------------------------------
243
244	1	w.startElement( "language" );
245	1	w.writeText( mojoDescriptor.getLanguage() );
246	1	w.endElement();
247
248		// ----------------------------------------------------------------------
249		//
250		// ----------------------------------------------------------------------
251
252	1	if ( mojoDescriptor.getComponentConfigurator() != null )
253		{
254	0	w.startElement( "configurator" );
255	0	w.writeText( mojoDescriptor.getComponentConfigurator() );
256	0	w.endElement();
257		}
258
259		// ----------------------------------------------------------------------
260		//
261		// ----------------------------------------------------------------------
262
263	1	if ( mojoDescriptor.getComponentComposer() != null )
264		{
265	0	w.startElement( "composer" );
266	0	w.writeText( mojoDescriptor.getComponentComposer() );
267	0	w.endElement();
268		}
269
270		// ----------------------------------------------------------------------
271		//
272		// ----------------------------------------------------------------------
273
274	1	w.startElement( "instantiationStrategy" );
275	1	w.writeText( mojoDescriptor.getInstantiationStrategy() );
276	1	w.endElement();
277
278		// ----------------------------------------------------------------------
279		// Strategy for handling repeated reference to mojo in
280		// the calculated (decorated, resolved) execution stack
281		// ----------------------------------------------------------------------
282	1	w.startElement( "executionStrategy" );
283	1	w.writeText( mojoDescriptor.getExecutionStrategy() );
284	1	w.endElement();
285
286		// ----------------------------------------------------------------------
287		//
288		// ----------------------------------------------------------------------
289
290	1	if ( mojoDescriptor.getDeprecated() != null )
291		{
292	0	w.startElement( "deprecated" );
293
294	0	if ( StringUtils.isEmpty( mojoDescriptor.getDeprecated() ) )
295		{
296	0	w.writeText( "No reason given" );
297		}
298		else
299		{
300	0	w.writeText( mojoDescriptor.getDeprecated() );
301		}
302
303	0	w.endElement();
304		}
305
306		// ----------------------------------------------------------------------
307		// Extended (3.0) descriptor
308		// ----------------------------------------------------------------------
309
310	1	if ( mojoDescriptor instanceof ExtendedMojoDescriptor )
311		{
312	0	ExtendedMojoDescriptor extendedMojoDescriptor = (ExtendedMojoDescriptor) mojoDescriptor;
313	0	if ( extendedMojoDescriptor.getDependencyCollectionRequired() != null )
314		{
315	0	PluginUtils.element( w, "requiresDependencyCollection",
316		extendedMojoDescriptor.getDependencyCollectionRequired() );
317		}
318
319	0	PluginUtils.element( w, "threadSafe", "" + extendedMojoDescriptor.isThreadSafe() );
320		}
321
322		// ----------------------------------------------------------------------
323		// Parameters
324		// ----------------------------------------------------------------------
325
326		@SuppressWarnings( "unchecked" )
327	1	List<Parameter> parameters = mojoDescriptor.getParameters();
328
329	1	w.startElement( "parameters" );
330
331	1	Map<String, Requirement> requirements = new LinkedHashMap<String, Requirement>();
332
333	1	Set<Parameter> configuration = new LinkedHashSet<Parameter>();
334
335	1	if ( parameters != null )
336		{
337	1	for ( Parameter parameter : parameters )
338		{
339	1	String expression = parameter.getExpression();
340
341	1	if ( StringUtils.isNotEmpty( expression ) && expression.startsWith( "${component." ) )
342		{
343		// treat it as a component...a requirement, in other words.
344
345		// remove "component." plus expression delimiters
346	0	String role = expression.substring( "${component.".length(), expression.length() - 1 );
347
348	0	String roleHint = null;
349
350	0	int posRoleHintSeparator = role.indexOf( "#" );
351	0	if ( posRoleHintSeparator > 0 )
352		{
353	0	roleHint = role.substring( posRoleHintSeparator + 1 );
354
355	0	role = role.substring( 0, posRoleHintSeparator );
356		}
357
358		// TODO: remove deprecated expression
359	0	requirements.put( parameter.getName(), new Requirement( role, roleHint ) );
360	0	}
361	1	else if ( parameter.getRequirement() != null )
362		{
363	0	requirements.put( parameter.getName(), parameter.getRequirement() );
364		}
365		else
366		{
367		// treat it as a normal parameter.
368
369	1	w.startElement( "parameter" );
370
371	1	PluginUtils.element( w, "name", parameter.getName() );
372
373	1	if ( parameter.getAlias() != null )
374		{
375	0	PluginUtils.element( w, "alias", parameter.getAlias() );
376		}
377
378	1	PluginUtils.element( w, "type", parameter.getType() );
379
380	1	if ( parameter.getDeprecated() != null )
381		{
382	0	if ( StringUtils.isEmpty( parameter.getDeprecated() ) )
383		{
384	0	PluginUtils.element( w, "deprecated", "No reason given" );
385		}
386		else
387		{
388	0	PluginUtils.element( w, "deprecated", parameter.getDeprecated() );
389		}
390		}
391
392	1	if ( parameter.getImplementation() != null )
393		{
394	0	PluginUtils.element( w, "implementation", parameter.getImplementation() );
395		}
396
397	1	PluginUtils.element( w, "required", Boolean.toString( parameter.isRequired() ) );
398
399	1	PluginUtils.element( w, "editable", Boolean.toString( parameter.isEditable() ) );
400
401	1	PluginUtils.element( w, "description", parameter.getDescription() );
402
403	1	if ( StringUtils.isNotEmpty( parameter.getDefaultValue() )
404		\|\| StringUtils.isNotEmpty( parameter.getExpression() ) )
405		{
406	1	configuration.add( parameter );
407		}
408
409	1	w.endElement();
410		}
411
412	1	}
413		}
414
415	1	w.endElement();
416
417		// ----------------------------------------------------------------------
418		// Configuration
419		// ----------------------------------------------------------------------
420
421	1	if ( !configuration.isEmpty() )
422		{
423	1	w.startElement( "configuration" );
424
425	1	for ( Parameter parameter : configuration )
426		{
427	1	w.startElement( parameter.getName() );
428
429	1	String type = parameter.getType();
430	1	if ( type != null )
431		{
432	1	w.addAttribute( "implementation", type );
433		}
434
435	1	if ( parameter.getDefaultValue() != null )
436		{
437	1	w.addAttribute( "default-value", parameter.getDefaultValue() );
438		}
439
440	1	if ( parameter.getExpression() != null )
441		{
442	1	w.writeText( parameter.getExpression() );
443		}
444
445	1	w.endElement();
446	1	}
447
448	1	w.endElement();
449		}
450
451		// ----------------------------------------------------------------------
452		// Requirements
453		// ----------------------------------------------------------------------
454
455	1	if ( !requirements.isEmpty() )
456		{
457	0	w.startElement( "requirements" );
458
459	0	for ( Map.Entry<String, Requirement> entry : requirements.entrySet() )
460		{
461	0	String key = entry.getKey();
462	0	Requirement requirement = entry.getValue();
463
464	0	w.startElement( "requirement" );
465
466	0	PluginUtils.element( w, "role", requirement.getRole() );
467
468	0	if ( requirement.getRoleHint() != null )
469		{
470	0	PluginUtils.element( w, "role-hint", requirement.getRoleHint() );
471		}
472
473	0	PluginUtils.element( w, "field-name", key );
474
475	0	w.endElement();
476	0	}
477
478	0	w.endElement();
479		}
480
481	1	w.endElement();
482	1	}
483		}