builtin/add.c

   1 /*
   2  * "git add" builtin command
   3  *
   4  * Copyright (C) 2006 Linus Torvalds
   5  */
   6 #include "cache.h"
   7 #include "builtin.h"
   8 #include "dir.h"
   9 #include "pathspec.h"
  10 #include "exec_cmd.h"
  11 #include "cache-tree.h"
  12 #include "run-command.h"
  13 #include "parse-options.h"
  14 #include "diff.h"
  15 #include "diffcore.h"
  16 #include "revision.h"
  17 #include "bulk-checkin.h"
  18
  19 static const char * const builtin_add_usage[] = {
  20         N_("git add [options] [--] <pathspec>..."),
  21         NULL
  22 };
  23 static int patch_interactive, add_interactive, edit_interactive;
  24 static int take_worktree_changes;
  25
  26 struct update_callback_data {
  27         int flags;
  28         int add_errors;
  29         const char *implicit_dot;
  30         size_t implicit_dot_len;
  31
  32         /* only needed for 2.0 transition preparation */
  33         int warn_add_would_remove;
  34 };
  35
  36 static const char *option_with_implicit_dot;
  37 static const char *short_option_with_implicit_dot;
  38
  39 static void warn_pathless_add(void)
  40 {
  41         static int shown;
  42         assert(option_with_implicit_dot && short_option_with_implicit_dot);
  43
  44         if (shown)
  45                 return;
  46         shown = 1;
  47
  48         /*
  49          * To be consistent with "git add -p" and most Git
  50          * commands, we should default to being tree-wide, but
  51          * this is not the original behavior and can't be
  52          * changed until users trained themselves not to type
  53          * "git add -u" or "git add -A". For now, we warn and
  54          * keep the old behavior. Later, the behavior can be changed
  55          * to tree-wide, keeping the warning for a while, and
  56          * eventually we can drop the warning.
  57          */
  58         warning(_("The behavior of 'git add %s (or %s)' with no path argument from a\n"
  59                   "subdirectory of the tree will change in Git 2.0 and should not be used anymore.\n"
  60                   "To add content for the whole tree, run:\n"
  61                   "\n"
  62                   "  git add %s :/\n"
  63                   "  (or git add %s :/)\n"
  64                   "\n"
  65                   "To restrict the command to the current directory, run:\n"
  66                   "\n"
  67                   "  git add %s .\n"
  68                   "  (or git add %s .)\n"
  69                   "\n"
  70                   "With the current Git version, the command is restricted to "
  71                   "the current directory.\n"
  72                   ""),
  73                 option_with_implicit_dot, short_option_with_implicit_dot,
  74                 option_with_implicit_dot, short_option_with_implicit_dot,
  75                 option_with_implicit_dot, short_option_with_implicit_dot);
  76 }
  77
  78 static int fix_unmerged_status(struct diff_filepair *p,
  79                                struct update_callback_data *data)
  80 {
  81         if (p->status != DIFF_STATUS_UNMERGED)
  82                 return p->status;
  83         if (!(data->flags & ADD_CACHE_IGNORE_REMOVAL) && !p->two->mode)
  84                 /*
  85                  * This is not an explicit add request, and the
  86                  * path is missing from the working tree (deleted)
  87                  */
  88                 return DIFF_STATUS_DELETED;
  89         else
  90                 /*
  91                  * Either an explicit add request, or path exists
  92                  * in the working tree.  An attempt to explicitly
  93                  * add a path that does not exist in the working tree
  94                  * will be caught as an error by the caller immediately.
  95                  */
  96                 return DIFF_STATUS_MODIFIED;
  97 }
  98
  99 static const char *add_would_remove_warning = N_(
 100         "You ran 'git add' with neither '-A (--all)' or '--ignore-removal',\n"
 101 "whose behaviour will change in Git 2.0 with respect to paths you removed.\n"
 102 "Paths like '%s' that are\n"
 103 "removed from your working tree are ignored with this version of Git.\n"
 104 "\n"
 105 "* 'git add --ignore-removal <pathspec>', which is the current default,\n"
 106 "  ignores paths you removed from your working tree.\n"
 107 "\n"
 108 "* 'git add --all <pathspec>' will let you also record the removals.\n"
 109 "\n"
 110 "Run 'git status' to check the paths you removed from your working tree.\n");
 111
 112 static void warn_add_would_remove(const char *path)
 113 {
 114         warning(_(add_would_remove_warning), path);
 115 }
 116
 117 static void update_callback(struct diff_queue_struct *q,
 118                             struct diff_options *opt, void *cbdata)
 119 {
 120         int i;
 121         struct update_callback_data *data = cbdata;
 122         const char *implicit_dot = data->implicit_dot;
 123         size_t implicit_dot_len = data->implicit_dot_len;
 124
 125         for (i = 0; i < q->nr; i++) {
 126                 struct diff_filepair *p = q->queue[i];
 127                 const char *path = p->one->path;
 128                 /*
 129                  * Check if "git add -A" or "git add -u" was run from a
 130                  * subdirectory with a modified file outside that directory,
 131                  * and warn if so.
 132                  *
 133                  * "git add -u" will behave like "git add -u :/" instead of
 134                  * "git add -u ." in the future.  This warning prepares for
 135                  * that change.
 136                  */
 137                 if (implicit_dot &&
 138                     strncmp_icase(path, implicit_dot, implicit_dot_len)) {
 139                         warn_pathless_add();
 140                         continue;
 141                 }
 142                 switch (fix_unmerged_status(p, data)) {
 143                 default:
 144                         die(_("unexpected diff status %c"), p->status);
 145                 case DIFF_STATUS_MODIFIED:
 146                 case DIFF_STATUS_TYPE_CHANGED:
 147                         if (add_file_to_index(&the_index, path, data->flags)) {
 148                                 if (!(data->flags & ADD_CACHE_IGNORE_ERRORS))
 149                                         die(_("updating files failed"));
 150                                 data->add_errors++;
 151                         }
 152                         break;
 153                 case DIFF_STATUS_DELETED:
 154                         if (data->warn_add_would_remove) {
 155                                 warn_add_would_remove(path);
 156                                 data->warn_add_would_remove = 0;
 157                         }
 158                         if (data->flags & ADD_CACHE_IGNORE_REMOVAL)
 159                                 break;
 160                         if (!(data->flags & ADD_CACHE_PRETEND))
 161                                 remove_file_from_index(&the_index, path);
 162                         if (data->flags & (ADD_CACHE_PRETEND|ADD_CACHE_VERBOSE))
 163                                 printf(_("remove '%s'\n"), path);
 164                         break;
 165                 }
 166         }
 167 }
 168
 169 static void update_files_in_cache(const char *prefix,
 170                                   const struct pathspec *pathspec,
 171                                   struct update_callback_data *data)
 172 {
 173         struct rev_info rev;
 174
 175         init_revisions(&rev, prefix);
 176         setup_revisions(0, NULL, &rev, NULL);
 177         if (pathspec)
 178                 copy_pathspec(&rev.prune_data, pathspec);
 179         rev.diffopt.output_format = DIFF_FORMAT_CALLBACK;
 180         rev.diffopt.format_callback = update_callback;
 181         rev.diffopt.format_callback_data = data;
 182         rev.max_count = 0; /* do not compare unmerged paths with stage #2 */
 183         run_diff_files(&rev, DIFF_RACY_IS_MODIFIED);
 184 }
 185
 186 int add_files_to_cache(const char *prefix,
 187                        const struct pathspec *pathspec, int flags)
 188 {
 189         struct update_callback_data data;
 190
 191         memset(&data, 0, sizeof(data));
 192         data.flags = flags;
 193         update_files_in_cache(prefix, pathspec, &data);
 194         return !!data.add_errors;
 195 }
 196
 197 #define WARN_IMPLICIT_DOT (1u << 0)
 198 static char *prune_directory(struct dir_struct *dir, struct pathspec *pathspec,
 199                              int prefix, unsigned flag)
 200 {
 201         char *seen;
 202         int i;
 203         struct dir_entry **src, **dst;
 204
 205         seen = xcalloc(pathspec->nr, 1);
 206
 207         src = dst = dir->entries;
 208         i = dir->nr;
 209         while (--i >= 0) {
 210                 struct dir_entry *entry = *src++;
 211                 if (match_pathspec_depth(pathspec, entry->name, entry->len,
 212                                          prefix, seen))
 213                         *dst++ = entry;
 214                 else if (flag & WARN_IMPLICIT_DOT)
 215                         /*
 216                          * "git add -A" was run from a subdirectory with a
 217                          * new file outside that directory.
 218                          *
 219                          * "git add -A" will behave like "git add -A :/"
 220                          * instead of "git add -A ." in the future.
 221                          * Warn about the coming behavior change.
 222                          */
 223                         warn_pathless_add();
 224         }
 225         dir->nr = dst - dir->entries;
 226         add_pathspec_matches_against_index(pathspec, seen);
 227         return seen;
 228 }
 229
 230 static void refresh(int verbose, const struct pathspec *pathspec)
 231 {
 232         char *seen;
 233         int i;
 234
 235         seen = xcalloc(pathspec->nr, 1);
 236         refresh_index(&the_index, verbose ? REFRESH_IN_PORCELAIN : REFRESH_QUIET,
 237                       pathspec, seen, _("Unstaged changes after refreshing the index:"));
 238         for (i = 0; i < pathspec->nr; i++) {
 239                 if (!seen[i])
 240                         die(_("pathspec '%s' did not match any files"),
 241                             pathspec->items[i].match);
 242         }
 243         free(seen);
 244 }
 245
 246 int run_add_interactive(const char *revision, const char *patch_mode,
 247                         const struct pathspec *pathspec)
 248 {
 249         int status, ac, i;
 250         const char **args;
 251
 252         args = xcalloc(sizeof(const char *), (pathspec->nr + 6));
 253         ac = 0;
 254         args[ac++] = "add--interactive";
 255         if (patch_mode)
 256                 args[ac++] = patch_mode;
 257         if (revision)
 258                 args[ac++] = revision;
 259         args[ac++] = "--";
 260         for (i = 0; i < pathspec->nr; i++)
 261                 /* pass original pathspec, to be re-parsed */
 262                 args[ac++] = pathspec->items[i].original;
 263
 264         status = run_command_v_opt(args, RUN_GIT_CMD);
 265         free(args);
 266         return status;
 267 }
 268
 269 int interactive_add(int argc, const char **argv, const char *prefix, int patch)
 270 {
 271         struct pathspec pathspec;
 272
 273         /*
 274          * git-add--interactive itself does not parse pathspec. It
 275          * simply passes the pathspec to other builtin commands. Let's
 276          * hope all of them support all magic, or we'll need to limit
 277          * the magic here.
 278          */
 279         parse_pathspec(&pathspec, PATHSPEC_ALL_MAGIC & ~PATHSPEC_FROMTOP,
 280                        PATHSPEC_PREFER_FULL |
 281                        PATHSPEC_SYMLINK_LEADING_PATH |
 282                        PATHSPEC_PREFIX_ORIGIN,
 283                        prefix, argv);
 284
 285         return run_add_interactive(NULL,
 286                                    patch ? "--patch" : NULL,
 287                                    &pathspec);
 288 }
 289
 290 static int edit_patch(int argc, const char **argv, const char *prefix)
 291 {
 292         char *file = git_pathdup("ADD_EDIT.patch");
 293         const char *apply_argv[] = { "apply", "--recount", "--cached",
 294                 NULL, NULL };
 295         struct child_process child;
 296         struct rev_info rev;
 297         int out;
 298         struct stat st;
 299
 300         apply_argv[3] = file;
 301
 302         git_config(git_diff_basic_config, NULL); /* no "diff" UI options */
 303
 304         if (read_cache() < 0)
 305                 die (_("Could not read the index"));
 306
 307         init_revisions(&rev, prefix);
 308         rev.diffopt.context = 7;
 309
 310         argc = setup_revisions(argc, argv, &rev, NULL);
 311         rev.diffopt.output_format = DIFF_FORMAT_PATCH;
 312         rev.diffopt.use_color = 0;
 313         DIFF_OPT_SET(&rev.diffopt, IGNORE_DIRTY_SUBMODULES);
 314         out = open(file, O_CREAT | O_WRONLY, 0666);
 315         if (out < 0)
 316                 die (_("Could not open '%s' for writing."), file);
 317         rev.diffopt.file = xfdopen(out, "w");
 318         rev.diffopt.close_file = 1;
 319         if (run_diff_files(&rev, 0))
 320                 die (_("Could not write patch"));
 321
 322         launch_editor(file, NULL, NULL);
 323
 324         if (stat(file, &st))
 325                 die_errno(_("Could not stat '%s'"), file);
 326         if (!st.st_size)
 327                 die(_("Empty patch. Aborted."));
 328
 329         memset(&child, 0, sizeof(child));
 330         child.git_cmd = 1;
 331         child.argv = apply_argv;
 332         if (run_command(&child))
 333                 die (_("Could not apply '%s'"), file);
 334
 335         unlink(file);
 336         free(file);
 337         return 0;
 338 }
 339
 340 static struct lock_file lock_file;
 341
 342 static const char ignore_error[] =
 343 N_("The following paths are ignored by one of your .gitignore files:\n");
 344
 345 static int verbose, show_only, ignored_too, refresh_only;
 346 static int ignore_add_errors, intent_to_add, ignore_missing;
 347
 348 #define ADDREMOVE_DEFAULT 0 /* Change to 1 in Git 2.0 */
 349 static int addremove = ADDREMOVE_DEFAULT;
 350 static int addremove_explicit = -1; /* unspecified */
 351
 352 static int ignore_removal_cb(const struct option *opt, const char *arg, int unset)
 353 {
 354         /* if we are told to ignore, we are not adding removals */
 355         *(int *)opt->value = !unset ? 0 : 1;
 356         return 0;
 357 }
 358
 359 static struct option builtin_add_options[] = {
 360         OPT__DRY_RUN(&show_only, N_("dry run")),
 361         OPT__VERBOSE(&verbose, N_("be verbose")),
 362         OPT_GROUP(""),
 363         OPT_BOOL('i', "interactive", &add_interactive, N_("interactive picking")),
 364         OPT_BOOL('p', "patch", &patch_interactive, N_("select hunks interactively")),
 365         OPT_BOOL('e', "edit", &edit_interactive, N_("edit current diff and apply")),
 366         OPT__FORCE(&ignored_too, N_("allow adding otherwise ignored files")),
 367         OPT_BOOL('u', "update", &take_worktree_changes, N_("update tracked files")),
 368         OPT_BOOL('N', "intent-to-add", &intent_to_add, N_("record only the fact that the path will be added later")),
 369         OPT_BOOL('A', "all", &addremove_explicit, N_("add changes from all tracked and untracked files")),
 370         { OPTION_CALLBACK, 0, "ignore-removal", &addremove_explicit,
 371           NULL /* takes no arguments */,
 372           N_("ignore paths removed in the working tree (same as --no-all)"),
 373           PARSE_OPT_NOARG, ignore_removal_cb },
 374         OPT_BOOL( 0 , "refresh", &refresh_only, N_("don't add, only refresh the index")),
 375         OPT_BOOL( 0 , "ignore-errors", &ignore_add_errors, N_("just skip files which cannot be added because of errors")),
 376         OPT_BOOL( 0 , "ignore-missing", &ignore_missing, N_("check if - even missing - files are ignored in dry run")),
 377         OPT_END(),
 378 };
 379
 380 static int add_config(const char *var, const char *value, void *cb)
 381 {
 382         if (!strcmp(var, "add.ignoreerrors") ||
 383             !strcmp(var, "add.ignore-errors")) {
 384                 ignore_add_errors = git_config_bool(var, value);
 385                 return 0;
 386         }
 387         return git_default_config(var, value, cb);
 388 }
 389
 390 static int add_files(struct dir_struct *dir, int flags)
 391 {
 392         int i, exit_status = 0;
 393
 394         if (dir->ignored_nr) {
 395                 fprintf(stderr, _(ignore_error));
 396                 for (i = 0; i < dir->ignored_nr; i++)
 397                         fprintf(stderr, "%s\n", dir->ignored[i]->name);
 398                 fprintf(stderr, _("Use -f if you really want to add them.\n"));
 399                 die(_("no files added"));
 400         }
 401
 402         for (i = 0; i < dir->nr; i++)
 403                 if (add_file_to_cache(dir->entries[i]->name, flags)) {
 404                         if (!ignore_add_errors)
 405                                 die(_("adding files failed"));
 406                         exit_status = 1;
 407                 }
 408         return exit_status;
 409 }
 410
 411 int cmd_add(int argc, const char **argv, const char *prefix)
 412 {
 413         int exit_status = 0;
 414         int newfd;
 415         struct pathspec pathspec;
 416         struct dir_struct dir;
 417         int flags;
 418         int add_new_files;
 419         int require_pathspec;
 420         char *seen = NULL;
 421         int implicit_dot = 0;
 422         struct update_callback_data update_data;
 423
 424         git_config(add_config, NULL);
 425
 426         argc = parse_options(argc, argv, prefix, builtin_add_options,
 427                           builtin_add_usage, PARSE_OPT_KEEP_ARGV0);
 428         if (patch_interactive)
 429                 add_interactive = 1;
 430         if (add_interactive)
 431                 exit(interactive_add(argc - 1, argv + 1, prefix, patch_interactive));
 432
 433         if (edit_interactive)
 434                 return(edit_patch(argc, argv, prefix));
 435         argc--;
 436         argv++;
 437
 438         if (0 <= addremove_explicit)
 439                 addremove = addremove_explicit;
 440         else if (take_worktree_changes && ADDREMOVE_DEFAULT)
 441                 addremove = 0; /* "-u" was given but not "-A" */
 442
 443         if (addremove && take_worktree_changes)
 444                 die(_("-A and -u are mutually incompatible"));
 445
 446         /*
 447          * Warn when "git add pathspec..." was given without "-u" or "-A"
 448          * and pathspec... covers a removed path.
 449          */
 450         memset(&update_data, 0, sizeof(update_data));
 451         if (!take_worktree_changes && addremove_explicit < 0)
 452                 update_data.warn_add_would_remove = 1;
 453
 454         if (!take_worktree_changes && addremove_explicit < 0 && argc)
 455                 /*
 456                  * Turn "git add pathspec..." to "git add -A pathspec..."
 457                  * in Git 2.0 but not yet
 458                  */
 459                 ; /* addremove = 1; */
 460
 461         if (!show_only && ignore_missing)
 462                 die(_("Option --ignore-missing can only be used together with --dry-run"));
 463         if (addremove) {
 464                 option_with_implicit_dot = "--all";
 465                 short_option_with_implicit_dot = "-A";
 466         }
 467         if (take_worktree_changes) {
 468                 option_with_implicit_dot = "--update";
 469                 short_option_with_implicit_dot = "-u";
 470         }
 471         if (option_with_implicit_dot && !argc) {
 472                 static const char *here[2] = { ".", NULL };
 473                 argc = 1;
 474                 argv = here;
 475                 implicit_dot = 1;
 476         }
 477
 478         add_new_files = !take_worktree_changes && !refresh_only;
 479         require_pathspec = !take_worktree_changes;
 480
 481         newfd = hold_locked_index(&lock_file, 1);
 482
 483         flags = ((verbose ? ADD_CACHE_VERBOSE : 0) |
 484                  (show_only ? ADD_CACHE_PRETEND : 0) |
 485                  (intent_to_add ? ADD_CACHE_INTENT : 0) |
 486                  (ignore_add_errors ? ADD_CACHE_IGNORE_ERRORS : 0) |
 487                  (!(addremove || take_worktree_changes)
 488                   ? ADD_CACHE_IGNORE_REMOVAL : 0)) |
 489                  (implicit_dot ? ADD_CACHE_IMPLICIT_DOT : 0);
 490
 491         if (require_pathspec && argc == 0) {
 492                 fprintf(stderr, _("Nothing specified, nothing added.\n"));
 493                 fprintf(stderr, _("Maybe you wanted to say 'git add .'?\n"));
 494                 return 0;
 495         }
 496
 497         if (read_cache() < 0)
 498                 die(_("index file corrupt"));
 499
 500         /*
 501          * Check the "pathspec '%s' did not match any files" block
 502          * below before enabling new magic.
 503          */
 504         parse_pathspec(&pathspec, 0,
 505                        PATHSPEC_PREFER_FULL |
 506                        PATHSPEC_SYMLINK_LEADING_PATH |
 507                        PATHSPEC_STRIP_SUBMODULE_SLASH_EXPENSIVE,
 508                        prefix, argv);
 509
 510         if (add_new_files) {
 511                 int baselen;
 512                 struct pathspec empty_pathspec;
 513
 514                 /* Set up the default git porcelain excludes */
 515                 memset(&dir, 0, sizeof(dir));
 516                 if (!ignored_too) {
 517                         dir.flags |= DIR_COLLECT_IGNORED;
 518                         setup_standard_excludes(&dir);
 519                 }
 520
 521                 memset(&empty_pathspec, 0, sizeof(empty_pathspec));
 522                 /* This picks up the paths that are not tracked */
 523                 baselen = fill_directory(&dir, implicit_dot ? &empty_pathspec : &pathspec);
 524                 if (pathspec.nr)
 525                         seen = prune_directory(&dir, &pathspec, baselen,
 526                                         implicit_dot ? WARN_IMPLICIT_DOT : 0);
 527         }
 528
 529         if (refresh_only) {
 530                 refresh(verbose, &pathspec);
 531                 goto finish;
 532         }
 533         if (implicit_dot && prefix)
 534                 refresh_cache(REFRESH_QUIET);
 535
 536         if (pathspec.nr) {
 537                 int i;
 538
 539                 if (!seen)
 540                         seen = find_pathspecs_matching_against_index(&pathspec);
 541
 542                 /*
 543                  * file_exists() assumes exact match
 544                  */
 545                 GUARD_PATHSPEC(&pathspec,
 546                                PATHSPEC_FROMTOP |
 547                                PATHSPEC_LITERAL |
 548                                PATHSPEC_GLOB |
 549                                PATHSPEC_ICASE);
 550
 551                 for (i = 0; i < pathspec.nr; i++) {
 552                         const char *path = pathspec.items[i].match;
 553                         if (!seen[i] &&
 554                             ((pathspec.items[i].magic &
 555                               (PATHSPEC_GLOB | PATHSPEC_ICASE)) ||
 556                              !file_exists(path))) {
 557                                 if (ignore_missing) {
 558                                         int dtype = DT_UNKNOWN;
 559                                         if (is_excluded(&dir, path, &dtype))
 560                                                 dir_add_ignored(&dir, path, pathspec.items[i].len);
 561                                 } else
 562                                         die(_("pathspec '%s' did not match any files"),
 563                                             pathspec.items[i].original);
 564                         }
 565                 }
 566                 free(seen);
 567         }
 568
 569         plug_bulk_checkin();
 570
 571         if ((flags & ADD_CACHE_IMPLICIT_DOT) && prefix) {
 572                 /*
 573                  * Check for modified files throughout the worktree so
 574                  * update_callback has a chance to warn about changes
 575                  * outside the cwd.
 576                  */
 577                 update_data.implicit_dot = prefix;
 578                 update_data.implicit_dot_len = strlen(prefix);
 579                 free_pathspec(&pathspec);
 580                 memset(&pathspec, 0, sizeof(pathspec));
 581         }
 582         update_data.flags = flags & ~ADD_CACHE_IMPLICIT_DOT;
 583         update_files_in_cache(prefix, &pathspec, &update_data);
 584
 585         exit_status |= !!update_data.add_errors;
 586         if (add_new_files)
 587                 exit_status |= add_files(&dir, flags);
 588
 589         unplug_bulk_checkin();
 590
 591  finish:
 592         if (active_cache_changed) {
 593                 if (write_cache(newfd, active_cache, active_nr) ||
 594                     commit_locked_index(&lock_file))
 595                         die(_("Unable to write new index file"));
 596         }
 597
 598         return exit_status;
 599 }