 ------
Release Notes - Previous versions
 ------
Brian Fox
 ------
8 April 2008
 ------

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

* 2.0.3 Release Notes

** Bug

    * <<MNG-1317>> - m2.bat doesn't work on Windows 2000

    * <<MNG-1318>> - mvn.bat sets incorrect value to M2_HOME [Windows 2000]

    * <<MNG-1337>> - Interpolation of POM values needs to be improved

    * <<MNG-1415>> - quoted arguments are not being protected

    * <<MNG-1509>> - Profile activation by os doesn't work

    * <<MNG-1703>> - <pluginManagement><dependencies> is not propagated to child POMs

    * <<MNG-1837>> - deploy-file succeeds even when local file not found

    * <<MNG-1856>> - legacy layout tag in a profile does not show up in child pom.

    * <<MNG-1882>> - activeByDefault is ignored in pom.xml

    * <<MNG-1895>> - Dependencies in two paths are not added to resolution when scope needs to be updated in the nearest  due to any of nearest parents

    * <<MNG-1898>> - Plugin classpath broken from 2.0 to 2.0.1

    * <<MNG-1980>> - "Duplicate project ID found" message with maven-artifact-ant-2.0.2

    * <<MNG-1999>> - Reporting inheritance does not work properly

    * <<MNG-2002>> - The mvn.bat Script does not return the error-code of Maven

    * <<MNG-2006>> - Module SCM URL is resolved as [...]/parent/module regardless of relativePath

    * <<MNG-2037>> - Strange NPE with profile and injectPlugins

    * <<MNG-2052>> - Transitive system deps are not interpolated correctly thus rendering them invalid

    * <<MNG-2068>> - Multiple inheritance fails to find "grand" parent in ../../pom.xml when the groupIds differ (Test Case Attached)

    * <<MNG-2078>> - Fixup super pom to activate the profile only when -DperformRelease=true.

    * <<MNG-2083>> - Path to missing dependency is not shown nor url to download

    * <<MNG-2087>> - NPE in PluginXdocGenerator

    * <<MNG-2124>> - Incorrect resolution of parent POM properties

    * <<MNG-2130>> - Parent POM not created by reactor if not found in repository

    * <<MNG-2136>> - Active profile in profiles.xml prevents active profile in pom.xml to be triggered automatically

    []

** Improvement

    * <<MNG-1644>> - parent pom = child pom results in stack overflow error

    * <<MNG-2030>> - Make -X show maven version as first thing

    * <<MNG-2096>> - allow <configuration> with <execution> in a lifecycle overlay, like a plugin allows

    []

** Task

    * <<MNG-2003>> - release and update to wagon-file 1.0-alpha-7

    * <<MNG-2095>> - Add "plugin-metadata-1.0.0.xsd" to http://maven.apache.org/xsd

    []

** Wish

    * <<MNG-547>> - being able to set the <head> of a page to wathever we want

    []


* Release notes for older versions

    * See {{{../../release-notes-older.html}here}}

