  ------
  Introduction
  ------
  Allan Ramirez
  ------
  2013-07-22
  ------

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

${project.name}

  The Install Plugin is used during the <<<install>>> phase to add
  artifact(s) to the local repository. The Install Plugin uses
  the information in the POM (groupId, artifactId, version) to determine
  the proper location for the artifact within the local repository.

  The local repository is the local cache where
  all artifacts needed for the build are stored. By default, it is located within
  the user's home directory <<<(~/.m2/repository)>>> but the location can be configured in
  <<<~/.m2/settings.xml>>> using the <<<\<localRepository\>>>> element.

* Goals Overview

  The Install Plugin has 3 goals:

  * {{{./install-mojo.html}install:install}} installs the
    project's main artifact (the JAR, WAR or EAR), its POM, and any attached artifacts
    (sources, javadoc, etc) produced by a particular project into the local repository.

  * {{{./install-file-mojo.html}install:install-file}} is mostly used to install an externally
    created artifact into the local repository, along with its POM. In that case
    the project information can be taken from an optionally specified pomFile, but can
    also be given using command line parameters.

  * {{{./help-mojo.html}install:help}} displays help information on maven-install-plugin.

  []

* Important Note for Version 3.0.0+

  The {{{./install-mojo.html}install:install}} goal no longer supports creating checksums
  via <<<-DcreateChecksum=true>>> because cause the checksums are only needed as a preparation
  for the transfer to a remote repository but not for an installation into a local repository.
  
* Usage

  General instructions can be found on the {{{./usage.html}usage page}}. Some more
  specific use cases are described in the examples below.

  In case you still have questions regarding the plugin's usage, please have a look at the {{{./faq.html}FAQ}} and feel
  free to contact the {{{./mailing-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 {{{./mailing-lists.html}mail archive}}.

  If you feel the plugin is missing a feature or has a defect, you can fill a feature request or bug report in our
  {{{./issue-management.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, POMs 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
  {{{./scm.html}source repository}} and will find supplementary information in the
  {{{http://maven.apache.org/guides/development/guide-helping.html}guide to helping with Maven}}.

* Examples

  To provide you with better understanding on some usages of the Maven Install Plugin,
  you can take a look into the following examples:

  * {{{./examples/custom-pom-installation.html}Installing a Custom POM}}

  * {{{./examples/generic-pom-generation.html}Generating a Generic POM}}

  * {{{./examples/update-release-info.html}Updating Release Info}}

  * {{{./examples/specific-local-repo.html}Installing an Artifact to a Specific Local Repository Path}}

  * {{{./examples/installing-secondary-artifacts.html}Installing Secondary Artifacts}}

  []
