[PATCH] Move pathspec to the beginning of the diffcore chain.

This changes the way how pathspec is used in the three diff-*
brothers.  Earlier, they tried to grab as much information from
the original input and used pathspec to limit the output.  This
version uses pathspec upfront to narrow the world diffcore
operates in, so "git-diff-* <arguments> some-directory" does not
look at things outside the specified subtree when finding
rename/copy or running pickaxe.

Since diff-tree already takes this view and does not feed
anything outside the specified directotires to begin with, this
patch does not have to touch that command.

Signed-off-by: Junio C Hamano <junkio@cox.net>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

diff --git a/diff-cache.c b/diff-cache.c
index 0a6720de6c994e6bcf3cc9236c71ae4870725eda..66e7bdb62e80f7dd114c72171842691c3a237df7 100644 (file)
--- a/diff-cache.c
+++ b/diff-cache.c
@@ -240,12 +240,12 @@ int main(int argc, const char **argv)
                die("unable to read tree object %s", tree_name);
 
        ret = diff_cache(active_cache, active_nr);
                die("unable to read tree object %s", tree_name);
 
        ret = diff_cache(active_cache, active_nr);

+       if (pathspec)
+               diffcore_pathspec(pathspec);

        if (detect_rename)
                diffcore_rename(detect_rename, diff_score_opt);
        if (pickaxe)
                diffcore_pickaxe(pickaxe, pickaxe_opts);
        if (detect_rename)
                diffcore_rename(detect_rename, diff_score_opt);
        if (pickaxe)
                diffcore_pickaxe(pickaxe, pickaxe_opts);

-       if (pathspec)
-               diffcore_pathspec(pathspec);

        diff_flush(diff_output_format, 1);
        return ret;
 }
        diff_flush(diff_output_format, 1);
        return ret;
 }

diff --git a/diff-files.c b/diff-files.c
index cf7721928535e2350c1e32b34bc0ca5bc6e77aab..bd0eb95f85f1ebfd684e4177ca85c54b585da138 100644 (file)
--- a/diff-files.c
+++ b/diff-files.c
@@ -116,12 +116,12 @@ int main(int argc, const char **argv)
                show_modified(oldmode, mode, ce->sha1, null_sha1,
                              ce->name);
        }
                show_modified(oldmode, mode, ce->sha1, null_sha1,
                              ce->name);
        }

+       if (1 < argc)
+               diffcore_pathspec(argv + 1);

        if (detect_rename)
                diffcore_rename(detect_rename, diff_score_opt);
        if (pickaxe)
                diffcore_pickaxe(pickaxe, pickaxe_opts);
        if (detect_rename)
                diffcore_rename(detect_rename, diff_score_opt);
        if (pickaxe)
                diffcore_pickaxe(pickaxe, pickaxe_opts);

-       if (1 < argc)
-               diffcore_pathspec(argv + 1);

        diff_flush(diff_output_format, 1);
        return 0;
 }
        diff_flush(diff_output_format, 1);
        return 0;
 }

diff --git a/diff-helper.c b/diff-helper.c
index 03ac9104cd3348eda69d626d33089753ac0d3ed0..6456405b53bc9ff419e1133aa4da816fe761d911 100644 (file)
--- a/diff-helper.c
+++ b/diff-helper.c
@@ -129,17 +129,17 @@ int main(int ac, const char **av) {
                                          new_path);
                        continue;
                }
                                          new_path);
                        continue;
                }

-               if (pickaxe)
-                       diffcore_pickaxe(pickaxe, pickaxe_opts);

                if (1 < ac)
                        diffcore_pathspec(av + 1);
                if (1 < ac)
                        diffcore_pathspec(av + 1);

+               if (pickaxe)
+                       diffcore_pickaxe(pickaxe, pickaxe_opts);

                diff_flush(DIFF_FORMAT_PATCH, 0);
                printf("%s\n", sb.buf);
        }
                diff_flush(DIFF_FORMAT_PATCH, 0);
                printf("%s\n", sb.buf);
        }

-       if (pickaxe)
-               diffcore_pickaxe(pickaxe, pickaxe_opts);

        if (1 < ac)
                diffcore_pathspec(av + 1);
        if (1 < ac)
                diffcore_pathspec(av + 1);

+       if (pickaxe)
+               diffcore_pickaxe(pickaxe, pickaxe_opts);

        diff_flush(DIFF_FORMAT_PATCH, 0);
        return 0;
 }
        diff_flush(DIFF_FORMAT_PATCH, 0);
        return 0;
 }

diff --git a/t/t4007-rename-3.sh b/t/t4007-rename-3.sh
index cf18440977e4c7be49b1ef62c6906494c9ef57f1..518892b90c7cbb3fb193d6bfb622046aff0f4431 100644 (file)
--- a/t/t4007-rename-3.sh
+++ b/t/t4007-rename-3.sh
@@ -46,23 +46,23 @@ cat >expected <<\EOF
 EOF
 
 test_expect_success \
 EOF
 
 test_expect_success \

-    'validate the result' \
+    'validate the result (#1)' \

     'compare_diff_raw current expected'
 
 # In the tree, there is only path0/COPYING.  In the cache, path0 and
 # path1 both have COPYING and the latter is a copy of path0/COPYING.
     'compare_diff_raw current expected'
 
 # In the tree, there is only path0/COPYING.  In the cache, path0 and
 # path1 both have COPYING and the latter is a copy of path0/COPYING.

-# When we omit output from path0 it should still be able to tell us
-# that path1/COPYING is result from a copy from path0/COPYING, not
-# rename, which would imply path0/COPYING is now gone.
+# However when we say we care only about path1, we should just see
+# path1/COPYING suddenly appearing from nowhere, not detected as
+# a copy from path0/COPYING.

 
 git-diff-cache -C $tree path1 >current
 
 cat >expected <<\EOF
 
 git-diff-cache -C $tree path1 >current
 
 cat >expected <<\EOF

-:100644 100644 6ff87c4664981e4397625791c8ea3bbb5f2279a3 6ff87c4664981e4397625791c8ea3bbb5f2279a3 C100  path0/COPYING   path1/COPYING
+:000000 100644 0000000000000000000000000000000000000000 6ff87c4664981e4397625791c8ea3bbb5f2279a3 N     path1/COPYING

 EOF
 
 test_expect_success \
 EOF
 
 test_expect_success \

-    'validate the result' \
+    'validate the result (#2)' \

     'compare_diff_raw current expected'
 
 test_expect_success \
     'compare_diff_raw current expected'
 
 test_expect_success \


@@ -82,22 +82,22 @@ cat >expected <<\EOF
 EOF
 
 test_expect_success \
 EOF
 
 test_expect_success \

-    'validate the result' \
+    'validate the result (#3)' \

     'compare_diff_raw current expected'
 
 # In the tree, there is only path0/COPYING.  In the cache, path0 does
 # not have COPYING anymore and path1 has COPYING which is a copy of
     'compare_diff_raw current expected'
 
 # In the tree, there is only path0/COPYING.  In the cache, path0 does
 # not have COPYING anymore and path1 has COPYING which is a copy of

-# path0/COPYING.  Even if we restrict the output to path1, it still
-# should show us the rename.
+# path0/COPYING.  When we say we care only about path1, we should just
+# see path1/COPYING appearing from nowhere.

 
 git-diff-cache -C $tree path1 >current
 
 cat >expected <<\EOF
 
 git-diff-cache -C $tree path1 >current
 
 cat >expected <<\EOF

-:100644 100644 6ff87c4664981e4397625791c8ea3bbb5f2279a3 6ff87c4664981e4397625791c8ea3bbb5f2279a3 R100  path0/COPYING   path1/COPYING
+:000000 100644 0000000000000000000000000000000000000000 6ff87c4664981e4397625791c8ea3bbb5f2279a3 N     path1/COPYING

 EOF
 
 test_expect_success \
 EOF
 
 test_expect_success \

-    'validate the result' \
+    'validate the result (#4)' \

     'compare_diff_raw current expected'
 
 test_done
     'compare_diff_raw current expected'
 
 test_done