builtin/clean.c

   1 /*
   2  * "git clean" builtin command
   3  *
   4  * Copyright (C) 2007 Shawn Bohrer
   5  *
   6  * Based on git-clean.sh by Pavel Roskin
   7  */
   8
   9 #define USE_THE_INDEX_VARIABLE
  10 #include "builtin.h"
  11 #include "cache.h"
  12 #include "config.h"
  13 #include "dir.h"
  14 #include "parse-options.h"
  15 #include "string-list.h"
  16 #include "quote.h"
  17 #include "column.h"
  18 #include "color.h"
  19 #include "pathspec.h"
  20 #include "help.h"
  21 #include "prompt.h"
  22
  23 static int force = -1; /* unset */
  24 static int interactive;
  25 static struct string_list del_list = STRING_LIST_INIT_DUP;
  26 static unsigned int colopts;
  27
  28 static const char *const builtin_clean_usage[] = {
  29         N_("git clean [-d] [-f] [-i] [-n] [-q] [-e <pattern>] [-x | -X] [--] [<pathspec>...]"),
  30         NULL
  31 };
  32
  33 static const char *msg_remove = N_("Removing %s\n");
  34 static const char *msg_would_remove = N_("Would remove %s\n");
  35 static const char *msg_skip_git_dir = N_("Skipping repository %s\n");
  36 static const char *msg_would_skip_git_dir = N_("Would skip repository %s\n");
  37 static const char *msg_warn_remove_failed = N_("failed to remove %s");
  38 static const char *msg_warn_lstat_failed = N_("could not lstat %s\n");
  39 static const char *msg_skip_cwd = N_("Refusing to remove current working directory\n");
  40 static const char *msg_would_skip_cwd = N_("Would refuse to remove current working directory\n");
  41
  42 enum color_clean {
  43         CLEAN_COLOR_RESET = 0,
  44         CLEAN_COLOR_PLAIN = 1,
  45         CLEAN_COLOR_PROMPT = 2,
  46         CLEAN_COLOR_HEADER = 3,
  47         CLEAN_COLOR_HELP = 4,
  48         CLEAN_COLOR_ERROR = 5
  49 };
  50
  51 static const char *color_interactive_slots[] = {
  52         [CLEAN_COLOR_ERROR]  = "error",
  53         [CLEAN_COLOR_HEADER] = "header",
  54         [CLEAN_COLOR_HELP]   = "help",
  55         [CLEAN_COLOR_PLAIN]  = "plain",
  56         [CLEAN_COLOR_PROMPT] = "prompt",
  57         [CLEAN_COLOR_RESET]  = "reset",
  58 };
  59
  60 static int clean_use_color = -1;
  61 static char clean_colors[][COLOR_MAXLEN] = {
  62         [CLEAN_COLOR_ERROR] = GIT_COLOR_BOLD_RED,
  63         [CLEAN_COLOR_HEADER] = GIT_COLOR_BOLD,
  64         [CLEAN_COLOR_HELP] = GIT_COLOR_BOLD_RED,
  65         [CLEAN_COLOR_PLAIN] = GIT_COLOR_NORMAL,
  66         [CLEAN_COLOR_PROMPT] = GIT_COLOR_BOLD_BLUE,
  67         [CLEAN_COLOR_RESET] = GIT_COLOR_RESET,
  68 };
  69
  70 #define MENU_OPTS_SINGLETON             01
  71 #define MENU_OPTS_IMMEDIATE             02
  72 #define MENU_OPTS_LIST_ONLY             04
  73
  74 struct menu_opts {
  75         const char *header;
  76         const char *prompt;
  77         int flags;
  78 };
  79
  80 #define MENU_RETURN_NO_LOOP             10
  81
  82 struct menu_item {
  83         char hotkey;
  84         const char *title;
  85         int selected;
  86         int (*fn)(void);
  87 };
  88
  89 enum menu_stuff_type {
  90         MENU_STUFF_TYPE_STRING_LIST = 1,
  91         MENU_STUFF_TYPE_MENU_ITEM
  92 };
  93
  94 struct menu_stuff {
  95         enum menu_stuff_type type;
  96         int nr;
  97         void *stuff;
  98 };
  99
 100 define_list_config_array(color_interactive_slots);
 101
 102 static int git_clean_config(const char *var, const char *value, void *cb)
 103 {
 104         const char *slot_name;
 105
 106         if (starts_with(var, "column."))
 107                 return git_column_config(var, value, "clean", &colopts);
 108
 109         /* honors the color.interactive* config variables which also
 110            applied in git-add--interactive and git-stash */
 111         if (!strcmp(var, "color.interactive")) {
 112                 clean_use_color = git_config_colorbool(var, value);
 113                 return 0;
 114         }
 115         if (skip_prefix(var, "color.interactive.", &slot_name)) {
 116                 int slot = LOOKUP_CONFIG(color_interactive_slots, slot_name);
 117                 if (slot < 0)
 118                         return 0;
 119                 if (!value)
 120                         return config_error_nonbool(var);
 121                 return color_parse(value, clean_colors[slot]);
 122         }
 123
 124         if (!strcmp(var, "clean.requireforce")) {
 125                 force = !git_config_bool(var, value);
 126                 return 0;
 127         }
 128
 129         /* inspect the color.ui config variable and others */
 130         return git_color_default_config(var, value, cb);
 131 }
 132
 133 static const char *clean_get_color(enum color_clean ix)
 134 {
 135         if (want_color(clean_use_color))
 136                 return clean_colors[ix];
 137         return "";
 138 }
 139
 140 static void clean_print_color(enum color_clean ix)
 141 {
 142         printf("%s", clean_get_color(ix));
 143 }
 144
 145 static int exclude_cb(const struct option *opt, const char *arg, int unset)
 146 {
 147         struct string_list *exclude_list = opt->value;
 148         BUG_ON_OPT_NEG(unset);
 149         string_list_append(exclude_list, arg);
 150         return 0;
 151 }
 152
 153 static int remove_dirs(struct strbuf *path, const char *prefix, int force_flag,
 154                 int dry_run, int quiet, int *dir_gone)
 155 {
 156         DIR *dir;
 157         struct strbuf quoted = STRBUF_INIT;
 158         struct strbuf realpath = STRBUF_INIT;
 159         struct strbuf real_ocwd = STRBUF_INIT;
 160         struct dirent *e;
 161         int res = 0, ret = 0, gone = 1, original_len = path->len, len;
 162         struct string_list dels = STRING_LIST_INIT_DUP;
 163
 164         *dir_gone = 1;
 165
 166         if ((force_flag & REMOVE_DIR_KEEP_NESTED_GIT) &&
 167             is_nonbare_repository_dir(path)) {
 168                 if (!quiet) {
 169                         quote_path(path->buf, prefix, &quoted, 0);
 170                         printf(dry_run ?  _(msg_would_skip_git_dir) : _(msg_skip_git_dir),
 171                                         quoted.buf);
 172                 }
 173
 174                 *dir_gone = 0;
 175                 goto out;
 176         }
 177
 178         dir = opendir(path->buf);
 179         if (!dir) {
 180                 /* an empty dir could be removed even if it is unreadble */
 181                 res = dry_run ? 0 : rmdir(path->buf);
 182                 if (res) {
 183                         int saved_errno = errno;
 184                         quote_path(path->buf, prefix, &quoted, 0);
 185                         errno = saved_errno;
 186                         warning_errno(_(msg_warn_remove_failed), quoted.buf);
 187                         *dir_gone = 0;
 188                 }
 189                 ret = res;
 190                 goto out;
 191         }
 192
 193         strbuf_complete(path, '/');
 194
 195         len = path->len;
 196         while ((e = readdir_skip_dot_and_dotdot(dir)) != NULL) {
 197                 struct stat st;
 198
 199                 strbuf_setlen(path, len);
 200                 strbuf_addstr(path, e->d_name);
 201                 if (lstat(path->buf, &st))
 202                         warning_errno(_(msg_warn_lstat_failed), path->buf);
 203                 else if (S_ISDIR(st.st_mode)) {
 204                         if (remove_dirs(path, prefix, force_flag, dry_run, quiet, &gone))
 205                                 ret = 1;
 206                         if (gone) {
 207                                 quote_path(path->buf, prefix, &quoted, 0);
 208                                 string_list_append(&dels, quoted.buf);
 209                         } else
 210                                 *dir_gone = 0;
 211                         continue;
 212                 } else {
 213                         res = dry_run ? 0 : unlink(path->buf);
 214                         if (!res) {
 215                                 quote_path(path->buf, prefix, &quoted, 0);
 216                                 string_list_append(&dels, quoted.buf);
 217                         } else {
 218                                 int saved_errno = errno;
 219                                 quote_path(path->buf, prefix, &quoted, 0);
 220                                 errno = saved_errno;
 221                                 warning_errno(_(msg_warn_remove_failed), quoted.buf);
 222                                 *dir_gone = 0;
 223                                 ret = 1;
 224                         }
 225                         continue;
 226                 }
 227
 228                 /* path too long, stat fails, or non-directory still exists */
 229                 *dir_gone = 0;
 230                 ret = 1;
 231                 break;
 232         }
 233         closedir(dir);
 234
 235         strbuf_setlen(path, original_len);
 236
 237         if (*dir_gone) {
 238                 /*
 239                  * Normalize path components in path->buf, e.g. change '\' to
 240                  * '/' on Windows.
 241                  */
 242                 strbuf_realpath(&realpath, path->buf, 1);
 243
 244                 /*
 245                  * path and realpath are absolute; for comparison, we would
 246                  * like to transform startup_info->original_cwd to an absolute
 247                  * path too.
 248                  */
 249                  if (startup_info->original_cwd)
 250                          strbuf_realpath(&real_ocwd,
 251                                          startup_info->original_cwd, 1);
 252
 253                 if (!strbuf_cmp(&realpath, &real_ocwd)) {
 254                         printf("%s", dry_run ? _(msg_would_skip_cwd) : _(msg_skip_cwd));
 255                         *dir_gone = 0;
 256                 } else {
 257                         res = dry_run ? 0 : rmdir(path->buf);
 258                         if (!res)
 259                                 *dir_gone = 1;
 260                         else {
 261                                 int saved_errno = errno;
 262                                 quote_path(path->buf, prefix, &quoted, 0);
 263                                 errno = saved_errno;
 264                                 warning_errno(_(msg_warn_remove_failed), quoted.buf);
 265                                 *dir_gone = 0;
 266                                 ret = 1;
 267                         }
 268                 }
 269         }
 270
 271         if (!*dir_gone && !quiet) {
 272                 int i;
 273                 for (i = 0; i < dels.nr; i++)
 274                         printf(dry_run ?  _(msg_would_remove) : _(msg_remove), dels.items[i].string);
 275         }
 276 out:
 277         strbuf_release(&realpath);
 278         strbuf_release(&real_ocwd);
 279         strbuf_release(&quoted);
 280         string_list_clear(&dels, 0);
 281         return ret;
 282 }
 283
 284 static void pretty_print_dels(void)
 285 {
 286         struct string_list list = STRING_LIST_INIT_DUP;
 287         struct string_list_item *item;
 288         struct strbuf buf = STRBUF_INIT;
 289         const char *qname;
 290         struct column_options copts;
 291
 292         for_each_string_list_item(item, &del_list) {
 293                 qname = quote_path(item->string, NULL, &buf, 0);
 294                 string_list_append(&list, qname);
 295         }
 296
 297         /*
 298          * always enable column display, we only consult column.*
 299          * about layout strategy and stuff
 300          */
 301         colopts = (colopts & ~COL_ENABLE_MASK) | COL_ENABLED;
 302         memset(&copts, 0, sizeof(copts));
 303         copts.indent = "  ";
 304         copts.padding = 2;
 305         print_columns(&list, colopts, &copts);
 306         strbuf_release(&buf);
 307         string_list_clear(&list, 0);
 308 }
 309
 310 static void pretty_print_menus(struct string_list *menu_list)
 311 {
 312         unsigned int local_colopts = 0;
 313         struct column_options copts;
 314
 315         local_colopts = COL_ENABLED | COL_ROW;
 316         memset(&copts, 0, sizeof(copts));
 317         copts.indent = "  ";
 318         copts.padding = 2;
 319         print_columns(menu_list, local_colopts, &copts);
 320 }
 321
 322 static void prompt_help_cmd(int singleton)
 323 {
 324         clean_print_color(CLEAN_COLOR_HELP);
 325         printf(singleton ?
 326                   _("Prompt help:\n"
 327                     "1          - select a numbered item\n"
 328                     "foo        - select item based on unique prefix\n"
 329                     "           - (empty) select nothing\n") :
 330                   _("Prompt help:\n"
 331                     "1          - select a single item\n"
 332                     "3-5        - select a range of items\n"
 333                     "2-3,6-9    - select multiple ranges\n"
 334                     "foo        - select item based on unique prefix\n"
 335                     "-...       - unselect specified items\n"
 336                     "*          - choose all items\n"
 337                     "           - (empty) finish selecting\n"));
 338         clean_print_color(CLEAN_COLOR_RESET);
 339 }
 340
 341 /*
 342  * display menu stuff with number prefix and hotkey highlight
 343  */
 344 static void print_highlight_menu_stuff(struct menu_stuff *stuff, int **chosen)
 345 {
 346         struct string_list menu_list = STRING_LIST_INIT_DUP;
 347         struct strbuf menu = STRBUF_INIT;
 348         struct menu_item *menu_item;
 349         struct string_list_item *string_list_item;
 350         int i;
 351
 352         switch (stuff->type) {
 353         default:
 354                 die("Bad type of menu_stuff when print menu");
 355         case MENU_STUFF_TYPE_MENU_ITEM:
 356                 menu_item = (struct menu_item *)stuff->stuff;
 357                 for (i = 0; i < stuff->nr; i++, menu_item++) {
 358                         const char *p;
 359                         int highlighted = 0;
 360
 361                         p = menu_item->title;
 362                         if ((*chosen)[i] < 0)
 363                                 (*chosen)[i] = menu_item->selected ? 1 : 0;
 364                         strbuf_addf(&menu, "%s%2d: ", (*chosen)[i] ? "*" : " ", i+1);
 365                         for (; *p; p++) {
 366                                 if (!highlighted && *p == menu_item->hotkey) {
 367                                         strbuf_addstr(&menu, clean_get_color(CLEAN_COLOR_PROMPT));
 368                                         strbuf_addch(&menu, *p);
 369                                         strbuf_addstr(&menu, clean_get_color(CLEAN_COLOR_RESET));
 370                                         highlighted = 1;
 371                                 } else {
 372                                         strbuf_addch(&menu, *p);
 373                                 }
 374                         }
 375                         string_list_append(&menu_list, menu.buf);
 376                         strbuf_reset(&menu);
 377                 }
 378                 break;
 379         case MENU_STUFF_TYPE_STRING_LIST:
 380                 i = 0;
 381                 for_each_string_list_item(string_list_item, (struct string_list *)stuff->stuff) {
 382                         if ((*chosen)[i] < 0)
 383                                 (*chosen)[i] = 0;
 384                         strbuf_addf(&menu, "%s%2d: %s",
 385                                     (*chosen)[i] ? "*" : " ", i+1, string_list_item->string);
 386                         string_list_append(&menu_list, menu.buf);
 387                         strbuf_reset(&menu);
 388                         i++;
 389                 }
 390                 break;
 391         }
 392
 393         pretty_print_menus(&menu_list);
 394
 395         strbuf_release(&menu);
 396         string_list_clear(&menu_list, 0);
 397 }
 398
 399 static int find_unique(const char *choice, struct menu_stuff *menu_stuff)
 400 {
 401         struct menu_item *menu_item;
 402         struct string_list_item *string_list_item;
 403         int i, len, found = 0;
 404
 405         len = strlen(choice);
 406         switch (menu_stuff->type) {
 407         default:
 408                 die("Bad type of menu_stuff when parse choice");
 409         case MENU_STUFF_TYPE_MENU_ITEM:
 410
 411                 menu_item = (struct menu_item *)menu_stuff->stuff;
 412                 for (i = 0; i < menu_stuff->nr; i++, menu_item++) {
 413                         if (len == 1 && *choice == menu_item->hotkey) {
 414                                 found = i + 1;
 415                                 break;
 416                         }
 417                         if (!strncasecmp(choice, menu_item->title, len)) {
 418                                 if (found) {
 419                                         if (len == 1) {
 420                                                 /* continue for hotkey matching */
 421                                                 found = -1;
 422                                         } else {
 423                                                 found = 0;
 424                                                 break;
 425                                         }
 426                                 } else {
 427                                         found = i + 1;
 428                                 }
 429                         }
 430                 }
 431                 break;
 432         case MENU_STUFF_TYPE_STRING_LIST:
 433                 string_list_item = ((struct string_list *)menu_stuff->stuff)->items;
 434                 for (i = 0; i < menu_stuff->nr; i++, string_list_item++) {
 435                         if (!strncasecmp(choice, string_list_item->string, len)) {
 436                                 if (found) {
 437                                         found = 0;
 438                                         break;
 439                                 }
 440                                 found = i + 1;
 441                         }
 442                 }
 443                 break;
 444         }
 445         return found;
 446 }
 447
 448 /*
 449  * Parse user input, and return choice(s) for menu (menu_stuff).
 450  *
 451  * Input
 452  *     (for single choice)
 453  *         1          - select a numbered item
 454  *         foo        - select item based on menu title
 455  *                    - (empty) select nothing
 456  *
 457  *     (for multiple choice)
 458  *         1          - select a single item
 459  *         3-5        - select a range of items
 460  *         2-3,6-9    - select multiple ranges
 461  *         foo        - select item based on menu title
 462  *         -...       - unselect specified items
 463  *         *          - choose all items
 464  *                    - (empty) finish selecting
 465  *
 466  * The parse result will be saved in array **chosen, and
 467  * return number of total selections.
 468  */
 469 static int parse_choice(struct menu_stuff *menu_stuff,
 470                         int is_single,
 471                         struct strbuf input,
 472                         int **chosen)
 473 {
 474         struct strbuf **choice_list, **ptr;
 475         int nr = 0;
 476         int i;
 477
 478         if (is_single) {
 479                 choice_list = strbuf_split_max(&input, '\n', 0);
 480         } else {
 481                 char *p = input.buf;
 482                 do {
 483                         if (*p == ',')
 484                                 *p = ' ';
 485                 } while (*p++);
 486                 choice_list = strbuf_split_max(&input, ' ', 0);
 487         }
 488
 489         for (ptr = choice_list; *ptr; ptr++) {
 490                 char *p;
 491                 int choose = 1;
 492                 int bottom = 0, top = 0;
 493                 int is_range, is_number;
 494
 495                 strbuf_trim(*ptr);
 496                 if (!(*ptr)->len)
 497                         continue;
 498
 499                 /* Input that begins with '-'; unchoose */
 500                 if (*(*ptr)->buf == '-') {
 501                         choose = 0;
 502                         strbuf_remove((*ptr), 0, 1);
 503                 }
 504
 505                 is_range = 0;
 506                 is_number = 1;
 507                 for (p = (*ptr)->buf; *p; p++) {
 508                         if ('-' == *p) {
 509                                 if (!is_range) {
 510                                         is_range = 1;
 511                                         is_number = 0;
 512                                 } else {
 513                                         is_number = 0;
 514                                         is_range = 0;
 515                                         break;
 516                                 }
 517                         } else if (!isdigit(*p)) {
 518                                 is_number = 0;
 519                                 is_range = 0;
 520                                 break;
 521                         }
 522                 }
 523
 524                 if (is_number) {
 525                         bottom = atoi((*ptr)->buf);
 526                         top = bottom;
 527                 } else if (is_range) {
 528                         bottom = atoi((*ptr)->buf);
 529                         /* a range can be specified like 5-7 or 5- */
 530                         if (!*(strchr((*ptr)->buf, '-') + 1))
 531                                 top = menu_stuff->nr;
 532                         else
 533                                 top = atoi(strchr((*ptr)->buf, '-') + 1);
 534                 } else if (!strcmp((*ptr)->buf, "*")) {
 535                         bottom = 1;
 536                         top = menu_stuff->nr;
 537                 } else {
 538                         bottom = find_unique((*ptr)->buf, menu_stuff);
 539                         top = bottom;
 540                 }
 541
 542                 if (top <= 0 || bottom <= 0 || top > menu_stuff->nr || bottom > top ||
 543                     (is_single && bottom != top)) {
 544                         clean_print_color(CLEAN_COLOR_ERROR);
 545                         printf(_("Huh (%s)?\n"), (*ptr)->buf);
 546                         clean_print_color(CLEAN_COLOR_RESET);
 547                         continue;
 548                 }
 549
 550                 for (i = bottom; i <= top; i++)
 551                         (*chosen)[i-1] = choose;
 552         }
 553
 554         strbuf_list_free(choice_list);
 555
 556         for (i = 0; i < menu_stuff->nr; i++)
 557                 nr += (*chosen)[i];
 558         return nr;
 559 }
 560
 561 /*
 562  * Implement a git-add-interactive compatible UI, which is borrowed
 563  * from add-interactive.c.
 564  *
 565  * Return value:
 566  *
 567  *   - Return an array of integers
 568  *   - , and it is up to you to free the allocated memory.
 569  *   - The array ends with EOF.
 570  *   - If user pressed CTRL-D (i.e. EOF), no selection returned.
 571  */
 572 static int *list_and_choose(struct menu_opts *opts, struct menu_stuff *stuff)
 573 {
 574         struct strbuf choice = STRBUF_INIT;
 575         int *chosen, *result;
 576         int nr = 0;
 577         int eof = 0;
 578         int i;
 579
 580         ALLOC_ARRAY(chosen, stuff->nr);
 581         /* set chosen as uninitialized */
 582         for (i = 0; i < stuff->nr; i++)
 583                 chosen[i] = -1;
 584
 585         for (;;) {
 586                 if (opts->header) {
 587                         printf_ln("%s%s%s",
 588                                   clean_get_color(CLEAN_COLOR_HEADER),
 589                                   _(opts->header),
 590                                   clean_get_color(CLEAN_COLOR_RESET));
 591                 }
 592
 593                 /* chosen will be initialized by print_highlight_menu_stuff */
 594                 print_highlight_menu_stuff(stuff, &chosen);
 595
 596                 if (opts->flags & MENU_OPTS_LIST_ONLY)
 597                         break;
 598
 599                 if (opts->prompt) {
 600                         printf("%s%s%s%s",
 601                                clean_get_color(CLEAN_COLOR_PROMPT),
 602                                _(opts->prompt),
 603                                opts->flags & MENU_OPTS_SINGLETON ? "> " : ">> ",
 604                                clean_get_color(CLEAN_COLOR_RESET));
 605                 }
 606
 607                 if (git_read_line_interactively(&choice) == EOF) {
 608                         eof = 1;
 609                         break;
 610                 }
 611
 612                 /* help for prompt */
 613                 if (!strcmp(choice.buf, "?")) {
 614                         prompt_help_cmd(opts->flags & MENU_OPTS_SINGLETON);
 615                         continue;
 616                 }
 617
 618                 /* for a multiple-choice menu, press ENTER (empty) will return back */
 619                 if (!(opts->flags & MENU_OPTS_SINGLETON) && !choice.len)
 620                         break;
 621
 622                 nr = parse_choice(stuff,
 623                                   opts->flags & MENU_OPTS_SINGLETON,
 624                                   choice,
 625                                   &chosen);
 626
 627                 if (opts->flags & MENU_OPTS_SINGLETON) {
 628                         if (nr)
 629                                 break;
 630                 } else if (opts->flags & MENU_OPTS_IMMEDIATE) {
 631                         break;
 632                 }
 633         }
 634
 635         if (eof) {
 636                 result = xmalloc(sizeof(int));
 637                 *result = EOF;
 638         } else {
 639                 int j = 0;
 640
 641                 /*
 642                  * recalculate nr, if return back from menu directly with
 643                  * default selections.
 644                  */
 645                 if (!nr) {
 646                         for (i = 0; i < stuff->nr; i++)
 647                                 nr += chosen[i];
 648                 }
 649
 650                 CALLOC_ARRAY(result, st_add(nr, 1));
 651                 for (i = 0; i < stuff->nr && j < nr; i++) {
 652                         if (chosen[i])
 653                                 result[j++] = i;
 654                 }
 655                 result[j] = EOF;
 656         }
 657
 658         free(chosen);
 659         strbuf_release(&choice);
 660         return result;
 661 }
 662
 663 static int clean_cmd(void)
 664 {
 665         return MENU_RETURN_NO_LOOP;
 666 }
 667
 668 static int filter_by_patterns_cmd(void)
 669 {
 670         struct dir_struct dir = DIR_INIT;
 671         struct strbuf confirm = STRBUF_INIT;
 672         struct strbuf **ignore_list;
 673         struct string_list_item *item;
 674         struct pattern_list *pl;
 675         int changed = -1, i;
 676
 677         for (;;) {
 678                 if (!del_list.nr)
 679                         break;
 680
 681                 if (changed)
 682                         pretty_print_dels();
 683
 684                 clean_print_color(CLEAN_COLOR_PROMPT);
 685                 printf(_("Input ignore patterns>> "));
 686                 clean_print_color(CLEAN_COLOR_RESET);
 687                 if (git_read_line_interactively(&confirm) == EOF)
 688                         putchar('\n');
 689
 690                 /* quit filter_by_pattern mode if press ENTER or Ctrl-D */
 691                 if (!confirm.len)
 692                         break;
 693
 694                 pl = add_pattern_list(&dir, EXC_CMDL, "manual exclude");
 695                 ignore_list = strbuf_split_max(&confirm, ' ', 0);
 696
 697                 for (i = 0; ignore_list[i]; i++) {
 698                         strbuf_trim(ignore_list[i]);
 699                         if (!ignore_list[i]->len)
 700                                 continue;
 701
 702                         add_pattern(ignore_list[i]->buf, "", 0, pl, -(i+1));
 703                 }
 704
 705                 changed = 0;
 706                 for_each_string_list_item(item, &del_list) {
 707                         int dtype = DT_UNKNOWN;
 708
 709                         if (is_excluded(&dir, &the_index, item->string, &dtype)) {
 710                                 *item->string = '\0';
 711                                 changed++;
 712                         }
 713                 }
 714
 715                 if (changed) {
 716                         string_list_remove_empty_items(&del_list, 0);
 717                 } else {
 718                         clean_print_color(CLEAN_COLOR_ERROR);
 719                         printf_ln(_("WARNING: Cannot find items matched by: %s"), confirm.buf);
 720                         clean_print_color(CLEAN_COLOR_RESET);
 721                 }
 722
 723                 strbuf_list_free(ignore_list);
 724                 dir_clear(&dir);
 725         }
 726
 727         strbuf_release(&confirm);
 728         return 0;
 729 }
 730
 731 static int select_by_numbers_cmd(void)
 732 {
 733         struct menu_opts menu_opts;
 734         struct menu_stuff menu_stuff;
 735         struct string_list_item *items;
 736         int *chosen;
 737         int i, j;
 738
 739         menu_opts.header = NULL;
 740         menu_opts.prompt = N_("Select items to delete");
 741         menu_opts.flags = 0;
 742
 743         menu_stuff.type = MENU_STUFF_TYPE_STRING_LIST;
 744         menu_stuff.stuff = &del_list;
 745         menu_stuff.nr = del_list.nr;
 746
 747         chosen = list_and_choose(&menu_opts, &menu_stuff);
 748         items = del_list.items;
 749         for (i = 0, j = 0; i < del_list.nr; i++) {
 750                 if (i < chosen[j]) {
 751                         *(items[i].string) = '\0';
 752                 } else if (i == chosen[j]) {
 753                         /* delete selected item */
 754                         j++;
 755                         continue;
 756                 } else {
 757                         /* end of chosen (chosen[j] == EOF), won't delete */
 758                         *(items[i].string) = '\0';
 759                 }
 760         }
 761
 762         string_list_remove_empty_items(&del_list, 0);
 763
 764         free(chosen);
 765         return 0;
 766 }
 767
 768 static int ask_each_cmd(void)
 769 {
 770         struct strbuf confirm = STRBUF_INIT;
 771         struct strbuf buf = STRBUF_INIT;
 772         struct string_list_item *item;
 773         const char *qname;
 774         int changed = 0, eof = 0;
 775
 776         for_each_string_list_item(item, &del_list) {
 777                 /* Ctrl-D should stop removing files */
 778                 if (!eof) {
 779                         qname = quote_path(item->string, NULL, &buf, 0);
 780                         /* TRANSLATORS: Make sure to keep [y/N] as is */
 781                         printf(_("Remove %s [y/N]? "), qname);
 782                         if (git_read_line_interactively(&confirm) == EOF) {
 783                                 putchar('\n');
 784                                 eof = 1;
 785                         }
 786                 }
 787                 if (!confirm.len || strncasecmp(confirm.buf, "yes", confirm.len)) {
 788                         *item->string = '\0';
 789                         changed++;
 790                 }
 791         }
 792
 793         if (changed)
 794                 string_list_remove_empty_items(&del_list, 0);
 795
 796         strbuf_release(&buf);
 797         strbuf_release(&confirm);
 798         return MENU_RETURN_NO_LOOP;
 799 }
 800
 801 static int quit_cmd(void)
 802 {
 803         string_list_clear(&del_list, 0);
 804         printf(_("Bye.\n"));
 805         return MENU_RETURN_NO_LOOP;
 806 }
 807
 808 static int help_cmd(void)
 809 {
 810         clean_print_color(CLEAN_COLOR_HELP);
 811         printf_ln(_(
 812                     "clean               - start cleaning\n"
 813                     "filter by pattern   - exclude items from deletion\n"
 814                     "select by numbers   - select items to be deleted by numbers\n"
 815                     "ask each            - confirm each deletion (like \"rm -i\")\n"
 816                     "quit                - stop cleaning\n"
 817                     "help                - this screen\n"
 818                     "?                   - help for prompt selection"
 819                    ));
 820         clean_print_color(CLEAN_COLOR_RESET);
 821         return 0;
 822 }
 823
 824 static void interactive_main_loop(void)
 825 {
 826         while (del_list.nr) {
 827                 struct menu_opts menu_opts;
 828                 struct menu_stuff menu_stuff;
 829                 struct menu_item menus[] = {
 830                         {'c', "clean",                  0, clean_cmd},
 831                         {'f', "filter by pattern",      0, filter_by_patterns_cmd},
 832                         {'s', "select by numbers",      0, select_by_numbers_cmd},
 833                         {'a', "ask each",               0, ask_each_cmd},
 834                         {'q', "quit",                   0, quit_cmd},
 835                         {'h', "help",                   0, help_cmd},
 836                 };
 837                 int *chosen;
 838
 839                 menu_opts.header = N_("*** Commands ***");
 840                 menu_opts.prompt = N_("What now");
 841                 menu_opts.flags = MENU_OPTS_SINGLETON;
 842
 843                 menu_stuff.type = MENU_STUFF_TYPE_MENU_ITEM;
 844                 menu_stuff.stuff = menus;
 845                 menu_stuff.nr = sizeof(menus) / sizeof(struct menu_item);
 846
 847                 clean_print_color(CLEAN_COLOR_HEADER);
 848                 printf_ln(Q_("Would remove the following item:",
 849                              "Would remove the following items:",
 850                              del_list.nr));
 851                 clean_print_color(CLEAN_COLOR_RESET);
 852
 853                 pretty_print_dels();
 854
 855                 chosen = list_and_choose(&menu_opts, &menu_stuff);
 856
 857                 if (*chosen != EOF) {
 858                         int ret;
 859                         ret = menus[*chosen].fn();
 860                         if (ret != MENU_RETURN_NO_LOOP) {
 861                                 FREE_AND_NULL(chosen);
 862                                 if (!del_list.nr) {
 863                                         clean_print_color(CLEAN_COLOR_ERROR);
 864                                         printf_ln(_("No more files to clean, exiting."));
 865                                         clean_print_color(CLEAN_COLOR_RESET);
 866                                         break;
 867                                 }
 868                                 continue;
 869                         }
 870                 } else {
 871                         quit_cmd();
 872                 }
 873
 874                 FREE_AND_NULL(chosen);
 875                 break;
 876         }
 877 }
 878
 879 static void correct_untracked_entries(struct dir_struct *dir)
 880 {
 881         int src, dst, ign;
 882
 883         for (src = dst = ign = 0; src < dir->nr; src++) {
 884                 /* skip paths in ignored[] that cannot be inside entries[src] */
 885                 while (ign < dir->ignored_nr &&
 886                        0 <= cmp_dir_entry(&dir->entries[src], &dir->ignored[ign]))
 887                         ign++;
 888
 889                 if (ign < dir->ignored_nr &&
 890                     check_dir_entry_contains(dir->entries[src], dir->ignored[ign])) {
 891                         /* entries[src] contains an ignored path, so we drop it */
 892                         free(dir->entries[src]);
 893                 } else {
 894                         struct dir_entry *ent = dir->entries[src++];
 895
 896                         /* entries[src] does not contain an ignored path, so we keep it */
 897                         dir->entries[dst++] = ent;
 898
 899                         /* then discard paths in entries[] contained inside entries[src] */
 900                         while (src < dir->nr &&
 901                                check_dir_entry_contains(ent, dir->entries[src]))
 902                                 free(dir->entries[src++]);
 903
 904                         /* compensate for the outer loop's loop control */
 905                         src--;
 906                 }
 907         }
 908         dir->nr = dst;
 909 }
 910
 911 int cmd_clean(int argc, const char **argv, const char *prefix)
 912 {
 913         int i, res;
 914         int dry_run = 0, remove_directories = 0, quiet = 0, ignored = 0;
 915         int ignored_only = 0, config_set = 0, errors = 0, gone = 1;
 916         int rm_flags = REMOVE_DIR_KEEP_NESTED_GIT;
 917         struct strbuf abs_path = STRBUF_INIT;
 918         struct dir_struct dir = DIR_INIT;
 919         struct pathspec pathspec;
 920         struct strbuf buf = STRBUF_INIT;
 921         struct string_list exclude_list = STRING_LIST_INIT_NODUP;
 922         struct pattern_list *pl;
 923         struct string_list_item *item;
 924         const char *qname;
 925         struct option options[] = {
 926                 OPT__QUIET(&quiet, N_("do not print names of files removed")),
 927                 OPT__DRY_RUN(&dry_run, N_("dry run")),
 928                 OPT__FORCE(&force, N_("force"), PARSE_OPT_NOCOMPLETE),
 929                 OPT_BOOL('i', "interactive", &interactive, N_("interactive cleaning")),
 930                 OPT_BOOL('d', NULL, &remove_directories,
 931                                 N_("remove whole directories")),
 932                 OPT_CALLBACK_F('e', "exclude", &exclude_list, N_("pattern"),
 933                   N_("add <pattern> to ignore rules"), PARSE_OPT_NONEG, exclude_cb),
 934                 OPT_BOOL('x', NULL, &ignored, N_("remove ignored files, too")),
 935                 OPT_BOOL('X', NULL, &ignored_only,
 936                                 N_("remove only ignored files")),
 937                 OPT_END()
 938         };
 939
 940         git_config(git_clean_config, NULL);
 941         if (force < 0)
 942                 force = 0;
 943         else
 944                 config_set = 1;
 945
 946         argc = parse_options(argc, argv, prefix, options, builtin_clean_usage,
 947                              0);
 948
 949         if (!interactive && !dry_run && !force) {
 950                 if (config_set)
 951                         die(_("clean.requireForce set to true and neither -i, -n, nor -f given; "
 952                                   "refusing to clean"));
 953                 else
 954                         die(_("clean.requireForce defaults to true and neither -i, -n, nor -f given;"
 955                                   " refusing to clean"));
 956         }
 957
 958         if (force > 1)
 959                 rm_flags = 0;
 960         else
 961                 dir.flags |= DIR_SKIP_NESTED_GIT;
 962
 963         dir.flags |= DIR_SHOW_OTHER_DIRECTORIES;
 964
 965         if (ignored && ignored_only)
 966                 die(_("-x and -X cannot be used together"));
 967         if (!ignored)
 968                 setup_standard_excludes(&dir);
 969         if (ignored_only)
 970                 dir.flags |= DIR_SHOW_IGNORED;
 971
 972         if (argc) {
 973                 /*
 974                  * Remaining args implies pathspecs specified, and we should
 975                  * recurse within those.
 976                  */
 977                 remove_directories = 1;
 978         }
 979
 980         if (remove_directories && !ignored_only) {
 981                 /*
 982                  * We need to know about ignored files too:
 983                  *
 984                  * If (ignored), then we will delete ignored files as well.
 985                  *
 986                  * If (!ignored), then even though we not are doing
 987                  * anything with ignored files, we need to know about them
 988                  * so that we can avoid deleting a directory of untracked
 989                  * files that also contains an ignored file within it.
 990                  *
 991                  * For the (!ignored) case, since we only need to avoid
 992                  * deleting ignored files, we can set
 993                  * DIR_SHOW_IGNORED_TOO_MODE_MATCHING in order to avoid
 994                  * recursing into a directory which is itself ignored.
 995                  */
 996                 dir.flags |= DIR_SHOW_IGNORED_TOO;
 997                 if (!ignored)
 998                         dir.flags |= DIR_SHOW_IGNORED_TOO_MODE_MATCHING;
 999
1000                 /*
1001                  * Let the fill_directory() machinery know that we aren't
1002                  * just recursing to collect the ignored files; we want all
1003                  * the untracked ones so that we can delete them.  (Note:
1004                  * we could also set DIR_KEEP_UNTRACKED_CONTENTS when
1005                  * ignored_only is true, since DIR_KEEP_UNTRACKED_CONTENTS
1006                  * only has effect in combination with DIR_SHOW_IGNORED_TOO.  It makes
1007                  * the code clearer to exclude it, though.
1008                  */
1009                 dir.flags |= DIR_KEEP_UNTRACKED_CONTENTS;
1010         }
1011
1012         prepare_repo_settings(the_repository);
1013         the_repository->settings.command_requires_full_index = 0;
1014
1015         if (repo_read_index(the_repository) < 0)
1016                 die(_("index file corrupt"));
1017
1018         pl = add_pattern_list(&dir, EXC_CMDL, "--exclude option");
1019         for (i = 0; i < exclude_list.nr; i++)
1020                 add_pattern(exclude_list.items[i].string, "", 0, pl, -(i+1));
1021
1022         parse_pathspec(&pathspec, 0,
1023                        PATHSPEC_PREFER_CWD,
1024                        prefix, argv);
1025
1026         fill_directory(&dir, &the_index, &pathspec);
1027         correct_untracked_entries(&dir);
1028
1029         for (i = 0; i < dir.nr; i++) {
1030                 struct dir_entry *ent = dir.entries[i];
1031                 struct stat st;
1032                 const char *rel;
1033
1034                 if (!index_name_is_other(&the_index, ent->name, ent->len))
1035                         continue;
1036
1037                 if (lstat(ent->name, &st))
1038                         die_errno("Cannot lstat '%s'", ent->name);
1039
1040                 if (S_ISDIR(st.st_mode) && !remove_directories)
1041                         continue;
1042
1043                 rel = relative_path(ent->name, prefix, &buf);
1044                 string_list_append(&del_list, rel);
1045         }
1046
1047         dir_clear(&dir);
1048
1049         if (interactive && del_list.nr > 0)
1050                 interactive_main_loop();
1051
1052         for_each_string_list_item(item, &del_list) {
1053                 struct stat st;
1054
1055                 strbuf_reset(&abs_path);
1056                 if (prefix)
1057                         strbuf_addstr(&abs_path, prefix);
1058
1059                 strbuf_addstr(&abs_path, item->string);
1060
1061                 /*
1062                  * we might have removed this as part of earlier
1063                  * recursive directory removal, so lstat() here could
1064                  * fail with ENOENT.
1065                  */
1066                 if (lstat(abs_path.buf, &st))
1067                         continue;
1068
1069                 if (S_ISDIR(st.st_mode)) {
1070                         if (remove_dirs(&abs_path, prefix, rm_flags, dry_run, quiet, &gone))
1071                                 errors++;
1072                         if (gone && !quiet) {
1073                                 qname = quote_path(item->string, NULL, &buf, 0);
1074                                 printf(dry_run ? _(msg_would_remove) : _(msg_remove), qname);
1075                         }
1076                 } else {
1077                         res = dry_run ? 0 : unlink(abs_path.buf);
1078                         if (res) {
1079                                 int saved_errno = errno;
1080                                 qname = quote_path(item->string, NULL, &buf, 0);
1081                                 errno = saved_errno;
1082                                 warning_errno(_(msg_warn_remove_failed), qname);
1083                                 errors++;
1084                         } else if (!quiet) {
1085                                 qname = quote_path(item->string, NULL, &buf, 0);
1086                                 printf(dry_run ? _(msg_would_remove) : _(msg_remove), qname);
1087                         }
1088                 }
1089         }
1090
1091         strbuf_release(&abs_path);
1092         strbuf_release(&buf);
1093         string_list_clear(&del_list, 0);
1094         string_list_clear(&exclude_list, 0);
1095         clear_pathspec(&pathspec);
1096         return (errors != 0);
1097 }