 ------
 Introduction
 ------
 John Casey
 Jesse McConnell
 ------
 22 June 2007
 ------

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

  The Patch Plugin is used to apply patches to source files.

* Goals Overview

  The Patch Plugin has a single goal that can apply either a single declared patch or a directory of patches.
  Application of an entire patch directory can be configured with various patch-inclusion, -exclusion, and -ordering
  options:

  * {{{apply-mojo.html}patch:apply}} Applies one or more patches to project sources.

* Usage

  Instructions on the basic usage of the Patch Plugin can be found on the
  {{{usage.html}usage page}}.

* Examples

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

  * {{{examples/single.html}How to patch from a single file.}}

  * {{{examples/multiple.html}How to patch from a directory of patches.}}

  []
