CODEWITHSUNDEEP
gitdiffgit-diff
Mzzzzzz
Mzzzzzz

Reputation: 4970

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

Upvotes: 201

Views: 76469

Answers (15)

himanshuxd
himanshuxd

Reputation: 411

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

Upvotes: 5

Davoud Taghawi-Nejad
Davoud Taghawi-Nejad

Reputation: 16826

add

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

to ~/.zshrc or ~/.bashrc

This uses git diff to do ordinary diff between two files

Upvotes: 0

jonescb
jonescb

Reputation: 22821

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.

Upvotes: 256

NoOneYouKnow
NoOneYouKnow

Reputation: 13

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

Upvotes: 1

Heechul Ryu
Heechul Ryu

Reputation: 1361

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;}

Upvotes: 3

Syrtis Major
Syrtis Major

Reputation: 3949

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 -; }

Upvotes: 1

Rakmo
Rakmo

Reputation: 1982

Use colordiff:

Installation:

sudo apt-get install colordiff

Usage:

colordiff -u file_one file_two

Gives exactly same difference as shown by git diff.

Upvotes: 0

codehearts
codehearts

Reputation: 505

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.

Upvotes: 7

Dejay Clayton
Dejay Clayton

Reputation: 3898

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.

Upvotes: 4

Nate
Nate

Reputation: 13262

This is what I suggest and it's pretty close

diff -u FILE1 FILE2 | colordiff | less -R
  • colordiff: You'll have to install this
  • -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; }

Upvotes: 21

Davoud Taghawi-Nejad
Davoud Taghawi-Nejad

Reputation: 16826

You are looking for colordiff:

sudo apt-get install colordiff

Upvotes: 2

Steve
Steve

Reputation: 7128

  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.

Upvotes: 28

eacousineau
eacousineau

Reputation: 3533

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

Upvotes: 116

Karl
Karl

Reputation: 706

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
    )
}

Upvotes: 0

Nanda Kishore
Nanda Kishore

Reputation: 2809

I think the config setting :

[color]
     ui = true

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

Upvotes: -2

Related Questions