Coverage Report

Coverage Report - org.apache.maven.plugin.descriptor.MojoDescriptor

Classes in this File

Line Coverage

Branch Coverage

Complexity

MojoDescriptor

0 %

0/120

0 %

0/38

1,431

 package org.apache.maven.plugin.descriptor;
 
 /*
  * 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.Mojo;
 import org.codehaus.plexus.component.repository.ComponentDescriptor;
 import org.codehaus.plexus.configuration.PlexusConfiguration;
 import org.codehaus.plexus.configuration.xml.XmlPlexusConfiguration;
 
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 
 /**
  * The bean containing the Mojo descriptor.
  * <br/>
  * For more information about the usage tag, have a look to:
  * <a href="http://maven.apache.org/developers/mojo-api-specification.html">http://maven.apache.org/developers/mojo-api-specification.html</a>
  *
  * @todo is there a need for the delegation of MavenMojoDescriptor to this?
  * Why not just extend ComponentDescriptor here?
  * @version $Id: MojoDescriptor.java 743587 2009-02-12 01:32:50Z jdcasey $
  */
 public class MojoDescriptor
     extends ComponentDescriptor
     implements Cloneable
 {
     /** The Plexus component type */
     public static String MAVEN_PLUGIN = "maven-plugin";
 
     /** "once-per-session" execution strategy */
     public static final String SINGLE_PASS_EXEC_STRATEGY = "once-per-session";
 
     /** "always" execution strategy */
     public static final String MULTI_PASS_EXEC_STRATEGY = "always";
 
     private static final String DEFAULT_INSTANTIATION_STRATEGY = "per-lookup";
 
     private static final String DEFAULT_LANGUAGE = "java";
 
     private List parameters;
 
     private Map parameterMap;
 
     /** By default, the execution strategy is "once-per-session" */
     private String executionStrategy = SINGLE_PASS_EXEC_STRATEGY;
 
     /** The goal name of the Mojo */
     private String goal;
 
     /** Reference the binded phase name of the Mojo */
     private String phase;
 
     /** Specify the version when the Mojo was added to the API. Similar to Javadoc since. */
     private String since;
 
     /** Reference the invocation phase of the Mojo */
     private String executePhase;
 
     /** Reference the invocation goal of the Mojo */
     private String executeGoal;
 
     /** Reference the invocation lifecycle of the Mojo */
     private String executeLifecycle;
 
     /** Specify the version when the Mojo was deprecated to the API. Similar to Javadoc deprecated. */
     private String deprecated;
 
     /** By default, no need to aggregate the Maven project and its child modules */
     private boolean aggregator = false;
 
     // ----------------------------------------------------------------------
     //
     // ----------------------------------------------------------------------
 
     /** Specify the required dependencies in a specified scope */
     private String dependencyResolutionRequired = null;
 
     /**  By default, the Mojo needs a Maven project to be executed */
     private boolean projectRequired = true;
 
     /**  By default, the Mojo is online */
     private boolean onlineRequired = false;
 
     /**  Plugin configuration */
     private PlexusConfiguration mojoConfiguration;
 
     /**  Plugin descriptor */
     private PluginDescriptor pluginDescriptor;
 
     /**  By default, the Mojo is herited */
     private boolean inheritedByDefault = true;
 
     /**  By default, the Mojo could not be invoke directly */
     private boolean directInvocationOnly = false;
 
     /**  By default, the Mojo don't need reports to run */
     private boolean requiresReports = false;
 
     /**
      * Default constructor.
      */
     public MojoDescriptor()
     {
         setInstantiationStrategy( DEFAULT_INSTANTIATION_STRATEGY );
         setComponentFactory( DEFAULT_LANGUAGE );
     }
 
     // ----------------------------------------------------------------------
     //
     // ----------------------------------------------------------------------
 
     /**
      * @return the language of this Mojo, i.e. <code>java</code>
      */
     public String getLanguage()
     {
         return getComponentFactory();
     }
 
     /**
      * @param language the new language
      */
     public void setLanguage( String language )
     {
         setComponentFactory( language );
     }
 
     /**
      * @return <code>true</code> if the Mojo is deprecated, <code>false</code> otherwise.
      */
     public String getDeprecated()
     {
         return deprecated;
     }
 
     /**
      * @param deprecated <code>true</code> to deprecate the Mojo, <code>false</code> otherwise.
      */
     public void setDeprecated( String deprecated )
     {
         this.deprecated = deprecated;
     }
 
     /**
      * @return the list of parameters
      */
     public List getParameters()
     {
         return parameters;
     }
 
     /**
      * @param parameters the new list of parameters
      * @throws DuplicateParameterException if any
      */
     public void setParameters( List parameters )
         throws DuplicateParameterException
     {
         for ( Iterator it = parameters.iterator(); it.hasNext(); )
         {
             Parameter parameter = (Parameter) it.next();
             addParameter( parameter );
         }
     }
 
     /**
      * @param parameter add a new parameter
      * @throws DuplicateParameterException if any
      */
     public void addParameter( Parameter parameter )
         throws DuplicateParameterException
     {
         if ( parameters != null && parameters.contains( parameter ) )
         {
             throw new DuplicateParameterException( parameter.getName() +
                 " has been declared multiple times in mojo with goal: " + getGoal() + " (implementation: " +
                 getImplementation() + ")" );
         }
 
         if ( parameters == null )
         {
             parameters = new LinkedList();
         }
 
         parameters.add( parameter );
         
         parameterMap = null;
     }
 
     /**
      * @return the list parameters as a Map
      */
     public Map getParameterMap()
     {
         if ( parameterMap == null )
         {
             parameterMap = new HashMap();
 
             if ( parameters != null )
             {
                 for ( Iterator iterator = parameters.iterator(); iterator.hasNext(); )
                 {
                     Parameter pd = (Parameter) iterator.next();
 
                     parameterMap.put( pd.getName(), pd );
                 }
             }
         }
 
         return parameterMap;
     }
 
     // ----------------------------------------------------------------------
     // Dependency requirement
     // ----------------------------------------------------------------------
 
     /**
      * @param requiresDependencyResolution the new required dependencies in a specified scope
      */
     public void setDependencyResolutionRequired( String requiresDependencyResolution )
     {
         this.dependencyResolutionRequired = requiresDependencyResolution;
     }
 
     /**
      * @return the required dependencies in a specified scope
      * @TODO the name is not intelligible
      */
     public String isDependencyResolutionRequired()
     {
         return dependencyResolutionRequired;
     }
 
     // ----------------------------------------------------------------------
     // Project requirement
     // ----------------------------------------------------------------------
 
     /**
      * @param requiresProject <code>true</code> if the Mojo needs a Maven project to be executed, <code>false</code> otherwise.
      */
     public void setProjectRequired( boolean requiresProject )
     {
         this.projectRequired = requiresProject;
     }
 
     /**
      * @return <code>true</code> if the Mojo needs a Maven project to be executed, <code>false</code> otherwise.
      */
     public boolean isProjectRequired()
     {
         return projectRequired;
     }
 
     // ----------------------------------------------------------------------
     // Online vs. Offline requirement
     // ----------------------------------------------------------------------
 
     /**
      * @param requiresOnline <code>true</code> if the Mojo is online, <code>false</code> otherwise.
      */
     public void setOnlineRequired( boolean requiresOnline )
     {
         this.onlineRequired = requiresOnline;
     }
 
     /**
      * @return <code>true</code> if the Mojo is online, <code>false</code> otherwise.
      */
     // blech! this isn't even intelligible as a method name. provided for
     // consistency...
     public boolean isOnlineRequired()
     {
         return onlineRequired;
     }
 
     /**
      * @return <code>true</code> if the Mojo is online, <code>false</code> otherwise.
      */
     // more english-friendly method...keep the code clean! :)
     public boolean requiresOnline()
     {
         return onlineRequired;
     }
 
     /**
      * @return the binded phase name of the Mojo
      */
     public String getPhase()
     {
         return phase;
     }
 
     /**
      * @param phase the new binded phase name of the Mojo
      */
     public void setPhase( String phase )
     {
         this.phase = phase;
     }
 
     /**
      * @return the version when the Mojo was added to the API
      */
     public String getSince()
     {
         return since;
     }
 
     /**
      * @param since the new version when the Mojo was added to the API
      */
     public void setSince( String since )
     {
         this.since = since;
     }
 
     /**
      * @return The goal name of the Mojo
      */
     public String getGoal()
     {
         return goal;
     }
 
     /**
      * @param goal The new goal name of the Mojo
      */
     public void setGoal( String goal )
     {
         this.goal = goal;
     }
 
     /**
      * @return the invocation phase of the Mojo
      */
     public String getExecutePhase()
     {
         return executePhase;
     }
 
     /**
      * @param executePhase the new invocation phase of the Mojo
      */
     public void setExecutePhase( String executePhase )
     {
         this.executePhase = executePhase;
     }
 
     /**
      * @return <code>true</code> if the Mojo uses <code>always</code> for the <code>executionStrategy</code>
      */
     public boolean alwaysExecute()
     {
         return MULTI_PASS_EXEC_STRATEGY.equals( executionStrategy );
     }
 
     /**
      * @return the execution strategy
      */
     public String getExecutionStrategy()
     {
         return executionStrategy;
     }
 
     /**
      * @param executionStrategy the new execution strategy
      */
     public void setExecutionStrategy( String executionStrategy )
     {
         this.executionStrategy = executionStrategy;
     }
 
     /**
      * @return the mojo configuration
      */
     public PlexusConfiguration getMojoConfiguration()
     {
         if ( mojoConfiguration == null )
         {
             mojoConfiguration = new XmlPlexusConfiguration( "configuration" );
         }
         return mojoConfiguration;
     }
 
     /**
      * @param mojoConfiguration a new mojo configuration
      */
     public void setMojoConfiguration( PlexusConfiguration mojoConfiguration )
     {
         this.mojoConfiguration = mojoConfiguration;
     }
 
     /** {@inheritDoc} */
     public String getRole()
     {
         return Mojo.ROLE;
     }
 
     /** {@inheritDoc} */
     public String getRoleHint()
     {
         return getId();
     }
 
     /**
      * @return the id of the mojo, based on the goal name
      */
     public String getId()
     {
         return getPluginDescriptor().getId() + ":" + getGoal();
     }
 
     /**
      * @return the full goal name
      * @see PluginDescriptor#getGoalPrefix()
      * @see #getGoal()
      */
     public String getFullGoalName()
     {
         return getPluginDescriptor().getGoalPrefix() + ":" + getGoal();
     }
 
     /** {@inheritDoc} */
     public String getComponentType()
     {
         return MAVEN_PLUGIN;
     }
 
     /**
      * @return the plugin descriptor
      */
     public PluginDescriptor getPluginDescriptor()
     {
         return pluginDescriptor;
     }
 
     /**
      * @param pluginDescriptor the new plugin descriptor
      */
     public void setPluginDescriptor( PluginDescriptor pluginDescriptor )
     {
         this.pluginDescriptor = pluginDescriptor;
     }
 
     /**
      * @return <code>true</code> if the Mojo is herited, <code>false</code> otherwise.
      */
     public boolean isInheritedByDefault()
     {
         return inheritedByDefault;
     }
 
     /**
      * @param inheritedByDefault <code>true</code> if the Mojo is herited, <code>false</code> otherwise.
      */
     public void setInheritedByDefault( boolean inheritedByDefault )
     {
         this.inheritedByDefault = inheritedByDefault;
     }
 
     /** {@inheritDoc} */
     public boolean equals( Object object )
     {
         if ( this == object )
         {
             return true;
         }
 
         if ( object instanceof MojoDescriptor )
         {
             MojoDescriptor other = (MojoDescriptor) object;
 
             if ( !compareObjects( getPluginDescriptor(), other.getPluginDescriptor() ) )
             {
                 return false;
             }
 
             if ( !compareObjects( getGoal(), other.getGoal() ) )
             {
                 return false;
             }
 
             return true;
         }
 
         return false;
     }
 
     private boolean compareObjects( Object first, Object second )
     {
         if ( ( first == null && second != null ) || ( first != null && second == null ) )
         {
             return false;
         }
 
         if ( !first.equals( second ) )
         {
             return false;
         }
 
         return true;
     }
 
     /** {@inheritDoc} */
     public int hashCode()
     {
         int result = 1;
 
         String goal = getGoal();
 
         if ( goal != null )
         {
             result += goal.hashCode();
         }
 
         PluginDescriptor pd = getPluginDescriptor();
 
         if ( pd != null )
         {
             result -= pd.hashCode();
         }
 
         return result;
     }
 
     /**
      * @return the invocation lifecycle of the Mojo
      */
     public String getExecuteLifecycle()
     {
         return executeLifecycle;
     }
 
     /**
      * @param executeLifecycle the new invocation lifecycle of the Mojo
      */
     public void setExecuteLifecycle( String executeLifecycle )
     {
         this.executeLifecycle = executeLifecycle;
     }
 
     /**
      * @param aggregator <code>true</code> if the Mojo uses the Maven project and its child modules, <code>false</code> otherwise.
      */
     public void setAggregator( boolean aggregator )
     {
         this.aggregator = aggregator;
     }
 
     /**
      * @return <code>true</code> if the Mojo uses the Maven project and its child modules, <code>false</code> otherwise.
      */
     public boolean isAggregator()
     {
         return aggregator;
     }
 
     /**
      * @return <code>true</code> if the Mojo could not be invoke directly, <code>false</code> otherwise.
      */
     public boolean isDirectInvocationOnly()
     {
         return directInvocationOnly;
     }
 
     /**
      * @param directInvocationOnly <code>true</code> if the Mojo could not be invoke directly, <code>false</code> otherwise.
      */
     public void setDirectInvocationOnly( boolean directInvocationOnly )
     {
         this.directInvocationOnly = directInvocationOnly;
     }
 
     /**
      * @return <code>true</code> if the Mojo needs reports to run, <code>false</code> otherwise.
      */
     public boolean isRequiresReports()
     {
         return requiresReports;
     }
 
     /**
      * @param requiresReports <code>true</code> if the Mojo needs reports to run, <code>false</code> otherwise.
      */
     public void setRequiresReports( boolean requiresReports )
     {
         this.requiresReports = requiresReports;
     }
 
     /**
      * @param executeGoal the new invocation goal of the Mojo
      */
     public void setExecuteGoal( String executeGoal )
     {
         this.executeGoal = executeGoal;
     }
 
     /**
      * @return the invocation goal of the Mojo
      */
     public String getExecuteGoal()
     {
         return executeGoal;
     }
 }

1		package org.apache.maven.plugin.descriptor;
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.Mojo;
23		import org.codehaus.plexus.component.repository.ComponentDescriptor;
24		import org.codehaus.plexus.configuration.PlexusConfiguration;
25		import org.codehaus.plexus.configuration.xml.XmlPlexusConfiguration;
26
27		import java.util.HashMap;
28		import java.util.Iterator;
29		import java.util.LinkedList;
30		import java.util.List;
31		import java.util.Map;
32
33		/**
34		* The bean containing the Mojo descriptor.
35		* <br/>
36		* For more information about the usage tag, have a look to:
37		* <a href="http://maven.apache.org/developers/mojo-api-specification.html">http://maven.apache.org/developers/mojo-api-specification.html</a>
38		*
39		* @todo is there a need for the delegation of MavenMojoDescriptor to this?
40		* Why not just extend ComponentDescriptor here?
41		* @version $Id: MojoDescriptor.java 743587 2009-02-12 01:32:50Z jdcasey $
42		*/
43		public class MojoDescriptor
44		extends ComponentDescriptor
45		implements Cloneable
46		{
47		/** The Plexus component type */
48	0	public static String MAVEN_PLUGIN = "maven-plugin";
49
50		/** "once-per-session" execution strategy */
51		public static final String SINGLE_PASS_EXEC_STRATEGY = "once-per-session";
52
53		/** "always" execution strategy */
54		public static final String MULTI_PASS_EXEC_STRATEGY = "always";
55
56		private static final String DEFAULT_INSTANTIATION_STRATEGY = "per-lookup";
57
58		private static final String DEFAULT_LANGUAGE = "java";
59
60		private List parameters;
61
62		private Map parameterMap;
63
64		/** By default, the execution strategy is "once-per-session" */
65	0	private String executionStrategy = SINGLE_PASS_EXEC_STRATEGY;
66
67		/** The goal name of the Mojo */
68		private String goal;
69
70		/** Reference the binded phase name of the Mojo */
71		private String phase;
72
73		/** Specify the version when the Mojo was added to the API. Similar to Javadoc since. */
74		private String since;
75
76		/** Reference the invocation phase of the Mojo */
77		private String executePhase;
78
79		/** Reference the invocation goal of the Mojo */
80		private String executeGoal;
81
82		/** Reference the invocation lifecycle of the Mojo */
83		private String executeLifecycle;
84
85		/** Specify the version when the Mojo was deprecated to the API. Similar to Javadoc deprecated. */
86		private String deprecated;
87
88		/** By default, no need to aggregate the Maven project and its child modules */
89	0	private boolean aggregator = false;
90
91		// ----------------------------------------------------------------------
92		//
93		// ----------------------------------------------------------------------
94
95		/** Specify the required dependencies in a specified scope */
96	0	private String dependencyResolutionRequired = null;
97
98		/** By default, the Mojo needs a Maven project to be executed */
99	0	private boolean projectRequired = true;
100
101		/** By default, the Mojo is online */
102	0	private boolean onlineRequired = false;
103
104		/** Plugin configuration */
105		private PlexusConfiguration mojoConfiguration;
106
107		/** Plugin descriptor */
108		private PluginDescriptor pluginDescriptor;
109
110		/** By default, the Mojo is herited */
111	0	private boolean inheritedByDefault = true;
112
113		/** By default, the Mojo could not be invoke directly */
114	0	private boolean directInvocationOnly = false;
115
116		/** By default, the Mojo don't need reports to run */
117	0	private boolean requiresReports = false;
118
119		/**
120		* Default constructor.
121		*/
122		public MojoDescriptor()
123	0	{
124	0	setInstantiationStrategy( DEFAULT_INSTANTIATION_STRATEGY );
125	0	setComponentFactory( DEFAULT_LANGUAGE );
126	0	}
127
128		// ----------------------------------------------------------------------
129		//
130		// ----------------------------------------------------------------------
131
132		/**
133		* @return the language of this Mojo, i.e. <code>java</code>
134		*/
135		public String getLanguage()
136		{
137	0	return getComponentFactory();
138		}
139
140		/**
141		* @param language the new language
142		*/
143		public void setLanguage( String language )
144		{
145	0	setComponentFactory( language );
146	0	}
147
148		/**
149		* @return <code>true</code> if the Mojo is deprecated, <code>false</code> otherwise.
150		*/
151		public String getDeprecated()
152		{
153	0	return deprecated;
154		}
155
156		/**
157		* @param deprecated <code>true</code> to deprecate the Mojo, <code>false</code> otherwise.
158		*/
159		public void setDeprecated( String deprecated )
160		{
161	0	this.deprecated = deprecated;
162	0	}
163
164		/**
165		* @return the list of parameters
166		*/
167		public List getParameters()
168		{
169	0	return parameters;
170		}
171
172		/**
173		* @param parameters the new list of parameters
174		* @throws DuplicateParameterException if any
175		*/
176		public void setParameters( List parameters )
177		throws DuplicateParameterException
178		{
179	0	for ( Iterator it = parameters.iterator(); it.hasNext(); )
180		{
181	0	Parameter parameter = (Parameter) it.next();
182	0	addParameter( parameter );
183	0	}
184	0	}
185
186		/**
187		* @param parameter add a new parameter
188		* @throws DuplicateParameterException if any
189		*/
190		public void addParameter( Parameter parameter )
191		throws DuplicateParameterException
192		{
193	0	if ( parameters != null && parameters.contains( parameter ) )
194		{
195	0	throw new DuplicateParameterException( parameter.getName() +
196		" has been declared multiple times in mojo with goal: " + getGoal() + " (implementation: " +
197		getImplementation() + ")" );
198		}
199
200	0	if ( parameters == null )
201		{
202	0	parameters = new LinkedList();
203		}
204
205	0	parameters.add( parameter );
206
207	0	parameterMap = null;
208	0	}
209
210		/**
211		* @return the list parameters as a Map
212		*/
213		public Map getParameterMap()
214		{
215	0	if ( parameterMap == null )
216		{
217	0	parameterMap = new HashMap();
218
219	0	if ( parameters != null )
220		{
221	0	for ( Iterator iterator = parameters.iterator(); iterator.hasNext(); )
222		{
223	0	Parameter pd = (Parameter) iterator.next();
224
225	0	parameterMap.put( pd.getName(), pd );
226	0	}
227		}
228		}
229
230	0	return parameterMap;
231		}
232
233		// ----------------------------------------------------------------------
234		// Dependency requirement
235		// ----------------------------------------------------------------------
236
237		/**
238		* @param requiresDependencyResolution the new required dependencies in a specified scope
239		*/
240		public void setDependencyResolutionRequired( String requiresDependencyResolution )
241		{
242	0	this.dependencyResolutionRequired = requiresDependencyResolution;
243	0	}
244
245		/**
246		* @return the required dependencies in a specified scope
247		* @TODO the name is not intelligible
248		*/
249		public String isDependencyResolutionRequired()
250		{
251	0	return dependencyResolutionRequired;
252		}
253
254		// ----------------------------------------------------------------------
255		// Project requirement
256		// ----------------------------------------------------------------------
257
258		/**
259		* @param requiresProject <code>true</code> if the Mojo needs a Maven project to be executed, <code>false</code> otherwise.
260		*/
261		public void setProjectRequired( boolean requiresProject )
262		{
263	0	this.projectRequired = requiresProject;
264	0	}
265
266		/**
267		* @return <code>true</code> if the Mojo needs a Maven project to be executed, <code>false</code> otherwise.
268		*/
269		public boolean isProjectRequired()
270		{
271	0	return projectRequired;
272		}
273
274		// ----------------------------------------------------------------------
275		// Online vs. Offline requirement
276		// ----------------------------------------------------------------------
277
278		/**
279		* @param requiresOnline <code>true</code> if the Mojo is online, <code>false</code> otherwise.
280		*/
281		public void setOnlineRequired( boolean requiresOnline )
282		{
283	0	this.onlineRequired = requiresOnline;
284	0	}
285
286		/**
287		* @return <code>true</code> if the Mojo is online, <code>false</code> otherwise.
288		*/
289		// blech! this isn't even intelligible as a method name. provided for
290		// consistency...
291		public boolean isOnlineRequired()
292		{
293	0	return onlineRequired;
294		}
295
296		/**
297		* @return <code>true</code> if the Mojo is online, <code>false</code> otherwise.
298		*/
299		// more english-friendly method...keep the code clean! :)
300		public boolean requiresOnline()
301		{
302	0	return onlineRequired;
303		}
304
305		/**
306		* @return the binded phase name of the Mojo
307		*/
308		public String getPhase()
309		{
310	0	return phase;
311		}
312
313		/**
314		* @param phase the new binded phase name of the Mojo
315		*/
316		public void setPhase( String phase )
317		{
318	0	this.phase = phase;
319	0	}
320
321		/**
322		* @return the version when the Mojo was added to the API
323		*/
324		public String getSince()
325		{
326	0	return since;
327		}
328
329		/**
330		* @param since the new version when the Mojo was added to the API
331		*/
332		public void setSince( String since )
333		{
334	0	this.since = since;
335	0	}
336
337		/**
338		* @return The goal name of the Mojo
339		*/
340		public String getGoal()
341		{
342	0	return goal;
343		}
344
345		/**
346		* @param goal The new goal name of the Mojo
347		*/
348		public void setGoal( String goal )
349		{
350	0	this.goal = goal;
351	0	}
352
353		/**
354		* @return the invocation phase of the Mojo
355		*/
356		public String getExecutePhase()
357		{
358	0	return executePhase;
359		}
360
361		/**
362		* @param executePhase the new invocation phase of the Mojo
363		*/
364		public void setExecutePhase( String executePhase )
365		{
366	0	this.executePhase = executePhase;
367	0	}
368
369		/**
370		* @return <code>true</code> if the Mojo uses <code>always</code> for the <code>executionStrategy</code>
371		*/
372		public boolean alwaysExecute()
373		{
374	0	return MULTI_PASS_EXEC_STRATEGY.equals( executionStrategy );
375		}
376
377		/**
378		* @return the execution strategy
379		*/
380		public String getExecutionStrategy()
381		{
382	0	return executionStrategy;
383		}
384
385		/**
386		* @param executionStrategy the new execution strategy
387		*/
388		public void setExecutionStrategy( String executionStrategy )
389		{
390	0	this.executionStrategy = executionStrategy;
391	0	}
392
393		/**
394		* @return the mojo configuration
395		*/
396		public PlexusConfiguration getMojoConfiguration()
397		{
398	0	if ( mojoConfiguration == null )
399		{
400	0	mojoConfiguration = new XmlPlexusConfiguration( "configuration" );
401		}
402	0	return mojoConfiguration;
403		}
404
405		/**
406		* @param mojoConfiguration a new mojo configuration
407		*/
408		public void setMojoConfiguration( PlexusConfiguration mojoConfiguration )
409		{
410	0	this.mojoConfiguration = mojoConfiguration;
411	0	}
412
413		/** {@inheritDoc} */
414		public String getRole()
415		{
416	0	return Mojo.ROLE;
417		}
418
419		/** {@inheritDoc} */
420		public String getRoleHint()
421		{
422	0	return getId();
423		}
424
425		/**
426		* @return the id of the mojo, based on the goal name
427		*/
428		public String getId()
429		{
430	0	return getPluginDescriptor().getId() + ":" + getGoal();
431		}
432
433		/**
434		* @return the full goal name
435		* @see PluginDescriptor#getGoalPrefix()
436		* @see #getGoal()
437		*/
438		public String getFullGoalName()
439		{
440	0	return getPluginDescriptor().getGoalPrefix() + ":" + getGoal();
441		}
442
443		/** {@inheritDoc} */
444		public String getComponentType()
445		{
446	0	return MAVEN_PLUGIN;
447		}
448
449		/**
450		* @return the plugin descriptor
451		*/
452		public PluginDescriptor getPluginDescriptor()
453		{
454	0	return pluginDescriptor;
455		}
456
457		/**
458		* @param pluginDescriptor the new plugin descriptor
459		*/
460		public void setPluginDescriptor( PluginDescriptor pluginDescriptor )
461		{
462	0	this.pluginDescriptor = pluginDescriptor;
463	0	}
464
465		/**
466		* @return <code>true</code> if the Mojo is herited, <code>false</code> otherwise.
467		*/
468		public boolean isInheritedByDefault()
469		{
470	0	return inheritedByDefault;
471		}
472
473		/**
474		* @param inheritedByDefault <code>true</code> if the Mojo is herited, <code>false</code> otherwise.
475		*/
476		public void setInheritedByDefault( boolean inheritedByDefault )
477		{
478	0	this.inheritedByDefault = inheritedByDefault;
479	0	}
480
481		/** {@inheritDoc} */
482		public boolean equals( Object object )
483		{
484	0	if ( this == object )
485		{
486	0	return true;
487		}
488
489	0	if ( object instanceof MojoDescriptor )
490		{
491	0	MojoDescriptor other = (MojoDescriptor) object;
492
493	0	if ( !compareObjects( getPluginDescriptor(), other.getPluginDescriptor() ) )
494		{
495	0	return false;
496		}
497
498	0	if ( !compareObjects( getGoal(), other.getGoal() ) )
499		{
500	0	return false;
501		}
502
503	0	return true;
504		}
505
506	0	return false;
507		}
508
509		private boolean compareObjects( Object first, Object second )
510		{
511	0	if ( ( first == null && second != null ) \|\| ( first != null && second == null ) )
512		{
513	0	return false;
514		}
515
516	0	if ( !first.equals( second ) )
517		{
518	0	return false;
519		}
520
521	0	return true;
522		}
523
524		/** {@inheritDoc} */
525		public int hashCode()
526		{
527	0	int result = 1;
528
529	0	String goal = getGoal();
530
531	0	if ( goal != null )
532		{
533	0	result += goal.hashCode();
534		}
535
536	0	PluginDescriptor pd = getPluginDescriptor();
537
538	0	if ( pd != null )
539		{
540	0	result -= pd.hashCode();
541		}
542
543	0	return result;
544		}
545
546		/**
547		* @return the invocation lifecycle of the Mojo
548		*/
549		public String getExecuteLifecycle()
550		{
551	0	return executeLifecycle;
552		}
553
554		/**
555		* @param executeLifecycle the new invocation lifecycle of the Mojo
556		*/
557		public void setExecuteLifecycle( String executeLifecycle )
558		{
559	0	this.executeLifecycle = executeLifecycle;
560	0	}
561
562		/**
563		* @param aggregator <code>true</code> if the Mojo uses the Maven project and its child modules, <code>false</code> otherwise.
564		*/
565		public void setAggregator( boolean aggregator )
566		{
567	0	this.aggregator = aggregator;
568	0	}
569
570		/**
571		* @return <code>true</code> if the Mojo uses the Maven project and its child modules, <code>false</code> otherwise.
572		*/
573		public boolean isAggregator()
574		{
575	0	return aggregator;
576		}
577
578		/**
579		* @return <code>true</code> if the Mojo could not be invoke directly, <code>false</code> otherwise.
580		*/
581		public boolean isDirectInvocationOnly()
582		{
583	0	return directInvocationOnly;
584		}
585
586		/**
587		* @param directInvocationOnly <code>true</code> if the Mojo could not be invoke directly, <code>false</code> otherwise.
588		*/
589		public void setDirectInvocationOnly( boolean directInvocationOnly )
590		{
591	0	this.directInvocationOnly = directInvocationOnly;
592	0	}
593
594		/**
595		* @return <code>true</code> if the Mojo needs reports to run, <code>false</code> otherwise.
596		*/
597		public boolean isRequiresReports()
598		{
599	0	return requiresReports;
600		}
601
602		/**
603		* @param requiresReports <code>true</code> if the Mojo needs reports to run, <code>false</code> otherwise.
604		*/
605		public void setRequiresReports( boolean requiresReports )
606		{
607	0	this.requiresReports = requiresReports;
608	0	}
609
610		/**
611		* @param executeGoal the new invocation goal of the Mojo
612		*/
613		public void setExecuteGoal( String executeGoal )
614		{
615	0	this.executeGoal = executeGoal;
616	0	}
617
618		/**
619		* @return the invocation goal of the Mojo
620		*/
621		public String getExecuteGoal()
622		{
623	0	return executeGoal;
624		}
625		}