I'm reviewing a patch that moved a lot of things around, added a few things, and removed a few things. I'm wondering if anyone's written a utility for picking out the unique adds/removes in a universal diff?
That is, an add and a remove of the same line should cancel themselves out.
Obviously this isn't useful all the time, but sometimes it's exactly what I want :)
This is what I ended up using.
Example usage:
git diff -w | /path/to/ignore_moves.py | less -R
#!/usr/bin/python
import sys
from itertools import *
RED = 31
GREEN = 32
RESET_SEQ = "\033[0m"
COLOR_SEQ = "\033[0;%dm"
stack = []
def inverse(line):
return ('-' if line[0] == '+' else '+') + line[1:].strip()
def reverse_enumerate(l):
for i, x in enumerate(reversed(l)):
yield len(l)-1-i, x
def dumpchanges():
for line in stack:
SEQ = COLOR_SEQ % (GREEN if line.startswith('+') else RED)
print SEQ + line.strip() + RESET_SEQ
stack[:] = []
for line in sys.stdin.readlines():
if not line[1:].strip():
continue # ignore empty lines
if line.startswith(('---', '+++')):
dumpchanges()
print line.strip()
elif line.startswith(('+', '-')):
inverted = inverse(line)
line = line[0] + line[1:].strip()
for i, match in reverse_enumerate(stack):
if inverted == match:
stack.pop(i)
break
else:
stack.append(line)
# finished reading, still have state to be dumped
dumpchanges()
This worked better for me to get the diff of the modified files (omitting files that were only moved).
git diff -M -C -D
From the git diff documentation:
-M[<n>], --find-renames[=<n>]
Detect renames. If n is specified, it is a threshold on the similarity index (i.e. amount of addition/deletions compared to the file's size). For example, -M90% means git should consider a delete/add pair to be a rename if more than 90% of the file hasn't changed.
-C[<n>], --find-copies[=<n>]
Detect copies as well as renames. See also --find-copies-harder. If n is specified, it has the same meaning as for -M<n>.
-D, --irreversible-delete
Omit the preimage for deletes, i.e. print only the header but not the diff between the preimage and /dev/null. The resulting patch is not meant to be applied with patch nor git apply; this is solely for people who want to just concentrate on reviewing the text after the change. In addition, the output obviously
lack enough information to apply such a patch in reverse, even manually, hence the name of the option.
To 'see' only the lines that are not moved, try this in a console with black background
git -c color.diff.newMoved=black -c color.diff.oldMoved=black diff --color-moved=plain --unified=0
All the moved lines will vanish visually. You will see only the lines that are actually changed. Do note that context is also not shown.
Ref: https://groups.google.com/g/git-users/c/kycBnxmmCcU?pli=1
This is a variation of the answer provided by @Zombo above https://stackoverflow.com/a/23462451/722087
When a lot of files have changes that are only moved lines and then there are files that actually have changes other than moved lines then you would want to find those files that have changed lines. The following will allow you to do that.
Copy the file diff-ignore-moved-lines.sh into your path so that you can execute it from anywhere. Then run the following in the git folder
for file in `git diff --name-only`; do echo $file; git --no-pager diff -- "$file" | diff-ignore-moved-lines; done