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