How to get diff working like git-diff?

I like the output formatting of git diff. The color and the +/- representation of changes between lines is easier to read than GNU diff.

I can run git diff using --no-index flag outside of a git repo and it works fine. However, it appears to be missing the --exclude option for excluding files or subdirectories from a recursive diff.

Is there a way to get the best of both worlds? (color options and +/- format of git diff and --exclude option of GNU diff).

I've experimented with colordiff, but I still prefer the output format of git diff

This will do the +/- rather than < and >.

diff -u file1 file2

Since GNU diffutils 3.4 the flag --color has been added. Combining both makes the following:

diff --color -u file1 file2

The flag --color also takes an argument, valid options are never, always, or auto. Useful when you want to be more explicit on what needs to be done.

You can also use git diff --no-index -- A B (via manpage).

1. Install colordiff.

2. Update your ~/.colordiffrc (copying /etc/colordiffrc first, if necessary):

    # be more git-like:
    plain=off
    newtext=darkgreen
    oldtext=darkred
    diffstuff=darkcyan
   

3. Use colordiff -u file1 file2 for two files or colordiff -ruN path1 path2 for recursively comparing paths.

It's not exactly the same, but it's very close.

This is what I suggest and it's pretty close

diff -u FILE1 FILE2 | colordiff | less -R

• colordiff: You'll have to install this
  • brew install colordiff on my Mac.
  • port install colordiff on some Macs.
  • sudo apt-get install colordiff on Debian or Ubuntu
  • For other platforms, download the source from the main page or GitHub and follow the installation instructions
• -R: this tells Less to show colors instead of the raw codes.

I ultimately used -w because I didn't want to see whitespace diffs.

diff -w -u FILE1 FILE2 | colordiff | less -R

Edit: As suggested by @Ciprian Tomoiaga in the comment, you can make this a function and put it in your ~/.bashrc file too.

function gdiff () { diff -u $@ | colordiff | less -R; }

GNU diff has a --color option since version 3.4 in late 2016 according to this answer on the Unix SE. That alongside -u should be enough to mimic the output of git diff:

diff -u --color=always file1 file2 | less -r

--color must be always when used in a pipe, auto will turn off color in pipes.

I've only tried this with Git Bash on Windows, where less -R would only color the first line of a hunk. less -r fixed it for me in that case.

Place this in your rc file, most commonly it would be either .bashrc or .zshrc :

diff() { git diff --no-index "$1" "$2" | colordiff; }

requirements : git and colordiff should have been installed.

usage : diff file1 file2

Using only bash, diff, tput, and less, we can closely approximate the output of git diff. There will be some notable differences, though, due to the short-sightedness of the diff programmers.

Put the following Bash function definition in some file that gets sourced automatically by your user account, and you'll be able to access the function from the command line:

function gdiff()
{
    local REG=`tput op`
    local GRP=`tput setaf 6`
    local ADD=`tput setaf 2`
    local REM=`tput setaf 1`

    local NL=$'\n'
    local GRP_LABEL="${GRP}@@ %df,%dn +%dF,%dN @@${REG}"

    local UNCH_GRP_FMT=''

    [[ "${1}" == '@full' ]] && {

        UNCH_GRP_FMT="${GRP_LABEL}${NL}%="
        shift
    }

    diff \
        --new-line-format="${ADD}+%L${REG}" \
        --old-line-format="${REM}-%L${REG}" \
        --unchanged-line-format=" %L${REG}" \
        --new-group-format="${GRP_LABEL}${NL}%>" \
        --old-group-format="${GRP_LABEL}${NL}%<" \
        --changed-group-format="${GRP_LABEL}${NL}%<%>" \
        --unchanged-group-format="${UNCH_GRP_FMT}" \
            "${@}" | less -FXR
}

This function works as follows:

1. Ultimately, diff gets invoked with various formatting options to specify how changes within the files will be displayed.
2. tput is used to insert ANSI color codes into those formatting options. Note that when using non-ANSI terminals, you may have to replace tput setaf with tput setf.
3. The output of diff is piped into less. -R allows ANSI colors to be preserved. -X prevents less from clearing the screen upon exiting. -F prevents less from operating as a pager if the output fits within one screen.
4. If the first parameter is @full, the function will display all unchanged lines in addition to added and removed lines.

Note the following differences between this approach and git diff:

1. git diff reports three lines of context surrounding each change. Unfortunately, diff seems to complain and exit if you want to specify the number of context lines while also simultaneously specifying formatting options. (At least it does in Mac OS X Yosemite). Thanks diff programmers. Therefore, you can either request no lines of context surrounding each change, which is the default behavior, or you can request that all unchanged lines within the file are also reported, by specifying @full as the first parameter.
2. Because the lines of context are different from git diff, the line numbers reported by this function will also vary from those reported by git diff.
3. You may see the presence of single-line changes reported, which is the correct behavior, but annoying when your changed file contains the insertion of single empty lines. I think git diff deals with this better, via its lines of context. You could try passing different options to diff to better deal with whitespace, if you prefer.

You are looking for colordiff:

sudo apt-get install colordiff

Since bat has nice colorizing, I've tested if that works with diff too and surprisingly it worked really well out of the box.

$ diff file1 file2 | bat or $ diff -u file1 file2 | bat

So I suppose you could make a function like this below to be more efficient:

function bdiff () { diff -u $@ | bat;}

Tested in debian 9 diff -u --color=always file1 file2

The other option is to do it from outside the repository so git knows to diff between files. eg. a shell function something like:

gdiff() {
    (
        dir=`pwd`
        cd ./$(git rev-parse --show-cdup)/..
        git diff  $dir/$1 $dir/$2
    )
}

Use colordiff:

Installation:

sudo apt-get install colordiff

Usage:

colordiff -u file_one file_two

Gives exactly same difference as shown by git diff.

If you don't have colordiff or git diff, you can get color by vim.

cdiff() { diff -u $@ | vim -R -; }

or simply

cdiff() { diff -u $@ | view -; }

add

> alias diff="git diff --no-index --"

to ~/.zshrc or ~/.bashrc

This uses git diff to do ordinary diff between two files

I think the config setting :

[color]
     ui = true

combined with "diff" command's --relative=<path> option would do what you wanted. Did you try ?