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 * @since 2.4 27 */ 28 @SuppressWarnings( "checkstyle:interfaceistype" ) 29 public interface JavadocMojoAnnotation 30 { 31 // ---------------------------------------------------------------------- 32 // Descriptor for type i.e. Mojo 33 // ---------------------------------------------------------------------- 34 35 /** 36 * <p> 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 * </p> 40 * <p> 41 * Refer to <code>@aggregator</code>. 42 * </p> 43 * <p> 44 * <b>Note</b>: Should be defined in a Mojo Type. 45 * </p> 46 */ 47 String AGGREGATOR = "aggregator"; 48 49 /** 50 * <p> 51 * The configurator type to use when injecting parameter values into this Mojo. The value is normally deduced 52 * from the Mojo's implementation language, but can be specified to allow a custom ComponentConfigurator 53 * implementation to be used. 54 * </p> 55 * <p> 56 * Refer to <code>@configurator <roleHint></code>. 57 * </p> 58 * <p> 59 * <b>Note</b>: Should be defined in a Mojo Type. 60 * </p> 61 */ 62 String CONFIGURATOR = "configurator"; 63 64 /** 65 * <p> 66 * The description for the Mojo. 67 * </p> 68 * <p> 69 * Refer to <code>@description</code>. 70 * </p> 71 * <p> 72 * <b>Note</b>: Should be defined in a Mojo Type. 73 * </p> 74 * <p> 75 * <b>Note</b>: Mojo's description is auto-detected. 76 * </p> 77 */ 78 String DESCRIPTION = "description"; 79 80 /** 81 * <p> 82 * Refer to <code>@execute ...</code>. 83 * </p> 84 * <p> 85 * <b>Note</b>: Should be defined in a Mojo Type. 86 * </p> 87 */ 88 String EXECUTE = "execute"; 89 90 /** 91 * <p> 92 * The Mojo goal will be executed in isolation. 93 * </p> 94 * <p> 95 * Refer to <code>@execute goal="<goalName>"</code>. 96 * </p> 97 * <p> 98 * <b>Note</b>: Should be defined in a Mojo Type. 99 * </p> 100 */ 101 String EXECUTE_GOAL = "goal"; 102 103 /** 104 * <p> 105 * The Mojo will be invoked in a parallel lifecycle. 106 * </p> 107 * <p> 108 * Refer to <code>@execute lifecycle="<lifecycleId>"</code>. 109 * </p> 110 * <p> 111 * <b>Note</b>: Should be defined in a Mojo Type. 112 * </p> 113 */ 114 String EXECUTE_LIFECYCLE = "lifecycle"; 115 116 /** 117 * <p> 118 * The Mojo will be invoked in a parallel lifecycle, ending at the given phase. 119 * </p> 120 * <p> 121 * Refer to <code>@execute phase="<phaseName>"</code>. 122 * </p> 123 * <p> 124 * Refer to <code>@execute lifecycle="<lifecycleId>" phase="<phaseName>"</code>. 125 * </p> 126 * <p> 127 * <b>Note</b>: Should be defined in a Mojo Type. 128 * </p> 129 */ 130 String EXECUTE_PHASE = "phase"; 131 132 /** 133 * <p> 134 * Refer to <code>@executionStrategy <strategy></code>. 135 * </p> 136 * <p> 137 * <b>Note</b>: Should be defined in a Mojo Type. 138 * </p> 139 */ 140 String EXECUTION_STATEGY = "executionStrategy"; 141 142 /** 143 * <p> 144 * The name for the Mojo that users will reference to execute it. 145 * </p> 146 * <p> 147 * Refer to <code>@goal <goalName></code>. 148 * </p> 149 * <p> 150 * <b>Note</b>: Should be defined in a Mojo Type. 151 * </p> 152 */ 153 String GOAL = "goal"; 154 155 /** 156 * <p> 157 * The Mojo's fully-qualified class name. 158 * </p> 159 * <p> 160 * Refer to <code>@implementation</code>. 161 * </p> 162 * <p> 163 * <b>Note</b>: Should be defined in a Mojo Type. 164 * </p> 165 * <p> 166 * <b>Note</b>: Mojo's implementation is auto-detected. 167 * </p> 168 */ 169 String IMPLEMENTATION = "implementation"; 170 171 /** 172 * <p> 173 * Allow Mojo inheritance. 174 * </p> 175 * <p> 176 * Refer to <code>@inheritByDefault <true|false></code>. 177 * </p> 178 * <p> 179 * <b>Note</b>: Should be defined in a Mojo Type. 180 * </p> 181 */ 182 String INHERIT_BY_DEFAULT = "inheritByDefault"; 183 184 /** 185 * <p> 186 * Refer to <code>@instantiationStrategy <per-lookup></code>. 187 * </p> 188 * <p> 189 * <b>Note</b>: Should be defined in a Mojo Type. 190 * </p> 191 */ 192 String INSTANTIATION_STRATEGY = "instantiationStrategy"; 193 194 /** 195 * <p> 196 * The implementation language for the Mojo. 197 * </p> 198 * <p> 199 * Refer to <code>@language</code>. 200 * </p> 201 * <p> 202 * <b>Note</b>: Should be defined in a Mojo Type. 203 * </p> 204 * <p> 205 * <b>Note</b>: Mojo's implementation is auto-detected. 206 * </p> 207 */ 208 String LANGUAGE = "language"; 209 210 /** 211 * <p> 212 * Specifies the execution strategy. 213 * </p> 214 * <p> 215 * Refer to <code>@attainAlways</code>. 216 * </p> 217 * <p> 218 * <b>Note</b>: Should be defined in a Mojo Type. 219 * </p> 220 * @deprecated use <code>@executionStrategy always</code> instead 221 */ 222 String MULTI_EXECUTION_STRATEGY = "attainAlways"; 223 224 /** 225 * <p> 226 * Refer to <code>@phase <phaseName></code>. 227 * </p> 228 * <p> 229 * <b>Note</b>: Should be defined in a Mojo Type. 230 * </p> 231 */ 232 String PHASE = "phase"; 233 234 /** 235 * <p> 236 * Flags this Mojo as requiring the dependencies in the specified scope (or an implied scope) to be resolved 237 * before it can execute. Currently supports <code>compile</code>, <code>runtime</code>, 238 * <code>compile+runtime</code> and <code>test</code> scopes. 239 * </p> 240 * <p> 241 * Refer to <code>@requiresDependencyResolution <requiredScope></code>. 242 * </p> 243 * <p> 244 * <b>Note</b>: Should be defined in a Mojo Type. 245 * </p> 246 */ 247 String REQUIRES_DEPENDENCY_RESOLUTION = "requiresDependencyResolution"; 248 249 /** 250 * <p> 251 * Flags this Mojo as requiring the dependencies in the specified scope (or an implied scope) to be collected 252 * before it can execute. Currently supports <code>compile</code>, <code>runtime</code>, 253 * <code>compile+runtime</code> and <code>test</code> scopes. 254 * </p> 255 * <p> 256 * Refer to <code>@requiresDependencyCollection <requiredScope></code>. 257 * </p> 258 * <p> 259 * <b>Note</b>: Should be defined in a Mojo Type. 260 * </p> 261 */ 262 String REQUIRES_DEPENDENCY_COLLECTION = "requiresDependencyCollection"; 263 264 265 /** 266 * <p> 267 * Refer to <code>@requiresDirectInvocation <true|false></code>. 268 * </p> 269 * <p> 270 * <b>Note</b>: Should be defined in a Mojo Type. 271 * </p> 272 */ 273 String REQUIRES_DIRECT_INVOCATION = "requiresDirectInvocation"; 274 275 /** 276 * <p> 277 * Flags this Mojo to run online. 278 * </p> 279 * <p> 280 * Refer to <code>@requiresOnline <true|false></code>. 281 * </p> 282 * <p> 283 * <b>Note</b>: Should be defined in a Mojo Type. 284 * </p> 285 */ 286 String REQUIRES_ONLINE = "requiresOnline"; 287 288 /** 289 * <p> 290 * Flags this Mojo to run inside of a project. 291 * </p> 292 * <p> 293 * Refer to <code>@requiresProject <true|false></code>. 294 * </p> 295 * <p> 296 * <b>Note</b>: Should be defined in a Mojo Type. 297 * </p> 298 */ 299 String REQUIRES_PROJECT = "requiresProject"; 300 301 /** 302 * <p> 303 * Flags this Mojo to run inside reports. 304 * </p> 305 * <p> 306 * Refer to <code>@requiresReports <true|false></code>. 307 * </p> 308 * <p> 309 * <b>Note</b>: Should be defined in a Mojo Type. 310 * </p> 311 */ 312 String REQUIRES_REPORTS = "requiresReports"; 313 314 /** 315 * <p> 316 * Indicates that this mojo is thread-safe and can be run in parallel. 317 * </p> 318 * <p> 319 * <b>Note</b>: Should be defined in a Mojo Type. 320 * </p> 321 */ 322 String THREAD_SAFE = "threadSafe"; 323 324 325 // ---------------------------------------------------------------------- 326 // Descriptor for fields i.e. parameters 327 // ---------------------------------------------------------------------- 328 329 /** 330 * <p> 331 * Populate the field with an instance of a Plexus component. This is like declaring a requirement in a 332 * Plexus component. 333 * </p> 334 * <p> 335 * Refer to <code>@component ...</code>. 336 * </p> 337 * <p> 338 * <b>Note</b>: Should be defined in a Mojo Field. 339 * </p> 340 */ 341 String COMPONENT = "component"; 342 343 /** 344 * <p> 345 * Refer to <code>@component role="..."</code>. 346 * </p> 347 * <p> 348 * <b>Note</b>: Should be defined in a Mojo Field. 349 * </p> 350 */ 351 String COMPONENT_ROLE = "role"; 352 353 /** 354 * <p> 355 * Refer to <code>@component roleHint="..."</code>. 356 * </p> 357 * <p> 358 * <b>Note</b>: Should be defined in a Mojo Field. 359 * </p> 360 */ 361 String COMPONENT_ROLEHINT = "roleHint"; 362 363 /** 364 * <p> 365 * Refer to <code>@parameter ...</code> 366 * </p> 367 * <p> 368 * <b>Note</b>: Should be defined in a Mojo Field. 369 * </p> 370 */ 371 String PARAMETER = "parameter"; 372 373 /** 374 * <p> 375 * This defines the name of the bean property used to get/set the field: by default, field name is used. 376 * </p> 377 * <p> 378 * Refer to <code>@parameter name="..."</code>. 379 * </p> 380 * <p> 381 * <b>Note</b>: Should be defined in a Mojo Field. 382 * </p> 383 */ 384 String PARAMETER_NAME = "name"; 385 386 /** 387 * <p> 388 * This defines an alias which can be used to configure a parameter. This is primarily useful to improve 389 * user-friendliness. 390 * </p> 391 * <p> 392 * Refer to <code>@parameter alias="..."</code>. 393 * </p> 394 * <p> 395 * <b>Note</b>: Should be defined in a Mojo Field. 396 * </p> 397 */ 398 String PARAMETER_ALIAS = "alias"; 399 400 /** 401 * <p> 402 * This defines the default value to be injected into this parameter of the Mojo at build time. 403 * </p> 404 * <p> 405 * Refer to <code>@parameter default-value="..."</code>. 406 * </p> 407 * <p> 408 * <b>Note</b>: Should be defined in a Mojo Field. 409 * </p> 410 */ 411 String PARAMETER_DEFAULT_VALUE = "default-value"; 412 413 /** 414 * <p> 415 * This defines the expression used to calculate the value to be injected into this parameter of the 416 * Mojo at build time. 417 * </p> 418 * <p> 419 * Refer to <code>@parameter expression="..."</code>. 420 * </p> 421 * <p> 422 * <b>Note</b>: Should be defined in a Mojo Field. 423 * </p> 424 * @deprecated use PARAMETER_PROPERTY instead 425 */ 426 String PARAMETER_EXPRESSION = "expression"; 427 428 /** 429 * <p> 430 * This defines the property used to calculate the value to be injected into this parameter of the 431 * Mojo at build time, which can come from <code>-D</code> execution, setting properties or pom properties. 432 * </p> 433 * <p> 434 * Refer to <code>@parameter property="..."</code>. 435 * </p> 436 * <p> 437 * <b>Note</b>: Should be defined in a Mojo Field. 438 * </p> 439 */ 440 String PARAMETER_PROPERTY = "property"; 441 442 /** 443 * <p> 444 * This defines the default implementation in the case the parameter type is an interface. 445 * </p> 446 * <p> 447 * Refer to <code>@parameter implementation="..."</code>. 448 * </p> 449 * <p> 450 * <b>Note</b>: Should be defined in a Mojo Field. 451 * </p> 452 */ 453 String PARAMETER_IMPLEMENTATION = "implementation"; 454 455 /** 456 * <p> 457 * Specifies that this parameter cannot be configured directly by the user (as in the case of POM-specified 458 * configuration). 459 * </p> 460 * <p> 461 * Refer to <code>@readonly</code>. 462 * </p> 463 * <p> 464 * <b>Note</b>: Should be defined in a Mojo Field. 465 * </p> 466 */ 467 String READONLY = "readonly"; 468 469 /** 470 * <p> 471 * Specifies that this parameter is required for the Mojo to function. 472 * </p> 473 * <p> 474 * Refer to <code>@required</code>. 475 * </p> 476 * <p> 477 * <b>Note</b>: Should be defined in a Mojo Field. 478 * </p> 479 */ 480 String REQUIRED = "required"; 481 482 // ---------------------------------------------------------------------- 483 // Descriptor for type and fields 484 // ---------------------------------------------------------------------- 485 486 /** 487 * <p> 488 * Refer to <code>@since <deprecated-text></code> 489 * </p> 490 * <p> 491 * <b>Note</b>: Could be defined in a Mojo Type or a Mojo Field. 492 * </p> 493 */ 494 String SINCE = "since"; 495 496 /** 497 * <p> 498 * Refer to <code>@deprecated <since-text></code> 499 * </p> 500 * <p> 501 * <b>Note</b>: Could be defined in a Mojo Type or a Mojo Field. 502 * </p> 503 */ 504 String DEPRECATED = "deprecated"; 505 506 }