JavadocMojoAnnotation.java

package org.apache.maven.tools.plugin.extractor.javadoc;

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

/**
 * List of all Javadoc annotations used to describe a java Mojo.
 *
 * @author <a href="mailto:vincent.siveton@gmail.com">Vincent Siveton</a>
 * @version $Id$
 * @since 2.4
 */
@SuppressWarnings( "checkstyle:interfaceistype" )
public interface JavadocMojoAnnotation
{
    // ----------------------------------------------------------------------
    // Descriptor for type i.e. Mojo
    // ----------------------------------------------------------------------

    /**
     * Flags this Mojo to run it in a multi module way, i.e. aggregate the build with the set of projects listed
     * as modules.
     * <br/>
     * Refer to <code>@aggregator</code>.
     * <br/>
     * <b>Note</b>: Should be defined in a Mojo Type.
     */
    String AGGREGATOR = "aggregator";

    /**
     * The configurator type to use when injecting parameter values into this Mojo. The value is normally deduced
     * from the Mojo's implementation language, but can be specified to allow a custom ComponentConfigurator
     * implementation to be used.
     * <br/>
     * Refer to <code>@configurator <roleHint></code>.
     * <br/>
     * <b>Note</b>: Should be defined in a Mojo Type.
     */
    String CONFIGURATOR = "configurator";

    /**
     * The description for the Mojo.
     * <br/>
     * Refer to <code>@description</code>.
     * <br/>
     * <b>Note</b>: Should be defined in a Mojo Type.
     * <br/>
     * <b>Note</b>: Mojo's description is auto-detected.
     */
    String DESCRIPTION = "description";

    /**
     * Refer to <code>@execute ...</code>.
     * <br/>
     * <b>Note</b>: Should be defined in a Mojo Type.
     */
    String EXECUTE = "execute";

    /**
     * The Mojo goal will be executed in isolation.
     * <br/>
     * Refer to <code>@execute goal="<goalName>"</code>.
     * <br/>
     * <b>Note</b>: Should be defined in a Mojo Type.
     */
    String EXECUTE_GOAL = "goal";

    /**
     * The Mojo will be invoked in a parallel lifecycle.
     * <br/>
     * Refer to <code>@execute lifecycle="<lifecycleId>"</code>.
     * <br/>
     * <b>Note</b>: Should be defined in a Mojo Type.
     */
    String EXECUTE_LIFECYCLE = "lifecycle";

    /**
     * The Mojo will be invoked in a parallel lifecycle, ending at the given phase.
     * <br/>
     * Refer to <code>@execute phase="<phaseName>"</code>.
     * <br/>
     * Refer to <code>@execute lifecycle="<lifecycleId>" phase="<phaseName>"</code>.
     * <br/>
     * <b>Note</b>: Should be defined in a Mojo Type.
     */
    String EXECUTE_PHASE = "phase";

    /**
     * Refer to <code>@executionStrategy <strategy></code>.
     * <br/>
     * <b>Note</b>: Should be defined in a Mojo Type.
     */
    String EXECUTION_STATEGY = "executionStrategy";

    /**
     * The name for the Mojo that users will reference to execute it.
     * <br/>
     * Refer to <code>@goal <goalName></code>.
     * <br/>
     * <b>Note</b>: Should be defined in a Mojo Type.
     */
    String GOAL = "goal";

    /**
     * The Mojo's fully-qualified class name.
     * <br/>
     * Refer to <code>@implementation</code>.
     * <br/>
     * <b>Note</b>: Should be defined in a Mojo Type.
     * <br/>
     * <b>Note</b>: Mojo's implementation is auto-detected.
     */
    String IMPLEMENTATION = "implementation";

    /**
     * Allow Mojo inheritance.
     * <br/>
     * Refer to <code>@inheritByDefault <true|false></code>.
     * <br/>
     * <b>Note</b>: Should be defined in a Mojo Type.
     */
    String INHERIT_BY_DEFAULT = "inheritByDefault";

    /**
     * Refer to <code>@instantiationStrategy <per-lookup></code>.
     * <br/>
     * <b>Note</b>: Should be defined in a Mojo Type.
     */
    String INSTANTIATION_STRATEGY = "instantiationStrategy";

    /**
     * The implementation language for the Mojo.
     * <br/>
     * Refer to <code>@language</code>.
     * <br/>
     * <b>Note</b>: Should be defined in a Mojo Type.
     * <br/>
     * <b>Note</b>: Mojo's implementation is auto-detected.
     */
    String LANGUAGE = "language";

    /**
     * Specifies the execution strategy.
     * <br/>
     * Refer to <code>@attainAlways</code>.
     * <br/>
     * <b>Note</b>: Should be defined in a Mojo Type.
     * @deprecated use <code>@executionStrategy always</code> instead
     */
    String MULTI_EXECUTION_STRATEGY = "attainAlways";

    /**
     * Refer to <code>@phase <phaseName></code>.
     * <br/>
     * <b>Note</b>: Should be defined in a Mojo Type.
     */
    String PHASE = "phase";

    /**
     * Flags this Mojo as requiring the dependencies in the specified scope (or an implied scope) to be resolved
     * before it can execute. Currently supports <code>compile</code>, <code>runtime</code>,
     * <code>compile+runtime</code> and <code>test</code> scopes.
     * <br/>
     * Refer to <code>@requiresDependencyResolution <requiredScope></code>.
     * <br/>
     * <b>Note</b>: Should be defined in a Mojo Type.
     */
    String REQUIRES_DEPENDENCY_RESOLUTION = "requiresDependencyResolution";

    /**
     * Flags this Mojo as requiring the dependencies in the specified scope (or an implied scope) to be collected
     * before it can execute. Currently supports <code>compile</code>, <code>runtime</code>,
     * <code>compile+runtime</code> and <code>test</code> scopes.
     * <br/>
     * Refer to <code>@requiresDependencyCollection <requiredScope></code>.
     * <br/>
     * <b>Note</b>: Should be defined in a Mojo Type.
     */
    String REQUIRES_DEPENDENCY_COLLECTION = "requiresDependencyCollection";


    /**
     * Refer to <code>@requiresDirectInvocation <true|false></code>.
     * <br/>
     * <b>Note</b>: Should be defined in a Mojo Type.
     */
    String REQUIRES_DIRECT_INVOCATION = "requiresDirectInvocation";

    /**
     * Flags this Mojo to run online.
     * <br/>
     * Refer to <code>@requiresOnline <true|false></code>.
     * <br/>
     * <b>Note</b>: Should be defined in a Mojo Type.
     */
    String REQUIRES_ONLINE = "requiresOnline";

    /**
     * Flags this Mojo to run inside of a project.
     * <br/>
     * Refer to <code>@requiresProject <true|false></code>.
     * <br/>
     * <b>Note</b>: Should be defined in a Mojo Type.
     */
    String REQUIRES_PROJECT = "requiresProject";

    /**
     * Flags this Mojo to run inside reports.
     * <br/>
     * Refer to <code>@requiresReports <true|false></code>.
     * <br/>
     * <b>Note</b>: Should be defined in a Mojo Type.
     */
    String REQUIRES_REPORTS = "requiresReports";

    /**
     * Indicates that this mojo is thread-safe and can be run in parallel.
     *
     * <b>Note</b>: Should be defined in a Mojo Type.
     */
    String THREAD_SAFE = "threadSafe";


    // ----------------------------------------------------------------------
    // Descriptor for fields i.e. parameters
    // ----------------------------------------------------------------------

    /**
     * Populate the field with an instance of a Plexus component. This is like declaring a requirement in a
     * Plexus component.
     * <br/>
     * Refer to <code>@component ...</code>.
     * <br/>
     * <b>Note</b>: Should be defined in a Mojo Field.
     */
    String COMPONENT = "component";

    /**
     * Refer to <code>@component role="..."</code>.
     * <br/>
     * <b>Note</b>: Should be defined in a Mojo Field.
     */
    String COMPONENT_ROLE = "role";

    /**
     * Refer to <code>@component roleHint="..."</code>.
     * <br/>
     * <b>Note</b>: Should be defined in a Mojo Field.
     */
    String COMPONENT_ROLEHINT = "roleHint";

    /**
     * Refer to <code>@parameter ...</code>
     * <br/>
     * <b>Note</b>: Should be defined in a Mojo Field.
     */
    String PARAMETER = "parameter";

    /**
     * This defines the name of the bean property used to get/set the field: by default, field name is used.
     * <br/>
     * Refer to <code>@parameter name="..."</code>.
     * <br/>
     * <b>Note</b>: Should be defined in a Mojo Field.
     */
    String PARAMETER_NAME = "name";

    /**
     * This defines an alias which can be used to configure a parameter. This is primarily useful to improve
     * user-friendliness.
     * <br/>
     * Refer to <code>@parameter alias="..."</code>.
     * <br/>
     * <b>Note</b>: Should be defined in a Mojo Field.
     */
    String PARAMETER_ALIAS = "alias";

    /**
     * This defines the default value to be injected into this parameter of the Mojo at build time.
     * <br/>
     * Refer to <code>@parameter default-value="..."</code>.
     * <br/>
     * <b>Note</b>: Should be defined in a Mojo Field.
     */
    String PARAMETER_DEFAULT_VALUE = "default-value";

    /**
     * This defines the expression used to calculate the value to be injected into this parameter of the
     * Mojo at build time.
     * <br/>
     * Refer to <code>@parameter expression="..."</code>.
     * <br/>
     * <b>Note</b>: Should be defined in a Mojo Field.
     * @deprecated use PARAMETER_PROPERTY instead
     */
    String PARAMETER_EXPRESSION = "expression";

    /**
     * This defines the property used to calculate the value to be injected into this parameter of the
     * Mojo at build time, which can come from <code>-D</code> execution, setting properties or pom properties.
     * <br/>
     * Refer to <code>@parameter property="..."</code>.
     * <br/>
     * <b>Note</b>: Should be defined in a Mojo Field.
     */
    String PARAMETER_PROPERTY = "property";

    /**
     * This defines the default implementation in the case the parameter type is an interface.
     * <br/>
     * Refer to <code>@parameter implementation="..."</code>.
     * <br/>
     * <b>Note</b>: Should be defined in a Mojo Field.
     */
    String PARAMETER_IMPLEMENTATION = "implementation";

    /**
     * Specifies that this parameter cannot be configured directly by the user (as in the case of POM-specified
     * configuration).
     * <br/>
     * Refer to <code>@readonly</code>.
     * <br/>
     * <b>Note</b>: Should be defined in a Mojo Field.
     */
    String READONLY = "readonly";

    /**
     * Specifies that this parameter is required for the Mojo to function.
     * <br/>
     * Refer to <code>@required</code>.
     * <br/>
     * <b>Note</b>: Should be defined in a Mojo Field.
     */
    String REQUIRED = "required";

    // ----------------------------------------------------------------------
    // Descriptor for type and fields
    // ----------------------------------------------------------------------

    /**
     * Refer to <code>@since <deprecated-text></code>
     * <br/>
     * <b>Note</b>: Could be defined in a Mojo Type or a Mojo Field.
     */
    String SINCE = "since";

    /**
     * Refer to <code>@deprecated <since-text></code>
     * <br/>
     * <b>Note</b>: Could be defined in a Mojo Type or a Mojo Field.
     */
    String DEPRECATED = "deprecated";

}