2 * "git clean" builtin command
4 * Copyright (C) 2007 Shawn Bohrer
6 * Based on git-clean.sh by Pavel Roskin
13 #include "parse-options.h"
14 #include "string-list.h"
21 static int force
= -1; /* unset */
22 static int interactive
;
23 static struct string_list del_list
= STRING_LIST_INIT_DUP
;
24 static unsigned int colopts
;
26 static const char *const builtin_clean_usage
[] = {
27 N_("git clean [-d] [-f] [-i] [-n] [-q] [-e <pattern>] [-x | -X] [--] <paths>..."),
31 static const char *msg_remove
= N_("Removing %s\n");
32 static const char *msg_would_remove
= N_("Would remove %s\n");
33 static const char *msg_skip_git_dir
= N_("Skipping repository %s\n");
34 static const char *msg_would_skip_git_dir
= N_("Would skip repository %s\n");
35 static const char *msg_warn_remove_failed
= N_("failed to remove %s");
38 CLEAN_COLOR_RESET
= 0,
39 CLEAN_COLOR_PLAIN
= 1,
40 CLEAN_COLOR_PROMPT
= 2,
41 CLEAN_COLOR_HEADER
= 3,
46 static const char *color_interactive_slots
[] = {
47 [CLEAN_COLOR_ERROR
] = "error",
48 [CLEAN_COLOR_HEADER
] = "header",
49 [CLEAN_COLOR_HELP
] = "help",
50 [CLEAN_COLOR_PLAIN
] = "plain",
51 [CLEAN_COLOR_PROMPT
] = "prompt",
52 [CLEAN_COLOR_RESET
] = "reset",
55 static int clean_use_color
= -1;
56 static char clean_colors
[][COLOR_MAXLEN
] = {
57 [CLEAN_COLOR_ERROR
] = GIT_COLOR_BOLD_RED
,
58 [CLEAN_COLOR_HEADER
] = GIT_COLOR_BOLD
,
59 [CLEAN_COLOR_HELP
] = GIT_COLOR_BOLD_RED
,
60 [CLEAN_COLOR_PLAIN
] = GIT_COLOR_NORMAL
,
61 [CLEAN_COLOR_PROMPT
] = GIT_COLOR_BOLD_BLUE
,
62 [CLEAN_COLOR_RESET
] = GIT_COLOR_RESET
,
65 #define MENU_OPTS_SINGLETON 01
66 #define MENU_OPTS_IMMEDIATE 02
67 #define MENU_OPTS_LIST_ONLY 04
75 #define MENU_RETURN_NO_LOOP 10
84 enum menu_stuff_type
{
85 MENU_STUFF_TYPE_STRING_LIST
= 1,
86 MENU_STUFF_TYPE_MENU_ITEM
90 enum menu_stuff_type type
;
95 define_list_config_array(color_interactive_slots
);
97 static int git_clean_config(const char *var
, const char *value
, void *cb
)
99 const char *slot_name
;
101 if (starts_with(var
, "column."))
102 return git_column_config(var
, value
, "clean", &colopts
);
104 /* honors the color.interactive* config variables which also
105 applied in git-add--interactive and git-stash */
106 if (!strcmp(var
, "color.interactive")) {
107 clean_use_color
= git_config_colorbool(var
, value
);
110 if (skip_prefix(var
, "color.interactive.", &slot_name
)) {
111 int slot
= LOOKUP_CONFIG(color_interactive_slots
, slot_name
);
115 return config_error_nonbool(var
);
116 return color_parse(value
, clean_colors
[slot
]);
119 if (!strcmp(var
, "clean.requireforce")) {
120 force
= !git_config_bool(var
, value
);
124 /* inspect the color.ui config variable and others */
125 return git_color_default_config(var
, value
, cb
);
128 static const char *clean_get_color(enum color_clean ix
)
130 if (want_color(clean_use_color
))
131 return clean_colors
[ix
];
135 static void clean_print_color(enum color_clean ix
)
137 printf("%s", clean_get_color(ix
));
140 static int exclude_cb(const struct option
*opt
, const char *arg
, int unset
)
142 struct string_list
*exclude_list
= opt
->value
;
143 BUG_ON_OPT_NEG(unset
);
144 string_list_append(exclude_list
, arg
);
148 static int remove_dirs(struct strbuf
*path
, const char *prefix
, int force_flag
,
149 int dry_run
, int quiet
, int *dir_gone
)
152 struct strbuf quoted
= STRBUF_INIT
;
154 int res
= 0, ret
= 0, gone
= 1, original_len
= path
->len
, len
;
155 struct string_list dels
= STRING_LIST_INIT_DUP
;
159 if ((force_flag
& REMOVE_DIR_KEEP_NESTED_GIT
) && is_nonbare_repository_dir(path
)) {
161 quote_path_relative(path
->buf
, prefix
, "ed
);
162 printf(dry_run
? _(msg_would_skip_git_dir
) : _(msg_skip_git_dir
),
170 dir
= opendir(path
->buf
);
172 /* an empty dir could be removed even if it is unreadble */
173 res
= dry_run
? 0 : rmdir(path
->buf
);
175 int saved_errno
= errno
;
176 quote_path_relative(path
->buf
, prefix
, "ed
);
178 warning_errno(_(msg_warn_remove_failed
), quoted
.buf
);
185 strbuf_complete(path
, '/');
188 while ((e
= readdir(dir
)) != NULL
) {
190 if (is_dot_or_dotdot(e
->d_name
))
193 strbuf_setlen(path
, len
);
194 strbuf_addstr(path
, e
->d_name
);
195 if (lstat(path
->buf
, &st
))
197 else if (S_ISDIR(st
.st_mode
)) {
198 if (remove_dirs(path
, prefix
, force_flag
, dry_run
, quiet
, &gone
))
201 quote_path_relative(path
->buf
, prefix
, "ed
);
202 string_list_append(&dels
, quoted
.buf
);
207 res
= dry_run
? 0 : unlink(path
->buf
);
209 quote_path_relative(path
->buf
, prefix
, "ed
);
210 string_list_append(&dels
, quoted
.buf
);
212 int saved_errno
= errno
;
213 quote_path_relative(path
->buf
, prefix
, "ed
);
215 warning_errno(_(msg_warn_remove_failed
), quoted
.buf
);
222 /* path too long, stat fails, or non-directory still exists */
229 strbuf_setlen(path
, original_len
);
232 res
= dry_run
? 0 : rmdir(path
->buf
);
236 int saved_errno
= errno
;
237 quote_path_relative(path
->buf
, prefix
, "ed
);
239 warning_errno(_(msg_warn_remove_failed
), quoted
.buf
);
245 if (!*dir_gone
&& !quiet
) {
247 for (i
= 0; i
< dels
.nr
; i
++)
248 printf(dry_run
? _(msg_would_remove
) : _(msg_remove
), dels
.items
[i
].string
);
251 strbuf_release("ed
);
252 string_list_clear(&dels
, 0);
256 static void pretty_print_dels(void)
258 struct string_list list
= STRING_LIST_INIT_DUP
;
259 struct string_list_item
*item
;
260 struct strbuf buf
= STRBUF_INIT
;
262 struct column_options copts
;
264 for_each_string_list_item(item
, &del_list
) {
265 qname
= quote_path_relative(item
->string
, NULL
, &buf
);
266 string_list_append(&list
, qname
);
270 * always enable column display, we only consult column.*
271 * about layout strategy and stuff
273 colopts
= (colopts
& ~COL_ENABLE_MASK
) | COL_ENABLED
;
274 memset(&copts
, 0, sizeof(copts
));
277 print_columns(&list
, colopts
, &copts
);
278 strbuf_release(&buf
);
279 string_list_clear(&list
, 0);
282 static void pretty_print_menus(struct string_list
*menu_list
)
284 unsigned int local_colopts
= 0;
285 struct column_options copts
;
287 local_colopts
= COL_ENABLED
| COL_ROW
;
288 memset(&copts
, 0, sizeof(copts
));
291 print_columns(menu_list
, local_colopts
, &copts
);
294 static void prompt_help_cmd(int singleton
)
296 clean_print_color(CLEAN_COLOR_HELP
);
299 "1 - select a numbered item\n"
300 "foo - select item based on unique prefix\n"
301 " - (empty) select nothing\n") :
303 "1 - select a single item\n"
304 "3-5 - select a range of items\n"
305 "2-3,6-9 - select multiple ranges\n"
306 "foo - select item based on unique prefix\n"
307 "-... - unselect specified items\n"
308 "* - choose all items\n"
309 " - (empty) finish selecting\n"));
310 clean_print_color(CLEAN_COLOR_RESET
);
314 * display menu stuff with number prefix and hotkey highlight
316 static void print_highlight_menu_stuff(struct menu_stuff
*stuff
, int **chosen
)
318 struct string_list menu_list
= STRING_LIST_INIT_DUP
;
319 struct strbuf menu
= STRBUF_INIT
;
320 struct menu_item
*menu_item
;
321 struct string_list_item
*string_list_item
;
324 switch (stuff
->type
) {
326 die("Bad type of menu_stuff when print menu");
327 case MENU_STUFF_TYPE_MENU_ITEM
:
328 menu_item
= (struct menu_item
*)stuff
->stuff
;
329 for (i
= 0; i
< stuff
->nr
; i
++, menu_item
++) {
333 p
= menu_item
->title
;
334 if ((*chosen
)[i
] < 0)
335 (*chosen
)[i
] = menu_item
->selected
? 1 : 0;
336 strbuf_addf(&menu
, "%s%2d: ", (*chosen
)[i
] ? "*" : " ", i
+1);
338 if (!highlighted
&& *p
== menu_item
->hotkey
) {
339 strbuf_addstr(&menu
, clean_get_color(CLEAN_COLOR_PROMPT
));
340 strbuf_addch(&menu
, *p
);
341 strbuf_addstr(&menu
, clean_get_color(CLEAN_COLOR_RESET
));
344 strbuf_addch(&menu
, *p
);
347 string_list_append(&menu_list
, menu
.buf
);
351 case MENU_STUFF_TYPE_STRING_LIST
:
353 for_each_string_list_item(string_list_item
, (struct string_list
*)stuff
->stuff
) {
354 if ((*chosen
)[i
] < 0)
356 strbuf_addf(&menu
, "%s%2d: %s",
357 (*chosen
)[i
] ? "*" : " ", i
+1, string_list_item
->string
);
358 string_list_append(&menu_list
, menu
.buf
);
365 pretty_print_menus(&menu_list
);
367 strbuf_release(&menu
);
368 string_list_clear(&menu_list
, 0);
371 static int find_unique(const char *choice
, struct menu_stuff
*menu_stuff
)
373 struct menu_item
*menu_item
;
374 struct string_list_item
*string_list_item
;
375 int i
, len
, found
= 0;
377 len
= strlen(choice
);
378 switch (menu_stuff
->type
) {
380 die("Bad type of menu_stuff when parse choice");
381 case MENU_STUFF_TYPE_MENU_ITEM
:
383 menu_item
= (struct menu_item
*)menu_stuff
->stuff
;
384 for (i
= 0; i
< menu_stuff
->nr
; i
++, menu_item
++) {
385 if (len
== 1 && *choice
== menu_item
->hotkey
) {
389 if (!strncasecmp(choice
, menu_item
->title
, len
)) {
392 /* continue for hotkey matching */
404 case MENU_STUFF_TYPE_STRING_LIST
:
405 string_list_item
= ((struct string_list
*)menu_stuff
->stuff
)->items
;
406 for (i
= 0; i
< menu_stuff
->nr
; i
++, string_list_item
++) {
407 if (!strncasecmp(choice
, string_list_item
->string
, len
)) {
422 * Parse user input, and return choice(s) for menu (menu_stuff).
425 * (for single choice)
426 * 1 - select a numbered item
427 * foo - select item based on menu title
428 * - (empty) select nothing
430 * (for multiple choice)
431 * 1 - select a single item
432 * 3-5 - select a range of items
433 * 2-3,6-9 - select multiple ranges
434 * foo - select item based on menu title
435 * -... - unselect specified items
436 * * - choose all items
437 * - (empty) finish selecting
439 * The parse result will be saved in array **chosen, and
440 * return number of total selections.
442 static int parse_choice(struct menu_stuff
*menu_stuff
,
447 struct strbuf
**choice_list
, **ptr
;
452 choice_list
= strbuf_split_max(&input
, '\n', 0);
459 choice_list
= strbuf_split_max(&input
, ' ', 0);
462 for (ptr
= choice_list
; *ptr
; ptr
++) {
465 int bottom
= 0, top
= 0;
466 int is_range
, is_number
;
472 /* Input that begins with '-'; unchoose */
473 if (*(*ptr
)->buf
== '-') {
475 strbuf_remove((*ptr
), 0, 1);
480 for (p
= (*ptr
)->buf
; *p
; p
++) {
490 } else if (!isdigit(*p
)) {
498 bottom
= atoi((*ptr
)->buf
);
500 } else if (is_range
) {
501 bottom
= atoi((*ptr
)->buf
);
502 /* a range can be specified like 5-7 or 5- */
503 if (!*(strchr((*ptr
)->buf
, '-') + 1))
504 top
= menu_stuff
->nr
;
506 top
= atoi(strchr((*ptr
)->buf
, '-') + 1);
507 } else if (!strcmp((*ptr
)->buf
, "*")) {
509 top
= menu_stuff
->nr
;
511 bottom
= find_unique((*ptr
)->buf
, menu_stuff
);
515 if (top
<= 0 || bottom
<= 0 || top
> menu_stuff
->nr
|| bottom
> top
||
516 (is_single
&& bottom
!= top
)) {
517 clean_print_color(CLEAN_COLOR_ERROR
);
518 printf(_("Huh (%s)?\n"), (*ptr
)->buf
);
519 clean_print_color(CLEAN_COLOR_RESET
);
523 for (i
= bottom
; i
<= top
; i
++)
524 (*chosen
)[i
-1] = choose
;
527 strbuf_list_free(choice_list
);
529 for (i
= 0; i
< menu_stuff
->nr
; i
++)
535 * Implement a git-add-interactive compatible UI, which is borrowed
536 * from git-add--interactive.perl.
540 * - Return an array of integers
541 * - , and it is up to you to free the allocated memory.
542 * - The array ends with EOF.
543 * - If user pressed CTRL-D (i.e. EOF), no selection returned.
545 static int *list_and_choose(struct menu_opts
*opts
, struct menu_stuff
*stuff
)
547 struct strbuf choice
= STRBUF_INIT
;
548 int *chosen
, *result
;
553 ALLOC_ARRAY(chosen
, stuff
->nr
);
554 /* set chosen as uninitialized */
555 for (i
= 0; i
< stuff
->nr
; i
++)
561 clean_get_color(CLEAN_COLOR_HEADER
),
563 clean_get_color(CLEAN_COLOR_RESET
));
566 /* chosen will be initialized by print_highlight_menu_stuff */
567 print_highlight_menu_stuff(stuff
, &chosen
);
569 if (opts
->flags
& MENU_OPTS_LIST_ONLY
)
574 clean_get_color(CLEAN_COLOR_PROMPT
),
576 opts
->flags
& MENU_OPTS_SINGLETON
? "> " : ">> ",
577 clean_get_color(CLEAN_COLOR_RESET
));
580 if (strbuf_getline_lf(&choice
, stdin
) != EOF
) {
581 strbuf_trim(&choice
);
587 /* help for prompt */
588 if (!strcmp(choice
.buf
, "?")) {
589 prompt_help_cmd(opts
->flags
& MENU_OPTS_SINGLETON
);
593 /* for a multiple-choice menu, press ENTER (empty) will return back */
594 if (!(opts
->flags
& MENU_OPTS_SINGLETON
) && !choice
.len
)
597 nr
= parse_choice(stuff
,
598 opts
->flags
& MENU_OPTS_SINGLETON
,
602 if (opts
->flags
& MENU_OPTS_SINGLETON
) {
605 } else if (opts
->flags
& MENU_OPTS_IMMEDIATE
) {
611 result
= xmalloc(sizeof(int));
617 * recalculate nr, if return back from menu directly with
618 * default selections.
621 for (i
= 0; i
< stuff
->nr
; i
++)
625 result
= xcalloc(st_add(nr
, 1), sizeof(int));
626 for (i
= 0; i
< stuff
->nr
&& j
< nr
; i
++) {
634 strbuf_release(&choice
);
638 static int clean_cmd(void)
640 return MENU_RETURN_NO_LOOP
;
643 static int filter_by_patterns_cmd(void)
645 struct dir_struct dir
;
646 struct strbuf confirm
= STRBUF_INIT
;
647 struct strbuf
**ignore_list
;
648 struct string_list_item
*item
;
649 struct exclude_list
*el
;
659 clean_print_color(CLEAN_COLOR_PROMPT
);
660 printf(_("Input ignore patterns>> "));
661 clean_print_color(CLEAN_COLOR_RESET
);
662 if (strbuf_getline_lf(&confirm
, stdin
) != EOF
)
663 strbuf_trim(&confirm
);
667 /* quit filter_by_pattern mode if press ENTER or Ctrl-D */
671 memset(&dir
, 0, sizeof(dir
));
672 el
= add_exclude_list(&dir
, EXC_CMDL
, "manual exclude");
673 ignore_list
= strbuf_split_max(&confirm
, ' ', 0);
675 for (i
= 0; ignore_list
[i
]; i
++) {
676 strbuf_trim(ignore_list
[i
]);
677 if (!ignore_list
[i
]->len
)
680 add_exclude(ignore_list
[i
]->buf
, "", 0, el
, -(i
+1));
684 for_each_string_list_item(item
, &del_list
) {
685 int dtype
= DT_UNKNOWN
;
687 if (is_excluded(&dir
, &the_index
, item
->string
, &dtype
)) {
688 *item
->string
= '\0';
694 string_list_remove_empty_items(&del_list
, 0);
696 clean_print_color(CLEAN_COLOR_ERROR
);
697 printf_ln(_("WARNING: Cannot find items matched by: %s"), confirm
.buf
);
698 clean_print_color(CLEAN_COLOR_RESET
);
701 strbuf_list_free(ignore_list
);
702 clear_directory(&dir
);
705 strbuf_release(&confirm
);
709 static int select_by_numbers_cmd(void)
711 struct menu_opts menu_opts
;
712 struct menu_stuff menu_stuff
;
713 struct string_list_item
*items
;
717 menu_opts
.header
= NULL
;
718 menu_opts
.prompt
= N_("Select items to delete");
721 menu_stuff
.type
= MENU_STUFF_TYPE_STRING_LIST
;
722 menu_stuff
.stuff
= &del_list
;
723 menu_stuff
.nr
= del_list
.nr
;
725 chosen
= list_and_choose(&menu_opts
, &menu_stuff
);
726 items
= del_list
.items
;
727 for (i
= 0, j
= 0; i
< del_list
.nr
; i
++) {
729 *(items
[i
].string
) = '\0';
730 } else if (i
== chosen
[j
]) {
731 /* delete selected item */
735 /* end of chosen (chosen[j] == EOF), won't delete */
736 *(items
[i
].string
) = '\0';
740 string_list_remove_empty_items(&del_list
, 0);
746 static int ask_each_cmd(void)
748 struct strbuf confirm
= STRBUF_INIT
;
749 struct strbuf buf
= STRBUF_INIT
;
750 struct string_list_item
*item
;
752 int changed
= 0, eof
= 0;
754 for_each_string_list_item(item
, &del_list
) {
755 /* Ctrl-D should stop removing files */
757 qname
= quote_path_relative(item
->string
, NULL
, &buf
);
758 /* TRANSLATORS: Make sure to keep [y/N] as is */
759 printf(_("Remove %s [y/N]? "), qname
);
760 if (strbuf_getline_lf(&confirm
, stdin
) != EOF
) {
761 strbuf_trim(&confirm
);
767 if (!confirm
.len
|| strncasecmp(confirm
.buf
, "yes", confirm
.len
)) {
768 *item
->string
= '\0';
774 string_list_remove_empty_items(&del_list
, 0);
776 strbuf_release(&buf
);
777 strbuf_release(&confirm
);
778 return MENU_RETURN_NO_LOOP
;
781 static int quit_cmd(void)
783 string_list_clear(&del_list
, 0);
785 return MENU_RETURN_NO_LOOP
;
788 static int help_cmd(void)
790 clean_print_color(CLEAN_COLOR_HELP
);
792 "clean - start cleaning\n"
793 "filter by pattern - exclude items from deletion\n"
794 "select by numbers - select items to be deleted by numbers\n"
795 "ask each - confirm each deletion (like \"rm -i\")\n"
796 "quit - stop cleaning\n"
797 "help - this screen\n"
798 "? - help for prompt selection"
800 clean_print_color(CLEAN_COLOR_RESET
);
804 static void interactive_main_loop(void)
806 while (del_list
.nr
) {
807 struct menu_opts menu_opts
;
808 struct menu_stuff menu_stuff
;
809 struct menu_item menus
[] = {
810 {'c', "clean", 0, clean_cmd
},
811 {'f', "filter by pattern", 0, filter_by_patterns_cmd
},
812 {'s', "select by numbers", 0, select_by_numbers_cmd
},
813 {'a', "ask each", 0, ask_each_cmd
},
814 {'q', "quit", 0, quit_cmd
},
815 {'h', "help", 0, help_cmd
},
819 menu_opts
.header
= N_("*** Commands ***");
820 menu_opts
.prompt
= N_("What now");
821 menu_opts
.flags
= MENU_OPTS_SINGLETON
;
823 menu_stuff
.type
= MENU_STUFF_TYPE_MENU_ITEM
;
824 menu_stuff
.stuff
= menus
;
825 menu_stuff
.nr
= sizeof(menus
) / sizeof(struct menu_item
);
827 clean_print_color(CLEAN_COLOR_HEADER
);
828 printf_ln(Q_("Would remove the following item:",
829 "Would remove the following items:",
831 clean_print_color(CLEAN_COLOR_RESET
);
835 chosen
= list_and_choose(&menu_opts
, &menu_stuff
);
837 if (*chosen
!= EOF
) {
839 ret
= menus
[*chosen
].fn();
840 if (ret
!= MENU_RETURN_NO_LOOP
) {
841 FREE_AND_NULL(chosen
);
843 clean_print_color(CLEAN_COLOR_ERROR
);
844 printf_ln(_("No more files to clean, exiting."));
845 clean_print_color(CLEAN_COLOR_RESET
);
854 FREE_AND_NULL(chosen
);
859 static void correct_untracked_entries(struct dir_struct
*dir
)
863 for (src
= dst
= ign
= 0; src
< dir
->nr
; src
++) {
864 /* skip paths in ignored[] that cannot be inside entries[src] */
865 while (ign
< dir
->ignored_nr
&&
866 0 <= cmp_dir_entry(&dir
->entries
[src
], &dir
->ignored
[ign
]))
869 if (ign
< dir
->ignored_nr
&&
870 check_dir_entry_contains(dir
->entries
[src
], dir
->ignored
[ign
])) {
871 /* entries[src] contains an ignored path, so we drop it */
872 free(dir
->entries
[src
]);
874 struct dir_entry
*ent
= dir
->entries
[src
++];
876 /* entries[src] does not contain an ignored path, so we keep it */
877 dir
->entries
[dst
++] = ent
;
879 /* then discard paths in entries[] contained inside entries[src] */
880 while (src
< dir
->nr
&&
881 check_dir_entry_contains(ent
, dir
->entries
[src
]))
882 free(dir
->entries
[src
++]);
884 /* compensate for the outer loop's loop control */
891 int cmd_clean(int argc
, const char **argv
, const char *prefix
)
894 int dry_run
= 0, remove_directories
= 0, quiet
= 0, ignored
= 0;
895 int ignored_only
= 0, config_set
= 0, errors
= 0, gone
= 1;
896 int rm_flags
= REMOVE_DIR_KEEP_NESTED_GIT
;
897 struct strbuf abs_path
= STRBUF_INIT
;
898 struct dir_struct dir
;
899 struct pathspec pathspec
;
900 struct strbuf buf
= STRBUF_INIT
;
901 struct string_list exclude_list
= STRING_LIST_INIT_NODUP
;
902 struct exclude_list
*el
;
903 struct string_list_item
*item
;
905 struct option options
[] = {
906 OPT__QUIET(&quiet
, N_("do not print names of files removed")),
907 OPT__DRY_RUN(&dry_run
, N_("dry run")),
908 OPT__FORCE(&force
, N_("force"), PARSE_OPT_NOCOMPLETE
),
909 OPT_BOOL('i', "interactive", &interactive
, N_("interactive cleaning")),
910 OPT_BOOL('d', NULL
, &remove_directories
,
911 N_("remove whole directories")),
912 { OPTION_CALLBACK
, 'e', "exclude", &exclude_list
, N_("pattern"),
913 N_("add <pattern> to ignore rules"), PARSE_OPT_NONEG
, exclude_cb
},
914 OPT_BOOL('x', NULL
, &ignored
, N_("remove ignored files, too")),
915 OPT_BOOL('X', NULL
, &ignored_only
,
916 N_("remove only ignored files")),
920 git_config(git_clean_config
, NULL
);
926 argc
= parse_options(argc
, argv
, prefix
, options
, builtin_clean_usage
,
929 memset(&dir
, 0, sizeof(dir
));
931 dir
.flags
|= DIR_SHOW_IGNORED
;
933 if (ignored
&& ignored_only
)
934 die(_("-x and -X cannot be used together"));
936 if (!interactive
&& !dry_run
&& !force
) {
938 die(_("clean.requireForce set to true and neither -i, -n, nor -f given; "
939 "refusing to clean"));
941 die(_("clean.requireForce defaults to true and neither -i, -n, nor -f given;"
942 " refusing to clean"));
948 dir
.flags
|= DIR_SHOW_OTHER_DIRECTORIES
;
950 if (remove_directories
)
951 dir
.flags
|= DIR_SHOW_IGNORED_TOO
| DIR_KEEP_UNTRACKED_CONTENTS
;
953 if (read_cache() < 0)
954 die(_("index file corrupt"));
957 setup_standard_excludes(&dir
);
959 el
= add_exclude_list(&dir
, EXC_CMDL
, "--exclude option");
960 for (i
= 0; i
< exclude_list
.nr
; i
++)
961 add_exclude(exclude_list
.items
[i
].string
, "", 0, el
, -(i
+1));
963 parse_pathspec(&pathspec
, 0,
967 fill_directory(&dir
, &the_index
, &pathspec
);
968 correct_untracked_entries(&dir
);
970 for (i
= 0; i
< dir
.nr
; i
++) {
971 struct dir_entry
*ent
= dir
.entries
[i
];
976 if (!cache_name_is_other(ent
->name
, ent
->len
))
980 matches
= dir_path_match(&the_index
, ent
, &pathspec
, 0, NULL
);
982 if (pathspec
.nr
&& !matches
)
985 if (lstat(ent
->name
, &st
))
986 die_errno("Cannot lstat '%s'", ent
->name
);
988 if (S_ISDIR(st
.st_mode
) && !remove_directories
&&
989 matches
!= MATCHED_EXACTLY
)
992 rel
= relative_path(ent
->name
, prefix
, &buf
);
993 string_list_append(&del_list
, rel
);
996 for (i
= 0; i
< dir
.nr
; i
++)
997 free(dir
.entries
[i
]);
999 for (i
= 0; i
< dir
.ignored_nr
; i
++)
1000 free(dir
.ignored
[i
]);
1002 if (interactive
&& del_list
.nr
> 0)
1003 interactive_main_loop();
1005 for_each_string_list_item(item
, &del_list
) {
1009 strbuf_addstr(&abs_path
, prefix
);
1011 strbuf_addstr(&abs_path
, item
->string
);
1014 * we might have removed this as part of earlier
1015 * recursive directory removal, so lstat() here could
1018 if (lstat(abs_path
.buf
, &st
))
1021 if (S_ISDIR(st
.st_mode
)) {
1022 if (remove_dirs(&abs_path
, prefix
, rm_flags
, dry_run
, quiet
, &gone
))
1024 if (gone
&& !quiet
) {
1025 qname
= quote_path_relative(item
->string
, NULL
, &buf
);
1026 printf(dry_run
? _(msg_would_remove
) : _(msg_remove
), qname
);
1029 res
= dry_run
? 0 : unlink(abs_path
.buf
);
1031 int saved_errno
= errno
;
1032 qname
= quote_path_relative(item
->string
, NULL
, &buf
);
1033 errno
= saved_errno
;
1034 warning_errno(_(msg_warn_remove_failed
), qname
);
1036 } else if (!quiet
) {
1037 qname
= quote_path_relative(item
->string
, NULL
, &buf
);
1038 printf(dry_run
? _(msg_would_remove
) : _(msg_remove
), qname
);
1041 strbuf_reset(&abs_path
);
1044 strbuf_release(&abs_path
);
1045 strbuf_release(&buf
);
1046 string_list_clear(&del_list
, 0);
1047 string_list_clear(&exclude_list
, 0);
1048 return (errors
!= 0);