git.oblomov.eu Git - git/blob - add-interactive.c

   1 #include "cache.h"
   2 #include "add-interactive.h"
   3 #include "color.h"
   4 #include "config.h"
   5 #include "diffcore.h"
   6 #include "revision.h"
   7 #include "refs.h"
   8 #include "string-list.h"
   9
  10 struct add_i_state {
  11         struct repository *r;
  12         int use_color;
  13         char header_color[COLOR_MAXLEN];
  14         char help_color[COLOR_MAXLEN];
  15         char prompt_color[COLOR_MAXLEN];
  16         char error_color[COLOR_MAXLEN];
  17         char reset_color[COLOR_MAXLEN];
  18 };
  19
  20 static void init_color(struct repository *r, struct add_i_state *s,
  21                        const char *slot_name, char *dst,
  22                        const char *default_color)
  23 {
  24         char *key = xstrfmt("color.interactive.%s", slot_name);
  25         const char *value;
  26
  27         if (!s->use_color)
  28                 dst[0] = '\0';
  29         else if (repo_config_get_value(r, key, &value) ||
  30                  color_parse(value, dst))
  31                 strlcpy(dst, default_color, COLOR_MAXLEN);
  32
  33         free(key);
  34 }
  35
  36 static void init_add_i_state(struct add_i_state *s, struct repository *r)
  37 {
  38         const char *value;
  39
  40         s->r = r;
  41
  42         if (repo_config_get_value(r, "color.interactive", &value))
  43                 s->use_color = -1;
  44         else
  45                 s->use_color =
  46                         git_config_colorbool("color.interactive", value);
  47         s->use_color = want_color(s->use_color);
  48
  49         init_color(r, s, "header", s->header_color, GIT_COLOR_BOLD);
  50         init_color(r, s, "help", s->help_color, GIT_COLOR_BOLD_RED);
  51         init_color(r, s, "prompt", s->prompt_color, GIT_COLOR_BOLD_BLUE);
  52         init_color(r, s, "error", s->error_color, GIT_COLOR_BOLD_RED);
  53         init_color(r, s, "reset", s->reset_color, GIT_COLOR_RESET);
  54 }
  55
  56 /*
  57  * A "prefix item list" is a list of items that are identified by a string, and
  58  * a unique prefix (if any) is determined for each item.
  59  *
  60  * It is implemented in the form of a pair of `string_list`s, the first one
  61  * duplicating the strings, with the `util` field pointing at a structure whose
  62  * first field must be `size_t prefix_length`.
  63  *
  64  * That `prefix_length` field will be computed by `find_unique_prefixes()`; It
  65  * will be set to zero if no valid, unique prefix could be found.
  66  *
  67  * The second `string_list` is called `sorted` and does _not_ duplicate the
  68  * strings but simply reuses the first one's, with the `util` field pointing at
  69  * the `string_item_list` of the first `string_list`. It  will be populated and
  70  * sorted by `find_unique_prefixes()`.
  71  */
  72 struct prefix_item_list {
  73         struct string_list items;
  74         struct string_list sorted;
  75         size_t min_length, max_length;
  76 };
  77 #define PREFIX_ITEM_LIST_INIT \
  78         { STRING_LIST_INIT_DUP, STRING_LIST_INIT_NODUP, 1, 4 }
  79
  80 static void prefix_item_list_clear(struct prefix_item_list *list)
  81 {
  82         string_list_clear(&list->items, 1);
  83         string_list_clear(&list->sorted, 0);
  84 }
  85
  86 static void extend_prefix_length(struct string_list_item *p,
  87                                  const char *other_string, size_t max_length)
  88 {
  89         size_t *len = p->util;
  90
  91         if (!*len || memcmp(p->string, other_string, *len))
  92                 return;
  93
  94         for (;;) {
  95                 char c = p->string[*len];
  96
  97                 /*
  98                  * Is `p` a strict prefix of `other`? Or have we exhausted the
  99                  * maximal length of the prefix? Or is the current character a
 100                  * multi-byte UTF-8 one? If so, there is no valid, unique
 101                  * prefix.
 102                  */
 103                 if (!c || ++*len > max_length || !isascii(c)) {
 104                         *len = 0;
 105                         break;
 106                 }
 107
 108                 if (c != other_string[*len - 1])
 109                         break;
 110         }
 111 }
 112
 113 static void find_unique_prefixes(struct prefix_item_list *list)
 114 {
 115         size_t i;
 116
 117         if (list->sorted.nr == list->items.nr)
 118                 return;
 119
 120         string_list_clear(&list->sorted, 0);
 121         /* Avoid reallocating incrementally */
 122         list->sorted.items = xmalloc(st_mult(sizeof(*list->sorted.items),
 123                                              list->items.nr));
 124         list->sorted.nr = list->sorted.alloc = list->items.nr;
 125
 126         for (i = 0; i < list->items.nr; i++) {
 127                 list->sorted.items[i].string = list->items.items[i].string;
 128                 list->sorted.items[i].util = list->items.items + i;
 129         }
 130
 131         string_list_sort(&list->sorted);
 132
 133         for (i = 0; i < list->sorted.nr; i++) {
 134                 struct string_list_item *sorted_item = list->sorted.items + i;
 135                 struct string_list_item *item = sorted_item->util;
 136                 size_t *len = item->util;
 137
 138                 *len = 0;
 139                 while (*len < list->min_length) {
 140                         char c = item->string[(*len)++];
 141
 142                         if (!c || !isascii(c)) {
 143                                 *len = 0;
 144                                 break;
 145                         }
 146                 }
 147
 148                 if (i > 0)
 149                         extend_prefix_length(item, sorted_item[-1].string,
 150                                              list->max_length);
 151                 if (i + 1 < list->sorted.nr)
 152                         extend_prefix_length(item, sorted_item[1].string,
 153                                              list->max_length);
 154         }
 155 }
 156
 157 static ssize_t find_unique(const char *string, struct prefix_item_list *list)
 158 {
 159         int index = string_list_find_insert_index(&list->sorted, string, 1);
 160         struct string_list_item *item;
 161
 162         if (list->items.nr != list->sorted.nr)
 163                 BUG("prefix_item_list in inconsistent state (%"PRIuMAX
 164                     " vs %"PRIuMAX")",
 165                     (uintmax_t)list->items.nr, (uintmax_t)list->sorted.nr);
 166
 167         if (index < 0)
 168                 item = list->sorted.items[-1 - index].util;
 169         else if (index > 0 &&
 170                  starts_with(list->sorted.items[index - 1].string, string))
 171                 return -1;
 172         else if (index + 1 < list->sorted.nr &&
 173                  starts_with(list->sorted.items[index + 1].string, string))
 174                 return -1;
 175         else if (index < list->sorted.nr)
 176                 item = list->sorted.items[index].util;
 177         else
 178                 return -1;
 179         return item - list->items.items;
 180 }
 181
 182 struct list_options {
 183         int columns;
 184         const char *header;
 185         void (*print_item)(int i, struct string_list_item *item, void *print_item_data);
 186         void *print_item_data;
 187 };
 188
 189 static void list(struct add_i_state *s, struct string_list *list,
 190                  struct list_options *opts)
 191 {
 192         int i, last_lf = 0;
 193
 194         if (!list->nr)
 195                 return;
 196
 197         if (opts->header)
 198                 color_fprintf_ln(stdout, s->header_color,
 199                                  "%s", opts->header);
 200
 201         for (i = 0; i < list->nr; i++) {
 202                 opts->print_item(i, list->items + i, opts->print_item_data);
 203
 204                 if ((opts->columns) && ((i + 1) % (opts->columns))) {
 205                         putchar('\t');
 206                         last_lf = 0;
 207                 }
 208                 else {
 209                         putchar('\n');
 210                         last_lf = 1;
 211                 }
 212         }
 213
 214         if (!last_lf)
 215                 putchar('\n');
 216 }
 217 struct list_and_choose_options {
 218         struct list_options list_opts;
 219
 220         const char *prompt;
 221         void (*print_help)(struct add_i_state *s);
 222 };
 223
 224 #define LIST_AND_CHOOSE_ERROR (-1)
 225 #define LIST_AND_CHOOSE_QUIT  (-2)
 226
 227 /*
 228  * Returns the selected index.
 229  *
 230  * If an error occurred, returns `LIST_AND_CHOOSE_ERROR`. Upon EOF,
 231  * `LIST_AND_CHOOSE_QUIT` is returned.
 232  */
 233 static ssize_t list_and_choose(struct add_i_state *s,
 234                                struct prefix_item_list *items,
 235                                struct list_and_choose_options *opts)
 236 {
 237         struct strbuf input = STRBUF_INIT;
 238         ssize_t res = LIST_AND_CHOOSE_ERROR;
 239
 240         find_unique_prefixes(items);
 241
 242         for (;;) {
 243                 char *p;
 244
 245                 strbuf_reset(&input);
 246
 247                 list(s, &items->items, &opts->list_opts);
 248
 249                 color_fprintf(stdout, s->prompt_color, "%s", opts->prompt);
 250                 fputs("> ", stdout);
 251                 fflush(stdout);
 252
 253                 if (strbuf_getline(&input, stdin) == EOF) {
 254                         putchar('\n');
 255                         res = LIST_AND_CHOOSE_QUIT;
 256                         break;
 257                 }
 258                 strbuf_trim(&input);
 259
 260                 if (!input.len)
 261                         break;
 262
 263                 if (!strcmp(input.buf, "?")) {
 264                         opts->print_help(s);
 265                         continue;
 266                 }
 267
 268                 p = input.buf;
 269                 for (;;) {
 270                         size_t sep = strcspn(p, " \t\r\n,");
 271                         ssize_t index = -1;
 272
 273                         if (!sep) {
 274                                 if (!*p)
 275                                         break;
 276                                 p++;
 277                                 continue;
 278                         }
 279
 280                         if (isdigit(*p)) {
 281                                 char *endp;
 282                                 index = strtoul(p, &endp, 10) - 1;
 283                                 if (endp != p + sep)
 284                                         index = -1;
 285                         }
 286
 287                         if (p[sep])
 288                                 p[sep++] = '\0';
 289                         if (index < 0)
 290                                 index = find_unique(p, items);
 291
 292                         if (index < 0 || index >= items->items.nr)
 293                                 color_fprintf_ln(stdout, s->error_color,
 294                                                  _("Huh (%s)?"), p);
 295                         else {
 296                                 res = index;
 297                                 break;
 298                         }
 299
 300                         p += sep;
 301                 }
 302
 303                 if (res != LIST_AND_CHOOSE_ERROR)
 304                         break;
 305         }
 306
 307         strbuf_release(&input);
 308         return res;
 309 }
 310
 311 struct adddel {
 312         uintmax_t add, del;
 313         unsigned seen:1, binary:1;
 314 };
 315
 316 struct file_item {
 317         struct adddel index, worktree;
 318 };
 319
 320 static void add_file_item(struct string_list *files, const char *name)
 321 {
 322         struct file_item *item = xcalloc(sizeof(*item), 1);
 323
 324         string_list_append(files, name)->util = item;
 325 }
 326
 327 struct pathname_entry {
 328         struct hashmap_entry ent;
 329         const char *name;
 330         struct file_item *item;
 331 };
 332
 333 static int pathname_entry_cmp(const void *unused_cmp_data,
 334                               const struct hashmap_entry *he1,
 335                               const struct hashmap_entry *he2,
 336                               const void *name)
 337 {
 338         const struct pathname_entry *e1 =
 339                 container_of(he1, const struct pathname_entry, ent);
 340         const struct pathname_entry *e2 =
 341                 container_of(he2, const struct pathname_entry, ent);
 342
 343         return strcmp(e1->name, name ? (const char *)name : e2->name);
 344 }
 345
 346 struct collection_status {
 347         enum { FROM_WORKTREE = 0, FROM_INDEX = 1 } phase;
 348
 349         const char *reference;
 350
 351         struct string_list *files;
 352         struct hashmap file_map;
 353 };
 354
 355 static void collect_changes_cb(struct diff_queue_struct *q,
 356                                struct diff_options *options,
 357                                void *data)
 358 {
 359         struct collection_status *s = data;
 360         struct diffstat_t stat = { 0 };
 361         int i;
 362
 363         if (!q->nr)
 364                 return;
 365
 366         compute_diffstat(options, &stat, q);
 367
 368         for (i = 0; i < stat.nr; i++) {
 369                 const char *name = stat.files[i]->name;
 370                 int hash = strhash(name);
 371                 struct pathname_entry *entry;
 372                 struct file_item *file_item;
 373                 struct adddel *adddel;
 374
 375                 entry = hashmap_get_entry_from_hash(&s->file_map, hash, name,
 376                                                     struct pathname_entry, ent);
 377                 if (!entry) {
 378                         add_file_item(s->files, name);
 379
 380                         entry = xcalloc(sizeof(*entry), 1);
 381                         hashmap_entry_init(&entry->ent, hash);
 382                         entry->name = s->files->items[s->files->nr - 1].string;
 383                         entry->item = s->files->items[s->files->nr - 1].util;
 384                         hashmap_add(&s->file_map, &entry->ent);
 385                 }
 386
 387                 file_item = entry->item;
 388                 adddel = s->phase == FROM_INDEX ?
 389                         &file_item->index : &file_item->worktree;
 390                 adddel->seen = 1;
 391                 adddel->add = stat.files[i]->added;
 392                 adddel->del = stat.files[i]->deleted;
 393                 if (stat.files[i]->is_binary)
 394                         adddel->binary = 1;
 395         }
 396         free_diffstat_info(&stat);
 397 }
 398
 399 static int get_modified_files(struct repository *r, struct string_list *files,
 400                               const struct pathspec *ps)
 401 {
 402         struct object_id head_oid;
 403         int is_initial = !resolve_ref_unsafe("HEAD", RESOLVE_REF_READING,
 404                                              &head_oid, NULL);
 405         struct collection_status s = { FROM_WORKTREE };
 406
 407         if (discard_index(r->index) < 0 ||
 408             repo_read_index_preload(r, ps, 0) < 0)
 409                 return error(_("could not read index"));
 410
 411         string_list_clear(files, 1);
 412         s.files = files;
 413         hashmap_init(&s.file_map, pathname_entry_cmp, NULL, 0);
 414
 415         for (s.phase = FROM_WORKTREE; s.phase <= FROM_INDEX; s.phase++) {
 416                 struct rev_info rev;
 417                 struct setup_revision_opt opt = { 0 };
 418
 419                 opt.def = is_initial ?
 420                         empty_tree_oid_hex() : oid_to_hex(&head_oid);
 421
 422                 init_revisions(&rev, NULL);
 423                 setup_revisions(0, NULL, &rev, &opt);
 424
 425                 rev.diffopt.output_format = DIFF_FORMAT_CALLBACK;
 426                 rev.diffopt.format_callback = collect_changes_cb;
 427                 rev.diffopt.format_callback_data = &s;
 428
 429                 if (ps)
 430                         copy_pathspec(&rev.prune_data, ps);
 431
 432                 if (s.phase == FROM_INDEX)
 433                         run_diff_index(&rev, 1);
 434                 else {
 435                         rev.diffopt.flags.ignore_dirty_submodules = 1;
 436                         run_diff_files(&rev, 0);
 437                 }
 438
 439                 if (ps)
 440                         clear_pathspec(&rev.prune_data);
 441         }
 442         hashmap_free_entries(&s.file_map, struct pathname_entry, ent);
 443
 444         /* While the diffs are ordered already, we ran *two* diffs... */
 445         string_list_sort(files);
 446
 447         return 0;
 448 }
 449
 450 static void render_adddel(struct strbuf *buf,
 451                                 struct adddel *ad, const char *no_changes)
 452 {
 453         if (ad->binary)
 454                 strbuf_addstr(buf, _("binary"));
 455         else if (ad->seen)
 456                 strbuf_addf(buf, "+%"PRIuMAX"/-%"PRIuMAX,
 457                             (uintmax_t)ad->add, (uintmax_t)ad->del);
 458         else
 459                 strbuf_addstr(buf, no_changes);
 460 }
 461
 462 /* filters out prefixes which have special meaning to list_and_choose() */
 463 static int is_valid_prefix(const char *prefix, size_t prefix_len)
 464 {
 465         return prefix_len && prefix &&
 466                 /*
 467                  * We expect `prefix` to be NUL terminated, therefore this
 468                  * `strcspn()` call is okay, even if it might do much more
 469                  * work than strictly necessary.
 470                  */
 471                 strcspn(prefix, " \t\r\n,") >= prefix_len &&    /* separators */
 472                 *prefix != '-' &&                               /* deselection */
 473                 !isdigit(*prefix) &&                            /* selection */
 474                 (prefix_len != 1 ||
 475                  (*prefix != '*' &&                             /* "all" wildcard */
 476                   *prefix != '?'));                             /* prompt help */
 477 }
 478
 479 struct print_file_item_data {
 480         const char *modified_fmt;
 481         struct strbuf buf, index, worktree;
 482 };
 483
 484 static void print_file_item(int i, struct string_list_item *item,
 485                             void *print_file_item_data)
 486 {
 487         struct file_item *c = item->util;
 488         struct print_file_item_data *d = print_file_item_data;
 489
 490         strbuf_reset(&d->index);
 491         strbuf_reset(&d->worktree);
 492         strbuf_reset(&d->buf);
 493
 494         render_adddel(&d->worktree, &c->worktree, _("nothing"));
 495         render_adddel(&d->index, &c->index, _("unchanged"));
 496         strbuf_addf(&d->buf, d->modified_fmt,
 497                     d->index.buf, d->worktree.buf, item->string);
 498
 499         printf(" %2d: %s", i + 1, d->buf.buf);
 500 }
 501
 502 static int run_status(struct add_i_state *s, const struct pathspec *ps,
 503                       struct string_list *files, struct list_options *opts)
 504 {
 505         if (get_modified_files(s->r, files, ps) < 0)
 506                 return -1;
 507
 508         list(s, files, opts);
 509         putchar('\n');
 510
 511         return 0;
 512 }
 513
 514 static int run_help(struct add_i_state *s, const struct pathspec *unused_ps,
 515                     struct string_list *unused_files,
 516                     struct list_options *unused_opts)
 517 {
 518         color_fprintf_ln(stdout, s->help_color, "status        - %s",
 519                          _("show paths with changes"));
 520         color_fprintf_ln(stdout, s->help_color, "update        - %s",
 521                          _("add working tree state to the staged set of changes"));
 522         color_fprintf_ln(stdout, s->help_color, "revert        - %s",
 523                          _("revert staged set of changes back to the HEAD version"));
 524         color_fprintf_ln(stdout, s->help_color, "patch         - %s",
 525                          _("pick hunks and update selectively"));
 526         color_fprintf_ln(stdout, s->help_color, "diff          - %s",
 527                          _("view diff between HEAD and index"));
 528         color_fprintf_ln(stdout, s->help_color, "add untracked - %s",
 529                          _("add contents of untracked files to the staged set of changes"));
 530
 531         return 0;
 532 }
 533
 534 typedef int (*command_t)(struct add_i_state *s, const struct pathspec *ps,
 535                          struct string_list *files,
 536                          struct list_options *opts);
 537
 538 struct command_item {
 539         size_t prefix_length;
 540         command_t command;
 541 };
 542
 543 struct print_command_item_data {
 544         const char *color, *reset;
 545 };
 546
 547 static void print_command_item(int i, struct string_list_item *item,
 548                                void *print_command_item_data)
 549 {
 550         struct print_command_item_data *d = print_command_item_data;
 551         struct command_item *util = item->util;
 552
 553         if (!util->prefix_length ||
 554             !is_valid_prefix(item->string, util->prefix_length))
 555                 printf(" %2d: %s", i + 1, item->string);
 556         else
 557                 printf(" %2d: %s%.*s%s%s", i + 1,
 558                        d->color, (int)util->prefix_length, item->string,
 559                        d->reset, item->string + util->prefix_length);
 560 }
 561
 562 static void command_prompt_help(struct add_i_state *s)
 563 {
 564         const char *help_color = s->help_color;
 565         color_fprintf_ln(stdout, help_color, "%s", _("Prompt help:"));
 566         color_fprintf_ln(stdout, help_color, "1          - %s",
 567                          _("select a numbered item"));
 568         color_fprintf_ln(stdout, help_color, "foo        - %s",
 569                          _("select item based on unique prefix"));
 570         color_fprintf_ln(stdout, help_color, "           - %s",
 571                          _("(empty) select nothing"));
 572 }
 573
 574 int run_add_i(struct repository *r, const struct pathspec *ps)
 575 {
 576         struct add_i_state s = { NULL };
 577         struct print_command_item_data data = { "[", "]" };
 578         struct list_and_choose_options main_loop_opts = {
 579                 { 4, N_("*** Commands ***"), print_command_item, &data },
 580                 N_("What now"), command_prompt_help
 581         };
 582         struct {
 583                 const char *string;
 584                 command_t command;
 585         } command_list[] = {
 586                 { "status", run_status },
 587                 { "help", run_help },
 588         };
 589         struct prefix_item_list commands = PREFIX_ITEM_LIST_INIT;
 590
 591         struct print_file_item_data print_file_item_data = {
 592                 "%12s %12s %s", STRBUF_INIT, STRBUF_INIT, STRBUF_INIT
 593         };
 594         struct list_options opts = {
 595                 0, NULL, print_file_item, &print_file_item_data
 596         };
 597         struct strbuf header = STRBUF_INIT;
 598         struct string_list files = STRING_LIST_INIT_DUP;
 599         ssize_t i;
 600         int res = 0;
 601
 602         for (i = 0; i < ARRAY_SIZE(command_list); i++) {
 603                 struct command_item *util = xcalloc(sizeof(*util), 1);
 604                 util->command = command_list[i].command;
 605                 string_list_append(&commands.items, command_list[i].string)
 606                         ->util = util;
 607         }
 608
 609         init_add_i_state(&s, r);
 610
 611         /*
 612          * When color was asked for, use the prompt color for
 613          * highlighting, otherwise use square brackets.
 614          */
 615         if (s.use_color) {
 616                 data.color = s.prompt_color;
 617                 data.reset = s.reset_color;
 618         }
 619
 620         strbuf_addstr(&header, "      ");
 621         strbuf_addf(&header, print_file_item_data.modified_fmt,
 622                     _("staged"), _("unstaged"), _("path"));
 623         opts.header = header.buf;
 624
 625         if (discard_index(r->index) < 0 ||
 626             repo_read_index(r) < 0 ||
 627             repo_refresh_and_write_index(r, REFRESH_QUIET, 0, 1,
 628                                          NULL, NULL, NULL) < 0)
 629                 warning(_("could not refresh index"));
 630
 631         res = run_status(&s, ps, &files, &opts);
 632
 633         for (;;) {
 634                 i = list_and_choose(&s, &commands, &main_loop_opts);
 635                 if (i == LIST_AND_CHOOSE_QUIT) {
 636                         printf(_("Bye.\n"));
 637                         res = 0;
 638                         break;
 639                 }
 640                 if (i != LIST_AND_CHOOSE_ERROR) {
 641                         struct command_item *util =
 642                                 commands.items.items[i].util;
 643                         res = util->command(&s, ps, &files, &opts);
 644                 }
 645         }
 646
 647         string_list_clear(&files, 1);
 648         strbuf_release(&print_file_item_data.buf);
 649         strbuf_release(&print_file_item_data.index);
 650         strbuf_release(&print_file_item_data.worktree);
 651         strbuf_release(&header);
 652         prefix_item_list_clear(&commands);
 653
 654         return res;
 655 }