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 @Deprecated 223 String MULTI_EXECUTION_STRATEGY = "attainAlways"; 224 225 /** 226 * <p> 227 * Refer to <code>@phase <phaseName></code>. 228 * </p> 229 * <p> 230 * <b>Note</b>: Should be defined in a Mojo Type. 231 * </p> 232 */ 233 String PHASE = "phase"; 234 235 /** 236 * <p> 237 * Flags this Mojo as requiring the dependencies in the specified scope (or an implied scope) to be resolved 238 * before it can execute. Currently supports <code>compile</code>, <code>runtime</code>, 239 * <code>compile+runtime</code> and <code>test</code> scopes. 240 * </p> 241 * <p> 242 * Refer to <code>@requiresDependencyResolution <requiredScope></code>. 243 * </p> 244 * <p> 245 * <b>Note</b>: Should be defined in a Mojo Type. 246 * </p> 247 */ 248 String REQUIRES_DEPENDENCY_RESOLUTION = "requiresDependencyResolution"; 249 250 /** 251 * <p> 252 * Flags this Mojo as requiring the dependencies in the specified scope (or an implied scope) to be collected 253 * before it can execute. Currently supports <code>compile</code>, <code>runtime</code>, 254 * <code>compile+runtime</code> and <code>test</code> scopes. 255 * </p> 256 * <p> 257 * Refer to <code>@requiresDependencyCollection <requiredScope></code>. 258 * </p> 259 * <p> 260 * <b>Note</b>: Should be defined in a Mojo Type. 261 * </p> 262 */ 263 String REQUIRES_DEPENDENCY_COLLECTION = "requiresDependencyCollection"; 264 265 266 /** 267 * <p> 268 * Refer to <code>@requiresDirectInvocation <true|false></code>. 269 * </p> 270 * <p> 271 * <b>Note</b>: Should be defined in a Mojo Type. 272 * </p> 273 */ 274 String REQUIRES_DIRECT_INVOCATION = "requiresDirectInvocation"; 275 276 /** 277 * <p> 278 * Flags this Mojo to run online. 279 * </p> 280 * <p> 281 * Refer to <code>@requiresOnline <true|false></code>. 282 * </p> 283 * <p> 284 * <b>Note</b>: Should be defined in a Mojo Type. 285 * </p> 286 */ 287 String REQUIRES_ONLINE = "requiresOnline"; 288 289 /** 290 * <p> 291 * Flags this Mojo to run inside of a project. 292 * </p> 293 * <p> 294 * Refer to <code>@requiresProject <true|false></code>. 295 * </p> 296 * <p> 297 * <b>Note</b>: Should be defined in a Mojo Type. 298 * </p> 299 */ 300 String REQUIRES_PROJECT = "requiresProject"; 301 302 /** 303 * <p> 304 * Flags this Mojo to run inside reports. 305 * </p> 306 * <p> 307 * Refer to <code>@requiresReports <true|false></code>. 308 * </p> 309 * <p> 310 * <b>Note</b>: Should be defined in a Mojo Type. 311 * </p> 312 */ 313 String REQUIRES_REPORTS = "requiresReports"; 314 315 /** 316 * <p> 317 * Indicates that this mojo is thread-safe and can be run in parallel. 318 * </p> 319 * <p> 320 * <b>Note</b>: Should be defined in a Mojo Type. 321 * </p> 322 */ 323 String THREAD_SAFE = "threadSafe"; 324 325 326 // ---------------------------------------------------------------------- 327 // Descriptor for fields i.e. parameters 328 // ---------------------------------------------------------------------- 329 330 /** 331 * <p> 332 * Populate the field with an instance of a Plexus component. This is like declaring a requirement in a 333 * Plexus component. 334 * </p> 335 * <p> 336 * Refer to <code>@component ...</code>. 337 * </p> 338 * <p> 339 * <b>Note</b>: Should be defined in a Mojo Field. 340 * </p> 341 */ 342 String COMPONENT = "component"; 343 344 /** 345 * <p> 346 * Refer to <code>@component role="..."</code>. 347 * </p> 348 * <p> 349 * <b>Note</b>: Should be defined in a Mojo Field. 350 * </p> 351 */ 352 String COMPONENT_ROLE = "role"; 353 354 /** 355 * <p> 356 * Refer to <code>@component roleHint="..."</code>. 357 * </p> 358 * <p> 359 * <b>Note</b>: Should be defined in a Mojo Field. 360 * </p> 361 */ 362 String COMPONENT_ROLEHINT = "roleHint"; 363 364 /** 365 * <p> 366 * Refer to <code>@parameter ...</code> 367 * </p> 368 * <p> 369 * <b>Note</b>: Should be defined in a Mojo Field. 370 * </p> 371 */ 372 String PARAMETER = "parameter"; 373 374 /** 375 * <p> 376 * This defines the name of the bean property used to get/set the field: by default, field name is used. 377 * </p> 378 * <p> 379 * Refer to <code>@parameter name="..."</code>. 380 * </p> 381 * <p> 382 * <b>Note</b>: Should be defined in a Mojo Field. 383 * </p> 384 */ 385 String PARAMETER_NAME = "name"; 386 387 /** 388 * <p> 389 * This defines an alias which can be used to configure a parameter. This is primarily useful to improve 390 * user-friendliness. 391 * </p> 392 * <p> 393 * Refer to <code>@parameter alias="..."</code>. 394 * </p> 395 * <p> 396 * <b>Note</b>: Should be defined in a Mojo Field. 397 * </p> 398 */ 399 String PARAMETER_ALIAS = "alias"; 400 401 /** 402 * <p> 403 * This defines the default value to be injected into this parameter of the Mojo at build time. 404 * </p> 405 * <p> 406 * Refer to <code>@parameter default-value="..."</code>. 407 * </p> 408 * <p> 409 * <b>Note</b>: Should be defined in a Mojo Field. 410 * </p> 411 */ 412 String PARAMETER_DEFAULT_VALUE = "default-value"; 413 414 /** 415 * <p> 416 * This defines the expression used to calculate the value to be injected into this parameter of the 417 * Mojo at build time. 418 * </p> 419 * <p> 420 * Refer to <code>@parameter expression="..."</code>. 421 * </p> 422 * <p> 423 * <b>Note</b>: Should be defined in a Mojo Field. 424 * </p> 425 * @deprecated use PARAMETER_PROPERTY instead 426 */ 427 @Deprecated 428 String PARAMETER_EXPRESSION = "expression"; 429 430 /** 431 * <p> 432 * This defines the property used to calculate the value to be injected into this parameter of the 433 * Mojo at build time, which can come from <code>-D</code> execution, setting properties or pom properties. 434 * </p> 435 * <p> 436 * Refer to <code>@parameter property="..."</code>. 437 * </p> 438 * <p> 439 * <b>Note</b>: Should be defined in a Mojo Field. 440 * </p> 441 */ 442 String PARAMETER_PROPERTY = "property"; 443 444 /** 445 * <p> 446 * This defines the default implementation in the case the parameter type is an interface. 447 * </p> 448 * <p> 449 * Refer to <code>@parameter implementation="..."</code>. 450 * </p> 451 * <p> 452 * <b>Note</b>: Should be defined in a Mojo Field. 453 * </p> 454 */ 455 String PARAMETER_IMPLEMENTATION = "implementation"; 456 457 /** 458 * <p> 459 * Specifies that this parameter cannot be configured directly by the user (as in the case of POM-specified 460 * configuration). 461 * </p> 462 * <p> 463 * Refer to <code>@readonly</code>. 464 * </p> 465 * <p> 466 * <b>Note</b>: Should be defined in a Mojo Field. 467 * </p> 468 */ 469 String READONLY = "readonly"; 470 471 /** 472 * <p> 473 * Specifies that this parameter is required for the Mojo to function. 474 * </p> 475 * <p> 476 * Refer to <code>@required</code>. 477 * </p> 478 * <p> 479 * <b>Note</b>: Should be defined in a Mojo Field. 480 * </p> 481 */ 482 String REQUIRED = "required"; 483 484 // ---------------------------------------------------------------------- 485 // Descriptor for type and fields 486 // ---------------------------------------------------------------------- 487 488 /** 489 * <p> 490 * Refer to <code>@since <deprecated-text></code> 491 * </p> 492 * <p> 493 * <b>Note</b>: Could be defined in a Mojo Type or a Mojo Field. 494 * </p> 495 */ 496 String SINCE = "since"; 497 498 /** 499 * <p> 500 * Refer to <code>@deprecated <since-text></code> 501 * </p> 502 * <p> 503 * <b>Note</b>: Could be defined in a Mojo Type or a Mojo Field. 504 * </p> 505 */ 506 String DEPRECATED = "deprecated"; 507 508 }