Jacob KellerFrom: Jacob Keller <jacob.keller@gmail.com>
The --no-index option of git-diff enables using the diff machinery when operating outside a repository. This mode of git diff is able to compare directories and produce a diff of their contents. In certain cases, it may be helpful to ignore certain portions of a directory.
In particular, git diff --no-index does not ignore '.git' or other VCS 'hidden' folders. If you pass a path which happens to be a git repository, it will attempt to diff the entire repository folder. Standard diff utilities often include options to exclude files by path. For example, the GNU diffutils program has the '-x' option to exclude files by a pattern match.
Teach git diff --no-index the ability to exclude files by wildmatch pattern when recursing through directories. The '--exclude' option builds up a string list containing the patterns. These are checked with wildmatch() in the read_directory_contents function. If any pattern matches, then the file is not included in the directory contents.
The --exclude option is only supported by the --no-index mode. Standard diff modes support negative pathspecs which is more powerful. I tried to see if there was a way to add support for negative pathspecs themselves, but haven't yet figured out if this is possible.
Signed-off-by: Jacob Keller <jacob.keller@gmail.com> --- I came across an issue when attempting to use git diff --no-index as a diff replacement. I wanted to compare two folders, and one of them happened to be a git repository. This caused the diff to recursively go into the .git folder and try to compare all the paths.
Other diff tools such as the diff from GNU difftools have options to exclude files by pattern match such as '-x'.
Git has negative pathspecs, but this doesn't work with git diff --no-index, and making them work seems tricky, so I thought it wouldn't be too hard to implement an exclude feature for git diff --no-index.
Is something like this worthwhile? I guess I could always try to use a regular diff tool in cases where I'm operating on a potential repository.. But I like the colorization and other options of git diff and it would be convenient to be able to still use git diff in this case.
Thoughts? What about trying to extend the tool to read in negative pathspecs? That seems like its significantly more difficult, but might feel more natural than the --exclude option.
Sent as RFC since this lacks tests and documentation.
diff-no-index.c | 32 +++++++++++++++++++++++++------- 1 file changed, 25 insertions(+), 7 deletions(-)
Show changes to diff-no-index.c +25 −7
diff --git a/diff-no-index.c b/diff-no-index.c index 6f277892d3ae..913b2f3f7869 100644 --- a/diff-no-index.c +++ b/diff-no-index.c @@ -17,8 +17,10 @@ #include "parse-options.h" #include "string-list.h" #include "dir.h" +#include "wildmatch.h" -static int read_directory_contents(const char *path, struct string_list *list) +static int read_directory_contents(const char *path, struct string_list *list, + struct string_list *exclude_patterns) { DIR *dir; struct dirent *e; @@ -26,8 +28,20 @@ static int read_directory_contents(const char *path, struct string_list *list) if (!(dir = opendir(path))) return error("Could not open directory %s", path); - while ((e = readdir_skip_dot_and_dotdot(dir))) + while ((e = readdir_skip_dot_and_dotdot(dir))) { + int skip = 0; + + for (int i = 0; i < exclude_patterns->nr; i++) { + if (!wildmatch(exclude_patterns->items[i].string, e->d_name, 0)) { + skip = 1; + break; + } + } + if (skip) + continue; + string_list_insert(list, e->d_name); + } closedir(dir); return 0; @@ -130,7 +144,8 @@ static struct diff_filespec *noindex_filespec(const char *name, int mode, } static int queue_diff(struct diff_options *o, - const char *name1, const char *name2, int recursing) + const char *name1, const char *name2, int recursing, + struct string_list *exclude_patterns) { int mode1 = 0, mode2 = 0; enum special special1 = SPECIAL_NONE, special2 = SPECIAL_NONE; @@ -170,9 +185,9 @@ static int queue_diff(struct diff_options *o, int i1, i2, ret = 0; size_t len1 = 0, len2 = 0; - if (name1 && read_directory_contents(name1, &p1)) + if (name1 && read_directory_contents(name1, &p1, exclude_patterns)) return -1; - if (name2 && read_directory_contents(name2, &p2)) { + if (name2 && read_directory_contents(name2, &p2, exclude_patterns)) { string_list_clear(&p1, 0); return -1; } @@ -217,7 +232,7 @@ static int queue_diff(struct diff_options *o, n2 = buffer2.buf; } - ret = queue_diff(o, n1, n2, 1); + ret = queue_diff(o, n1, n2, 1, exclude_patterns); } string_list_clear(&p1, 0); string_list_clear(&p2, 0); @@ -306,10 +321,13 @@ int diff_no_index(struct rev_info *revs, const char *paths[2]; char *to_free[ARRAY_SIZE(paths)] = { 0 }; struct strbuf replacement = STRBUF_INIT; + struct string_list exclude_patterns = STRING_LIST_INIT_NODUP; const char *prefix = revs->prefix; struct option no_index_options[] = { OPT_BOOL_F(0, "no-index", &no_index, "", PARSE_OPT_NONEG | PARSE_OPT_HIDDEN), + OPT_STRING_LIST(0, "exclude", &exclude_patterns, N_("pattern"), + N_("exclude files matching pattern when recursing a directory")), OPT_END(), }; struct option *options; @@ -354,7 +372,7 @@ int diff_no_index(struct rev_info *revs, setup_diff_pager(&revs->diffopt); revs->diffopt.flags.exit_with_status = 1; - if (queue_diff(&revs->diffopt, paths[0], paths[1], 0)) + if (queue_diff(&revs->diffopt, paths[0], paths[1], 0, &exclude_patterns)) goto out; diff_set_mnemonic_prefix(&revs->diffopt, "1/", "2/"); diffcore_std(&revs->diffopt);
-- 2.48.1.397.gec9d649cc640
