Get the --no-index diff of files in two directories, but ignore pattern(s)

Here's one way to go at it. Temporarily make a commit for each directory, then diff the changesets between those two commits for those directories.

git add dir1
git commit -m "this is dir1"
git add dir2
git commit -m "this is dir2"

And for the final trick

git diff HEAD~1:dir1 HEAD:dir2

Here is a variation on @Marteen Bicknese's answer, which doesn't create new commits nor modifies your index, but which still writes the content of all files to compare in your local git storage :

# in a script file :

export GIT_INDEX_FILE=.git/my.tmp.index

git add dir1 dir2
CMP_TREE=$(git write-tree)
git diff $CMP_TREE:dir1 $CMP_TREE:dir2

rm $GIT_INDEX_FILE

if you're really into one liners, you can cheat and put the above commands between parentheses :

(export GIT_INDEX_FILE=.git/my.tmp.index; git add dir1 dir2; \
    CMP_TREE=$(git write-tree); \
    git diff $CMP_TREE:dir1 $CMP_TREE:dir2; rm $GIT_INDEX_FILE)

(note : parenthese start a subshell, so variables defined inside will not interfere with your current shell)

Turning it into a reusable script :

# in script file named git-dir-diff :
#!/bin/bash

path1=$1
path2=$2

export GIT_INDEX_FILE=`mktemp -u .git/my.XXXXXX.index`

git add "$path1" "$path2"
CMP_TREE=$(git write-tree)
git diff "$CMP_TREE:$path1" "$CMP_TREE:$path2"

rm $GIT_INDEX_FILE

if you put git-dir-diff in your path, you can then type :

git dir-diff dir1 dir2

additionally : if you want a more visual diff view of your directories, you can use git difftool -d in the script instead of git diff.

My idea is to get the diff output first and then remove the diff hunks of the files you want to ignore. Here's a demo mydiff.py in Python(>=3.6). Disclaimer, the script is not fully tested.

#!/usr/bin/env python

import subprocess
import glob
import re
import sys

# the patterns of the ignored files
IGNORED_PATTERNS = [
    # regex, starting with ^
    '^.+/c\.txt$',
    # glob, starting with *. The first * is removed before being consumed.
    '***/f.txt',
    # plain, others
    'foo/a.txt',
]


def ignored(path):
    matched = False
    for pattern in IGNORED_PATTERNS:
        if pattern.startswith('^') and re.findall(pattern, path):
            matched = True
            break
        elif pattern.startswith('*'):
            globs = [
                g.replace('\\', '/')
                for g in glob.glob(pattern[1:], recursive=True)
            ]
            if path in globs:
                matched = True
                break
        elif pattern == path:
            matched = True
            break
    return matched


_local = sys.argv[1]
_remote = sys.argv[2]
cmd = 'git diff --no-index %s %s' % (_local, _remote)
o = subprocess.getoutput(cmd)
lines = []
ignore = False
for line in o.split('\n'):
    if line.startswith('diff --git'):
        _, _, local_path, remote_path = line.strip().split()
        local_path = '/'.join(local_path.split('/')[1:])
        remote_path = '/'.join(remote_path.split('/')[1:])
        if ignored(local_path) or ignored(remote_path):
            ignore = True
            continue
        else:
            ignore = False
            lines.append(line)
    else:
        if ignore:
            continue
        else:
            lines.append(line)
print('\n'.join(lines))

You could edit IGNORED_PATTERNS or modify the script to read the patterns from a config file.

Usage, python mydiff.py dir1 dir2 | less. In Git-Bash for windows, use python.exe mydiff.py dir1 dir2 | less to avoid the error stdout is not a tty, or make mydiff.py executable and run ./mydiff.py dir1 dir2 | less.