View Javadoc
1   package org.apache.maven.tools.plugin.extractor.javadoc;
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  /**
23   * List of all Javadoc annotations used to describe a java Mojo.
24   *
25   * @author <a href="mailto:vincent.siveton@gmail.com">Vincent Siveton</a>
26   * @version $Id: JavadocMojoAnnotation.html 1024032 2018-01-19 18:16:30Z hboutemy $
27   * @since 2.4
28   */
29  @SuppressWarnings( "checkstyle:interfaceistype" )
30  public interface JavadocMojoAnnotation
31  {
32      // ----------------------------------------------------------------------
33      // Descriptor for type i.e. Mojo
34      // ----------------------------------------------------------------------
35  
36      /**
37       * Flags this Mojo to run it in a multi module way, i.e. aggregate the build with the set of projects listed
38       * as modules.
39       * <br/>
40       * Refer to <code>&#64;aggregator</code>.
41       * <br/>
42       * <b>Note</b>: Should be defined in a Mojo Type.
43       */
44      String AGGREGATOR = "aggregator";
45  
46      /**
47       * The configurator type to use when injecting parameter values into this Mojo. The value is normally deduced
48       * from the Mojo's implementation language, but can be specified to allow a custom ComponentConfigurator
49       * implementation to be used.
50       * <br/>
51       * Refer to <code>&#64;configurator &lt;roleHint&gt;</code>.
52       * <br/>
53       * <b>Note</b>: Should be defined in a Mojo Type.
54       */
55      String CONFIGURATOR = "configurator";
56  
57      /**
58       * The description for the Mojo.
59       * <br/>
60       * Refer to <code>&#64;description</code>.
61       * <br/>
62       * <b>Note</b>: Should be defined in a Mojo Type.
63       * <br/>
64       * <b>Note</b>: Mojo's description is auto-detected.
65       */
66      String DESCRIPTION = "description";
67  
68      /**
69       * Refer to <code>&#64;execute ...</code>.
70       * <br/>
71       * <b>Note</b>: Should be defined in a Mojo Type.
72       */
73      String EXECUTE = "execute";
74  
75      /**
76       * The Mojo goal will be executed in isolation.
77       * <br/>
78       * Refer to <code>&#64;execute goal="&lt;goalName&gt;"</code>.
79       * <br/>
80       * <b>Note</b>: Should be defined in a Mojo Type.
81       */
82      String EXECUTE_GOAL = "goal";
83  
84      /**
85       * The Mojo will be invoked in a parallel lifecycle.
86       * <br/>
87       * Refer to <code>&#64;execute lifecycle="&lt;lifecycleId&gt;"</code>.
88       * <br/>
89       * <b>Note</b>: Should be defined in a Mojo Type.
90       */
91      String EXECUTE_LIFECYCLE = "lifecycle";
92  
93      /**
94       * The Mojo will be invoked in a parallel lifecycle, ending at the given phase.
95       * <br/>
96       * Refer to <code>&#64;execute phase="&lt;phaseName&gt;"</code>.
97       * <br/>
98       * Refer to <code>&#64;execute lifecycle="&lt;lifecycleId&gt;" phase="&lt;phaseName&gt;"</code>.
99       * <br/>
100      * <b>Note</b>: Should be defined in a Mojo Type.
101      */
102     String EXECUTE_PHASE = "phase";
103 
104     /**
105      * Refer to <code>&#64;executionStrategy &lt;strategy&gt;</code>.
106      * <br/>
107      * <b>Note</b>: Should be defined in a Mojo Type.
108      */
109     String EXECUTION_STATEGY = "executionStrategy";
110 
111     /**
112      * The name for the Mojo that users will reference to execute it.
113      * <br/>
114      * Refer to <code>&#64;goal &lt;goalName&gt;</code>.
115      * <br/>
116      * <b>Note</b>: Should be defined in a Mojo Type.
117      */
118     String GOAL = "goal";
119 
120     /**
121      * The Mojo's fully-qualified class name.
122      * <br/>
123      * Refer to <code>&#64;implementation</code>.
124      * <br/>
125      * <b>Note</b>: Should be defined in a Mojo Type.
126      * <br/>
127      * <b>Note</b>: Mojo's implementation is auto-detected.
128      */
129     String IMPLEMENTATION = "implementation";
130 
131     /**
132      * Allow Mojo inheritance.
133      * <br/>
134      * Refer to <code>&#64;inheritByDefault &lt;true|false&gt;</code>.
135      * <br/>
136      * <b>Note</b>: Should be defined in a Mojo Type.
137      */
138     String INHERIT_BY_DEFAULT = "inheritByDefault";
139 
140     /**
141      * Refer to <code>&#64;instantiationStrategy &lt;per-lookup&gt;</code>.
142      * <br/>
143      * <b>Note</b>: Should be defined in a Mojo Type.
144      */
145     String INSTANTIATION_STRATEGY = "instantiationStrategy";
146 
147     /**
148      * The implementation language for the Mojo.
149      * <br/>
150      * Refer to <code>&#64;language</code>.
151      * <br/>
152      * <b>Note</b>: Should be defined in a Mojo Type.
153      * <br/>
154      * <b>Note</b>: Mojo's implementation is auto-detected.
155      */
156     String LANGUAGE = "language";
157 
158     /**
159      * Specifies the execution strategy.
160      * <br/>
161      * Refer to <code>&#64;attainAlways</code>.
162      * <br/>
163      * <b>Note</b>: Should be defined in a Mojo Type.
164      * @deprecated use <code>&#64executionStrategy always</code> instead
165      */
166     String MULTI_EXECUTION_STRATEGY = "attainAlways";
167 
168     /**
169      * Refer to <code>&#64;phase &lt;phaseName&gt;</code>.
170      * <br/>
171      * <b>Note</b>: Should be defined in a Mojo Type.
172      */
173     String PHASE = "phase";
174 
175     /**
176      * Flags this Mojo as requiring the dependencies in the specified scope (or an implied scope) to be resolved
177      * before it can execute. Currently supports <code>compile</code>, <code>runtime</code>,
178      * <code>compile+runtime</code> and <code>test</code> scopes.
179      * <br/>
180      * Refer to <code>&#64;requiresDependencyResolution &lt;requiredScope&gt;</code>.
181      * <br/>
182      * <b>Note</b>: Should be defined in a Mojo Type.
183      */
184     String REQUIRES_DEPENDENCY_RESOLUTION = "requiresDependencyResolution";
185 
186     /**
187      * Flags this Mojo as requiring the dependencies in the specified scope (or an implied scope) to be collected
188      * before it can execute. Currently supports <code>compile</code>, <code>runtime</code>,
189      * <code>compile+runtime</code> and <code>test</code> scopes.
190      * <br/>
191      * Refer to <code>&#64;requiresDependencyCollection &lt;requiredScope&gt;</code>.
192      * <br/>
193      * <b>Note</b>: Should be defined in a Mojo Type.
194      */
195     String REQUIRES_DEPENDENCY_COLLECTION = "requiresDependencyCollection";
196 
197 
198     /**
199      * Refer to <code>&#64;requiresDirectInvocation &lt;true|false&gt;</code>.
200      * <br/>
201      * <b>Note</b>: Should be defined in a Mojo Type.
202      */
203     String REQUIRES_DIRECT_INVOCATION = "requiresDirectInvocation";
204 
205     /**
206      * Flags this Mojo to run online.
207      * <br/>
208      * Refer to <code>&#64;requiresOnline &lt;true|false&gt;</code>.
209      * <br/>
210      * <b>Note</b>: Should be defined in a Mojo Type.
211      */
212     String REQUIRES_ONLINE = "requiresOnline";
213 
214     /**
215      * Flags this Mojo to run inside of a project.
216      * <br/>
217      * Refer to <code>&#64;requiresProject &lt;true|false&gt;</code>.
218      * <br/>
219      * <b>Note</b>: Should be defined in a Mojo Type.
220      */
221     String REQUIRES_PROJECT = "requiresProject";
222 
223     /**
224      * Flags this Mojo to run inside reports.
225      * <br/>
226      * Refer to <code>&#64;requiresReports &lt;true|false&gt;</code>.
227      * <br/>
228      * <b>Note</b>: Should be defined in a Mojo Type.
229      */
230     String REQUIRES_REPORTS = "requiresReports";
231 
232     /**
233      * Indicates that this mojo is thread-safe and can be run in parallel.
234      *
235      * <b>Note</b>: Should be defined in a Mojo Type.
236      */
237     String THREAD_SAFE = "threadSafe";
238 
239 
240     // ----------------------------------------------------------------------
241     // Descriptor for fields i.e. parameters
242     // ----------------------------------------------------------------------
243 
244     /**
245      * Populate the field with an instance of a Plexus component. This is like declaring a requirement in a
246      * Plexus component.
247      * <br/>
248      * Refer to <code>&#64;component ...</code>.
249      * <br/>
250      * <b>Note</b>: Should be defined in a Mojo Field.
251      */
252     String COMPONENT = "component";
253 
254     /**
255      * Refer to <code>&#64;component role="..."</code>.
256      * <br/>
257      * <b>Note</b>: Should be defined in a Mojo Field.
258      */
259     String COMPONENT_ROLE = "role";
260 
261     /**
262      * Refer to <code>&#64;component roleHint="..."</code>.
263      * <br/>
264      * <b>Note</b>: Should be defined in a Mojo Field.
265      */
266     String COMPONENT_ROLEHINT = "roleHint";
267 
268     /**
269      * Refer to <code>&#64;parameter ...</code>
270      * <br/>
271      * <b>Note</b>: Should be defined in a Mojo Field.
272      */
273     String PARAMETER = "parameter";
274 
275     /**
276      * This defines the name of the bean property used to get/set the field: by default, field name is used.
277      * <br/>
278      * Refer to <code>&#64;parameter name="..."</code>.
279      * <br/>
280      * <b>Note</b>: Should be defined in a Mojo Field.
281      */
282     String PARAMETER_NAME = "name";
283 
284     /**
285      * This defines an alias which can be used to configure a parameter. This is primarily useful to improve
286      * user-friendliness.
287      * <br/>
288      * Refer to <code>&#64;parameter alias="..."</code>.
289      * <br/>
290      * <b>Note</b>: Should be defined in a Mojo Field.
291      */
292     String PARAMETER_ALIAS = "alias";
293 
294     /**
295      * This defines the default value to be injected into this parameter of the Mojo at build time.
296      * <br/>
297      * Refer to <code>&#64;parameter default-value="..."</code>.
298      * <br/>
299      * <b>Note</b>: Should be defined in a Mojo Field.
300      */
301     String PARAMETER_DEFAULT_VALUE = "default-value";
302 
303     /**
304      * This defines the expression used to calculate the value to be injected into this parameter of the
305      * Mojo at build time.
306      * <br/>
307      * Refer to <code>&#64;parameter expression="..."</code>.
308      * <br/>
309      * <b>Note</b>: Should be defined in a Mojo Field.
310      * @deprecated use PARAMETER_PROPERTY instead
311      */
312     String PARAMETER_EXPRESSION = "expression";
313 
314     /**
315      * This defines the property used to calculate the value to be injected into this parameter of the
316      * Mojo at build time, which can come from <code>-D</code> execution, setting properties or pom properties.
317      * <br/>
318      * Refer to <code>&#64;parameter property="..."</code>.
319      * <br/>
320      * <b>Note</b>: Should be defined in a Mojo Field.
321      */
322     String PARAMETER_PROPERTY = "property";
323 
324     /**
325      * This defines the default implementation in the case the parameter type is an interface.
326      * <br/>
327      * Refer to <code>&#64;parameter implementation="..."</code>.
328      * <br/>
329      * <b>Note</b>: Should be defined in a Mojo Field.
330      */
331     String PARAMETER_IMPLEMENTATION = "implementation";
332 
333     /**
334      * Specifies that this parameter cannot be configured directly by the user (as in the case of POM-specified
335      * configuration).
336      * <br/>
337      * Refer to <code>&#64;readonly</code>.
338      * <br/>
339      * <b>Note</b>: Should be defined in a Mojo Field.
340      */
341     String READONLY = "readonly";
342 
343     /**
344      * Specifies that this parameter is required for the Mojo to function.
345      * <br/>
346      * Refer to <code>&#64;required</code>.
347      * <br/>
348      * <b>Note</b>: Should be defined in a Mojo Field.
349      */
350     String REQUIRED = "required";
351 
352     // ----------------------------------------------------------------------
353     // Descriptor for type and fields
354     // ----------------------------------------------------------------------
355 
356     /**
357      * Refer to <code>&#64;since &lt;deprecated-text&gt;</code>
358      * <br/>
359      * <b>Note</b>: Could be defined in a Mojo Type or a Mojo Field.
360      */
361     String SINCE = "since";
362 
363     /**
364      * Refer to <code>&#64;deprecated &lt;since-text&gt;</code>
365      * <br/>
366      * <b>Note</b>: Could be defined in a Mojo Type or a Mojo Field.
367      */
368     String DEPRECATED = "deprecated";
369 
370 }