001package org.apache.maven.tools.plugin.extractor.javadoc; 002 003/* 004 * Licensed to the Apache Software Foundation (ASF) under one 005 * or more contributor license agreements. See the NOTICE file 006 * distributed with this work for additional information 007 * regarding copyright ownership. The ASF licenses this file 008 * to you under the Apache License, Version 2.0 (the 009 * "License"); you may not use this file except in compliance 010 * with the License. You may obtain a copy of the License at 011 * 012 * http://www.apache.org/licenses/LICENSE-2.0 013 * 014 * Unless required by applicable law or agreed to in writing, 015 * software distributed under the License is distributed on an 016 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 017 * KIND, either express or implied. See the License for the 018 * specific language governing permissions and limitations 019 * under the License. 020 */ 021 022/** 023 * List of all Javadoc annotations used to describe a java Mojo. 024 * 025 * @author <a href="mailto:vincent.siveton@gmail.com">Vincent Siveton</a> 026 * @version $Id: JavadocMojoAnnotation.html 934731 2015-01-01 22:17:21Z hboutemy $ 027 * @since 2.4 028 */ 029@SuppressWarnings( "checkstyle:interfaceistype" ) 030public interface JavadocMojoAnnotation 031{ 032 // ---------------------------------------------------------------------- 033 // Descriptor for type i.e. Mojo 034 // ---------------------------------------------------------------------- 035 036 /** 037 * Flags this Mojo to run it in a multi module way, i.e. aggregate the build with the set of projects listed 038 * as modules. 039 * <br/> 040 * Refer to <code>@aggregator</code>. 041 * <br/> 042 * <b>Note</b>: Should be defined in a Mojo Type. 043 */ 044 String AGGREGATOR = "aggregator"; 045 046 /** 047 * The configurator type to use when injecting parameter values into this Mojo. The value is normally deduced 048 * from the Mojo's implementation language, but can be specified to allow a custom ComponentConfigurator 049 * implementation to be used. 050 * <br/> 051 * Refer to <code>@configurator <roleHint></code>. 052 * <br/> 053 * <b>Note</b>: Should be defined in a Mojo Type. 054 */ 055 String CONFIGURATOR = "configurator"; 056 057 /** 058 * The description for the Mojo. 059 * <br/> 060 * Refer to <code>@description</code>. 061 * <br/> 062 * <b>Note</b>: Should be defined in a Mojo Type. 063 * <br/> 064 * <b>Note</b>: Mojo's description is auto-detected. 065 */ 066 String DESCRIPTION = "description"; 067 068 /** 069 * Refer to <code>@execute ...</code>. 070 * <br/> 071 * <b>Note</b>: Should be defined in a Mojo Type. 072 */ 073 String EXECUTE = "execute"; 074 075 /** 076 * The Mojo goal will be executed in isolation. 077 * <br/> 078 * Refer to <code>@execute goal="<goalName>"</code>. 079 * <br/> 080 * <b>Note</b>: Should be defined in a Mojo Type. 081 */ 082 String EXECUTE_GOAL = "goal"; 083 084 /** 085 * The Mojo will be invoked in a parallel lifecycle. 086 * <br/> 087 * Refer to <code>@execute lifecycle="<lifecycleId>"</code>. 088 * <br/> 089 * <b>Note</b>: Should be defined in a Mojo Type. 090 */ 091 String EXECUTE_LIFECYCLE = "lifecycle"; 092 093 /** 094 * The Mojo will be invoked in a parallel lifecycle, ending at the given phase. 095 * <br/> 096 * Refer to <code>@execute phase="<phaseName>"</code>. 097 * <br/> 098 * Refer to <code>@execute lifecycle="<lifecycleId>" phase="<phaseName>"</code>. 099 * <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}