  --------
  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}}
