23

I'm regularly using the gnu-utils patch and diff. Using git, I often do:

git diff

Often simple changes create a large patch because the only that changed was, for example, adding a if/else loop and everything inside is indented to the right.

Reviewing such a patch can be cumbersome because only line by line manual comparison can indicate if anything has essentially changed within the indented code. We may be speaking about a few lines of code only, or about dozens (or much more) of nested code. (I know: such an hypothetically large function would better be split into smaller functions, but that's beside the point).

Can't GNU diff/patch be aware when the only change within a code block is the indentation and let the developer know as much?

Are there any other diff tools that operate this way?

Edit: Ok, there is --ignore-space-change but then we are in a either/or situation: either we have a human-more-readable patch or we have a complete patch that the machine would know how to read. Can't we have the best of both world with a more elaborate diff tool that would show to the human space changes for what they are while allowing the machine to apply the patch fully?

Daniel Serodio
  • 4,229
  • 5
  • 37
  • 33
augustin
  • 14,373
  • 13
  • 66
  • 79

4 Answers4

18

With GNU diff you can pass -b or --ignore-space-change to ignore changes in the amount of white space in a patch.

If you use emacs and have been sent a patch, you can also use M-x diff-ignore-whitespace-hunk to reformat the patch to ignore white space in a particular hunk. Or diff-refine-hunk to highlight changes at a character by character level, which tends to point out the "meat" of a change.

As for applying patches, you can use the -l or --ignore-whitespace with GNU patch to ignore tabs and spaces changes. Just be careful with Python code :-)

richq
  • 55,548
  • 20
  • 150
  • 144
  • 2
    +1 Good to know. git diff -b > my.patch works too. That's useful. However, the output wouldn't work as a proper patch or else the intended indentation wouldn't be applied. I was wondering if we could get the best of both sides of the problem, e.g. having a patch file with 3 types of lines (colored accordingly): lines that have not changed, lines that have changed (- or +) and the lines that have merely been indented... Both the machine would know how to apply the patch and the human would understand it better. – augustin Nov 10 '10 at 11:55
2

For what is worth, using git difftool with a tool like meld or xxdiff makes the diff much more readable.

Kalle Richter
  • 8,008
  • 26
  • 77
  • 177
lucascaro
  • 16,550
  • 4
  • 37
  • 47
  • Since I just stumbled across this: see here for how to ignore whitespaces in meld: https://codeyarns.com/2015/01/27/how-to-ignore-whitespace-in-meld/ – packoman Apr 10 '19 at 08:35
2

I don't know about git diff. But a diff-like tool that understands not just indentation but in fact any layout changes in your target language is our Smart Differencer.

This tool parses the before- and after- versions of your code the same way compiler does, and compares the resulting syntax trees, so it isn't affected by whitespace changes (except semantically important whitespace such as Python indentation) of any kind, inserted or deleted comments, or even change of radix on constants.

The result is report in terms of programmer editing actions ("move, insert, delete, copy, rename") over language structures (expressions, statements, declarations, blocks, methods, ...) rather than "insert line" or "delete line".

Ira Baxter
  • 93,541
  • 22
  • 172
  • 341
1

I try to not do file-wide indentation changes in the same commit as some other changes. And I commit the indentation changes in a separate commit before or after, with a commit message of "Changed indentation only.", to make it clear so that no manual diff inspection is needed, to see if something else was changed.

Magne
  • 16,401
  • 10
  • 68
  • 88