  --------
  Introduction
  --------
  Brett Porter
  Hervé Boutemy
  --------
  2008-07-17
  --------

~~ 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.

~~ NOTE: For help with the syntax of this file, see:
~~ http://maven.apache.org/doxia/references/apt-format.html

Maven Ant Tasks

  The Mavent Ant Tasks allow several of Maven's artifact handling features to be used
  from within an Ant build. These include:

    * <Dependency management> - including transitive dependencies, scope recognition and SNAPSHOT handling

    * <Artifact deployment> - deployment to a Maven repository (file integrated, other with extensions)

    * <POM processing> - for reading and writing a Maven 2 <<<pom.xml>>> file

  The Ant tasks can be downloaded from the {{{./download.html} download page}}.

* System Requirements

*-----------------+------------------------------------------------------------------------------------------------+
| <<JDK>>         | JDK version 1.5 or above is required (This is due to dependencies on internal Maven libraries.)
*-----------------+------------------------------------------------------------------------------------------------+
| <<Ant>>         | Ant version 1.6.x, 1.7.x or 1.8.x is required
*-----------------+------------------------------------------------------------------------------------------------+

* Usage

  General instructions for installing and using the Maven Ant Tasks can be found on the
  {{{./installation.html}installation page}} and the {{{./usage.html}usage page}} respectively.
  Some more specific use cases are described in the examples given below. Last but not least,
  users occasionally contribute additional examples, tips or errata to the
  {{{http://docs.codehaus.org/display/MAVENUSER/Maven+Ant+Tasks}project's wiki page}}.

* Examples

  Several common usage examples are provided for the following tasks:

  * {{{./examples/dependencies.html}Dependencies task}}

  * {{{./examples/install-deploy.html}Install and Deploy tasks}}

  * {{{./examples/pom.html}Pom task}}

  * {{{./examples/write-pom.html}WritePom task}}

  * {{{./examples/mvn.html}Mvn task}}

* Getting Help

  In case you still have questions regarding the Maven Ant Tasks usage, please have a look at the {{{./faq.html}FAQ}} and feel
  free to contact the {{{./mail-lists.html}user mailing list}}. The posts to the mailing list are archived and could
  already contain the answer to your question as part of an older thread. Hence, it is also worth browsing/searching
  the {{{./mail-lists.html}mail archive}}.

  If you feel like the Ant tasks are missing a feature or have a defect, you can fill a feature request or bug report in our
  {{{./issue-tracking.html}issue tracker}}. When creating a new issue, please provide a comprehensive description of your
  concern. Especially for fixing bugs it is crucial that the developers can reproduce your problem. For this reason,
  entire debug logs, Ant build scripts or most preferably little demo projects attached to the issue are very much appreciated.
  Of course, patches are welcome, too. Contributors can check out the project from our
  {{{./source-repository.html}source repository}} and will find supplementary information in the
  {{{http://maven.apache.org/guides/development/guide-helping.html}guide to helping with Maven}}.

  For more information on the Maven functionality behind the Ant tasks, try the following links:

    * {{{http://maven.apache.org/guides/introduction/introduction-to-dependency-mechanism.html} Dependency Mechanism}}

    * {{{http://maven.apache.org/ref/current/maven-settings/settings.html} Settings Reference}}

    * {{{http://maven.apache.org/ref/current/maven-model/maven.html} POM Reference}}
