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 934731 2015-01-01 22:17:21Z 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>@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>@configurator <roleHint></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>@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>@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>@execute goal="<goalName>"</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>@execute lifecycle="<lifecycleId>"</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>@execute phase="<phaseName>"</code>. 97 * <br/> 98 * Refer to <code>@execute lifecycle="<lifecycleId>" phase="<phaseName>"</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>@executionStrategy <strategy></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>@goal <goalName></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>@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>@inheritByDefault <true|false></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>@instantiationStrategy <per-lookup></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>@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>@attainAlways</code>. 162 * <br/> 163 * <b>Note</b>: Should be defined in a Mojo Type. 164 * @deprecated use <code>@executionStrategy always</code> instead 165 */ 166 String MULTI_EXECUTION_STRATEGY = "attainAlways"; 167 168 /** 169 * Refer to <code>@phase <phaseName></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>@requiresDependencyResolution <requiredScope></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>@requiresDependencyCollection <requiredScope></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>@requiresDirectInvocation <true|false></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>@requiresOnline <true|false></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>@requiresProject <true|false></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>@requiresReports <true|false></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>@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>@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>@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>@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>@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>@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>@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>@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>@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>@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>@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>@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>@since <deprecated-text></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>@deprecated <since-text></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 }