 -----
 Maven Skins Parent POM
 -----
 Hervé Boutemy
 -----
 2012-01-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:
~~ https://maven.apache.org/doxia/references/apt-format.html

Maven Skins Parent POM

    This POM is the common parent of all of the {{{/skins/}Maven Skins}}
    in the Apache Maven project.

History

#if( $project.version.endsWith( "SNAPSHOT" ) )
#**##set( $prev = 33 )
  master: {{{https://github.com/apache/maven-parent/tree/master/maven-skins/pom.xml}$project.version}}
  ({{{https://gitbox.apache.org/repos/asf?p=maven-parent.git;a=blobdiff;f=maven-skins/pom.xml;hb=master;hpb=maven-parent-$prev}diff}})
#end
#macro ( display $version $date )
#**##set( $prev = $version - 1 )
|  {{{https://github.com/apache/maven-parent/tree/maven-parent-$version/maven-skins/pom.xml}$version}}
| ({{{https://gitbox.apache.org/repos/asf?p=maven-parent.git;a=blobdiff;f=maven-skins/pom.xml;hb=maven-parent-$version;hpb=maven-parent-$prev}diff}}) | $date |
#end

*--------------+------------+
|| <<Version>> || <<Release Date>> ||
*--------------+------------+
#display( 33, '2018-09-11' )
*--------------+------------+
#display( 32, '2018-07-18' )
*--------------+------------+
#display( 31, '2018-02-05' )
*--------------+------------+
| {{{https://svn.apache.org/viewvc/maven/pom/tags/maven-parent-30/maven-skins/pom.xml?view=markup}30}} ({{{https://svn.apache.org/viewvc/maven/pom/tags/maven-parent-30/maven-skins/pom.xml?r1=HEAD&r2=1632941&diff_format=h}diff}}) | 2016-05-26  |
*--------------+------------+
| {{{https://svn.apache.org/viewvc/maven/skins/tags/maven-skins-10/pom.xml?view=markup}10}} ({{{https://svn.apache.org/viewvc/maven/skins/tags/maven-skins-10/pom.xml?r1=HEAD&r2=1582517&diff_format=h}diff}}) | 2014-10-22 |
*--------------+------------+
| {{{https://svn.apache.org/viewvc/maven/skins/tags/maven-skins-9/pom.xml?view=markup}9}} ({{{https://svn.apache.org/viewvc/maven/skins/tags/maven-skins-9/pom.xml?r1=HEAD&r2=1549585&diff_format=h}diff}}) | 2014-03-27 |
*--------------+------------+
| {{{https://svn.apache.org/viewvc/maven/skins/tags/maven-skins-8/pom.xml?view=markup}8}} ({{{https://svn.apache.org/viewvc/maven/skins/tags/maven-skins-8/pom.xml?r1=HEAD&r2=1377628&diff_format=h}diff}}) | 2013-12-09 |
*--------------+------------+
| {{{https://svn.apache.org/viewvc/maven/skins/tags/maven-skins-7/pom.xml?view=markup}7}} ({{{https://svn.apache.org/viewvc/maven/skins/tags/maven-skins-7/pom.xml?r1=HEAD&r2=1233017&diff_format=h}diff}}) | 2012-01-18 |
*--------------+------------+
| {{{https://svn.apache.org/viewvc/maven/skins/tags/maven-skins-6/pom.xml?view=markup}6}} ({{{https://svn.apache.org/viewvc/maven/skins/tags/maven-skins-6/pom.xml?r1=HEAD&r2=922895&diff_format=h}diff}}) | 2011-01-22 |
*--------------+------------+
| {{{https://svn.apache.org/viewvc/maven/skins/tags/maven-skins-5/pom.xml?view=markup}5}} ({{{https://svn.apache.org/viewvc/maven/skins/tags/maven-skins-5/pom.xml?r1=HEAD&r2=730790&diff_format=h}diff}}) | 2010-03-14 |
*--------------+------------+
| {{{https://svn.apache.org/viewvc/maven/skins/tags/maven-skins-4/pom.xml?view=markup}4}} ({{{https://svn.apache.org/viewvc/maven/skins/tags/maven-skins-4/pom.xml?r1=HEAD&r2=526733&diff_format=h}diff}}) | 2009-01-02 |
*--------------+------------+
