Add literal binary patch support

Author: shanman190

jgit/src/main/java/org/openrewrite/jgit/diff/DiffFormatter.java

@@ -28,6 +28,8 @@
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
+import java.util.zip.Deflater;
+import java.util.zip.DeflaterOutputStream;
 
 import org.openrewrite.jgit.diff.DiffAlgorithm.SupportedAlgorithm;
 import org.openrewrite.jgit.diff.DiffEntry.ChangeType;
@@ -68,6 +70,7 @@
 import org.openrewrite.jgit.treewalk.filter.TreeFilter;
 import org.openrewrite.jgit.util.LfsFactory;
 import org.openrewrite.jgit.util.QuotedString;
+import org.openrewrite.jgit.util.io.BinaryHunkOutputStream;
 
 /**
  * Format a Git style patch script.
@@ -96,6 +99,8 @@ public class DiffFormatter implements AutoCloseable {
 
 	private RawTextComparator comparator = RawTextComparator.DEFAULT;
 
+	private PatchType patchType = PatchType.UNIFIED;
+
 	private int binaryFileThreshold = DEFAULT_BINARY_FILE_THRESHOLD;
 
 	private String oldPrefix = "a/"; //$NON-NLS-1$
@@ -259,6 +264,10 @@ public void setBinaryFileThreshold(int threshold) {
 		this.binaryFileThreshold = threshold;
 	}
 
+	public void setPatchType(PatchType type) {
+		this.patchType = type;
+	}
+
 	/**
 	 * Set the prefix applied in front of old file paths.
 	 *
@@ -714,7 +723,7 @@ private static byte[] writeGitLinkText(AbbreviatedObjectId id) {
 	}
 
 	private String format(AbbreviatedObjectId id) {
-		if (id.isComplete() && reader != null) {
+		if (id.isComplete() && reader != null && patchType != PatchType.GIT_BINARY) {
 			try {
 				id = reader.abbreviate(id.toObjectId(), abbreviationLength);
 			} catch (IOException cannotAbbreviate) {
@@ -764,6 +773,8 @@ public void format(FileHeader head, RawText a, RawText b)
 		out.write(head.getBuffer(), start, end - start);
 		if (head.getPatchType() == PatchType.UNIFIED)
 			format(head.toEditList(), a, b);
+		else if (head.getPatchType() == PatchType.GIT_BINARY)
+			formatBinary(a, b);
 	}
 
 	/**
@@ -816,6 +827,26 @@ public void format(EditList edits, RawText a, RawText b)
 		}
 	}
 
+	private void formatBinary(RawText a, RawText b) throws IOException {
+		byte[] oldImage = a.getRawContent();
+		byte[] newImage = b.getRawContent();
+		out.write(encodeASCII("literal " + newImage.length + "\n"));
+		Deflater deflater = new Deflater();
+		deflater.setLevel(Deflater.BEST_SPEED);
+		try (OutputStream os = new DeflaterOutputStream(new BinaryHunkOutputStream(out), deflater, 1024)) {
+			os.write(newImage);
+		}
+		out.write('\n');
+		out.write(encodeASCII("literal " + oldImage.length + "\n"));
+		deflater = new Deflater(); // deflater is stateful, reset it
+		deflater.setLevel(Deflater.BEST_SPEED);
+		try (OutputStream os = new DeflaterOutputStream(new BinaryHunkOutputStream(out), deflater, 1024)) {
+			os.write(oldImage);
+		}
+		out.write('\n');
+		out.write('\n');
+	}
+
 	/**
 	 * Output a line of context (unmodified line).
 	 *
@@ -997,17 +1028,39 @@ private FormatResult createFormatResult(DiffEntry ent) throws IOException,
 			aRaw = new RawText(writeGitLinkText(ent.getOldId()));
 			bRaw = new RawText(writeGitLinkText(ent.getNewId()));
 		} else {
-			try {
-				aRaw = open(OLD, ent);
-				bRaw = open(NEW, ent);
-			} catch (BinaryBlobException e) {
-				// Do nothing; we check for null below.
-				formatOldNewPaths(buf, ent);
-				buf.write(encodeASCII("Binary files differ\n")); //$NON-NLS-1$
-				editList = new EditList();
-				type = PatchType.BINARY;
-				res.header = new FileHeader(buf.toByteArray(), editList, type);
+			if (patchType == PatchType.GIT_BINARY) {
+				try {
+					aRaw = open(OLD, ent);
+					bRaw = open(NEW, ent);
+				} catch (BinaryBlobException e) {
+					// Do nothing; we check for null below.
+					formatOldNewPaths(buf, ent);
+					buf.write(encodeASCII("Binary files differ\n")); //$NON-NLS-1$
+					editList = new EditList();
+					type = PatchType.BINARY;
+					res.header = new FileHeader(buf.toByteArray(), editList, type);
+					return res;
+				}
+
+				buf.write(encodeASCII("GIT binary patch\n"));
+				type = PatchType.GIT_BINARY;
+				res.header = new FileHeader(buf.toByteArray(), type);
+				res.a = aRaw;
+				res.b = bRaw;
 				return res;
+			} else {
+				try {
+					aRaw = open(OLD, ent);
+					bRaw = open(NEW, ent);
+				} catch (BinaryBlobException e) {
+					// Do nothing; we check for null below.
+					formatOldNewPaths(buf, ent);
+					buf.write(encodeASCII("Binary files differ\n")); //$NON-NLS-1$
+					editList = new EditList();
+					type = PatchType.BINARY;
+					res.header = new FileHeader(buf.toByteArray(), editList, type);
+					return res;
+				}
 			}
 		}
 
@@ -1072,7 +1125,11 @@ private RawText open(DiffEntry.Side side, DiffEntry entry)
 
 		ObjectLoader ldr = LfsFactory.getInstance().applySmudgeFilter(repository,
 				source.open(side, entry), entry.getDiffAttribute());
-		return RawText.load(ldr, binaryFileThreshold);
+		if (patchType == PatchType.GIT_BINARY) {
+			return RawText.loadBinary(ldr, binaryFileThreshold);
+		} else {
+			return RawText.load(ldr, binaryFileThreshold);
+		}
 	}
 
 	/**

jgit/src/main/java/org/openrewrite/jgit/diff/RawText.java

@@ -449,4 +449,41 @@ public static RawText load(ObjectLoader ldr, int threshold)
 			return new RawText(data, RawParseUtils.lineMapOrBinary(data, 0, (int) sz));
 		}
 	}
+
+	/**
+	 * Read a blob object into RawText, or throw BinaryBlobException if the blob
+	 * is binary.
+	 *
+	 * @param ldr
+	 *            the ObjectLoader for the blob
+	 * @param threshold
+	 *            if the blob is larger than this size, it is always assumed to
+	 *            be binary.
+	 * @since 4.10
+	 * @return the RawText representing the blob.
+	 * @throws org.openrewrite.jgit.errors.BinaryBlobException
+	 *             if the blob contains binary data.
+	 * @throws java.io.IOException
+	 *             if the input could not be read.
+	 */
+	public static RawText loadBinary(ObjectLoader ldr, int threshold)
+			throws IOException, BinaryBlobException {
+		long sz = ldr.getSize();
+
+		if (sz > threshold) {
+			throw new BinaryBlobException();
+		}
+
+		try (InputStream stream = ldr.openStream()) {
+			byte[] data;
+			try {
+				data = new byte[(int) sz];
+			} catch (OutOfMemoryError e) {
+				throw new LargeObjectException.OutOfMemory(e);
+			}
+
+			IO.readFully(stream, data, 0, (int) sz);
+			return new RawText(data);
+		}
+	}
 }

jgit/src/main/java/org/openrewrite/jgit/patch/FileHeader.java

@@ -108,17 +108,29 @@ public enum PatchType {
 	 *
 	 * @param headerLines
 	 *            buffer holding the diff header for this file
-	 * @param edits
-	 *            the edits for this file
 	 * @param type
 	 *            the type of patch used to modify this file
 	 */
-	public FileHeader(byte[] headerLines, EditList edits, PatchType type) {
+	public FileHeader(byte[] headerLines, PatchType type) {
 		this(headerLines, 0);
 		endOffset = headerLines.length;
 		int ptr = parseGitFileName(Patch.DIFF_GIT.length, headerLines.length);
 		parseGitHeaders(ptr, headerLines.length);
 		this.patchType = type;
+	}
+
+	/**
+	 * Constructs a new FileHeader
+	 *
+	 * @param headerLines
+	 *            buffer holding the diff header for this file
+	 * @param edits
+	 *            the edits for this file
+	 * @param type
+	 *            the type of patch used to modify this file
+	 */
+	public FileHeader(byte[] headerLines, EditList edits, PatchType type) {
+		this(headerLines, type);
 		addHunk(new HunkHeader(this, edits));
 	}