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"
|
2013-06-25 15:53:49 +00:00
|
|
|
#include "column.h"
|
2013-06-25 15:53:50 +00:00
|
|
|
#include "color.h"
|
2013-07-14 08:35:37 +00:00
|
|
|
#include "pathspec.h"
|
2007-11-12 01:48:47 +00:00
|
|
|
|
2007-11-13 05:13:05 +00:00
|
|
|
static int force = -1; /* unset */
|
2013-06-25 15:53:48 +00:00
|
|
|
static int interactive;
|
2013-06-25 15:53:47 +00:00
|
|
|
static struct string_list del_list = STRING_LIST_INIT_DUP;
|
2013-06-25 15:53:49 +00:00
|
|
|
static unsigned int colopts;
|
2007-11-12 01:48:47 +00:00
|
|
|
|
|
|
|
static const char *const builtin_clean_usage[] = {
|
2013-06-25 15:53:48 +00:00
|
|
|
N_("git clean [-d] [-f] [-i] [-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");
|
|
|
|
|
2013-06-25 15:53:50 +00:00
|
|
|
static int clean_use_color = -1;
|
|
|
|
static char clean_colors[][COLOR_MAXLEN] = {
|
|
|
|
GIT_COLOR_RESET,
|
|
|
|
GIT_COLOR_NORMAL, /* PLAIN */
|
|
|
|
GIT_COLOR_BOLD_BLUE, /* PROMPT */
|
|
|
|
GIT_COLOR_BOLD, /* HEADER */
|
|
|
|
GIT_COLOR_BOLD_RED, /* HELP */
|
|
|
|
GIT_COLOR_BOLD_RED, /* ERROR */
|
|
|
|
};
|
|
|
|
enum color_clean {
|
|
|
|
CLEAN_COLOR_RESET = 0,
|
|
|
|
CLEAN_COLOR_PLAIN = 1,
|
|
|
|
CLEAN_COLOR_PROMPT = 2,
|
|
|
|
CLEAN_COLOR_HEADER = 3,
|
|
|
|
CLEAN_COLOR_HELP = 4,
|
|
|
|
CLEAN_COLOR_ERROR = 5,
|
|
|
|
};
|
|
|
|
|
2013-06-25 15:53:51 +00:00
|
|
|
#define MENU_OPTS_SINGLETON 01
|
|
|
|
#define MENU_OPTS_IMMEDIATE 02
|
|
|
|
#define MENU_OPTS_LIST_ONLY 04
|
|
|
|
|
|
|
|
struct menu_opts {
|
|
|
|
const char *header;
|
|
|
|
const char *prompt;
|
|
|
|
int flags;
|
|
|
|
};
|
|
|
|
|
|
|
|
#define MENU_RETURN_NO_LOOP 10
|
|
|
|
|
|
|
|
struct menu_item {
|
|
|
|
char hotkey;
|
|
|
|
const char *title;
|
|
|
|
int selected;
|
|
|
|
int (*fn)();
|
|
|
|
};
|
|
|
|
|
|
|
|
enum menu_stuff_type {
|
|
|
|
MENU_STUFF_TYPE_STRING_LIST = 1,
|
|
|
|
MENU_STUFF_TYPE_MENU_ITEM
|
|
|
|
};
|
|
|
|
|
|
|
|
struct menu_stuff {
|
|
|
|
enum menu_stuff_type type;
|
|
|
|
int nr;
|
|
|
|
void *stuff;
|
|
|
|
};
|
|
|
|
|
2013-06-25 15:53:50 +00:00
|
|
|
static int parse_clean_color_slot(const char *var)
|
|
|
|
{
|
|
|
|
if (!strcasecmp(var, "reset"))
|
|
|
|
return CLEAN_COLOR_RESET;
|
|
|
|
if (!strcasecmp(var, "plain"))
|
|
|
|
return CLEAN_COLOR_PLAIN;
|
|
|
|
if (!strcasecmp(var, "prompt"))
|
|
|
|
return CLEAN_COLOR_PROMPT;
|
|
|
|
if (!strcasecmp(var, "header"))
|
|
|
|
return CLEAN_COLOR_HEADER;
|
|
|
|
if (!strcasecmp(var, "help"))
|
|
|
|
return CLEAN_COLOR_HELP;
|
|
|
|
if (!strcasecmp(var, "error"))
|
|
|
|
return CLEAN_COLOR_ERROR;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
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
|
|
|
{
|
2013-11-30 20:55:40 +00:00
|
|
|
if (starts_with(var, "column."))
|
2013-06-25 15:53:49 +00:00
|
|
|
return git_column_config(var, value, "clean", &colopts);
|
|
|
|
|
2013-06-25 15:53:50 +00:00
|
|
|
/* honors the color.interactive* config variables which also
|
|
|
|
applied in git-add--interactive and git-stash */
|
|
|
|
if (!strcmp(var, "color.interactive")) {
|
|
|
|
clean_use_color = git_config_colorbool(var, value);
|
|
|
|
return 0;
|
|
|
|
}
|
2013-11-30 20:55:40 +00:00
|
|
|
if (starts_with(var, "color.interactive.")) {
|
2013-06-25 15:53:50 +00:00
|
|
|
int slot = parse_clean_color_slot(var +
|
|
|
|
strlen("color.interactive."));
|
|
|
|
if (slot < 0)
|
|
|
|
return 0;
|
|
|
|
if (!value)
|
|
|
|
return config_error_nonbool(var);
|
|
|
|
color_parse(value, var, clean_colors[slot]);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-06-25 15:53:49 +00:00
|
|
|
if (!strcmp(var, "clean.requireforce")) {
|
2007-11-12 01:48:47 +00:00
|
|
|
force = !git_config_bool(var, value);
|
2013-06-25 15:53:49 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2013-06-25 15:53:50 +00:00
|
|
|
|
|
|
|
/* inspect the color.ui config variable and others */
|
|
|
|
return git_color_default_config(var, value, cb);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const char *clean_get_color(enum color_clean ix)
|
|
|
|
{
|
|
|
|
if (want_color(clean_use_color))
|
|
|
|
return clean_colors[ix];
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
|
|
|
static void clean_print_color(enum color_clean ix)
|
|
|
|
{
|
|
|
|
printf("%s", clean_get_color(ix));
|
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;
|
2014-01-29 13:36:15 +00:00
|
|
|
int res = 0, ret = 0, gone = 1, original_len = path->len, len;
|
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
|
|
|
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) {
|
2013-06-25 15:53:45 +00:00
|
|
|
quote_path_relative(path->buf, prefix, "ed);
|
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
|
|
|
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) {
|
2013-06-25 15:53:45 +00:00
|
|
|
quote_path_relative(path->buf, prefix, "ed);
|
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
|
|
|
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) {
|
2013-06-25 15:53:45 +00:00
|
|
|
quote_path_relative(path->buf, prefix, "ed);
|
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
|
|
|
string_list_append(&dels, quoted.buf);
|
|
|
|
} else
|
|
|
|
*dir_gone = 0;
|
|
|
|
continue;
|
|
|
|
} else {
|
|
|
|
res = dry_run ? 0 : unlink(path->buf);
|
|
|
|
if (!res) {
|
2013-06-25 15:53:45 +00:00
|
|
|
quote_path_relative(path->buf, prefix, "ed);
|
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
|
|
|
string_list_append(&dels, quoted.buf);
|
|
|
|
} else {
|
2013-06-25 15:53:45 +00:00
|
|
|
quote_path_relative(path->buf, prefix, "ed);
|
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
|
|
|
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 {
|
2013-06-25 15:53:45 +00:00
|
|
|
quote_path_relative(path->buf, prefix, "ed);
|
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
|
|
|
warning(_(msg_warn_remove_failed), quoted.buf);
|
|
|
|
*dir_gone = 0;
|
|
|
|
ret = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!*dir_gone && !quiet) {
|
2014-01-29 13:36:15 +00:00
|
|
|
int i;
|
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
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2013-06-25 15:53:49 +00:00
|
|
|
static void pretty_print_dels(void)
|
2013-06-25 15:53:48 +00:00
|
|
|
{
|
2013-06-25 15:53:49 +00:00
|
|
|
struct string_list list = STRING_LIST_INIT_DUP;
|
2013-06-25 15:53:48 +00:00
|
|
|
struct string_list_item *item;
|
2013-06-25 15:53:49 +00:00
|
|
|
struct strbuf buf = STRBUF_INIT;
|
2013-06-25 15:53:48 +00:00
|
|
|
const char *qname;
|
2013-06-25 15:53:49 +00:00
|
|
|
struct column_options copts;
|
|
|
|
|
|
|
|
for_each_string_list_item(item, &del_list) {
|
|
|
|
qname = quote_path_relative(item->string, NULL, &buf);
|
|
|
|
string_list_append(&list, qname);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* always enable column display, we only consult column.*
|
|
|
|
* about layout strategy and stuff
|
|
|
|
*/
|
|
|
|
colopts = (colopts & ~COL_ENABLE_MASK) | COL_ENABLED;
|
|
|
|
memset(&copts, 0, sizeof(copts));
|
|
|
|
copts.indent = " ";
|
|
|
|
copts.padding = 2;
|
|
|
|
print_columns(&list, colopts, &copts);
|
|
|
|
strbuf_release(&buf);
|
|
|
|
string_list_clear(&list, 0);
|
|
|
|
}
|
|
|
|
|
2013-06-25 15:53:51 +00:00
|
|
|
static void pretty_print_menus(struct string_list *menu_list)
|
|
|
|
{
|
|
|
|
unsigned int local_colopts = 0;
|
|
|
|
struct column_options copts;
|
|
|
|
|
|
|
|
local_colopts = COL_ENABLED | COL_ROW;
|
|
|
|
memset(&copts, 0, sizeof(copts));
|
|
|
|
copts.indent = " ";
|
|
|
|
copts.padding = 2;
|
|
|
|
print_columns(menu_list, local_colopts, &copts);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void prompt_help_cmd(int singleton)
|
|
|
|
{
|
|
|
|
clean_print_color(CLEAN_COLOR_HELP);
|
|
|
|
printf_ln(singleton ?
|
|
|
|
_("Prompt help:\n"
|
|
|
|
"1 - select a numbered item\n"
|
|
|
|
"foo - select item based on unique prefix\n"
|
|
|
|
" - (empty) select nothing") :
|
|
|
|
_("Prompt help:\n"
|
|
|
|
"1 - select a single item\n"
|
|
|
|
"3-5 - select a range of items\n"
|
|
|
|
"2-3,6-9 - select multiple ranges\n"
|
|
|
|
"foo - select item based on unique prefix\n"
|
|
|
|
"-... - unselect specified items\n"
|
|
|
|
"* - choose all items\n"
|
|
|
|
" - (empty) finish selecting"));
|
|
|
|
clean_print_color(CLEAN_COLOR_RESET);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* display menu stuff with number prefix and hotkey highlight
|
|
|
|
*/
|
|
|
|
static void print_highlight_menu_stuff(struct menu_stuff *stuff, int **chosen)
|
|
|
|
{
|
|
|
|
struct string_list menu_list = STRING_LIST_INIT_DUP;
|
|
|
|
struct strbuf menu = STRBUF_INIT;
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
struct menu_item *menu_item;
|
|
|
|
struct string_list_item *string_list_item;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
switch (stuff->type) {
|
|
|
|
default:
|
|
|
|
die("Bad type of menu_staff when print menu");
|
|
|
|
case MENU_STUFF_TYPE_MENU_ITEM:
|
|
|
|
menu_item = (struct menu_item *)stuff->stuff;
|
|
|
|
for (i = 0; i < stuff->nr; i++, menu_item++) {
|
|
|
|
const char *p;
|
|
|
|
int highlighted = 0;
|
|
|
|
|
|
|
|
p = menu_item->title;
|
|
|
|
if ((*chosen)[i] < 0)
|
|
|
|
(*chosen)[i] = menu_item->selected ? 1 : 0;
|
|
|
|
strbuf_addf(&menu, "%s%2d: ", (*chosen)[i] ? "*" : " ", i+1);
|
|
|
|
for (; *p; p++) {
|
|
|
|
if (!highlighted && *p == menu_item->hotkey) {
|
|
|
|
strbuf_addstr(&menu, clean_get_color(CLEAN_COLOR_PROMPT));
|
|
|
|
strbuf_addch(&menu, *p);
|
|
|
|
strbuf_addstr(&menu, clean_get_color(CLEAN_COLOR_RESET));
|
|
|
|
highlighted = 1;
|
|
|
|
} else {
|
|
|
|
strbuf_addch(&menu, *p);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
string_list_append(&menu_list, menu.buf);
|
|
|
|
strbuf_reset(&menu);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case MENU_STUFF_TYPE_STRING_LIST:
|
|
|
|
i = 0;
|
|
|
|
for_each_string_list_item(string_list_item, (struct string_list *)stuff->stuff) {
|
|
|
|
if ((*chosen)[i] < 0)
|
|
|
|
(*chosen)[i] = 0;
|
|
|
|
strbuf_addf(&menu, "%s%2d: %s",
|
|
|
|
(*chosen)[i] ? "*" : " ", i+1, string_list_item->string);
|
|
|
|
string_list_append(&menu_list, menu.buf);
|
|
|
|
strbuf_reset(&menu);
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
pretty_print_menus(&menu_list);
|
|
|
|
|
|
|
|
strbuf_release(&menu);
|
|
|
|
strbuf_release(&buf);
|
|
|
|
string_list_clear(&menu_list, 0);
|
|
|
|
}
|
|
|
|
|
2013-07-24 02:22:04 +00:00
|
|
|
static int find_unique(const char *choice, struct menu_stuff *menu_stuff)
|
|
|
|
{
|
|
|
|
struct menu_item *menu_item;
|
|
|
|
struct string_list_item *string_list_item;
|
|
|
|
int i, len, found = 0;
|
|
|
|
|
|
|
|
len = strlen(choice);
|
|
|
|
switch (menu_stuff->type) {
|
|
|
|
default:
|
|
|
|
die("Bad type of menu_stuff when parse choice");
|
|
|
|
case MENU_STUFF_TYPE_MENU_ITEM:
|
|
|
|
|
|
|
|
menu_item = (struct menu_item *)menu_stuff->stuff;
|
|
|
|
for (i = 0; i < menu_stuff->nr; i++, menu_item++) {
|
|
|
|
if (len == 1 && *choice == menu_item->hotkey) {
|
|
|
|
found = i + 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (!strncasecmp(choice, menu_item->title, len)) {
|
|
|
|
if (found) {
|
|
|
|
if (len == 1) {
|
|
|
|
/* continue for hotkey matching */
|
|
|
|
found = -1;
|
|
|
|
} else {
|
|
|
|
found = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
found = i + 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case MENU_STUFF_TYPE_STRING_LIST:
|
|
|
|
string_list_item = ((struct string_list *)menu_stuff->stuff)->items;
|
|
|
|
for (i = 0; i < menu_stuff->nr; i++, string_list_item++) {
|
|
|
|
if (!strncasecmp(choice, string_list_item->string, len)) {
|
|
|
|
if (found) {
|
|
|
|
found = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
found = i + 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return found;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-06-25 15:53:51 +00:00
|
|
|
/*
|
|
|
|
* Parse user input, and return choice(s) for menu (menu_stuff).
|
|
|
|
*
|
|
|
|
* Input
|
|
|
|
* (for single choice)
|
|
|
|
* 1 - select a numbered item
|
|
|
|
* foo - select item based on menu title
|
|
|
|
* - (empty) select nothing
|
|
|
|
*
|
|
|
|
* (for multiple choice)
|
|
|
|
* 1 - select a single item
|
|
|
|
* 3-5 - select a range of items
|
|
|
|
* 2-3,6-9 - select multiple ranges
|
|
|
|
* foo - select item based on menu title
|
|
|
|
* -... - unselect specified items
|
|
|
|
* * - choose all items
|
|
|
|
* - (empty) finish selecting
|
|
|
|
*
|
|
|
|
* The parse result will be saved in array **chosen, and
|
|
|
|
* return number of total selections.
|
|
|
|
*/
|
|
|
|
static int parse_choice(struct menu_stuff *menu_stuff,
|
|
|
|
int is_single,
|
|
|
|
struct strbuf input,
|
|
|
|
int **chosen)
|
|
|
|
{
|
|
|
|
struct strbuf **choice_list, **ptr;
|
|
|
|
int nr = 0;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (is_single) {
|
|
|
|
choice_list = strbuf_split_max(&input, '\n', 0);
|
|
|
|
} else {
|
|
|
|
char *p = input.buf;
|
|
|
|
do {
|
|
|
|
if (*p == ',')
|
|
|
|
*p = ' ';
|
|
|
|
} while (*p++);
|
|
|
|
choice_list = strbuf_split_max(&input, ' ', 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (ptr = choice_list; *ptr; ptr++) {
|
|
|
|
char *p;
|
|
|
|
int choose = 1;
|
|
|
|
int bottom = 0, top = 0;
|
|
|
|
int is_range, is_number;
|
|
|
|
|
|
|
|
strbuf_trim(*ptr);
|
|
|
|
if (!(*ptr)->len)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* Input that begins with '-'; unchoose */
|
|
|
|
if (*(*ptr)->buf == '-') {
|
|
|
|
choose = 0;
|
|
|
|
strbuf_remove((*ptr), 0, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
is_range = 0;
|
|
|
|
is_number = 1;
|
|
|
|
for (p = (*ptr)->buf; *p; p++) {
|
|
|
|
if ('-' == *p) {
|
|
|
|
if (!is_range) {
|
|
|
|
is_range = 1;
|
|
|
|
is_number = 0;
|
|
|
|
} else {
|
|
|
|
is_number = 0;
|
|
|
|
is_range = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else if (!isdigit(*p)) {
|
|
|
|
is_number = 0;
|
|
|
|
is_range = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (is_number) {
|
|
|
|
bottom = atoi((*ptr)->buf);
|
|
|
|
top = bottom;
|
|
|
|
} else if (is_range) {
|
|
|
|
bottom = atoi((*ptr)->buf);
|
|
|
|
/* a range can be specified like 5-7 or 5- */
|
|
|
|
if (!*(strchr((*ptr)->buf, '-') + 1))
|
|
|
|
top = menu_stuff->nr;
|
|
|
|
else
|
|
|
|
top = atoi(strchr((*ptr)->buf, '-') + 1);
|
|
|
|
} else if (!strcmp((*ptr)->buf, "*")) {
|
|
|
|
bottom = 1;
|
|
|
|
top = menu_stuff->nr;
|
|
|
|
} else {
|
2013-07-24 02:22:04 +00:00
|
|
|
bottom = find_unique((*ptr)->buf, menu_stuff);
|
|
|
|
top = bottom;
|
2013-06-25 15:53:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (top <= 0 || bottom <= 0 || top > menu_stuff->nr || bottom > top ||
|
|
|
|
(is_single && bottom != top)) {
|
|
|
|
clean_print_color(CLEAN_COLOR_ERROR);
|
|
|
|
printf_ln(_("Huh (%s)?"), (*ptr)->buf);
|
|
|
|
clean_print_color(CLEAN_COLOR_RESET);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = bottom; i <= top; i++)
|
|
|
|
(*chosen)[i-1] = choose;
|
|
|
|
}
|
|
|
|
|
|
|
|
strbuf_list_free(choice_list);
|
|
|
|
|
|
|
|
for (i = 0; i < menu_stuff->nr; i++)
|
|
|
|
nr += (*chosen)[i];
|
|
|
|
return nr;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Implement a git-add-interactive compatible UI, which is borrowed
|
|
|
|
* from git-add--interactive.perl.
|
|
|
|
*
|
|
|
|
* Return value:
|
|
|
|
*
|
|
|
|
* - Return an array of integers
|
|
|
|
* - , and it is up to you to free the allocated memory.
|
|
|
|
* - The array ends with EOF.
|
|
|
|
* - If user pressed CTRL-D (i.e. EOF), no selection returned.
|
|
|
|
*/
|
|
|
|
static int *list_and_choose(struct menu_opts *opts, struct menu_stuff *stuff)
|
|
|
|
{
|
|
|
|
struct strbuf choice = STRBUF_INIT;
|
|
|
|
int *chosen, *result;
|
|
|
|
int nr = 0;
|
|
|
|
int eof = 0;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
chosen = xmalloc(sizeof(int) * stuff->nr);
|
|
|
|
/* set chosen as uninitialized */
|
|
|
|
for (i = 0; i < stuff->nr; i++)
|
|
|
|
chosen[i] = -1;
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
if (opts->header) {
|
|
|
|
printf_ln("%s%s%s",
|
|
|
|
clean_get_color(CLEAN_COLOR_HEADER),
|
|
|
|
_(opts->header),
|
|
|
|
clean_get_color(CLEAN_COLOR_RESET));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* chosen will be initialized by print_highlight_menu_stuff */
|
|
|
|
print_highlight_menu_stuff(stuff, &chosen);
|
|
|
|
|
|
|
|
if (opts->flags & MENU_OPTS_LIST_ONLY)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (opts->prompt) {
|
|
|
|
printf("%s%s%s%s",
|
|
|
|
clean_get_color(CLEAN_COLOR_PROMPT),
|
|
|
|
_(opts->prompt),
|
|
|
|
opts->flags & MENU_OPTS_SINGLETON ? "> " : ">> ",
|
|
|
|
clean_get_color(CLEAN_COLOR_RESET));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (strbuf_getline(&choice, stdin, '\n') != EOF) {
|
|
|
|
strbuf_trim(&choice);
|
|
|
|
} else {
|
|
|
|
eof = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* help for prompt */
|
|
|
|
if (!strcmp(choice.buf, "?")) {
|
|
|
|
prompt_help_cmd(opts->flags & MENU_OPTS_SINGLETON);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* for a multiple-choice menu, press ENTER (empty) will return back */
|
|
|
|
if (!(opts->flags & MENU_OPTS_SINGLETON) && !choice.len)
|
|
|
|
break;
|
|
|
|
|
|
|
|
nr = parse_choice(stuff,
|
|
|
|
opts->flags & MENU_OPTS_SINGLETON,
|
|
|
|
choice,
|
|
|
|
&chosen);
|
|
|
|
|
|
|
|
if (opts->flags & MENU_OPTS_SINGLETON) {
|
|
|
|
if (nr)
|
|
|
|
break;
|
|
|
|
} else if (opts->flags & MENU_OPTS_IMMEDIATE) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (eof) {
|
|
|
|
result = xmalloc(sizeof(int));
|
|
|
|
*result = EOF;
|
|
|
|
} else {
|
|
|
|
int j = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* recalculate nr, if return back from menu directly with
|
|
|
|
* default selections.
|
|
|
|
*/
|
|
|
|
if (!nr) {
|
|
|
|
for (i = 0; i < stuff->nr; i++)
|
|
|
|
nr += chosen[i];
|
|
|
|
}
|
|
|
|
|
|
|
|
result = xmalloc(sizeof(int) * (nr + 1));
|
|
|
|
memset(result, 0, sizeof(int) * (nr + 1));
|
|
|
|
for (i = 0; i < stuff->nr && j < nr; i++) {
|
|
|
|
if (chosen[i])
|
|
|
|
result[j++] = i;
|
|
|
|
}
|
|
|
|
result[j] = EOF;
|
|
|
|
}
|
|
|
|
|
|
|
|
free(chosen);
|
|
|
|
strbuf_release(&choice);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int clean_cmd(void)
|
2013-06-25 15:53:49 +00:00
|
|
|
{
|
2013-06-25 15:53:51 +00:00
|
|
|
return MENU_RETURN_NO_LOOP;
|
|
|
|
}
|
|
|
|
|
2013-06-25 15:53:52 +00:00
|
|
|
static int filter_by_patterns_cmd(void)
|
|
|
|
{
|
|
|
|
struct dir_struct dir;
|
|
|
|
struct strbuf confirm = STRBUF_INIT;
|
|
|
|
struct strbuf **ignore_list;
|
|
|
|
struct string_list_item *item;
|
|
|
|
struct exclude_list *el;
|
|
|
|
int changed = -1, i;
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
if (!del_list.nr)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (changed)
|
|
|
|
pretty_print_dels();
|
|
|
|
|
|
|
|
clean_print_color(CLEAN_COLOR_PROMPT);
|
|
|
|
printf(_("Input ignore patterns>> "));
|
|
|
|
clean_print_color(CLEAN_COLOR_RESET);
|
|
|
|
if (strbuf_getline(&confirm, stdin, '\n') != EOF)
|
|
|
|
strbuf_trim(&confirm);
|
|
|
|
else
|
|
|
|
putchar('\n');
|
|
|
|
|
|
|
|
/* quit filter_by_pattern mode if press ENTER or Ctrl-D */
|
|
|
|
if (!confirm.len)
|
|
|
|
break;
|
|
|
|
|
|
|
|
memset(&dir, 0, sizeof(dir));
|
|
|
|
el = add_exclude_list(&dir, EXC_CMDL, "manual exclude");
|
|
|
|
ignore_list = strbuf_split_max(&confirm, ' ', 0);
|
|
|
|
|
|
|
|
for (i = 0; ignore_list[i]; i++) {
|
|
|
|
strbuf_trim(ignore_list[i]);
|
|
|
|
if (!ignore_list[i]->len)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
add_exclude(ignore_list[i]->buf, "", 0, el, -(i+1));
|
|
|
|
}
|
|
|
|
|
|
|
|
changed = 0;
|
|
|
|
for_each_string_list_item(item, &del_list) {
|
|
|
|
int dtype = DT_UNKNOWN;
|
|
|
|
|
|
|
|
if (is_excluded(&dir, item->string, &dtype)) {
|
|
|
|
*item->string = '\0';
|
|
|
|
changed++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (changed) {
|
|
|
|
string_list_remove_empty_items(&del_list, 0);
|
|
|
|
} else {
|
|
|
|
clean_print_color(CLEAN_COLOR_ERROR);
|
|
|
|
printf_ln(_("WARNING: Cannot find items matched by: %s"), confirm.buf);
|
|
|
|
clean_print_color(CLEAN_COLOR_RESET);
|
|
|
|
}
|
|
|
|
|
|
|
|
strbuf_list_free(ignore_list);
|
|
|
|
clear_directory(&dir);
|
|
|
|
}
|
|
|
|
|
|
|
|
strbuf_release(&confirm);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-06-25 15:53:53 +00:00
|
|
|
static int select_by_numbers_cmd(void)
|
|
|
|
{
|
|
|
|
struct menu_opts menu_opts;
|
|
|
|
struct menu_stuff menu_stuff;
|
|
|
|
struct string_list_item *items;
|
|
|
|
int *chosen;
|
|
|
|
int i, j;
|
|
|
|
|
|
|
|
menu_opts.header = NULL;
|
|
|
|
menu_opts.prompt = N_("Select items to delete");
|
|
|
|
menu_opts.flags = 0;
|
|
|
|
|
|
|
|
menu_stuff.type = MENU_STUFF_TYPE_STRING_LIST;
|
|
|
|
menu_stuff.stuff = &del_list;
|
|
|
|
menu_stuff.nr = del_list.nr;
|
|
|
|
|
|
|
|
chosen = list_and_choose(&menu_opts, &menu_stuff);
|
|
|
|
items = del_list.items;
|
|
|
|
for (i = 0, j = 0; i < del_list.nr; i++) {
|
|
|
|
if (i < chosen[j]) {
|
|
|
|
*(items[i].string) = '\0';
|
|
|
|
} else if (i == chosen[j]) {
|
|
|
|
/* delete selected item */
|
|
|
|
j++;
|
|
|
|
continue;
|
|
|
|
} else {
|
|
|
|
/* end of chosen (chosen[j] == EOF), won't delete */
|
|
|
|
*(items[i].string) = '\0';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
string_list_remove_empty_items(&del_list, 0);
|
|
|
|
|
|
|
|
free(chosen);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-06-25 15:53:54 +00:00
|
|
|
static int ask_each_cmd(void)
|
|
|
|
{
|
|
|
|
struct strbuf confirm = STRBUF_INIT;
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
struct string_list_item *item;
|
|
|
|
const char *qname;
|
|
|
|
int changed = 0, eof = 0;
|
|
|
|
|
|
|
|
for_each_string_list_item(item, &del_list) {
|
|
|
|
/* Ctrl-D should stop removing files */
|
|
|
|
if (!eof) {
|
|
|
|
qname = quote_path_relative(item->string, NULL, &buf);
|
|
|
|
printf(_("remove %s? "), qname);
|
|
|
|
if (strbuf_getline(&confirm, stdin, '\n') != EOF) {
|
|
|
|
strbuf_trim(&confirm);
|
|
|
|
} else {
|
|
|
|
putchar('\n');
|
|
|
|
eof = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!confirm.len || strncasecmp(confirm.buf, "yes", confirm.len)) {
|
|
|
|
*item->string = '\0';
|
|
|
|
changed++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (changed)
|
|
|
|
string_list_remove_empty_items(&del_list, 0);
|
|
|
|
|
|
|
|
strbuf_release(&buf);
|
|
|
|
strbuf_release(&confirm);
|
|
|
|
return MENU_RETURN_NO_LOOP;
|
|
|
|
}
|
|
|
|
|
2013-06-25 15:53:51 +00:00
|
|
|
static int quit_cmd(void)
|
|
|
|
{
|
|
|
|
string_list_clear(&del_list, 0);
|
|
|
|
printf_ln(_("Bye."));
|
|
|
|
return MENU_RETURN_NO_LOOP;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int help_cmd(void)
|
|
|
|
{
|
|
|
|
clean_print_color(CLEAN_COLOR_HELP);
|
|
|
|
printf_ln(_(
|
|
|
|
"clean - start cleaning\n"
|
2013-06-25 15:53:52 +00:00
|
|
|
"filter by pattern - exclude items from deletion\n"
|
2013-06-25 15:53:53 +00:00
|
|
|
"select by numbers - select items to be deleted by numbers\n"
|
2013-06-25 15:53:54 +00:00
|
|
|
"ask each - confirm each deletion (like \"rm -i\")\n"
|
2013-06-25 15:53:51 +00:00
|
|
|
"quit - stop cleaning\n"
|
|
|
|
"help - this screen\n"
|
|
|
|
"? - help for prompt selection"
|
|
|
|
));
|
|
|
|
clean_print_color(CLEAN_COLOR_RESET);
|
|
|
|
return 0;
|
|
|
|
}
|
2013-06-25 15:53:48 +00:00
|
|
|
|
2013-06-25 15:53:51 +00:00
|
|
|
static void interactive_main_loop(void)
|
|
|
|
{
|
2013-06-25 15:53:48 +00:00
|
|
|
while (del_list.nr) {
|
2013-06-25 15:53:51 +00:00
|
|
|
struct menu_opts menu_opts;
|
|
|
|
struct menu_stuff menu_stuff;
|
|
|
|
struct menu_item menus[] = {
|
|
|
|
{'c', "clean", 0, clean_cmd},
|
2013-06-25 15:53:52 +00:00
|
|
|
{'f', "filter by pattern", 0, filter_by_patterns_cmd},
|
2013-06-25 15:53:53 +00:00
|
|
|
{'s', "select by numbers", 0, select_by_numbers_cmd},
|
2013-06-25 15:53:54 +00:00
|
|
|
{'a', "ask each", 0, ask_each_cmd},
|
2013-06-25 15:53:51 +00:00
|
|
|
{'q', "quit", 0, quit_cmd},
|
|
|
|
{'h', "help", 0, help_cmd},
|
|
|
|
};
|
|
|
|
int *chosen;
|
|
|
|
|
|
|
|
menu_opts.header = N_("*** Commands ***");
|
|
|
|
menu_opts.prompt = N_("What now");
|
|
|
|
menu_opts.flags = MENU_OPTS_SINGLETON;
|
|
|
|
|
|
|
|
menu_stuff.type = MENU_STUFF_TYPE_MENU_ITEM;
|
|
|
|
menu_stuff.stuff = menus;
|
|
|
|
menu_stuff.nr = sizeof(menus) / sizeof(struct menu_item);
|
|
|
|
|
2013-06-25 15:53:50 +00:00
|
|
|
clean_print_color(CLEAN_COLOR_HEADER);
|
2013-06-25 15:53:49 +00:00
|
|
|
printf_ln(Q_("Would remove the following item:",
|
|
|
|
"Would remove the following items:",
|
|
|
|
del_list.nr));
|
2013-06-25 15:53:50 +00:00
|
|
|
clean_print_color(CLEAN_COLOR_RESET);
|
2013-06-25 15:53:48 +00:00
|
|
|
|
2013-06-25 15:53:49 +00:00
|
|
|
pretty_print_dels();
|
|
|
|
|
2013-06-25 15:53:51 +00:00
|
|
|
chosen = list_and_choose(&menu_opts, &menu_stuff);
|
|
|
|
|
|
|
|
if (*chosen != EOF) {
|
|
|
|
int ret;
|
|
|
|
ret = menus[*chosen].fn();
|
|
|
|
if (ret != MENU_RETURN_NO_LOOP) {
|
|
|
|
free(chosen);
|
|
|
|
chosen = NULL;
|
|
|
|
if (!del_list.nr) {
|
|
|
|
clean_print_color(CLEAN_COLOR_ERROR);
|
|
|
|
printf_ln(_("No more files to clean, exiting."));
|
|
|
|
clean_print_color(CLEAN_COLOR_RESET);
|
|
|
|
break;
|
|
|
|
}
|
2013-06-25 15:53:48 +00:00
|
|
|
continue;
|
|
|
|
}
|
2013-06-25 15:53:51 +00:00
|
|
|
} else {
|
|
|
|
quit_cmd();
|
2013-06-25 15:53:48 +00:00
|
|
|
}
|
|
|
|
|
2013-06-25 15:53:51 +00:00
|
|
|
free(chosen);
|
|
|
|
chosen = NULL;
|
|
|
|
break;
|
|
|
|
}
|
2013-06-25 15:53:48 +00:00
|
|
|
}
|
|
|
|
|
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;
|
2013-06-25 15:53:47 +00:00
|
|
|
struct strbuf abs_path = STRBUF_INIT;
|
2007-11-12 01:48:47 +00:00
|
|
|
struct dir_struct dir;
|
2013-07-14 08:35:37 +00:00
|
|
|
struct pathspec 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;
|
2013-06-25 15:53:47 +00:00
|
|
|
struct string_list_item *item;
|
2008-03-07 01:13:17 +00:00
|
|
|
const char *qname;
|
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")),
|
2013-06-25 15:53:48 +00:00
|
|
|
OPT_BOOL('i', "interactive", &interactive, N_("interactive cleaning")),
|
2013-08-03 11:51:19 +00:00
|
|
|
OPT_BOOL('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 },
|
2013-08-03 11:51:19 +00:00
|
|
|
OPT_BOOL('x', NULL, &ignored, N_("remove ignored files, too")),
|
|
|
|
OPT_BOOL('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
|
|
|
|
2013-06-25 15:53:48 +00:00
|
|
|
if (!interactive && !dry_run && !force) {
|
2011-02-22 23:42:22 +00:00
|
|
|
if (config_set)
|
2014-03-31 22:11:47 +00:00
|
|
|
die(_("clean.requireForce set to true and neither -i, -n, nor -f given; "
|
2011-02-22 23:42:22 +00:00
|
|
|
"refusing to clean"));
|
|
|
|
else
|
2014-03-31 22:11:47 +00:00
|
|
|
die(_("clean.requireForce defaults to true and neither -i, -n, nor -f given;"
|
|
|
|
" refusing to clean"));
|
2011-02-22 23:42:22 +00:00
|
|
|
}
|
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
|
|
|
|
2013-07-14 08:35:37 +00:00
|
|
|
parse_pathspec(&pathspec, 0,
|
|
|
|
PATHSPEC_PREFER_CWD,
|
|
|
|
prefix, argv);
|
2007-11-12 01:48:47 +00:00
|
|
|
|
2013-07-14 08:35:55 +00:00
|
|
|
fill_directory(&dir, &pathspec);
|
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 matches = 0;
|
2007-11-12 01:48:47 +00:00
|
|
|
struct stat st;
|
2013-06-25 15:53:47 +00:00
|
|
|
const char *rel;
|
2007-11-12 01:48:47 +00:00
|
|
|
|
2014-01-24 13:40:35 +00:00
|
|
|
if (!cache_name_is_other(ent->name, ent->len))
|
|
|
|
continue;
|
2007-11-12 01:48:47 +00:00
|
|
|
|
2007-12-05 07:55:41 +00:00
|
|
|
if (lstat(ent->name, &st))
|
2013-06-25 15:53:47 +00:00
|
|
|
die_errno("Cannot lstat '%s'", ent->name);
|
2007-12-05 07:55:41 +00:00
|
|
|
|
2013-07-14 08:35:37 +00:00
|
|
|
if (pathspec.nr)
|
2014-01-24 13:40:34 +00:00
|
|
|
matches = dir_path_match(ent, &pathspec, 0, NULL);
|
2007-12-05 07:55:41 +00:00
|
|
|
|
2014-03-10 20:37:30 +00:00
|
|
|
if (pathspec.nr && !matches)
|
|
|
|
continue;
|
|
|
|
|
2014-03-10 17:24:47 +00:00
|
|
|
if (S_ISDIR(st.st_mode) && !remove_directories &&
|
|
|
|
matches != MATCHED_EXACTLY)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
rel = relative_path(ent->name, prefix, &buf);
|
|
|
|
string_list_append(&del_list, rel);
|
2013-06-25 15:53:47 +00:00
|
|
|
}
|
|
|
|
|
2013-06-25 15:53:48 +00:00
|
|
|
if (interactive && del_list.nr > 0)
|
|
|
|
interactive_main_loop();
|
2013-06-25 15:53:47 +00:00
|
|
|
|
|
|
|
for_each_string_list_item(item, &del_list) {
|
|
|
|
struct stat st;
|
|
|
|
|
|
|
|
if (prefix)
|
|
|
|
strbuf_addstr(&abs_path, prefix);
|
|
|
|
|
|
|
|
strbuf_addstr(&abs_path, item->string);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* we might have removed this as part of earlier
|
|
|
|
* recursive directory removal, so lstat() here could
|
|
|
|
* fail with ENOENT.
|
|
|
|
*/
|
|
|
|
if (lstat(abs_path.buf, &st))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (S_ISDIR(st.st_mode)) {
|
|
|
|
if (remove_dirs(&abs_path, prefix, rm_flags, dry_run, quiet, &gone))
|
|
|
|
errors++;
|
|
|
|
if (gone && !quiet) {
|
|
|
|
qname = quote_path_relative(item->string, NULL, &buf);
|
|
|
|
printf(dry_run ? _(msg_would_remove) : _(msg_remove), qname);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
res = dry_run ? 0 : unlink(abs_path.buf);
|
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 (res) {
|
2013-06-25 15:53:47 +00:00
|
|
|
qname = quote_path_relative(item->string, NULL, &buf);
|
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
|
|
|
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) {
|
2013-06-25 15:53:47 +00:00
|
|
|
qname = quote_path_relative(item->string, NULL, &buf);
|
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
|
|
|
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
|
|
|
}
|
2013-06-25 15:53:47 +00:00
|
|
|
strbuf_reset(&abs_path);
|
2007-11-12 01:48:47 +00:00
|
|
|
}
|
|
|
|
|
2013-06-25 15:53:47 +00:00
|
|
|
strbuf_release(&abs_path);
|
|
|
|
strbuf_release(&buf);
|
|
|
|
string_list_clear(&del_list, 0);
|
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
|
|
|
}
|