clean: teach clean -d to preserve ignored paths

There is an implicit assumption that a directory containing only
untracked and ignored paths should itself be considered untracked. This
makes sense in use cases where we're asking if a directory should be
added to the git database, but not when we're asking if a directory can
be safely removed from the working tree; as a result, clean -d would
assume that an "untracked" directory containing ignored paths could be
deleted, even though doing so would also remove the ignored paths.

To get around this, we teach clean -d to collect ignored paths and skip
an untracked directory if it contained an ignored path, instead just
removing the untracked contents thereof. To achieve this, cmd_clean()
has to collect all untracked contents of untracked directories, in
addition to all ignored paths, to determine which untracked dirs must be
skipped (because they contain ignored paths) and which ones should *not*
be skipped.

For this purpose, correct_untracked_entries() is introduced to prune a
given dir_struct of untracked entries containing ignored paths and those
untracked entries encompassed by the untracked entries which are not
pruned away.

A memory leak is also fixed in cmd_clean().

This also fixes the known breakage in t7300, since clean -d now skips
untracked directories containing ignored paths.

Signed-off-by: Samuel Lijin <sxlijin@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/builtin/clean.c b/builtin/clean.c
index d6bc3aaaea0dfdbac2386d54f4ff2d25dbccf7e6..727203318726bf3e6dbd7a6881391d233b4f106e 100644 (file)
--- a/builtin/clean.c
+++ b/builtin/clean.c
@@ -851,6 +851,38 @@ static void interactive_main_loop(void)
        }
 }
 
        }
 }
 

+static void correct_untracked_entries(struct dir_struct *dir)
+{
+       int src, dst, ign;
+
+       for (src = dst = ign = 0; src < dir->nr; src++) {
+               /* skip paths in ignored[] that cannot be inside entries[src] */
+               while (ign < dir->ignored_nr &&
+                      0 <= cmp_dir_entry(&dir->entries[src], &dir->ignored[ign]))
+                       ign++;
+
+               if (ign < dir->ignored_nr &&
+                   check_dir_entry_contains(dir->entries[src], dir->ignored[ign])) {
+                       /* entries[src] contains an ignored path, so we drop it */
+                       free(dir->entries[src]);
+               } else {
+                       struct dir_entry *ent = dir->entries[src++];
+
+                       /* entries[src] does not contain an ignored path, so we keep it */
+                       dir->entries[dst++] = ent;
+
+                       /* then discard paths in entries[] contained inside entries[src] */
+                       while (src < dir->nr &&
+                              check_dir_entry_contains(ent, dir->entries[src]))
+                               free(dir->entries[src++]);
+
+                       /* compensate for the outer loop's loop control */
+                       src--;
+               }
+       }
+       dir->nr = dst;
+}
+

 int cmd_clean(int argc, const char **argv, const char *prefix)
 {
        int i, res;
 int cmd_clean(int argc, const char **argv, const char *prefix)
 {
        int i, res;


@@ -910,6 +942,9 @@ int cmd_clean(int argc, const char **argv, const char *prefix)
 
        dir.flags |= DIR_SHOW_OTHER_DIRECTORIES;
 
 
        dir.flags |= DIR_SHOW_OTHER_DIRECTORIES;
 

+       if (remove_directories)
+               dir.flags |= DIR_SHOW_IGNORED_TOO | DIR_KEEP_UNTRACKED_CONTENTS;
+

        if (read_cache() < 0)
                die(_("index file corrupt"));
 
        if (read_cache() < 0)
                die(_("index file corrupt"));
 


@@ -925,6 +960,7 @@ int cmd_clean(int argc, const char **argv, const char *prefix)
                       prefix, argv);
 
        fill_directory(&dir, &pathspec);
                       prefix, argv);
 
        fill_directory(&dir, &pathspec);

+       correct_untracked_entries(&dir);

 
        for (i = 0; i < dir.nr; i++) {
                struct dir_entry *ent = dir.entries[i];
 
        for (i = 0; i < dir.nr; i++) {
                struct dir_entry *ent = dir.entries[i];


@@ -952,6 +988,12 @@ int cmd_clean(int argc, const char **argv, const char *prefix)
                string_list_append(&del_list, rel);
        }
 
                string_list_append(&del_list, rel);
        }
 

+       for (i = 0; i < dir.nr; i++)
+               free(dir.entries[i]);
+
+       for (i = 0; i < dir.ignored_nr; i++)
+               free(dir.ignored[i]);
+

        if (interactive && del_list.nr > 0)
                interactive_main_loop();
 
        if (interactive && del_list.nr > 0)
                interactive_main_loop();
 

diff --git a/t/t7300-clean.sh b/t/t7300-clean.sh
index 3a2d709c2977ea3c9b735a3b56caf9d16274fdd3..7b36954d63d70e79149cf1558a93586e1b39c867 100755 (executable)
--- a/t/t7300-clean.sh
+++ b/t/t7300-clean.sh
@@ -653,7 +653,7 @@ test_expect_success 'git clean -d respects pathspecs (pathspec is prefix of dir)
        test_path_is_dir foobar
 '
 
        test_path_is_dir foobar
 '
 

-test_expect_failure 'git clean -d skips untracked dirs containing ignored files' '
+test_expect_success 'git clean -d skips untracked dirs containing ignored files' '

        echo /foo/bar >.gitignore &&
        echo ignoreme >>.gitignore &&
        rm -rf foo &&
        echo /foo/bar >.gitignore &&
        echo ignoreme >>.gitignore &&
        rm -rf foo &&