Allow applying a patch with conflicts

In some settings, we want to let users apply a patch that does
not cleanly apply and add conflict markers. In Gerrit, this is
useful when cherry picking (via Git patches) from one host to
another.

This commit takes a simple approach: If a hunk doesn't apply,
go to the pre-image line, treat all lines in pre-image length
as left side of the conflict and all context and newly added
lines as right side of the conflict.

Change-Id: I01411d7a32b3f3207097b26231909aae6b835650

1 files changed, 115 insertions, 19 deletions

diff --git a/org.eclipse.jgit/src/org/eclipse/jgit/patch/PatchApplier.java b/org.eclipse.jgit/src/org/eclipse/jgit/patch/PatchApplier.java
index a327095c81..84c2ec43dc 100644
--- a/org.eclipse.jgit/src/org/eclipse/jgit/patch/PatchApplier.java
+++ b/org.eclipse.jgit/src/org/eclipse/jgit/patch/PatchApplier.java
@@ -23,6 +23,7 @@ import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.nio.ByteBuffer;
+import java.nio.charset.Charset;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.nio.file.StandardCopyOption;
@@ -33,9 +34,11 @@ import java.util.Arrays;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
+import java.util.Objects;
 import java.util.Set;
 import java.util.stream.Collectors;
 import java.util.zip.InflaterInputStream;
+
 import org.eclipse.jgit.annotations.Nullable;
 import org.eclipse.jgit.api.errors.FilterFailedException;
 import org.eclipse.jgit.api.errors.PatchFormatException;
@@ -101,11 +104,12 @@ import org.eclipse.jgit.util.sha1.SHA1;
  * @since 6.4
  */
 public class PatchApplier {
-
 	private static final byte[] NO_EOL = "\\ No newline at end of file" //$NON-NLS-1$
 			.getBytes(StandardCharsets.US_ASCII);
 
-	/** The tree before applying the patch. Only non-null for inCore operation. */
+	/**
+	 * The tree before applying the patch. Only non-null for inCore operation.
+	 */
 	@Nullable
 	private final RevTree beforeTree;
 
@@ -115,10 +119,14 @@ public class PatchApplier {
 
 	private final ObjectReader reader;
 
+	private final Charset charset;
+
 	private WorkingTreeOptions workingTreeOptions;
 
 	private int inCoreSizeLimit;
 
+	private boolean allowConflicts;
+
 	/**
 	 * @param repo
 	 *            repository to apply the patch in
@@ -128,7 +136,8 @@ public class PatchApplier {
 		inserter = repo.newObjectInserter();
 		reader = inserter.newReader();
 		beforeTree = null;
-
+		allowConflicts = false;
+		charset = StandardCharsets.UTF_8;
 		Config config = repo.getConfig();
 		workingTreeOptions = config.get(WorkingTreeOptions.KEY);
 		inCoreSizeLimit = config.getInt(ConfigConstants.CONFIG_MERGE_SECTION,
@@ -143,11 +152,14 @@ public class PatchApplier {
 	 * @param oi
 	 *            to be used for modifying objects
 	 */
-	public PatchApplier(Repository repo, RevTree beforeTree, ObjectInserter oi)  {
+	public PatchApplier(Repository repo, RevTree beforeTree,
+			ObjectInserter oi) {
 		this.repo = repo;
 		this.beforeTree = beforeTree;
 		inserter = oi;
 		reader = oi.newReader();
+		allowConflicts = false;
+		charset = StandardCharsets.UTF_8;
 	}
 
 	/**
@@ -157,7 +169,6 @@ public class PatchApplier {
 	 * @since 6.3
 	 */
 	public static class Result {
-
 		/**
 		 * A wrapper for a patch applying error that affects a given file.
 		 *
@@ -166,13 +177,14 @@ public class PatchApplier {
 		// TODO(ms): rename this class in next major release
 		@SuppressWarnings("JavaLangClash")
 		public static class Error {
+			String msg;
+
+			String oldFileName;
 
-			private String msg;
-			private String oldFileName;
-			private @Nullable HunkHeader hh;
+			@Nullable
+			HunkHeader hh;
 
-			private Error(String msg, String oldFileName,
-					@Nullable HunkHeader hh) {
+			Error(String msg, String oldFileName, @Nullable HunkHeader hh) {
 				this.msg = msg;
 				this.oldFileName = oldFileName;
 				this.hh = hh;
@@ -181,13 +193,33 @@ public class PatchApplier {
 			@Override
 			public String toString() {
 				if (hh != null) {
-					return MessageFormat.format(JGitText.get().patchApplyErrorWithHunk,
-							oldFileName, hh, msg);
+					return MessageFormat.format(
+							JGitText.get().patchApplyErrorWithHunk, oldFileName,
+							hh, msg);
 				}
-				return MessageFormat.format(JGitText.get().patchApplyErrorWithoutHunk,
-						oldFileName, msg);
+				return MessageFormat.format(
+						JGitText.get().patchApplyErrorWithoutHunk, oldFileName,
+						msg);
 			}
 
+			@Override
+			public boolean equals(Object o) {
+				if (this == o) {
+					return true;
+				}
+				if (o == null || !(o instanceof Error)) {
+					return false;
+				}
+				Error error = (Error) o;
+				return Objects.equals(msg, error.msg)
+						&& Objects.equals(oldFileName, error.oldFileName)
+						&& Objects.equals(hh, error.hh);
+			}
+
+			@Override
+			public int hashCode() {
+				return Objects.hash(msg, oldFileName, hh);
+			}
 		}
 
 		private ObjectId treeId;
@@ -357,6 +389,17 @@ public class PatchApplier {
 		return result;
 	}
 
+	/**
+	 * Sets up the {@link PatchApplier} to apply patches even if they conflict.
+	 *
+	 * @return the {@link PatchApplier} to apply any patches
+	 * @since 6.10
+	 */
+	public PatchApplier allowConflicts() {
+		allowConflicts = true;
+		return this;
+	}
+
 	private File getFile(String path) {
 		return inCore() ? null : new File(repo.getWorkTree(), path);
 	}
@@ -439,6 +482,7 @@ public class PatchApplier {
 			return false;
 		}
 	}
+
 	private static final int FILE_TREE_INDEX = 1;
 
 	/**
@@ -539,7 +583,9 @@ public class PatchApplier {
 					convertCrLf);
 			resultStreamLoader = applyText(raw, fh, result);
 		}
-		if (resultStreamLoader == null || !result.getErrors().isEmpty()) {
+		if (resultStreamLoader == null
+				|| (!result.getErrors().isEmpty() && result.getErrors().stream()
+						.anyMatch(e -> !e.msg.equals("cannot apply hunk")))) { //$NON-NLS-1$
 			return;
 		}
 
@@ -961,9 +1007,51 @@ public class PatchApplier {
 				}
 			}
 			if (!applies) {
-				result.addError(JGitText.get().applyTextPatchCannotApplyHunk,
-						fh.getOldPath(), hh);
-				return null;
+				if (!allowConflicts) {
+					result.addError(
+							JGitText.get().applyTextPatchCannotApplyHunk,
+							fh.getOldPath(), hh);
+					return null;
+				}
+				// Insert conflict markers. This is best-guess because the
+				// file might have changed completely. But at least we give
+				// the user a graceful state that they can resolve manually.
+				// An alternative to this is using the 3-way merger. This
+				// only works if the pre-image SHA is contained in the repo.
+				// If that was the case, cherry-picking the original commit
+				// should be preferred to apply a patch.
+				result.addError("cannot apply hunk", fh.getOldPath(), hh); //$NON-NLS-1$
+				newLines.add(Math.min(applyAt++, newLines.size()),
+						asBytes("<<<<<<< HEAD")); //$NON-NLS-1$
+				applyAt += hh.getOldImage().lineCount;
+				newLines.add(Math.min(applyAt++, newLines.size()),
+						asBytes("=======")); //$NON-NLS-1$
+
+				int sz = hunkLines.size();
+				for (int j = 1; j < sz; j++) {
+					ByteBuffer hunkLine = hunkLines.get(j);
+					if (!hunkLine.hasRemaining()) {
+						// Completely empty line; accept as empty context
+						// line
+						applyAt++;
+						lastWasRemoval = false;
+						continue;
+					}
+					switch (hunkLine.array()[hunkLine.position()]) {
+					case ' ':
+					case '+':
+						newLines.add(Math.min(applyAt++, newLines.size()),
+								slice(hunkLine, 1));
+						break;
+					case '-':
+					case '\\':
+					default:
+						break;
+					}
+				}
+				newLines.add(Math.min(applyAt++, newLines.size()),
+						asBytes(">>>>>>> PATCH")); //$NON-NLS-1$
+				continue;
 			}
 			// Hunk applies at applyAt. Apply it, and update afterLastHunk and
 			// lineNumberShift
@@ -1010,7 +1098,11 @@ public class PatchApplier {
 		} else if (!rt.isMissingNewlineAtEnd()) {
 			newLines.add(null);
 		}
+		return toContentStreamLoader(newLines);
+	}
 
+	private static ContentStreamLoader toContentStreamLoader(
+			List<ByteBuffer> newLines) throws IOException {
 		// We could check if old == new, but the short-circuiting complicates
 		// logic for inCore patching, so just write the new thing regardless.
 		TemporaryBuffer buffer = new TemporaryBuffer.LocalFile(null);
@@ -1034,6 +1126,10 @@ public class PatchApplier {
 		}
 	}
 
+	private ByteBuffer asBytes(String str) {
+		return ByteBuffer.wrap(str.getBytes(charset));
+	}
+
 	@SuppressWarnings("ByteBufferBackingArray")
 	private boolean canApplyAt(List<ByteBuffer> hunkLines,
 			List<ByteBuffer> newLines, int line) {
@@ -1123,4 +1219,4 @@ public class PatchApplier {
 			in.close();
 		}
 	}
-}
+}
\ No newline at end of file