2007-11-12 01:48:47 +00:00
|
|
|
/*
|
|
|
|
* "git clean" builtin command
|
|
|
|
*
|
|
|
|
* Copyright (C) 2007 Shawn Bohrer
|
|
|
|
*
|
|
|
|
* Based on git-clean.sh by Pavel Roskin
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "builtin.h"
|
|
|
|
#include "cache.h"
|
|
|
|
#include "dir.h"
|
|
|
|
#include "parse-options.h"
|
git-clean: Display more accurate delete messages
(1) Only print out the names of the files and directories that got
actually deleted. Also do not mention that we are not removing
directories when the user did not ask us to do so with '-d'.
(2) Show ignore message for skipped untracked git repositories.
Consider the following repo layout:
test.git/
|-- tracked_dir/
| |-- some_tracked_file
| |-- some_untracked_file
|-- tracked_file
|-- untracked_file
|-- untracked_foo/
| |-- bar/
| | |-- bar.txt
| |-- emptydir/
| |-- frotz.git/
| |-- frotz.tx
|-- untracked_some.git/
|-- some.txt
Suppose the user issues 'git clean -fd' from the test.git directory.
When -d option is used and untracked directory 'foo' contains a
subdirectory 'frotz.git' that is managed by a different git repository
therefore it will not be removed.
$ git clean -fd
Removing tracked_dir/some_untracked_file
Removing untracked_file
Removing untracked_foo/
Removing untracked_some.git/
The message displayed to the user is slightly misleading. The foo/
directory has not been removed because of foo/frotz.git still exists.
On the other hand the subdirectories 'bar' and 'emptydir' have been
deleted but they're not mentioned anywhere. Also, untracked_some.git
has not been removed either.
This behaviour is the result of the way the deletion of untracked
directories are reported. In the current implementation they are
deleted recursively but only the name of the top most directory is
printed out. The calling function does not know about any
subdirectories that could not be removed during the recursion.
Improve the way the deleted directories are reported back to
the user:
(1) Create a recursive delete function 'remove_dirs' in builtin/clean.c
to run in both dry_run and delete modes with the delete logic as
follows:
(a) Check if the current directory to be deleted is an untracked
git repository. If it is and --force --force option is not set
do not touch this directory, print ignore message, set dir_gone
flag to false for the caller and return.
(b) Otherwise for each item in current directory:
(i) If current directory cannot be accessed, print warning,
set dir_gone flag to false and return.
(ii) If the item is a subdirectory recurse into it,
check for the returned value of the dir_gone flag.
If the subdirectory is gone, add the name of the deleted
directory to a list of successfully removed items 'dels'.
Else set the dir_gone flag as the current directory
cannot be removed because we have at least one subdirectory
hanging around.
(iii) If it is a file try to remove it. If success add the
file name to the 'dels' list, else print error and set
dir_gone flag to false.
(c) After we finished deleting all items in the current directory and
the dir_gone flag is still true, remove the directory itself.
If failed set the dir_gone flag to false.
(d) If the current directory cannot be deleted because the dir_gone flag
has been set to false, print out all the successfully deleted items
for this directory from the 'dels' list.
(e) We're done with the current directory, return.
(2) Modify the cmd_clean() function to:
(a) call the recursive delete function 'remove_dirs()' for each
topmost directory it wants to remove
(b) check for the returned value of dir_gone flag. If it's true
print the name of the directory as being removed.
Consider the output of the improved version:
$ git clean -fd
Removing tracked_dir/some_untracked_file
Removing untracked_file
Skipping repository untracked_foo/frotz.git
Removing untracked_foo/bar
Removing untracked_foo/emptydir
Skipping repository untracked_some.git/
Now it displays only the file and directory names that got actually
deleted and shows the name of the untracked git repositories it ignored.
Reported-by: Soren Brinkmann <soren.brinkmann@xilinx.com>
Signed-off-by: Zoltan Klinger <zoltan.klinger@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-01-10 22:53:46 +00:00
|
|
|
#include "refs.h"
|
2010-07-20 19:35:56 +00:00
|
|
|
#include "string-list.h"
|
2008-03-07 01:13:17 +00:00
|
|
|
#include "quote.h"
|
2007-11-12 01:48:47 +00:00
|
|
|
|
2007-11-13 05:13:05 +00:00
|
|
|
static int force = -1; /* unset */
|
2007-11-12 01:48:47 +00:00
|
|
|
|
|
|
|
static const char *const builtin_clean_usage[] = {
|
2012-08-20 12:32:01 +00:00
|
|
|
N_("git clean [-d] [-f] [-n] [-q] [-e <pattern>] [-x | -X] [--] <paths>..."),
|
2007-11-12 01:48:47 +00:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
git-clean: Display more accurate delete messages
(1) Only print out the names of the files and directories that got
actually deleted. Also do not mention that we are not removing
directories when the user did not ask us to do so with '-d'.
(2) Show ignore message for skipped untracked git repositories.
Consider the following repo layout:
test.git/
|-- tracked_dir/
| |-- some_tracked_file
| |-- some_untracked_file
|-- tracked_file
|-- untracked_file
|-- untracked_foo/
| |-- bar/
| | |-- bar.txt
| |-- emptydir/
| |-- frotz.git/
| |-- frotz.tx
|-- untracked_some.git/
|-- some.txt
Suppose the user issues 'git clean -fd' from the test.git directory.
When -d option is used and untracked directory 'foo' contains a
subdirectory 'frotz.git' that is managed by a different git repository
therefore it will not be removed.
$ git clean -fd
Removing tracked_dir/some_untracked_file
Removing untracked_file
Removing untracked_foo/
Removing untracked_some.git/
The message displayed to the user is slightly misleading. The foo/
directory has not been removed because of foo/frotz.git still exists.
On the other hand the subdirectories 'bar' and 'emptydir' have been
deleted but they're not mentioned anywhere. Also, untracked_some.git
has not been removed either.
This behaviour is the result of the way the deletion of untracked
directories are reported. In the current implementation they are
deleted recursively but only the name of the top most directory is
printed out. The calling function does not know about any
subdirectories that could not be removed during the recursion.
Improve the way the deleted directories are reported back to
the user:
(1) Create a recursive delete function 'remove_dirs' in builtin/clean.c
to run in both dry_run and delete modes with the delete logic as
follows:
(a) Check if the current directory to be deleted is an untracked
git repository. If it is and --force --force option is not set
do not touch this directory, print ignore message, set dir_gone
flag to false for the caller and return.
(b) Otherwise for each item in current directory:
(i) If current directory cannot be accessed, print warning,
set dir_gone flag to false and return.
(ii) If the item is a subdirectory recurse into it,
check for the returned value of the dir_gone flag.
If the subdirectory is gone, add the name of the deleted
directory to a list of successfully removed items 'dels'.
Else set the dir_gone flag as the current directory
cannot be removed because we have at least one subdirectory
hanging around.
(iii) If it is a file try to remove it. If success add the
file name to the 'dels' list, else print error and set
dir_gone flag to false.
(c) After we finished deleting all items in the current directory and
the dir_gone flag is still true, remove the directory itself.
If failed set the dir_gone flag to false.
(d) If the current directory cannot be deleted because the dir_gone flag
has been set to false, print out all the successfully deleted items
for this directory from the 'dels' list.
(e) We're done with the current directory, return.
(2) Modify the cmd_clean() function to:
(a) call the recursive delete function 'remove_dirs()' for each
topmost directory it wants to remove
(b) check for the returned value of dir_gone flag. If it's true
print the name of the directory as being removed.
Consider the output of the improved version:
$ git clean -fd
Removing tracked_dir/some_untracked_file
Removing untracked_file
Skipping repository untracked_foo/frotz.git
Removing untracked_foo/bar
Removing untracked_foo/emptydir
Skipping repository untracked_some.git/
Now it displays only the file and directory names that got actually
deleted and shows the name of the untracked git repositories it ignored.
Reported-by: Soren Brinkmann <soren.brinkmann@xilinx.com>
Signed-off-by: Zoltan Klinger <zoltan.klinger@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-01-10 22:53:46 +00:00
|
|
|
static const char *msg_remove = N_("Removing %s\n");
|
|
|
|
static const char *msg_would_remove = N_("Would remove %s\n");
|
|
|
|
static const char *msg_skip_git_dir = N_("Skipping repository %s\n");
|
|
|
|
static const char *msg_would_skip_git_dir = N_("Would skip repository %s\n");
|
|
|
|
static const char *msg_warn_remove_failed = N_("failed to remove %s");
|
|
|
|
|
2008-05-14 17:46:53 +00:00
|
|
|
static int git_clean_config(const char *var, const char *value, void *cb)
|
2007-11-12 01:48:47 +00:00
|
|
|
{
|
|
|
|
if (!strcmp(var, "clean.requireforce"))
|
|
|
|
force = !git_config_bool(var, value);
|
2008-05-14 17:46:53 +00:00
|
|
|
return git_default_config(var, value, cb);
|
2007-11-12 01:48:47 +00:00
|
|
|
}
|
|
|
|
|
2010-07-20 19:35:56 +00:00
|
|
|
static int exclude_cb(const struct option *opt, const char *arg, int unset)
|
|
|
|
{
|
|
|
|
struct string_list *exclude_list = opt->value;
|
|
|
|
string_list_append(exclude_list, arg);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
git-clean: Display more accurate delete messages
(1) Only print out the names of the files and directories that got
actually deleted. Also do not mention that we are not removing
directories when the user did not ask us to do so with '-d'.
(2) Show ignore message for skipped untracked git repositories.
Consider the following repo layout:
test.git/
|-- tracked_dir/
| |-- some_tracked_file
| |-- some_untracked_file
|-- tracked_file
|-- untracked_file
|-- untracked_foo/
| |-- bar/
| | |-- bar.txt
| |-- emptydir/
| |-- frotz.git/
| |-- frotz.tx
|-- untracked_some.git/
|-- some.txt
Suppose the user issues 'git clean -fd' from the test.git directory.
When -d option is used and untracked directory 'foo' contains a
subdirectory 'frotz.git' that is managed by a different git repository
therefore it will not be removed.
$ git clean -fd
Removing tracked_dir/some_untracked_file
Removing untracked_file
Removing untracked_foo/
Removing untracked_some.git/
The message displayed to the user is slightly misleading. The foo/
directory has not been removed because of foo/frotz.git still exists.
On the other hand the subdirectories 'bar' and 'emptydir' have been
deleted but they're not mentioned anywhere. Also, untracked_some.git
has not been removed either.
This behaviour is the result of the way the deletion of untracked
directories are reported. In the current implementation they are
deleted recursively but only the name of the top most directory is
printed out. The calling function does not know about any
subdirectories that could not be removed during the recursion.
Improve the way the deleted directories are reported back to
the user:
(1) Create a recursive delete function 'remove_dirs' in builtin/clean.c
to run in both dry_run and delete modes with the delete logic as
follows:
(a) Check if the current directory to be deleted is an untracked
git repository. If it is and --force --force option is not set
do not touch this directory, print ignore message, set dir_gone
flag to false for the caller and return.
(b) Otherwise for each item in current directory:
(i) If current directory cannot be accessed, print warning,
set dir_gone flag to false and return.
(ii) If the item is a subdirectory recurse into it,
check for the returned value of the dir_gone flag.
If the subdirectory is gone, add the name of the deleted
directory to a list of successfully removed items 'dels'.
Else set the dir_gone flag as the current directory
cannot be removed because we have at least one subdirectory
hanging around.
(iii) If it is a file try to remove it. If success add the
file name to the 'dels' list, else print error and set
dir_gone flag to false.
(c) After we finished deleting all items in the current directory and
the dir_gone flag is still true, remove the directory itself.
If failed set the dir_gone flag to false.
(d) If the current directory cannot be deleted because the dir_gone flag
has been set to false, print out all the successfully deleted items
for this directory from the 'dels' list.
(e) We're done with the current directory, return.
(2) Modify the cmd_clean() function to:
(a) call the recursive delete function 'remove_dirs()' for each
topmost directory it wants to remove
(b) check for the returned value of dir_gone flag. If it's true
print the name of the directory as being removed.
Consider the output of the improved version:
$ git clean -fd
Removing tracked_dir/some_untracked_file
Removing untracked_file
Skipping repository untracked_foo/frotz.git
Removing untracked_foo/bar
Removing untracked_foo/emptydir
Skipping repository untracked_some.git/
Now it displays only the file and directory names that got actually
deleted and shows the name of the untracked git repositories it ignored.
Reported-by: Soren Brinkmann <soren.brinkmann@xilinx.com>
Signed-off-by: Zoltan Klinger <zoltan.klinger@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-01-10 22:53:46 +00:00
|
|
|
static int remove_dirs(struct strbuf *path, const char *prefix, int force_flag,
|
|
|
|
int dry_run, int quiet, int *dir_gone)
|
|
|
|
{
|
|
|
|
DIR *dir;
|
|
|
|
struct strbuf quoted = STRBUF_INIT;
|
|
|
|
struct dirent *e;
|
|
|
|
int res = 0, ret = 0, gone = 1, original_len = path->len, len, i;
|
|
|
|
unsigned char submodule_head[20];
|
|
|
|
struct string_list dels = STRING_LIST_INIT_DUP;
|
|
|
|
|
|
|
|
*dir_gone = 1;
|
|
|
|
|
|
|
|
if ((force_flag & REMOVE_DIR_KEEP_NESTED_GIT) &&
|
|
|
|
!resolve_gitlink_ref(path->buf, "HEAD", submodule_head)) {
|
|
|
|
if (!quiet) {
|
|
|
|
quote_path_relative(path->buf, strlen(path->buf), "ed, prefix);
|
|
|
|
printf(dry_run ? _(msg_would_skip_git_dir) : _(msg_skip_git_dir),
|
|
|
|
quoted.buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
*dir_gone = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
dir = opendir(path->buf);
|
|
|
|
if (!dir) {
|
|
|
|
/* an empty dir could be removed even if it is unreadble */
|
|
|
|
res = dry_run ? 0 : rmdir(path->buf);
|
|
|
|
if (res) {
|
|
|
|
quote_path_relative(path->buf, strlen(path->buf), "ed, prefix);
|
|
|
|
warning(_(msg_warn_remove_failed), quoted.buf);
|
|
|
|
*dir_gone = 0;
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (path->buf[original_len - 1] != '/')
|
|
|
|
strbuf_addch(path, '/');
|
|
|
|
|
|
|
|
len = path->len;
|
|
|
|
while ((e = readdir(dir)) != NULL) {
|
|
|
|
struct stat st;
|
|
|
|
if (is_dot_or_dotdot(e->d_name))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
strbuf_setlen(path, len);
|
|
|
|
strbuf_addstr(path, e->d_name);
|
|
|
|
if (lstat(path->buf, &st))
|
|
|
|
; /* fall thru */
|
|
|
|
else if (S_ISDIR(st.st_mode)) {
|
|
|
|
if (remove_dirs(path, prefix, force_flag, dry_run, quiet, &gone))
|
|
|
|
ret = 1;
|
|
|
|
if (gone) {
|
|
|
|
quote_path_relative(path->buf, strlen(path->buf), "ed, prefix);
|
|
|
|
string_list_append(&dels, quoted.buf);
|
|
|
|
} else
|
|
|
|
*dir_gone = 0;
|
|
|
|
continue;
|
|
|
|
} else {
|
|
|
|
res = dry_run ? 0 : unlink(path->buf);
|
|
|
|
if (!res) {
|
|
|
|
quote_path_relative(path->buf, strlen(path->buf), "ed, prefix);
|
|
|
|
string_list_append(&dels, quoted.buf);
|
|
|
|
} else {
|
|
|
|
quote_path_relative(path->buf, strlen(path->buf), "ed, prefix);
|
|
|
|
warning(_(msg_warn_remove_failed), quoted.buf);
|
|
|
|
*dir_gone = 0;
|
|
|
|
ret = 1;
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* path too long, stat fails, or non-directory still exists */
|
|
|
|
*dir_gone = 0;
|
|
|
|
ret = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
closedir(dir);
|
|
|
|
|
|
|
|
strbuf_setlen(path, original_len);
|
|
|
|
|
|
|
|
if (*dir_gone) {
|
|
|
|
res = dry_run ? 0 : rmdir(path->buf);
|
|
|
|
if (!res)
|
|
|
|
*dir_gone = 1;
|
|
|
|
else {
|
|
|
|
quote_path_relative(path->buf, strlen(path->buf), "ed, prefix);
|
|
|
|
warning(_(msg_warn_remove_failed), quoted.buf);
|
|
|
|
*dir_gone = 0;
|
|
|
|
ret = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!*dir_gone && !quiet) {
|
|
|
|
for (i = 0; i < dels.nr; i++)
|
|
|
|
printf(dry_run ? _(msg_would_remove) : _(msg_remove), dels.items[i].string);
|
|
|
|
}
|
|
|
|
string_list_clear(&dels, 0);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-11-12 01:48:47 +00:00
|
|
|
int cmd_clean(int argc, const char **argv, const char *prefix)
|
|
|
|
{
|
git-clean: Display more accurate delete messages
(1) Only print out the names of the files and directories that got
actually deleted. Also do not mention that we are not removing
directories when the user did not ask us to do so with '-d'.
(2) Show ignore message for skipped untracked git repositories.
Consider the following repo layout:
test.git/
|-- tracked_dir/
| |-- some_tracked_file
| |-- some_untracked_file
|-- tracked_file
|-- untracked_file
|-- untracked_foo/
| |-- bar/
| | |-- bar.txt
| |-- emptydir/
| |-- frotz.git/
| |-- frotz.tx
|-- untracked_some.git/
|-- some.txt
Suppose the user issues 'git clean -fd' from the test.git directory.
When -d option is used and untracked directory 'foo' contains a
subdirectory 'frotz.git' that is managed by a different git repository
therefore it will not be removed.
$ git clean -fd
Removing tracked_dir/some_untracked_file
Removing untracked_file
Removing untracked_foo/
Removing untracked_some.git/
The message displayed to the user is slightly misleading. The foo/
directory has not been removed because of foo/frotz.git still exists.
On the other hand the subdirectories 'bar' and 'emptydir' have been
deleted but they're not mentioned anywhere. Also, untracked_some.git
has not been removed either.
This behaviour is the result of the way the deletion of untracked
directories are reported. In the current implementation they are
deleted recursively but only the name of the top most directory is
printed out. The calling function does not know about any
subdirectories that could not be removed during the recursion.
Improve the way the deleted directories are reported back to
the user:
(1) Create a recursive delete function 'remove_dirs' in builtin/clean.c
to run in both dry_run and delete modes with the delete logic as
follows:
(a) Check if the current directory to be deleted is an untracked
git repository. If it is and --force --force option is not set
do not touch this directory, print ignore message, set dir_gone
flag to false for the caller and return.
(b) Otherwise for each item in current directory:
(i) If current directory cannot be accessed, print warning,
set dir_gone flag to false and return.
(ii) If the item is a subdirectory recurse into it,
check for the returned value of the dir_gone flag.
If the subdirectory is gone, add the name of the deleted
directory to a list of successfully removed items 'dels'.
Else set the dir_gone flag as the current directory
cannot be removed because we have at least one subdirectory
hanging around.
(iii) If it is a file try to remove it. If success add the
file name to the 'dels' list, else print error and set
dir_gone flag to false.
(c) After we finished deleting all items in the current directory and
the dir_gone flag is still true, remove the directory itself.
If failed set the dir_gone flag to false.
(d) If the current directory cannot be deleted because the dir_gone flag
has been set to false, print out all the successfully deleted items
for this directory from the 'dels' list.
(e) We're done with the current directory, return.
(2) Modify the cmd_clean() function to:
(a) call the recursive delete function 'remove_dirs()' for each
topmost directory it wants to remove
(b) check for the returned value of dir_gone flag. If it's true
print the name of the directory as being removed.
Consider the output of the improved version:
$ git clean -fd
Removing tracked_dir/some_untracked_file
Removing untracked_file
Skipping repository untracked_foo/frotz.git
Removing untracked_foo/bar
Removing untracked_foo/emptydir
Skipping repository untracked_some.git/
Now it displays only the file and directory names that got actually
deleted and shows the name of the untracked git repositories it ignored.
Reported-by: Soren Brinkmann <soren.brinkmann@xilinx.com>
Signed-off-by: Zoltan Klinger <zoltan.klinger@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-01-10 22:53:46 +00:00
|
|
|
int i, res;
|
|
|
|
int dry_run = 0, remove_directories = 0, quiet = 0, ignored = 0;
|
|
|
|
int ignored_only = 0, config_set = 0, errors = 0, gone = 1;
|
2009-06-30 22:33:45 +00:00
|
|
|
int rm_flags = REMOVE_DIR_KEEP_NESTED_GIT;
|
2008-10-09 19:12:12 +00:00
|
|
|
struct strbuf directory = STRBUF_INIT;
|
2007-11-12 01:48:47 +00:00
|
|
|
struct dir_struct dir;
|
|
|
|
static const char **pathspec;
|
2008-10-09 19:12:12 +00:00
|
|
|
struct strbuf buf = STRBUF_INIT;
|
2010-09-06 23:32:55 +00:00
|
|
|
struct string_list exclude_list = STRING_LIST_INIT_NODUP;
|
2013-01-16 13:25:58 +00:00
|
|
|
struct exclude_list *el;
|
2008-03-07 01:13:17 +00:00
|
|
|
const char *qname;
|
2007-12-05 07:55:41 +00:00
|
|
|
char *seen = NULL;
|
2007-11-12 01:48:47 +00:00
|
|
|
struct option options[] = {
|
2012-08-20 12:32:01 +00:00
|
|
|
OPT__QUIET(&quiet, N_("do not print names of files removed")),
|
git-clean: Display more accurate delete messages
(1) Only print out the names of the files and directories that got
actually deleted. Also do not mention that we are not removing
directories when the user did not ask us to do so with '-d'.
(2) Show ignore message for skipped untracked git repositories.
Consider the following repo layout:
test.git/
|-- tracked_dir/
| |-- some_tracked_file
| |-- some_untracked_file
|-- tracked_file
|-- untracked_file
|-- untracked_foo/
| |-- bar/
| | |-- bar.txt
| |-- emptydir/
| |-- frotz.git/
| |-- frotz.tx
|-- untracked_some.git/
|-- some.txt
Suppose the user issues 'git clean -fd' from the test.git directory.
When -d option is used and untracked directory 'foo' contains a
subdirectory 'frotz.git' that is managed by a different git repository
therefore it will not be removed.
$ git clean -fd
Removing tracked_dir/some_untracked_file
Removing untracked_file
Removing untracked_foo/
Removing untracked_some.git/
The message displayed to the user is slightly misleading. The foo/
directory has not been removed because of foo/frotz.git still exists.
On the other hand the subdirectories 'bar' and 'emptydir' have been
deleted but they're not mentioned anywhere. Also, untracked_some.git
has not been removed either.
This behaviour is the result of the way the deletion of untracked
directories are reported. In the current implementation they are
deleted recursively but only the name of the top most directory is
printed out. The calling function does not know about any
subdirectories that could not be removed during the recursion.
Improve the way the deleted directories are reported back to
the user:
(1) Create a recursive delete function 'remove_dirs' in builtin/clean.c
to run in both dry_run and delete modes with the delete logic as
follows:
(a) Check if the current directory to be deleted is an untracked
git repository. If it is and --force --force option is not set
do not touch this directory, print ignore message, set dir_gone
flag to false for the caller and return.
(b) Otherwise for each item in current directory:
(i) If current directory cannot be accessed, print warning,
set dir_gone flag to false and return.
(ii) If the item is a subdirectory recurse into it,
check for the returned value of the dir_gone flag.
If the subdirectory is gone, add the name of the deleted
directory to a list of successfully removed items 'dels'.
Else set the dir_gone flag as the current directory
cannot be removed because we have at least one subdirectory
hanging around.
(iii) If it is a file try to remove it. If success add the
file name to the 'dels' list, else print error and set
dir_gone flag to false.
(c) After we finished deleting all items in the current directory and
the dir_gone flag is still true, remove the directory itself.
If failed set the dir_gone flag to false.
(d) If the current directory cannot be deleted because the dir_gone flag
has been set to false, print out all the successfully deleted items
for this directory from the 'dels' list.
(e) We're done with the current directory, return.
(2) Modify the cmd_clean() function to:
(a) call the recursive delete function 'remove_dirs()' for each
topmost directory it wants to remove
(b) check for the returned value of dir_gone flag. If it's true
print the name of the directory as being removed.
Consider the output of the improved version:
$ git clean -fd
Removing tracked_dir/some_untracked_file
Removing untracked_file
Skipping repository untracked_foo/frotz.git
Removing untracked_foo/bar
Removing untracked_foo/emptydir
Skipping repository untracked_some.git/
Now it displays only the file and directory names that got actually
deleted and shows the name of the untracked git repositories it ignored.
Reported-by: Soren Brinkmann <soren.brinkmann@xilinx.com>
Signed-off-by: Zoltan Klinger <zoltan.klinger@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-01-10 22:53:46 +00:00
|
|
|
OPT__DRY_RUN(&dry_run, N_("dry run")),
|
2012-08-20 12:32:01 +00:00
|
|
|
OPT__FORCE(&force, N_("force")),
|
2007-11-12 01:48:47 +00:00
|
|
|
OPT_BOOLEAN('d', NULL, &remove_directories,
|
2012-08-20 12:32:01 +00:00
|
|
|
N_("remove whole directories")),
|
|
|
|
{ OPTION_CALLBACK, 'e', "exclude", &exclude_list, N_("pattern"),
|
|
|
|
N_("add <pattern> to ignore rules"), PARSE_OPT_NONEG, exclude_cb },
|
|
|
|
OPT_BOOLEAN('x', NULL, &ignored, N_("remove ignored files, too")),
|
2007-11-12 01:48:47 +00:00
|
|
|
OPT_BOOLEAN('X', NULL, &ignored_only,
|
2012-08-20 12:32:01 +00:00
|
|
|
N_("remove only ignored files")),
|
2007-11-12 01:48:47 +00:00
|
|
|
OPT_END()
|
|
|
|
};
|
|
|
|
|
2008-05-14 17:46:53 +00:00
|
|
|
git_config(git_clean_config, NULL);
|
2007-11-13 05:13:05 +00:00
|
|
|
if (force < 0)
|
|
|
|
force = 0;
|
|
|
|
else
|
|
|
|
config_set = 1;
|
|
|
|
|
2009-05-23 18:53:12 +00:00
|
|
|
argc = parse_options(argc, argv, prefix, options, builtin_clean_usage,
|
|
|
|
0);
|
2007-11-12 01:48:47 +00:00
|
|
|
|
|
|
|
memset(&dir, 0, sizeof(dir));
|
2007-11-15 05:00:54 +00:00
|
|
|
if (ignored_only)
|
2009-02-16 12:20:25 +00:00
|
|
|
dir.flags |= DIR_SHOW_IGNORED;
|
2007-11-12 01:48:47 +00:00
|
|
|
|
|
|
|
if (ignored && ignored_only)
|
2011-02-22 23:42:21 +00:00
|
|
|
die(_("-x and -X cannot be used together"));
|
2007-11-12 01:48:47 +00:00
|
|
|
|
git-clean: Display more accurate delete messages
(1) Only print out the names of the files and directories that got
actually deleted. Also do not mention that we are not removing
directories when the user did not ask us to do so with '-d'.
(2) Show ignore message for skipped untracked git repositories.
Consider the following repo layout:
test.git/
|-- tracked_dir/
| |-- some_tracked_file
| |-- some_untracked_file
|-- tracked_file
|-- untracked_file
|-- untracked_foo/
| |-- bar/
| | |-- bar.txt
| |-- emptydir/
| |-- frotz.git/
| |-- frotz.tx
|-- untracked_some.git/
|-- some.txt
Suppose the user issues 'git clean -fd' from the test.git directory.
When -d option is used and untracked directory 'foo' contains a
subdirectory 'frotz.git' that is managed by a different git repository
therefore it will not be removed.
$ git clean -fd
Removing tracked_dir/some_untracked_file
Removing untracked_file
Removing untracked_foo/
Removing untracked_some.git/
The message displayed to the user is slightly misleading. The foo/
directory has not been removed because of foo/frotz.git still exists.
On the other hand the subdirectories 'bar' and 'emptydir' have been
deleted but they're not mentioned anywhere. Also, untracked_some.git
has not been removed either.
This behaviour is the result of the way the deletion of untracked
directories are reported. In the current implementation they are
deleted recursively but only the name of the top most directory is
printed out. The calling function does not know about any
subdirectories that could not be removed during the recursion.
Improve the way the deleted directories are reported back to
the user:
(1) Create a recursive delete function 'remove_dirs' in builtin/clean.c
to run in both dry_run and delete modes with the delete logic as
follows:
(a) Check if the current directory to be deleted is an untracked
git repository. If it is and --force --force option is not set
do not touch this directory, print ignore message, set dir_gone
flag to false for the caller and return.
(b) Otherwise for each item in current directory:
(i) If current directory cannot be accessed, print warning,
set dir_gone flag to false and return.
(ii) If the item is a subdirectory recurse into it,
check for the returned value of the dir_gone flag.
If the subdirectory is gone, add the name of the deleted
directory to a list of successfully removed items 'dels'.
Else set the dir_gone flag as the current directory
cannot be removed because we have at least one subdirectory
hanging around.
(iii) If it is a file try to remove it. If success add the
file name to the 'dels' list, else print error and set
dir_gone flag to false.
(c) After we finished deleting all items in the current directory and
the dir_gone flag is still true, remove the directory itself.
If failed set the dir_gone flag to false.
(d) If the current directory cannot be deleted because the dir_gone flag
has been set to false, print out all the successfully deleted items
for this directory from the 'dels' list.
(e) We're done with the current directory, return.
(2) Modify the cmd_clean() function to:
(a) call the recursive delete function 'remove_dirs()' for each
topmost directory it wants to remove
(b) check for the returned value of dir_gone flag. If it's true
print the name of the directory as being removed.
Consider the output of the improved version:
$ git clean -fd
Removing tracked_dir/some_untracked_file
Removing untracked_file
Skipping repository untracked_foo/frotz.git
Removing untracked_foo/bar
Removing untracked_foo/emptydir
Skipping repository untracked_some.git/
Now it displays only the file and directory names that got actually
deleted and shows the name of the untracked git repositories it ignored.
Reported-by: Soren Brinkmann <soren.brinkmann@xilinx.com>
Signed-off-by: Zoltan Klinger <zoltan.klinger@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-01-10 22:53:46 +00:00
|
|
|
if (!dry_run && !force) {
|
2011-02-22 23:42:22 +00:00
|
|
|
if (config_set)
|
|
|
|
die(_("clean.requireForce set to true and neither -n nor -f given; "
|
|
|
|
"refusing to clean"));
|
|
|
|
else
|
|
|
|
die(_("clean.requireForce defaults to true and neither -n nor -f given; "
|
|
|
|
"refusing to clean"));
|
|
|
|
}
|
2007-11-12 01:48:47 +00:00
|
|
|
|
2009-06-30 22:33:45 +00:00
|
|
|
if (force > 1)
|
|
|
|
rm_flags = 0;
|
|
|
|
|
2009-02-16 12:20:25 +00:00
|
|
|
dir.flags |= DIR_SHOW_OTHER_DIRECTORIES;
|
2007-11-12 01:48:47 +00:00
|
|
|
|
2009-08-20 13:47:01 +00:00
|
|
|
if (read_cache() < 0)
|
2011-02-22 23:42:21 +00:00
|
|
|
die(_("index file corrupt"));
|
2009-08-20 13:47:01 +00:00
|
|
|
|
2007-11-15 05:00:54 +00:00
|
|
|
if (!ignored)
|
|
|
|
setup_standard_excludes(&dir);
|
2007-11-12 01:48:47 +00:00
|
|
|
|
2013-01-16 13:25:58 +00:00
|
|
|
el = add_exclude_list(&dir, EXC_CMDL, "--exclude option");
|
2010-07-20 19:35:56 +00:00
|
|
|
for (i = 0; i < exclude_list.nr; i++)
|
2013-01-16 13:25:58 +00:00
|
|
|
add_exclude(exclude_list.items[i].string, "", 0, el, -(i+1));
|
2010-07-20 19:35:56 +00:00
|
|
|
|
2007-11-12 01:48:47 +00:00
|
|
|
pathspec = get_pathspec(prefix, argv);
|
|
|
|
|
2009-05-14 20:22:36 +00:00
|
|
|
fill_directory(&dir, pathspec);
|
2007-11-12 01:48:47 +00:00
|
|
|
|
2007-12-05 07:55:41 +00:00
|
|
|
if (pathspec)
|
2008-01-12 09:04:32 +00:00
|
|
|
seen = xmalloc(argc > 0 ? argc : 1);
|
2007-12-05 07:55:41 +00:00
|
|
|
|
|
|
|
for (i = 0; i < dir.nr; i++) {
|
|
|
|
struct dir_entry *ent = dir.entries[i];
|
2008-04-15 03:14:09 +00:00
|
|
|
int len, pos;
|
|
|
|
int matches = 0;
|
2007-11-12 01:48:47 +00:00
|
|
|
struct cache_entry *ce;
|
|
|
|
struct stat st;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Remove the '/' at the end that directory
|
|
|
|
* walking adds for directory entries.
|
|
|
|
*/
|
|
|
|
len = ent->len;
|
|
|
|
if (len && ent->name[len-1] == '/')
|
|
|
|
len--;
|
|
|
|
pos = cache_name_pos(ent->name, len);
|
|
|
|
if (0 <= pos)
|
|
|
|
continue; /* exact match */
|
|
|
|
pos = -pos - 1;
|
|
|
|
if (pos < active_nr) {
|
|
|
|
ce = active_cache[pos];
|
|
|
|
if (ce_namelen(ce) == len &&
|
|
|
|
!memcmp(ce->name, ent->name, len))
|
|
|
|
continue; /* Yup, this one exists unmerged */
|
|
|
|
}
|
|
|
|
|
2007-12-05 07:55:41 +00:00
|
|
|
/*
|
|
|
|
* we might have removed this as part of earlier
|
|
|
|
* recursive directory removal, so lstat() here could
|
|
|
|
* fail with ENOENT.
|
|
|
|
*/
|
|
|
|
if (lstat(ent->name, &st))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (pathspec) {
|
2008-01-12 09:04:32 +00:00
|
|
|
memset(seen, 0, argc > 0 ? argc : 1);
|
2008-04-15 03:14:09 +00:00
|
|
|
matches = match_pathspec(pathspec, ent->name, len,
|
2010-11-15 06:42:44 +00:00
|
|
|
0, seen);
|
2007-12-05 07:55:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (S_ISDIR(st.st_mode)) {
|
2007-11-12 01:48:47 +00:00
|
|
|
strbuf_addstr(&directory, ent->name);
|
git-clean: Display more accurate delete messages
(1) Only print out the names of the files and directories that got
actually deleted. Also do not mention that we are not removing
directories when the user did not ask us to do so with '-d'.
(2) Show ignore message for skipped untracked git repositories.
Consider the following repo layout:
test.git/
|-- tracked_dir/
| |-- some_tracked_file
| |-- some_untracked_file
|-- tracked_file
|-- untracked_file
|-- untracked_foo/
| |-- bar/
| | |-- bar.txt
| |-- emptydir/
| |-- frotz.git/
| |-- frotz.tx
|-- untracked_some.git/
|-- some.txt
Suppose the user issues 'git clean -fd' from the test.git directory.
When -d option is used and untracked directory 'foo' contains a
subdirectory 'frotz.git' that is managed by a different git repository
therefore it will not be removed.
$ git clean -fd
Removing tracked_dir/some_untracked_file
Removing untracked_file
Removing untracked_foo/
Removing untracked_some.git/
The message displayed to the user is slightly misleading. The foo/
directory has not been removed because of foo/frotz.git still exists.
On the other hand the subdirectories 'bar' and 'emptydir' have been
deleted but they're not mentioned anywhere. Also, untracked_some.git
has not been removed either.
This behaviour is the result of the way the deletion of untracked
directories are reported. In the current implementation they are
deleted recursively but only the name of the top most directory is
printed out. The calling function does not know about any
subdirectories that could not be removed during the recursion.
Improve the way the deleted directories are reported back to
the user:
(1) Create a recursive delete function 'remove_dirs' in builtin/clean.c
to run in both dry_run and delete modes with the delete logic as
follows:
(a) Check if the current directory to be deleted is an untracked
git repository. If it is and --force --force option is not set
do not touch this directory, print ignore message, set dir_gone
flag to false for the caller and return.
(b) Otherwise for each item in current directory:
(i) If current directory cannot be accessed, print warning,
set dir_gone flag to false and return.
(ii) If the item is a subdirectory recurse into it,
check for the returned value of the dir_gone flag.
If the subdirectory is gone, add the name of the deleted
directory to a list of successfully removed items 'dels'.
Else set the dir_gone flag as the current directory
cannot be removed because we have at least one subdirectory
hanging around.
(iii) If it is a file try to remove it. If success add the
file name to the 'dels' list, else print error and set
dir_gone flag to false.
(c) After we finished deleting all items in the current directory and
the dir_gone flag is still true, remove the directory itself.
If failed set the dir_gone flag to false.
(d) If the current directory cannot be deleted because the dir_gone flag
has been set to false, print out all the successfully deleted items
for this directory from the 'dels' list.
(e) We're done with the current directory, return.
(2) Modify the cmd_clean() function to:
(a) call the recursive delete function 'remove_dirs()' for each
topmost directory it wants to remove
(b) check for the returned value of dir_gone flag. If it's true
print the name of the directory as being removed.
Consider the output of the improved version:
$ git clean -fd
Removing tracked_dir/some_untracked_file
Removing untracked_file
Skipping repository untracked_foo/frotz.git
Removing untracked_foo/bar
Removing untracked_foo/emptydir
Skipping repository untracked_some.git/
Now it displays only the file and directory names that got actually
deleted and shows the name of the untracked git repositories it ignored.
Reported-by: Soren Brinkmann <soren.brinkmann@xilinx.com>
Signed-off-by: Zoltan Klinger <zoltan.klinger@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-01-10 22:53:46 +00:00
|
|
|
if (remove_directories || (matches == MATCHED_EXACTLY)) {
|
|
|
|
if (remove_dirs(&directory, prefix, rm_flags, dry_run, quiet, &gone))
|
2008-02-21 01:44:46 +00:00
|
|
|
errors++;
|
git-clean: Display more accurate delete messages
(1) Only print out the names of the files and directories that got
actually deleted. Also do not mention that we are not removing
directories when the user did not ask us to do so with '-d'.
(2) Show ignore message for skipped untracked git repositories.
Consider the following repo layout:
test.git/
|-- tracked_dir/
| |-- some_tracked_file
| |-- some_untracked_file
|-- tracked_file
|-- untracked_file
|-- untracked_foo/
| |-- bar/
| | |-- bar.txt
| |-- emptydir/
| |-- frotz.git/
| |-- frotz.tx
|-- untracked_some.git/
|-- some.txt
Suppose the user issues 'git clean -fd' from the test.git directory.
When -d option is used and untracked directory 'foo' contains a
subdirectory 'frotz.git' that is managed by a different git repository
therefore it will not be removed.
$ git clean -fd
Removing tracked_dir/some_untracked_file
Removing untracked_file
Removing untracked_foo/
Removing untracked_some.git/
The message displayed to the user is slightly misleading. The foo/
directory has not been removed because of foo/frotz.git still exists.
On the other hand the subdirectories 'bar' and 'emptydir' have been
deleted but they're not mentioned anywhere. Also, untracked_some.git
has not been removed either.
This behaviour is the result of the way the deletion of untracked
directories are reported. In the current implementation they are
deleted recursively but only the name of the top most directory is
printed out. The calling function does not know about any
subdirectories that could not be removed during the recursion.
Improve the way the deleted directories are reported back to
the user:
(1) Create a recursive delete function 'remove_dirs' in builtin/clean.c
to run in both dry_run and delete modes with the delete logic as
follows:
(a) Check if the current directory to be deleted is an untracked
git repository. If it is and --force --force option is not set
do not touch this directory, print ignore message, set dir_gone
flag to false for the caller and return.
(b) Otherwise for each item in current directory:
(i) If current directory cannot be accessed, print warning,
set dir_gone flag to false and return.
(ii) If the item is a subdirectory recurse into it,
check for the returned value of the dir_gone flag.
If the subdirectory is gone, add the name of the deleted
directory to a list of successfully removed items 'dels'.
Else set the dir_gone flag as the current directory
cannot be removed because we have at least one subdirectory
hanging around.
(iii) If it is a file try to remove it. If success add the
file name to the 'dels' list, else print error and set
dir_gone flag to false.
(c) After we finished deleting all items in the current directory and
the dir_gone flag is still true, remove the directory itself.
If failed set the dir_gone flag to false.
(d) If the current directory cannot be deleted because the dir_gone flag
has been set to false, print out all the successfully deleted items
for this directory from the 'dels' list.
(e) We're done with the current directory, return.
(2) Modify the cmd_clean() function to:
(a) call the recursive delete function 'remove_dirs()' for each
topmost directory it wants to remove
(b) check for the returned value of dir_gone flag. If it's true
print the name of the directory as being removed.
Consider the output of the improved version:
$ git clean -fd
Removing tracked_dir/some_untracked_file
Removing untracked_file
Skipping repository untracked_foo/frotz.git
Removing untracked_foo/bar
Removing untracked_foo/emptydir
Skipping repository untracked_some.git/
Now it displays only the file and directory names that got actually
deleted and shows the name of the untracked git repositories it ignored.
Reported-by: Soren Brinkmann <soren.brinkmann@xilinx.com>
Signed-off-by: Zoltan Klinger <zoltan.klinger@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-01-10 22:53:46 +00:00
|
|
|
if (gone && !quiet) {
|
|
|
|
qname = quote_path_relative(directory.buf, directory.len, &buf, prefix);
|
|
|
|
printf(dry_run ? _(msg_would_remove) : _(msg_remove), qname);
|
2008-02-21 01:44:46 +00:00
|
|
|
}
|
2007-11-12 01:48:47 +00:00
|
|
|
}
|
|
|
|
strbuf_reset(&directory);
|
|
|
|
} else {
|
2007-12-05 07:55:41 +00:00
|
|
|
if (pathspec && !matches)
|
|
|
|
continue;
|
git-clean: Display more accurate delete messages
(1) Only print out the names of the files and directories that got
actually deleted. Also do not mention that we are not removing
directories when the user did not ask us to do so with '-d'.
(2) Show ignore message for skipped untracked git repositories.
Consider the following repo layout:
test.git/
|-- tracked_dir/
| |-- some_tracked_file
| |-- some_untracked_file
|-- tracked_file
|-- untracked_file
|-- untracked_foo/
| |-- bar/
| | |-- bar.txt
| |-- emptydir/
| |-- frotz.git/
| |-- frotz.tx
|-- untracked_some.git/
|-- some.txt
Suppose the user issues 'git clean -fd' from the test.git directory.
When -d option is used and untracked directory 'foo' contains a
subdirectory 'frotz.git' that is managed by a different git repository
therefore it will not be removed.
$ git clean -fd
Removing tracked_dir/some_untracked_file
Removing untracked_file
Removing untracked_foo/
Removing untracked_some.git/
The message displayed to the user is slightly misleading. The foo/
directory has not been removed because of foo/frotz.git still exists.
On the other hand the subdirectories 'bar' and 'emptydir' have been
deleted but they're not mentioned anywhere. Also, untracked_some.git
has not been removed either.
This behaviour is the result of the way the deletion of untracked
directories are reported. In the current implementation they are
deleted recursively but only the name of the top most directory is
printed out. The calling function does not know about any
subdirectories that could not be removed during the recursion.
Improve the way the deleted directories are reported back to
the user:
(1) Create a recursive delete function 'remove_dirs' in builtin/clean.c
to run in both dry_run and delete modes with the delete logic as
follows:
(a) Check if the current directory to be deleted is an untracked
git repository. If it is and --force --force option is not set
do not touch this directory, print ignore message, set dir_gone
flag to false for the caller and return.
(b) Otherwise for each item in current directory:
(i) If current directory cannot be accessed, print warning,
set dir_gone flag to false and return.
(ii) If the item is a subdirectory recurse into it,
check for the returned value of the dir_gone flag.
If the subdirectory is gone, add the name of the deleted
directory to a list of successfully removed items 'dels'.
Else set the dir_gone flag as the current directory
cannot be removed because we have at least one subdirectory
hanging around.
(iii) If it is a file try to remove it. If success add the
file name to the 'dels' list, else print error and set
dir_gone flag to false.
(c) After we finished deleting all items in the current directory and
the dir_gone flag is still true, remove the directory itself.
If failed set the dir_gone flag to false.
(d) If the current directory cannot be deleted because the dir_gone flag
has been set to false, print out all the successfully deleted items
for this directory from the 'dels' list.
(e) We're done with the current directory, return.
(2) Modify the cmd_clean() function to:
(a) call the recursive delete function 'remove_dirs()' for each
topmost directory it wants to remove
(b) check for the returned value of dir_gone flag. If it's true
print the name of the directory as being removed.
Consider the output of the improved version:
$ git clean -fd
Removing tracked_dir/some_untracked_file
Removing untracked_file
Skipping repository untracked_foo/frotz.git
Removing untracked_foo/bar
Removing untracked_foo/emptydir
Skipping repository untracked_some.git/
Now it displays only the file and directory names that got actually
deleted and shows the name of the untracked git repositories it ignored.
Reported-by: Soren Brinkmann <soren.brinkmann@xilinx.com>
Signed-off-by: Zoltan Klinger <zoltan.klinger@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-01-10 22:53:46 +00:00
|
|
|
res = dry_run ? 0 : unlink(ent->name);
|
|
|
|
if (res) {
|
|
|
|
qname = quote_path_relative(ent->name, -1, &buf, prefix);
|
|
|
|
warning(_(msg_warn_remove_failed), qname);
|
2008-02-21 01:44:46 +00:00
|
|
|
errors++;
|
git-clean: Display more accurate delete messages
(1) Only print out the names of the files and directories that got
actually deleted. Also do not mention that we are not removing
directories when the user did not ask us to do so with '-d'.
(2) Show ignore message for skipped untracked git repositories.
Consider the following repo layout:
test.git/
|-- tracked_dir/
| |-- some_tracked_file
| |-- some_untracked_file
|-- tracked_file
|-- untracked_file
|-- untracked_foo/
| |-- bar/
| | |-- bar.txt
| |-- emptydir/
| |-- frotz.git/
| |-- frotz.tx
|-- untracked_some.git/
|-- some.txt
Suppose the user issues 'git clean -fd' from the test.git directory.
When -d option is used and untracked directory 'foo' contains a
subdirectory 'frotz.git' that is managed by a different git repository
therefore it will not be removed.
$ git clean -fd
Removing tracked_dir/some_untracked_file
Removing untracked_file
Removing untracked_foo/
Removing untracked_some.git/
The message displayed to the user is slightly misleading. The foo/
directory has not been removed because of foo/frotz.git still exists.
On the other hand the subdirectories 'bar' and 'emptydir' have been
deleted but they're not mentioned anywhere. Also, untracked_some.git
has not been removed either.
This behaviour is the result of the way the deletion of untracked
directories are reported. In the current implementation they are
deleted recursively but only the name of the top most directory is
printed out. The calling function does not know about any
subdirectories that could not be removed during the recursion.
Improve the way the deleted directories are reported back to
the user:
(1) Create a recursive delete function 'remove_dirs' in builtin/clean.c
to run in both dry_run and delete modes with the delete logic as
follows:
(a) Check if the current directory to be deleted is an untracked
git repository. If it is and --force --force option is not set
do not touch this directory, print ignore message, set dir_gone
flag to false for the caller and return.
(b) Otherwise for each item in current directory:
(i) If current directory cannot be accessed, print warning,
set dir_gone flag to false and return.
(ii) If the item is a subdirectory recurse into it,
check for the returned value of the dir_gone flag.
If the subdirectory is gone, add the name of the deleted
directory to a list of successfully removed items 'dels'.
Else set the dir_gone flag as the current directory
cannot be removed because we have at least one subdirectory
hanging around.
(iii) If it is a file try to remove it. If success add the
file name to the 'dels' list, else print error and set
dir_gone flag to false.
(c) After we finished deleting all items in the current directory and
the dir_gone flag is still true, remove the directory itself.
If failed set the dir_gone flag to false.
(d) If the current directory cannot be deleted because the dir_gone flag
has been set to false, print out all the successfully deleted items
for this directory from the 'dels' list.
(e) We're done with the current directory, return.
(2) Modify the cmd_clean() function to:
(a) call the recursive delete function 'remove_dirs()' for each
topmost directory it wants to remove
(b) check for the returned value of dir_gone flag. If it's true
print the name of the directory as being removed.
Consider the output of the improved version:
$ git clean -fd
Removing tracked_dir/some_untracked_file
Removing untracked_file
Skipping repository untracked_foo/frotz.git
Removing untracked_foo/bar
Removing untracked_foo/emptydir
Skipping repository untracked_some.git/
Now it displays only the file and directory names that got actually
deleted and shows the name of the untracked git repositories it ignored.
Reported-by: Soren Brinkmann <soren.brinkmann@xilinx.com>
Signed-off-by: Zoltan Klinger <zoltan.klinger@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-01-10 22:53:46 +00:00
|
|
|
} else if (!quiet) {
|
|
|
|
qname = quote_path_relative(ent->name, -1, &buf, prefix);
|
|
|
|
printf(dry_run ? _(msg_would_remove) : _(msg_remove), qname);
|
2008-02-21 01:44:46 +00:00
|
|
|
}
|
2007-11-12 01:48:47 +00:00
|
|
|
}
|
|
|
|
}
|
2007-12-05 07:55:41 +00:00
|
|
|
free(seen);
|
2007-11-12 01:48:47 +00:00
|
|
|
|
|
|
|
strbuf_release(&directory);
|
2010-07-20 19:35:56 +00:00
|
|
|
string_list_clear(&exclude_list, 0);
|
2008-02-21 01:44:46 +00:00
|
|
|
return (errors != 0);
|
2007-11-12 01:48:47 +00:00
|
|
|
}
|