 -----
 Apache Software Foundation Parent POM
 -----
 Benson Margulies
 Hervé Boutemy
 -----
 2013-09-29
 -----

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

Apache Software Foundation Parent POM

    This project consists of a POM that contains settings that are
    likely to be useful to any Apache project that is building and
    releasing code with Maven 2/3. By using this project as a parent,
    a project gets these settings.

    Most project will want to override some of these settings.

    The following is a list of the items configured in this POM:

 * Top-level project properties:
    
  ** <<license>>: The Apache Software License, version 2.0.
    
  ** <<organization>>: The Apache Software Foundation
    
  ** <<url>>: <<<http://www.apache.org/>>>. You should override this.
    
  ** <<repositories>>: The pom adds the Apache snapshot
     repository (<<<http://repository.apache.org/snapshots>>>)
    
  ** <<distributionManagement>>: The POM sets up for releases to the Apache Nexus
     instance at
     <<<https://repository.apache.org/service/local/staging/deploy/maven2>>>
     and snapshots to
     <<<https://repository.apache.org/content/repositories/snapshots>>>. Note
     that there are POM parameters (<<<distMgmtSnapshotsName>>> and <<<distMgmtSnapshotsUrl>>>)
     that you can override to change the snapshot location. 
    
  ** <<mailingLists>>: The POM sets up generic Apache announcement
     lists. You should override this.
    
 * <<pluginManagement>>: The plugin management section specifies versions
    of a list of plugins. See the {{{./plugin-management.html}Plugin Management report}} for
    the complete list with versions. 
    
  ** The compiler plugin is set to default to Java 1.4 and UTF-8 source.
    
  ** the jar plugin is set to add default specification and implementation entries.
    
  ** the resources plugin is set for UTF-8.
    
  ** the release plugin: the release plugin is set, via the
    \<arguments\> configuration element, to enable the
    <<apache-release>> profile for <<all>> executions and to disable
    \<useReleaseProfiles\>.  You can remove this with an empty
    \<arguments/\> element in the configuration of the release plugin.

 * <<plugins>>: The plugins section configures one execution:
    
  ** maven-remote-resources-plugin for
    org.apache:apache-jar-resource-bundle:1.4.

The <<<apache-release>>> Profile

   As noted above, this pom configures the release plugin to enable
    the <<<apache-release>>> profile for all executions of the release
    plugin. The profile includes the following plugins:

 * maven-assembly-plugin:
    org.apache.apache.resources:apache-source-release-assembly-descriptor:1.0.3
    is in the dependencies, and an execution is configured.The plugin
    is configured to take a descriptorRef name from the
    <<sourceReleaseAssemblyDescriptor>> property, which by default is
    set to 'source-release'.

 * maven-deploy-plugin

 * maven-source-plugin: configured to build and attach a source jar.

 * maven-javadoc-plugin: configured to build and attach a javadoc jar.

 * maven-gpg-plugin: configured to sign everything. It expects to find
    a passphrase in $\{gpg.passphrase\}, presumably in your <<<settings.xml>>>.
    
Settings Configuration
  
  You can have a look at the page in Apache website
  {{{http://www.apache.org/dev/publishing-maven-artifacts.html}Publishing Maven Artifacts}}.
  
  You can test your environment setup using <<<-Papache-release>>> with the command line.

History

~~ {{{http://svn.apache.org/viewvc/maven/pom/trunk/asf/pom.xml?view=markup}14-SNAPSHOT}} ({{{http://svn.apache.org/viewvc/maven/pom/trunk/asf/pom.xml?r1=HEAD&r2=1434717&diff_format=h}diff}})

*--------------+------------+
|| <<Version>> || <<Release Date>> ||
*--------------+------------+
| {{{http://svn.apache.org/viewvc/maven/pom/tags/apache-14/pom.xml?view=markup}14}} ({{{http://svn.apache.org/viewvc/maven/pom/tags/apache-14/pom.xml?r1=HEAD&r2=1434717&diff_format=h}diff}}) | 2014-03-06 |
*--------------+------------+
| {{{http://svn.apache.org/viewvc/maven/pom/tags/apache-13/pom.xml?view=markup}13}} ({{{http://svn.apache.org/viewvc/maven/pom/tags/apache-13/pom.xml?r1=HEAD&r2=1404788&diff_format=h}diff}}) | 2013-01-20 |
*--------------+------------+
| {{{http://svn.apache.org/viewvc/maven/pom/tags/apache-12/pom.xml?view=markup}12}} ({{{http://svn.apache.org/viewvc/maven/pom/tags/apache-12/pom.xml?r1=HEAD&r2=1369674&diff_format=h}diff}}) | 2012-11-01 |
*--------------+------------+
| {{{http://svn.apache.org/viewvc/maven/pom/tags/apache-11/pom.xml?view=markup}11}} ({{{http://svn.apache.org/viewvc/maven/pom/tags/apache-11/pom.xml?r1=HEAD&r2=1154610&diff_format=h}diff}}) | 2012-08-08 |
*--------------+------------+
| {{{http://svn.apache.org/viewvc/maven/pom/tags/apache-10/pom.xml?view=markup}10}} ({{{http://svn.apache.org/viewvc/maven/pom/tags/apache-10/pom.xml?r1=HEAD&r2=1069621&diff_format=h}diff}}) | 2011-08-09 |
*--------------+------------+
| {{{http://svn.apache.org/viewvc/maven/pom/tags/apache-9/pom.xml?view=markup}9}} ({{{http://svn.apache.org/viewvc/maven/pom/tags/apache-9/pom.xml?r1=HEAD&r2=1038252&diff_format=h}diff}}) | 2011-02-15 |
*--------------+------------+
| {{{http://svn.apache.org/viewvc/maven/pom/tags/apache-8/pom.xml?view=markup}8}} ({{{http://svn.apache.org/viewvc/maven/pom/tags/apache-8/pom.xml?r1=HEAD&r2=893967&diff_format=h}diff}}) | 2010-11-26 |
*--------------+------------+
| {{{http://svn.apache.org/viewvc/maven/pom/tags/apache-7/pom.xml?view=markup}7}} ({{{http://svn.apache.org/viewvc/maven/pom/tags/apache-7/pom.xml?r1=HEAD&r2=766952&diff_format=h}diff}}) | 2009-12-29 |
*--------------+------------+
| {{{http://svn.apache.org/viewvc/maven/pom/tags/apache-6/pom.xml?view=markup}6}} ({{{http://svn.apache.org/viewvc/maven/pom/tags/apache-6/pom.xml?r1=HEAD&r2=766946&diff_format=h}diff}}) | 2009-04-24 |
*--------------+------------+
  
