Better handling for git diffs in filterdiff/lsdiff

Assisted-by: Cursor

Author: twaugh

Makefile.am

@@ -281,7 +281,11 @@ TESTS = tests/newline1/run-test \
 	tests/patch-ignore-whitespace/run-test \
 	tests/whitespace-w/run-test \
 	tests/filterdiff-inplace1/run-test \
-	tests/rediff-inplace1/run-test
+	tests/rediff-inplace1/run-test \
+	tests/git-rename-issue22/run-test \
+	tests/git-binary-issue57/run-test \
+	tests/git-mode-issue59/run-test \
+	tests/git-exclude-issue27/run-test
 
 # These ones don't work yet.
 # Feel free to send me patches. :-)

NEWS

@@ -3,6 +3,14 @@ Patchutils news
 
 0.4.4 (stable)
 
+	Enhanced Git diff format support in filterdiff/lsdiff/grepdiff.
+	Improved handling of Git diffs without traditional hunks,
+	including proper support for file renames, binary file changes,
+	and permission mode changes. Fixed exclusion filtering (-x) for
+	multi-file Git diffs to prevent orphaned headers. Enhanced filename
+	extraction to properly strip Git's a/ and b/ prefixes for consistent
+	output. Addresses GitHub issues #22, #27, #57, and #59.
+
 	Code improvements and build system enhancements. Added redirectfd()
 	utility function to redirect stdout without reassignment. Enhanced
 	CI testing with musl support for better compatibility testing.

doc/patchutils.xml

@@ -724,6 +724,10 @@
 
 	<screen>filterdiff message-with-diff-in-the-body > patch</screen></para>
 
+	<para>Filterdiff supports unified, context, and Git format diffs.
+	  Git format includes support for binary files, file renames,
+	  permission mode changes, and other Git-specific diff features.</para>
+
 	<para>Note that the interpretation of the shell wildcard
 	  pattern does not count slash characters or periods as
 	  special (in other words, no flags are given to
@@ -1039,6 +1043,12 @@ patch.file]]></screen></para>
 	  and context format diffs:
 
 <screen><![CDATA[filterdiff -v --format=unified context.diff]]></screen></para>
+
+	<para>Git format diffs are fully supported, including binary files,
+	  file renames, and permission mode changes. For example, to extract
+	  only the renames from a git diff:
+
+<screen><![CDATA[filterdiff -i '*/newname' git-patch-with-renames.patch]]></screen></para>
       </refsect1>
 
       <refsect1>
@@ -1243,8 +1253,10 @@ patch.file]]></screen></para>
 
 	<para>List the files modified by a patch.</para>
 
-	<para>You can use both unified and context format diffs with
-	  this program.</para>
+	<para>You can use unified, context, and Git format diffs with
+	  this program. Git format includes support for binary files,
+	  file renames, permission mode changes, and other Git-specific
+	  diff features.</para>
 
       </refsect1>
 
@@ -2291,8 +2303,10 @@ will pipe patch of file #2 to vim - -R
 <screen><![CDATA[grepdiff pf_gfp_mask my.patch | \
   xargs -rn1 filterdiff my.patch -i]]></screen></para>
 
-	<para>You can use both unified and context format diffs with
-	  this program.</para>
+	<para>You can use unified, context, and Git format diffs with
+	  this program. Git format includes support for binary files,
+	  file renames, permission mode changes, and other Git-specific
+	  diff features.</para>
 
       </refsect1>
 
@@ -2603,6 +2617,20 @@ will pipe patch of file #2 to vim - -R
 	</variablelist>
       </refsect1>
 
+      <refsect1>
+	<title>Examples</title>
+
+	<para>Git format diffs are fully supported. For example, to find
+	  files in a git patch that contain changes to malloc calls:
+
+<screen><![CDATA[grepdiff "malloc" git-patch.patch]]></screen></para>
+
+	<para>Note that grepdiff searches in the hunk content (the actual
+	  code changes), not in Git metadata like rename headers. Files with
+	  only renames or mode changes (no content hunks) won't be found
+	  even if the pattern appears in the Git headers.</para>
+      </refsect1>
+
       <refsect1>
 	<title>See also</title>
 

src/diff.c

@@ -939,7 +939,7 @@ static FILE *do_convert (FILE *f, const char *mode, int seekable,
 			    error (EXIT_FAILURE, errno, "fdopen failed");
 
 			if (seekable) {
-				FILE *tmp = xtmpfile ();	
+				FILE *tmp = xtmpfile ();
 				while (!feof (ret)) {
 					int c = fgetc (ret);
 
@@ -1112,3 +1112,118 @@ filename_from_header (const char *header)
 
 	return xstrndup (header, h);
 }
+
+enum git_diff_type
+detect_git_diff_type (char **headers, unsigned int num_headers)
+{
+	unsigned int i;
+	int has_similarity_100 = 0;
+	int has_rename = 0;
+	int has_binary = 0;
+	int has_mode_change = 0;
+	int has_new_file = 0;
+	int has_deleted_file = 0;
+
+	/* Check if this is even a git diff */
+	if (num_headers == 0 || strncmp (headers[0], "diff --git ", 11))
+		return GIT_DIFF_NORMAL;
+
+	/* Analyze the headers */
+	for (i = 0; i < num_headers; i++) {
+		if (!strncmp (headers[i], "similarity index 100%", 21))
+			has_similarity_100 = 1;
+		else if (!strncmp (headers[i], "rename from ", 12) ||
+			 !strncmp (headers[i], "rename to ", 10))
+			has_rename = 1;
+		else if (!strncmp (headers[i], "old mode ", 9) ||
+			 !strncmp (headers[i], "new mode ", 9))
+			has_mode_change = 1;
+		else if (!strncmp (headers[i], "new file mode ", 14))
+			has_new_file = 1;
+		else if (!strncmp (headers[i], "deleted file mode ", 18))
+			has_deleted_file = 1;
+		else if (strstr (headers[i], "Binary files ") ||
+			 !strncmp (headers[i], "GIT binary patch", 16))
+			has_binary = 1;
+	}
+
+	/* Determine the type based on header combinations */
+	if (has_similarity_100 && has_rename)
+		return GIT_DIFF_RENAME;
+	else if (has_binary)
+		return GIT_DIFF_BINARY;
+	else if (has_mode_change && !has_new_file && !has_deleted_file)
+		return GIT_DIFF_MODE_ONLY;
+	else if (has_new_file)
+		return GIT_DIFF_NEW_FILE;
+	else if (has_deleted_file)
+		return GIT_DIFF_DELETED_FILE;
+	else
+		return GIT_DIFF_NORMAL;
+}
+
+int
+extract_git_filenames (char **headers, unsigned int num_headers,
+		       char **old_name, char **new_name)
+{
+	unsigned int i;
+	char *git_line = NULL;
+	char *rename_from = NULL, *rename_to = NULL;
+
+	*old_name = NULL;
+	*new_name = NULL;
+
+	/* Find the diff --git line */
+	for (i = 0; i < num_headers; i++) {
+		if (!strncmp (headers[i], "diff --git ", 11)) {
+			git_line = headers[i];
+			break;
+		}
+	}
+
+	if (!git_line)
+		return 1; /* Not a git diff */
+
+	/* Look for rename headers first */
+	for (i = 0; i < num_headers; i++) {
+		if (!strncmp (headers[i], "rename from ", 12))
+			rename_from = headers[i] + 12;
+		else if (!strncmp (headers[i], "rename to ", 10))
+			rename_to = headers[i] + 10;
+	}
+
+	if (rename_from && rename_to) {
+		/* Use rename headers for filenames */
+		*old_name = xstrndup (rename_from, strcspn (rename_from, "\n\r"));
+		*new_name = xstrndup (rename_to, strcspn (rename_to, "\n\r"));
+	} else {
+		/* Parse filenames from "diff --git a/path b/path" line */
+		char *p = git_line + 11; /* Skip "diff --git " */
+		char *space1, *space2;
+
+		/* Find the space between a/path and b/path */
+		space1 = strchr (p, ' ');
+		if (!space1)
+			return 1;
+
+		/* Extract old filename, stripping a/ prefix if present */
+		if (space1 - p > 2 && p[0] == 'a' && p[1] == '/') {
+			*old_name = xstrndup (p + 2, space1 - p - 2);
+		} else {
+			*old_name = xstrndup (p, space1 - p);
+		}
+
+		/* Find start of new filename (b/path) */
+		space2 = space1 + 1;
+
+		/* Extract new filename, stripping b/ prefix if present */
+		size_t new_len = strcspn (space2, "\n\r");
+		if (new_len > 2 && space2[0] == 'b' && space2[1] == '/') {
+			*new_name = xstrndup (space2 + 2, new_len - 2);
+		} else {
+			*new_name = xstrndup (space2, new_len);
+		}
+	}
+
+	return 0;
+}

src/diff.h

@@ -55,3 +55,17 @@ int read_timestamp (const char *timestamp,
 		    long *zone        /* may be NULL */);
 
 char *filename_from_header (const char *header);
+
+/* Git diff support */
+enum git_diff_type {
+	GIT_DIFF_NORMAL = 0,	/* Regular diff with hunks */
+	GIT_DIFF_RENAME,	/* Pure rename (similarity index 100%) */
+	GIT_DIFF_BINARY,	/* Binary file diff */
+	GIT_DIFF_MODE_ONLY,	/* Mode change only */
+	GIT_DIFF_NEW_FILE,	/* New file creation */
+	GIT_DIFF_DELETED_FILE	/* File deletion */
+};
+
+enum git_diff_type detect_git_diff_type (char **headers, unsigned int num_headers);
+int extract_git_filenames (char **headers, unsigned int num_headers,
+			   char **old_name, char **new_name);