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

  General instructions on how to use the Patch Plugin can be found on the {{{usage.html}usage page}}. Some more
  specific use cases are described in the examples given 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 {{{mail-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 mail archive.

  If you feel like the plugin is missing a feature or has a defect, you can fill a feature request or bug report in our
  {{{issue-tracking.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
  {{{source-repository.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 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.}}

  []
