~~ 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.    
 
  ------
  Usage
  ------
  Brian Fox
  ------
  Mar 2007
  ------

Usage
 
  Brief examples on how to use the enforcer goals.
 
* Generic Plugin configuration information

  See the following links for information about including and configuring plugins in your project:
  
  *{{{http://maven.apache.org/guides/mini/guide-configuring-plugins.html}Configuring Plugins}}
  
  *{{{http://maven.apache.org/guides/plugin/guide-java-plugin-development.html}Plugin Development}}

  *{{{http://maven.apache.org/guides/introduction/introduction-to-plugin-prefix-mapping.html}Plugin Prefix}}
  
  []

* The <<<enforcer:enforce>>> and <<<enforcer:enforce-once>>> mojos

   These goals are meant to be bound to a lifecycle phase and configured in your
   <<<pom.xml>>>. The enforcers execute the configured rules to check for certain constraints. 
   The available standard rules are described {{{rules/index.html}here}}. Besides the rules to execute, these goals support three options:
   
   * {{{enforce-mojo.html#skip}skip}} - a quick way to skip checks via a profile or using <<<-Denforcer.skip=true>>> from the command line.
   
   * {{{enforce-mojo.html#fail}fail}} - if the goal should fail the build when a rule fails. The default is <<<true>>>. If false, the errors will be logged as warnings.
   
   * {{{enforce-mojo.html#failFast}failFast}} - if the goal should stop checking after the first failure. The default is <<<false>>>.
   
   []
   
   Each rule to be executed should be added to the rules element along with the specific configuration for that rule.
   
   The <<<enforce>>> goal executes against each project in a multi-project build. The <<<enforce-once>>> goal executes
   just once per build. This is most effective for the standard rules because the Maven, Java and OS versions will not change between projects in the same build.
   
   
   Sample Plugin Configuration:
   
+---+
<project>
  [...]
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-enforcer-plugin</artifactId>
        <version>${project.version}</version>
        <executions>
          <execution>
            <id>enforce-versions</id>
            <goals>
              <goal>enforce</goal>
            </goals>
            <configuration>
              <rules>
                <requireMavenVersion>
                  <version>2.0.6</version>
                </requireMavenVersion>
                <requireJavaVersion>
                  <version>1.5</version>
                </requireJavaVersion>
                <requireOS>
                  <family>unix</family>
                </requireOS>
              </rules>
            </configuration>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
  [...]
</project>
+---+
  
* The <<<enforcer:display-info>>> mojo

   This goal is used to determine the current information as detected by the standard rules:
     
+---+
   mvn enforcer:display-info
   ...
   [enforcer:display-info]
       Maven Version: 2.0.6
       JDK Version: 1.5.0_11 normalized as: 1.5.0-11
       OS Info: Arch: x86 Family: windows Name: windows xp Version: 5.1
+---+
  