src/main/java/org/apache/maven/plugin/patch/ApplyMojo.java - maven-patch-plugin - Git at Google

 package org.apache.maven.plugin.patch;

 /*
  * 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.
  */

 import org.apache.maven.plugin.AbstractMojo;
 import org.apache.maven.plugin.MojoExecutionException;
 import org.apache.maven.plugin.MojoFailureException;
 import org.apache.maven.plugins.annotations.LifecyclePhase;
 import org.apache.maven.plugins.annotations.Mojo;
 import org.apache.maven.plugins.annotations.Parameter;
 import org.codehaus.plexus.util.FileUtils;
 import org.codehaus.plexus.util.IOUtil;
 import org.codehaus.plexus.util.cli.CommandLineException;
 import org.codehaus.plexus.util.cli.CommandLineUtils;
 import org.codehaus.plexus.util.cli.Commandline;
 import org.codehaus.plexus.util.cli.StreamConsumer;

 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.StringWriter;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Iterator;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;

 /**
  * Apply one or more patches to project sources.
  */
 @Mojo( name = "apply", defaultPhase = LifecyclePhase.PROCESS_SOURCES )
 public class ApplyMojo
     extends AbstractMojo
 {

     public static final List PATCH_FAILURE_WATCH_PHRASES;

     public static final List DEFAULT_IGNORED_PATCHES;

     public static final List DEFAULT_IGNORED_PATCH_PATTERNS;

     static
     {
         List watches = new ArrayList();

         watches.add( "fail" );
         watches.add( "skip" );
         watches.add( "reject" );

         PATCH_FAILURE_WATCH_PHRASES = watches;

         List ignored = new ArrayList();

         ignored.add( ".svn" );
         ignored.add( "CVS" );

         DEFAULT_IGNORED_PATCHES = ignored;

         List ignoredPatterns = new ArrayList();

         ignoredPatterns.add( ".svn/**" );
         ignoredPatterns.add( "CVS/**" );

         DEFAULT_IGNORED_PATCH_PATTERNS = ignoredPatterns;
     }

     /**
      * Whether to exclude default ignored patch items, such as <code>.svn</code> or <code>CVS</code> directories.
      */
     @Parameter( defaultValue = "true" )
     private boolean useDefaultIgnores;

     /**
      * The list of patch file names, supplying the order in which patches should be applied. The path names in this list
      * must be relative to the base directory specified by the parameter <code>patchDirectory</code>. This parameter
      * is mutually exclusive with the <code>patchfile</code> parameter.
      */
     @Parameter
     protected List patches;

     /**
      * Whether to skip this goal's execution.
      */
     @Parameter( alias = "patch.apply.skip", defaultValue = "false" )
     private boolean skipApplication;

     /**
      * Flag to enable/disable optimization file from being written. This file tracks the patches that were applied the
      * last time this goal actually executed. It is required for cases where project-sources optimizations are enabled,
      * since project-sources will not be re-unpacked if they are at least as fresh as the source archive. If we avoid
      * re-unpacking project sources, we need to make sure we don't reapply patches.<br/> <strong>Note:</strong> If the
      * list of patches changes and this flag is enabled, a "<code>mvn clean</code>" must be executed before the next
      * build, to remove the tracking file.
      */
     @Parameter( defaultValue = "true" )
     private boolean optimizations;

     /**
      * This is the tracking file used to maintain a list of the patches applied to the unpacked project sources which
      * are currently in the target directory. If this file is present, and project-source unpacking is optimized
      * (meaning it won't re-unpack unless the project-sources archive is newer), this goal will not execute and no
      * patches will be applied in the current build.
      */
     @Parameter( defaultValue = "${project.build.directory}/optimization-files/patches-applied.txt" )
     private File patchTrackingFile;

     /**
      * The target directory for applying patches. Files in this directory will be modified.
      */
     @Parameter( alias = "patchTargetDir", defaultValue = "${project.build.sourceDirectory}" )
     private File targetDirectory;

     /**
      * Flag being <code>true</code> if the desired behavior is to fail the build on the first failed patch detected.
      */
     @Parameter( defaultValue = "true" )
     private boolean failFast;

     /**
      * Setting natural order processing to <code>true</code> will cause all patches in a directory to be processed in
      * a natural order alleviating the need to declare patches directly in the project file.
      */
     @Parameter( defaultValue = "false" )
     private boolean naturalOrderProcessing;

     /**
      * When the <code>strictPatching</code> flag is set, this parameter is useful to mark certain contents of the
      * patch-source directory that should be ignored without causing the build to fail.
      */
     @Parameter
     private List ignoredPatches;

     /**
      * Flag that, when set to <code>true</code>, will make sure that all patches included in the <code>patches</code>
      * list must be present and describe the full contents of the patch directory. If <code>strictPatching</code> is
      * set to <code>true</code>, and the <code>patches</code> list has a value that does not correspond to a file
      * in the patch directory, the build will fail. If <code>strictPatching</code> is set to <code>true</code>, and
      * the patch directory contains files not listed in the <code>patches</code> parameter, the build will fail. If
      * set to <code>false</code>, only the patches listed in the <code>patches</code> parameter that have
      * corresponding files will be applied; the rest will be ignored.
      */
     @Parameter( defaultValue = "false" )
     private boolean strictPatching;

     /**
      * The number of directories to be stripped from patch file paths, before applying, starting from the leftmost, or
      * root-est.
      */
     @Parameter( defaultValue = "0" )
     private int strip;

     /**
      * Whether to ignore whitespaces when applying the patches.
      */
     @Parameter( defaultValue = "true" )
     private boolean ignoreWhitespace;

     /**
      * Whether to treat these patches as having reversed source and dest in the patch syntax.
      */
     @Parameter( defaultValue = "false" )
     private boolean reverse;

     /**
      * Whether to make backups of the original files before modding them.
      */
     @Parameter( defaultValue = "false" )
     private boolean backups;

     /**
      * List of phrases to watch for in the command output from the patch tool. If one is found, it will cause the build
      * to fail. All phrases should be lower-case <em>only</em>. By default, the phrases <code>fail</code>,
      * <code>skip</code> and <code>reject</code> are used.
      */
     @Parameter
     private List failurePhrases = PATCH_FAILURE_WATCH_PHRASES;

     /**
      * The original file which will be modified by the patch. By default, the patch tool will automatically derive the
      * original file from the header of the patch file.
      */
     @Parameter
     private File originalFile;

     /**
      * The output file which is the original file, plus modifications from the patch. By default, the file(s) will be
      * patched inplace.
      */
     @Parameter
     private File destFile;

     /**
      * The single patch file to apply. This parameter is mutually exclusive with the <code>patches</code> parameter.
      */
     @Parameter
     private File patchFile;

     /**
      * The base directory for the file names specified by the parameter <code>patches</code>.
      */
     @Parameter( defaultValue = "src/main/patches" )
     private File patchDirectory;

     /**
      * When set to <code>true</code>, the empty files resulting from the patching process are removed. Empty ancestor
      * directories are removed as well.
      *
      * @since 1.1
      */
     @Parameter( defaultValue = "false" )
     private boolean removeEmptyFiles;

     /**
      * apply --binary option to patch command line
      * @since 1.2
      */
     @Parameter( defaultValue = "false" )
     private boolean binary;

     /**
      * Apply the patches. Give preference to patchFile over patchSourceDir/patches, and preference to originalFile over
      * workDir.
      */
     public void execute()
         throws MojoExecutionException, MojoFailureException
     {
         boolean patchDirEnabled = ( ( patches != null ) && !patches.isEmpty() ) || naturalOrderProcessing;
         boolean patchFileEnabled = patchFile != null;

         // if patches is null or empty, and naturalOrderProcessing is not true then disable patching
         if ( !patchFileEnabled && !patchDirEnabled )
         {
             getLog().info( "Patching is disabled for this project." );
             return;
         }

         if ( skipApplication )
         {
             getLog().info( "Skipping patch file application (per configuration)." );
             return;
         }

         patchTrackingFile.getParentFile().mkdirs();

         Map patchesToApply;

         try
         {
             if ( patchFileEnabled )
             {
                 patchesToApply = Collections.singletonMap( patchFile.getName(), createPatchCommand( patchFile ) );
             }
             else
             {
                 if ( !patchDirectory.isDirectory() )
                 {
                     throw new FileNotFoundException( "The base directory for patch files does not exist: "
                         + patchDirectory );
                 }

                 List foundPatchFiles = FileUtils.getFileNames( patchDirectory, "*", null, false );

                 patchesToApply = findPatchesToApply( foundPatchFiles, patchDirectory );

                 checkStrictPatchCompliance( foundPatchFiles );
             }

             String output = applyPatches( patchesToApply );

             checkForWatchPhrases( output );

             writeTrackingFile( patchesToApply );
         }
         catch ( IOException ioe )
         {
             throw new MojoExecutionException( "Unable to obtain list of patch files", ioe );
         }
     }

     private Map findPatchesToApply( List foundPatchFiles, File patchSourceDir )
         throws MojoFailureException
     {
         Map patchesApplied = new LinkedHashMap();

         if ( naturalOrderProcessing )
         {
             patches = new ArrayList( foundPatchFiles );
             Collections.sort( patches );
         }

         String alreadyAppliedPatches = "";

         try
         {
             if ( optimizations && patchTrackingFile.exists() )
             {
                 alreadyAppliedPatches = FileUtils.fileRead( patchTrackingFile );
             }
         }
         catch ( IOException ioe )
         {
             throw new MojoFailureException( "unable to read patch tracking file: " + ioe.getMessage() );
         }

         for (Object patche : patches) {
             String patch = (String) patche;

             if (!alreadyAppliedPatches.contains(patch)) {
                 File patchFile = new File(patchSourceDir, patch);

                 getLog().debug("Looking for patch: " + patch + " in: " + patchFile);

                 if (!patchFile.exists()) {
                     if (strictPatching) {
                         throw new MojoFailureException(this, "Patch operation cannot proceed.",
                                 "Cannot find specified patch: \'" + patch
                                         + "\' in patch-source directory: \'" + patchSourceDir
                                         + "\'.\n\nEither fix this error, "
                                         + "or relax strictPatching.");
                     } else {
                         getLog().info(
                                 "Skipping patch: " + patch + " listed in the parameter \"patches\"; "
                                         + "it is missing.");
                     }
                 } else {
                     foundPatchFiles.remove(patch);

                     patchesApplied.put(patch, createPatchCommand(patchFile));
                 }
             }
         }

         return patchesApplied;
     }

     private void checkStrictPatchCompliance( List foundPatchFiles )
         throws MojoExecutionException
     {
         if ( strictPatching )
         {
             List ignored = new ArrayList();

             if ( ignoredPatches != null )
             {
                 ignored.addAll( ignoredPatches );
             }

             if ( useDefaultIgnores )
             {
                 ignored.addAll( DEFAULT_IGNORED_PATCHES );
             }

             List limbo = new ArrayList( foundPatchFiles );

             for (Object anIgnored : ignored) {
                 String ignoredFile = (String) anIgnored;

                 limbo.remove(ignoredFile);
             }

             if ( !limbo.isEmpty() )
             {
                 StringBuilder extraFileBuffer = new StringBuilder();

                 extraFileBuffer.append("Found ").append(limbo.size()).append(" unlisted patch files:");

                 for (Object foundPatchFile : foundPatchFiles) {
                     String patch = (String) foundPatchFile;

                     extraFileBuffer.append("\n  \'").append(patch).append('\'');
                 }

                 extraFileBuffer.append( "\n\nEither remove these files, "
                     + "add them to the patches configuration list, " + "or relax strictPatching." );

                 throw new MojoExecutionException( extraFileBuffer.toString() );
             }
         }
     }

     private String applyPatches( Map patchesApplied )
         throws MojoExecutionException
     {
         final StringWriter outputWriter = new StringWriter();

         StreamConsumer consumer = new StreamConsumer()
         {
             public void consumeLine( String line )
             {
                 if ( getLog().isDebugEnabled() )
                 {
                     getLog().debug( line );
                 }

                 outputWriter.write( line + "\n" );
             }
         };

         // used if failFast is false
         List failedPatches = new ArrayList();

         for (Object o : patchesApplied.entrySet()) {
             Entry entry = (Entry) o;
             String patchName = (String) entry.getKey();
             Commandline cli = (Commandline) entry.getValue();

             try {
                 getLog().info("Applying patch: " + patchName);

                 int result = executeCommandLine(cli, consumer, consumer);

                 if (result != 0) {
                     if (failFast) {
                         throw new MojoExecutionException("Patch command failed with exit code " + result + " for "
                                 + patchName + ". Please see console and debug output for more information.");
                     } else {
                         failedPatches.add(patchName);
                     }
                 }
             } catch (CommandLineException e) {
                 throw new MojoExecutionException("Failed to apply patch: " + patchName
                         + ". See debug output for more information.", e);
             }
         }

         if ( !failedPatches.isEmpty() )
         {
             getLog().error( "Failed applying one or more patches:" );
             for (Object failedPatche : failedPatches) {
                 getLog().error("* " + failedPatche);
             }
             throw new MojoExecutionException( "Patch command failed for one or more patches."
                 + " Please see console and debug output for more information." );
         }

         return outputWriter.toString();
     }

     private int executeCommandLine( Commandline cli, StreamConsumer out, StreamConsumer err )
         throws CommandLineException
     {
         if ( getLog().isDebugEnabled() )
         {
             getLog().debug( "Executing: " + cli );
         }

         int result = CommandLineUtils.executeCommandLine( cli, out, err );

         if ( getLog().isDebugEnabled() )
         {
             getLog().debug( "Exit code: " + result );
         }

         return result;
     }

     private void writeTrackingFile( Map patchesApplied )
         throws MojoExecutionException
     {
         FileWriter writer = null;
         try
         {
             boolean appending = patchTrackingFile.exists();

             writer = new FileWriter( patchTrackingFile, appending );

             for ( Iterator it = patchesApplied.keySet().iterator(); it.hasNext(); )
             {
                 if ( appending )
                 {
                     writer.write( System.getProperty( "line.separator" ) );
                 }

                 String patch = (String) it.next();
                 writer.write( patch );

                 if ( it.hasNext() )
                 {
                     writer.write( System.getProperty( "line.separator" ) );
                 }
             }

             writer.flush();
         }
         catch ( IOException e )
         {
             throw new MojoExecutionException( "Failed to write patch-tracking file: " + patchTrackingFile, e );
         }
         finally
         {
             IOUtil.close( writer );
         }
     }

     private void checkForWatchPhrases( String output )
         throws MojoExecutionException
     {
         for (Object failurePhrase : failurePhrases) {
             String phrase = (String) failurePhrase;

             if (output.contains(phrase)) {
                 throw new MojoExecutionException("Failed to apply patches (detected watch-phrase: \'" + phrase
                         + "\' in output). " + "If this is in error, configure the patchFailureWatchPhrases parameter.");
             }
         }
     }

     /**
      * Add a new Patch task to the Ant calling mechanism. Give preference to originalFile/destFile, then workDir, and
      * finally ${basedir}.
      */
     private Commandline createPatchCommand( File patchFile )
     {
         Commandline cli = new Commandline();

         cli.setExecutable( "patch" );

         cli.setWorkingDirectory( targetDirectory.getAbsolutePath() );

         cli.createArg().setValue( "-p" + strip );

         if ( binary )
         {
             cli.createArg().setValue( "--binary" );
         }

         if ( ignoreWhitespace )
         {
             cli.createArg().setValue( "-l" );
         }

         if ( reverse )
         {
             cli.createArg().setValue( "-R" );
         }

         if ( backups )
         {
             cli.createArg().setValue( "-b" );
         }

         if ( removeEmptyFiles )
         {
             cli.createArg().setValue( "-E" );
         }

         cli.createArg().setValue( "-i" );
         cli.createArg().setFile( patchFile );

         if ( destFile != null )
         {
             cli.createArg().setValue( "-o" );
             cli.createArg().setFile( destFile );
         }

         if ( originalFile != null )
         {
             cli.createArg().setFile( originalFile );
         }

         return cli;
     }

 }
	package org.apache.maven.plugin.patch;

	/*
	* 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.
	*/

	import org.apache.maven.plugin.AbstractMojo;
	import org.apache.maven.plugin.MojoExecutionException;
	import org.apache.maven.plugin.MojoFailureException;
	import org.apache.maven.plugins.annotations.LifecyclePhase;
	import org.apache.maven.plugins.annotations.Mojo;
	import org.apache.maven.plugins.annotations.Parameter;
	import org.codehaus.plexus.util.FileUtils;
	import org.codehaus.plexus.util.IOUtil;
	import org.codehaus.plexus.util.cli.CommandLineException;
	import org.codehaus.plexus.util.cli.CommandLineUtils;
	import org.codehaus.plexus.util.cli.Commandline;
	import org.codehaus.plexus.util.cli.StreamConsumer;

	import java.io.File;
	import java.io.FileNotFoundException;
	import java.io.FileWriter;
	import java.io.IOException;
	import java.io.StringWriter;
	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.Iterator;
	import java.util.LinkedHashMap;
	import java.util.List;
	import java.util.Map;
	import java.util.Map.Entry;

	/**
	* Apply one or more patches to project sources.
	*/
	@Mojo( name = "apply", defaultPhase = LifecyclePhase.PROCESS_SOURCES )
	public class ApplyMojo
	extends AbstractMojo
	{

	public static final List PATCH_FAILURE_WATCH_PHRASES;

	public static final List DEFAULT_IGNORED_PATCHES;

	public static final List DEFAULT_IGNORED_PATCH_PATTERNS;

	static
	{
	List watches = new ArrayList();

	watches.add( "fail" );
	watches.add( "skip" );
	watches.add( "reject" );

	PATCH_FAILURE_WATCH_PHRASES = watches;

	List ignored = new ArrayList();

	ignored.add( ".svn" );
	ignored.add( "CVS" );

	DEFAULT_IGNORED_PATCHES = ignored;

	List ignoredPatterns = new ArrayList();

	ignoredPatterns.add( ".svn/**" );
	ignoredPatterns.add( "CVS/**" );

	DEFAULT_IGNORED_PATCH_PATTERNS = ignoredPatterns;
	}

	/**
	* Whether to exclude default ignored patch items, such as <code>.svn</code> or <code>CVS</code> directories.
	*/
	@Parameter( defaultValue = "true" )
	private boolean useDefaultIgnores;

	/**
	* The list of patch file names, supplying the order in which patches should be applied. The path names in this list
	* must be relative to the base directory specified by the parameter <code>patchDirectory</code>. This parameter
	* is mutually exclusive with the <code>patchfile</code> parameter.
	*/
	@Parameter
	protected List patches;

	/**
	* Whether to skip this goal's execution.
	*/
	@Parameter( alias = "patch.apply.skip", defaultValue = "false" )
	private boolean skipApplication;

	/**
	* Flag to enable/disable optimization file from being written. This file tracks the patches that were applied the
	* last time this goal actually executed. It is required for cases where project-sources optimizations are enabled,
	* since project-sources will not be re-unpacked if they are at least as fresh as the source archive. If we avoid
	* re-unpacking project sources, we need to make sure we don't reapply patches.<br/> <strong>Note:</strong> If the
	* list of patches changes and this flag is enabled, a "<code>mvn clean</code>" must be executed before the next
	* build, to remove the tracking file.
	*/
	@Parameter( defaultValue = "true" )
	private boolean optimizations;

	/**
	* This is the tracking file used to maintain a list of the patches applied to the unpacked project sources which
	* are currently in the target directory. If this file is present, and project-source unpacking is optimized
	* (meaning it won't re-unpack unless the project-sources archive is newer), this goal will not execute and no
	* patches will be applied in the current build.
	*/
	@Parameter( defaultValue = "${project.build.directory}/optimization-files/patches-applied.txt" )
	private File patchTrackingFile;

	/**
	* The target directory for applying patches. Files in this directory will be modified.
	*/
	@Parameter( alias = "patchTargetDir", defaultValue = "${project.build.sourceDirectory}" )
	private File targetDirectory;

	/**
	* Flag being <code>true</code> if the desired behavior is to fail the build on the first failed patch detected.
	*/
	@Parameter( defaultValue = "true" )
	private boolean failFast;

	/**
	* Setting natural order processing to <code>true</code> will cause all patches in a directory to be processed in
	* a natural order alleviating the need to declare patches directly in the project file.
	*/
	@Parameter( defaultValue = "false" )
	private boolean naturalOrderProcessing;

	/**
	* When the <code>strictPatching</code> flag is set, this parameter is useful to mark certain contents of the
	* patch-source directory that should be ignored without causing the build to fail.
	*/
	@Parameter
	private List ignoredPatches;

	/**
	* Flag that, when set to <code>true</code>, will make sure that all patches included in the <code>patches</code>
	* list must be present and describe the full contents of the patch directory. If <code>strictPatching</code> is
	* set to <code>true</code>, and the <code>patches</code> list has a value that does not correspond to a file
	* in the patch directory, the build will fail. If <code>strictPatching</code> is set to <code>true</code>, and
	* the patch directory contains files not listed in the <code>patches</code> parameter, the build will fail. If
	* set to <code>false</code>, only the patches listed in the <code>patches</code> parameter that have
	* corresponding files will be applied; the rest will be ignored.
	*/
	@Parameter( defaultValue = "false" )
	private boolean strictPatching;

	/**
	* The number of directories to be stripped from patch file paths, before applying, starting from the leftmost, or
	* root-est.
	*/
	@Parameter( defaultValue = "0" )
	private int strip;

	/**
	* Whether to ignore whitespaces when applying the patches.
	*/
	@Parameter( defaultValue = "true" )
	private boolean ignoreWhitespace;

	/**
	* Whether to treat these patches as having reversed source and dest in the patch syntax.
	*/
	@Parameter( defaultValue = "false" )
	private boolean reverse;

	/**
	* Whether to make backups of the original files before modding them.
	*/
	@Parameter( defaultValue = "false" )
	private boolean backups;

	/**
	* List of phrases to watch for in the command output from the patch tool. If one is found, it will cause the build
	* to fail. All phrases should be lower-case <em>only</em>. By default, the phrases <code>fail</code>,
	* <code>skip</code> and <code>reject</code> are used.
	*/
	@Parameter
	private List failurePhrases = PATCH_FAILURE_WATCH_PHRASES;

	/**
	* The original file which will be modified by the patch. By default, the patch tool will automatically derive the
	* original file from the header of the patch file.
	*/
	@Parameter
	private File originalFile;

	/**
	* The output file which is the original file, plus modifications from the patch. By default, the file(s) will be
	* patched inplace.
	*/
	@Parameter
	private File destFile;

	/**
	* The single patch file to apply. This parameter is mutually exclusive with the <code>patches</code> parameter.
	*/
	@Parameter
	private File patchFile;

	/**
	* The base directory for the file names specified by the parameter <code>patches</code>.
	*/
	@Parameter( defaultValue = "src/main/patches" )
	private File patchDirectory;

	/**
	* When set to <code>true</code>, the empty files resulting from the patching process are removed. Empty ancestor
	* directories are removed as well.
	*
	* @since 1.1
	*/
	@Parameter( defaultValue = "false" )
	private boolean removeEmptyFiles;

	/**
	* apply --binary option to patch command line
	* @since 1.2
	*/
	@Parameter( defaultValue = "false" )
	private boolean binary;

	/**
	* Apply the patches. Give preference to patchFile over patchSourceDir/patches, and preference to originalFile over
	* workDir.
	*/
	public void execute()
	throws MojoExecutionException, MojoFailureException
	{
	boolean patchDirEnabled = ( ( patches != null ) && !patches.isEmpty() ) \|\| naturalOrderProcessing;
	boolean patchFileEnabled = patchFile != null;

	// if patches is null or empty, and naturalOrderProcessing is not true then disable patching
	if ( !patchFileEnabled && !patchDirEnabled )
	{
	getLog().info( "Patching is disabled for this project." );
	return;
	}

	if ( skipApplication )
	{
	getLog().info( "Skipping patch file application (per configuration)." );
	return;
	}

	patchTrackingFile.getParentFile().mkdirs();

	Map patchesToApply;

	try
	{
	if ( patchFileEnabled )
	{
	patchesToApply = Collections.singletonMap( patchFile.getName(), createPatchCommand( patchFile ) );
	}
	else
	{
	if ( !patchDirectory.isDirectory() )
	{
	throw new FileNotFoundException( "The base directory for patch files does not exist: "
	+ patchDirectory );
	}

	List foundPatchFiles = FileUtils.getFileNames( patchDirectory, "*", null, false );

	patchesToApply = findPatchesToApply( foundPatchFiles, patchDirectory );

	checkStrictPatchCompliance( foundPatchFiles );
	}

	String output = applyPatches( patchesToApply );

	checkForWatchPhrases( output );

	writeTrackingFile( patchesToApply );
	}
	catch ( IOException ioe )
	{
	throw new MojoExecutionException( "Unable to obtain list of patch files", ioe );
	}
	}

	private Map findPatchesToApply( List foundPatchFiles, File patchSourceDir )
	throws MojoFailureException
	{
	Map patchesApplied = new LinkedHashMap();

	if ( naturalOrderProcessing )
	{
	patches = new ArrayList( foundPatchFiles );
	Collections.sort( patches );
	}

	String alreadyAppliedPatches = "";

	try
	{
	if ( optimizations && patchTrackingFile.exists() )
	{
	alreadyAppliedPatches = FileUtils.fileRead( patchTrackingFile );
	}
	}
	catch ( IOException ioe )
	{
	throw new MojoFailureException( "unable to read patch tracking file: " + ioe.getMessage() );
	}

	for (Object patche : patches) {
	String patch = (String) patche;

	if (!alreadyAppliedPatches.contains(patch)) {
	File patchFile = new File(patchSourceDir, patch);

	getLog().debug("Looking for patch: " + patch + " in: " + patchFile);

	if (!patchFile.exists()) {
	if (strictPatching) {
	throw new MojoFailureException(this, "Patch operation cannot proceed.",
	"Cannot find specified patch: \'" + patch
	+ "\' in patch-source directory: \'" + patchSourceDir
	+ "\'.\n\nEither fix this error, "
	+ "or relax strictPatching.");
	} else {
	getLog().info(
	"Skipping patch: " + patch + " listed in the parameter \"patches\"; "
	+ "it is missing.");
	}
	} else {
	foundPatchFiles.remove(patch);

	patchesApplied.put(patch, createPatchCommand(patchFile));
	}
	}
	}

	return patchesApplied;
	}

	private void checkStrictPatchCompliance( List foundPatchFiles )
	throws MojoExecutionException
	{
	if ( strictPatching )
	{
	List ignored = new ArrayList();

	if ( ignoredPatches != null )
	{
	ignored.addAll( ignoredPatches );
	}

	if ( useDefaultIgnores )
	{
	ignored.addAll( DEFAULT_IGNORED_PATCHES );
	}

	List limbo = new ArrayList( foundPatchFiles );

	for (Object anIgnored : ignored) {
	String ignoredFile = (String) anIgnored;

	limbo.remove(ignoredFile);
	}

	if ( !limbo.isEmpty() )
	{
	StringBuilder extraFileBuffer = new StringBuilder();

	extraFileBuffer.append("Found ").append(limbo.size()).append(" unlisted patch files:");

	for (Object foundPatchFile : foundPatchFiles) {
	String patch = (String) foundPatchFile;

	extraFileBuffer.append("\n \'").append(patch).append('\'');
	}

	extraFileBuffer.append( "\n\nEither remove these files, "
	+ "add them to the patches configuration list, " + "or relax strictPatching." );

	throw new MojoExecutionException( extraFileBuffer.toString() );
	}
	}
	}

	private String applyPatches( Map patchesApplied )
	throws MojoExecutionException
	{
	final StringWriter outputWriter = new StringWriter();

	StreamConsumer consumer = new StreamConsumer()
	{
	public void consumeLine( String line )
	{
	if ( getLog().isDebugEnabled() )
	{
	getLog().debug( line );
	}

	outputWriter.write( line + "\n" );
	}
	};

	// used if failFast is false
	List failedPatches = new ArrayList();

	for (Object o : patchesApplied.entrySet()) {
	Entry entry = (Entry) o;
	String patchName = (String) entry.getKey();
	Commandline cli = (Commandline) entry.getValue();

	try {
	getLog().info("Applying patch: " + patchName);

	int result = executeCommandLine(cli, consumer, consumer);

	if (result != 0) {
	if (failFast) {
	throw new MojoExecutionException("Patch command failed with exit code " + result + " for "
	+ patchName + ". Please see console and debug output for more information.");
	} else {
	failedPatches.add(patchName);
	}
	}
	} catch (CommandLineException e) {
	throw new MojoExecutionException("Failed to apply patch: " + patchName
	+ ". See debug output for more information.", e);
	}
	}

	if ( !failedPatches.isEmpty() )
	{
	getLog().error( "Failed applying one or more patches:" );
	for (Object failedPatche : failedPatches) {
	getLog().error("* " + failedPatche);
	}
	throw new MojoExecutionException( "Patch command failed for one or more patches."
	+ " Please see console and debug output for more information." );
	}

	return outputWriter.toString();
	}

	private int executeCommandLine( Commandline cli, StreamConsumer out, StreamConsumer err )
	throws CommandLineException
	{
	if ( getLog().isDebugEnabled() )
	{
	getLog().debug( "Executing: " + cli );
	}

	int result = CommandLineUtils.executeCommandLine( cli, out, err );

	if ( getLog().isDebugEnabled() )
	{
	getLog().debug( "Exit code: " + result );
	}

	return result;
	}

	private void writeTrackingFile( Map patchesApplied )
	throws MojoExecutionException
	{
	FileWriter writer = null;
	try
	{
	boolean appending = patchTrackingFile.exists();

	writer = new FileWriter( patchTrackingFile, appending );

	for ( Iterator it = patchesApplied.keySet().iterator(); it.hasNext(); )
	{
	if ( appending )
	{
	writer.write( System.getProperty( "line.separator" ) );
	}

	String patch = (String) it.next();
	writer.write( patch );

	if ( it.hasNext() )
	{
	writer.write( System.getProperty( "line.separator" ) );
	}
	}

	writer.flush();
	}
	catch ( IOException e )
	{
	throw new MojoExecutionException( "Failed to write patch-tracking file: " + patchTrackingFile, e );
	}
	finally
	{
	IOUtil.close( writer );
	}
	}

	private void checkForWatchPhrases( String output )
	throws MojoExecutionException
	{
	for (Object failurePhrase : failurePhrases) {
	String phrase = (String) failurePhrase;

	if (output.contains(phrase)) {
	throw new MojoExecutionException("Failed to apply patches (detected watch-phrase: \'" + phrase
	+ "\' in output). " + "If this is in error, configure the patchFailureWatchPhrases parameter.");
	}
	}
	}

	/**
	* Add a new Patch task to the Ant calling mechanism. Give preference to originalFile/destFile, then workDir, and
	* finally ${basedir}.
	*/
	private Commandline createPatchCommand( File patchFile )
	{
	Commandline cli = new Commandline();

	cli.setExecutable( "patch" );

	cli.setWorkingDirectory( targetDirectory.getAbsolutePath() );

	cli.createArg().setValue( "-p" + strip );

	if ( binary )
	{
	cli.createArg().setValue( "--binary" );
	}

	if ( ignoreWhitespace )
	{
	cli.createArg().setValue( "-l" );
	}

	if ( reverse )
	{
	cli.createArg().setValue( "-R" );
	}

	if ( backups )
	{
	cli.createArg().setValue( "-b" );
	}

	if ( removeEmptyFiles )
	{
	cli.createArg().setValue( "-E" );
	}

	cli.createArg().setValue( "-i" );
	cli.createArg().setFile( patchFile );

	if ( destFile != null )
	{
	cli.createArg().setValue( "-o" );
	cli.createArg().setFile( destFile );
	}

	if ( originalFile != null )
	{
	cli.createArg().setFile( originalFile );
	}

	return cli;
	}

	}