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, const char **pathspec,
 170                                   struct update_callback_data *data)
 171 {
 172         struct rev_info rev;
 173
 174         init_revisions(&rev, prefix);
 175         setup_revisions(0, NULL, &rev, NULL);
 176         init_pathspec(&rev.prune_data, pathspec);
 177         rev.diffopt.output_format = DIFF_FORMAT_CALLBACK;
 178         rev.diffopt.format_callback = update_callback;
 179         rev.diffopt.format_callback_data = data;
 180         rev.max_count = 0; /* do not compare unmerged paths with stage #2 */
 181         run_diff_files(&rev, DIFF_RACY_IS_MODIFIED);
 182 }
 183
 184 int add_files_to_cache(const char *prefix, const char **pathspec, int flags)
 185 {
 186         struct update_callback_data data;
 187
 188         memset(&data, 0, sizeof(data));
 189         data.flags = flags;
 190         update_files_in_cache(prefix, pathspec, &data);
 191         return !!data.add_errors;
 192 }
 193
 194 #define WARN_IMPLICIT_DOT (1u << 0)
 195 static char *prune_directory(struct dir_struct *dir, const char **pathspec,
 196                              int prefix, unsigned flag)
 197 {
 198         char *seen;
 199         int i, specs;
 200         struct dir_entry **src, **dst;
 201
 202         for (specs = 0; pathspec[specs];  specs++)
 203                 /* nothing */;
 204         seen = xcalloc(specs, 1);
 205
 206         src = dst = dir->entries;
 207         i = dir->nr;
 208         while (--i >= 0) {
 209                 struct dir_entry *entry = *src++;
 210                 if (match_pathspec(pathspec, entry->name, entry->len,
 211                                    prefix, seen))
 212                         *dst++ = entry;
 213                 else if (flag & WARN_IMPLICIT_DOT)
 214                         /*
 215                          * "git add -A" was run from a subdirectory with a
 216                          * new file outside that directory.
 217                          *
 218                          * "git add -A" will behave like "git add -A :/"
 219                          * instead of "git add -A ." in the future.
 220                          * Warn about the coming behavior change.
 221                          */
 222                         warn_pathless_add();
 223         }
 224         dir->nr = dst - dir->entries;
 225         add_pathspec_matches_against_index(pathspec, seen, specs);
 226         return seen;
 227 }
 228
 229 static void refresh(int verbose, const char **pathspec)
 230 {
 231         char *seen;
 232         int i, specs;
 233
 234         for (specs = 0; pathspec[specs];  specs++)
 235                 /* nothing */;
 236         seen = xcalloc(specs, 1);
 237         refresh_index(&the_index, verbose ? REFRESH_IN_PORCELAIN : REFRESH_QUIET,
 238                       pathspec, seen, _("Unstaged changes after refreshing the index:"));
 239         for (i = 0; i < specs; i++) {
 240                 if (!seen[i])
 241                         die(_("pathspec '%s' did not match any files"), pathspec[i]);
 242         }
 243         free(seen);
 244 }
 245
 246 int run_add_interactive(const char *revision, const char *patch_mode,
 247                         const char **pathspec)
 248 {
 249         int status, ac, pc = 0;
 250         const char **args;
 251
 252         if (pathspec)
 253                 while (pathspec[pc])
 254                         pc++;
 255
 256         args = xcalloc(sizeof(const char *), (pc + 5));
 257         ac = 0;
 258         args[ac++] = "add--interactive";
 259         if (patch_mode)
 260                 args[ac++] = patch_mode;
 261         if (revision)
 262                 args[ac++] = revision;
 263         args[ac++] = "--";
 264         if (pc) {
 265                 memcpy(&(args[ac]), pathspec, sizeof(const char *) * pc);
 266                 ac += pc;
 267         }
 268         args[ac] = NULL;
 269
 270         status = run_command_v_opt(args, RUN_GIT_CMD);
 271         free(args);
 272         return status;
 273 }
 274
 275 int interactive_add(int argc, const char **argv, const char *prefix, int patch)
 276 {
 277         struct pathspec pathspec;
 278
 279         /*
 280          * git-add--interactive itself does not parse pathspec. It
 281          * simply passes the pathspec to other builtin commands. Let's
 282          * hope all of them support all magic, or we'll need to limit
 283          * the magic here. There is still a problem with prefix. But
 284          * that'll be worked on later on.
 285          */
 286         parse_pathspec(&pathspec, PATHSPEC_ALL_MAGIC & ~PATHSPEC_FROMTOP,
 287                        PATHSPEC_PREFER_FULL |
 288                        PATHSPEC_SYMLINK_LEADING_PATH,
 289                        prefix, argv);
 290
 291         return run_add_interactive(NULL,
 292                                    patch ? "--patch" : NULL,
 293                                    pathspec.raw);
 294 }
 295
 296 static int edit_patch(int argc, const char **argv, const char *prefix)
 297 {
 298         char *file = git_pathdup("ADD_EDIT.patch");
 299         const char *apply_argv[] = { "apply", "--recount", "--cached",
 300                 NULL, NULL };
 301         struct child_process child;
 302         struct rev_info rev;
 303         int out;
 304         struct stat st;
 305
 306         apply_argv[3] = file;
 307
 308         git_config(git_diff_basic_config, NULL); /* no "diff" UI options */
 309
 310         if (read_cache() < 0)
 311                 die (_("Could not read the index"));
 312
 313         init_revisions(&rev, prefix);
 314         rev.diffopt.context = 7;
 315
 316         argc = setup_revisions(argc, argv, &rev, NULL);
 317         rev.diffopt.output_format = DIFF_FORMAT_PATCH;
 318         DIFF_OPT_SET(&rev.diffopt, IGNORE_DIRTY_SUBMODULES);
 319         out = open(file, O_CREAT | O_WRONLY, 0666);
 320         if (out < 0)
 321                 die (_("Could not open '%s' for writing."), file);
 322         rev.diffopt.file = xfdopen(out, "w");
 323         rev.diffopt.close_file = 1;
 324         if (run_diff_files(&rev, 0))
 325                 die (_("Could not write patch"));
 326
 327         launch_editor(file, NULL, NULL);
 328
 329         if (stat(file, &st))
 330                 die_errno(_("Could not stat '%s'"), file);
 331         if (!st.st_size)
 332                 die(_("Empty patch. Aborted."));
 333
 334         memset(&child, 0, sizeof(child));
 335         child.git_cmd = 1;
 336         child.argv = apply_argv;
 337         if (run_command(&child))
 338                 die (_("Could not apply '%s'"), file);
 339
 340         unlink(file);
 341         free(file);
 342         return 0;
 343 }
 344
 345 static struct lock_file lock_file;
 346
 347 static const char ignore_error[] =
 348 N_("The following paths are ignored by one of your .gitignore files:\n");
 349
 350 static int verbose, show_only, ignored_too, refresh_only;
 351 static int ignore_add_errors, intent_to_add, ignore_missing;
 352
 353 #define ADDREMOVE_DEFAULT 0 /* Change to 1 in Git 2.0 */
 354 static int addremove = ADDREMOVE_DEFAULT;
 355 static int addremove_explicit = -1; /* unspecified */
 356
 357 static int ignore_removal_cb(const struct option *opt, const char *arg, int unset)
 358 {
 359         /* if we are told to ignore, we are not adding removals */
 360         *(int *)opt->value = !unset ? 0 : 1;
 361         return 0;
 362 }
 363
 364 static struct option builtin_add_options[] = {
 365         OPT__DRY_RUN(&show_only, N_("dry run")),
 366         OPT__VERBOSE(&verbose, N_("be verbose")),
 367         OPT_GROUP(""),
 368         OPT_BOOL('i', "interactive", &add_interactive, N_("interactive picking")),
 369         OPT_BOOL('p', "patch", &patch_interactive, N_("select hunks interactively")),
 370         OPT_BOOL('e', "edit", &edit_interactive, N_("edit current diff and apply")),
 371         OPT__FORCE(&ignored_too, N_("allow adding otherwise ignored files")),
 372         OPT_BOOL('u', "update", &take_worktree_changes, N_("update tracked files")),
 373         OPT_BOOL('N', "intent-to-add", &intent_to_add, N_("record only the fact that the path will be added later")),
 374         OPT_BOOL('A', "all", &addremove_explicit, N_("add changes from all tracked and untracked files")),
 375         { OPTION_CALLBACK, 0, "ignore-removal", &addremove_explicit,
 376           NULL /* takes no arguments */,
 377           N_("ignore paths removed in the working tree (same as --no-all)"),
 378           PARSE_OPT_NOARG, ignore_removal_cb },
 379         OPT_BOOL( 0 , "refresh", &refresh_only, N_("don't add, only refresh the index")),
 380         OPT_BOOL( 0 , "ignore-errors", &ignore_add_errors, N_("just skip files which cannot be added because of errors")),
 381         OPT_BOOL( 0 , "ignore-missing", &ignore_missing, N_("check if - even missing - files are ignored in dry run")),
 382         OPT_END(),
 383 };
 384
 385 static int add_config(const char *var, const char *value, void *cb)
 386 {
 387         if (!strcmp(var, "add.ignoreerrors") ||
 388             !strcmp(var, "add.ignore-errors")) {
 389                 ignore_add_errors = git_config_bool(var, value);
 390                 return 0;
 391         }
 392         return git_default_config(var, value, cb);
 393 }
 394
 395 static int add_files(struct dir_struct *dir, int flags)
 396 {
 397         int i, exit_status = 0;
 398
 399         if (dir->ignored_nr) {
 400                 fprintf(stderr, _(ignore_error));
 401                 for (i = 0; i < dir->ignored_nr; i++)
 402                         fprintf(stderr, "%s\n", dir->ignored[i]->name);
 403                 fprintf(stderr, _("Use -f if you really want to add them.\n"));
 404                 die(_("no files added"));
 405         }
 406
 407         for (i = 0; i < dir->nr; i++)
 408                 if (add_file_to_cache(dir->entries[i]->name, flags)) {
 409                         if (!ignore_add_errors)
 410                                 die(_("adding files failed"));
 411                         exit_status = 1;
 412                 }
 413         return exit_status;
 414 }
 415
 416 int cmd_add(int argc, const char **argv, const char *prefix)
 417 {
 418         int exit_status = 0;
 419         int newfd;
 420         struct pathspec pathspec;
 421         struct dir_struct dir;
 422         int flags;
 423         int add_new_files;
 424         int require_pathspec;
 425         char *seen = NULL;
 426         int implicit_dot = 0;
 427         struct update_callback_data update_data;
 428
 429         git_config(add_config, NULL);
 430
 431         argc = parse_options(argc, argv, prefix, builtin_add_options,
 432                           builtin_add_usage, PARSE_OPT_KEEP_ARGV0);
 433         if (patch_interactive)
 434                 add_interactive = 1;
 435         if (add_interactive)
 436                 exit(interactive_add(argc - 1, argv + 1, prefix, patch_interactive));
 437
 438         if (edit_interactive)
 439                 return(edit_patch(argc, argv, prefix));
 440         argc--;
 441         argv++;
 442
 443         if (0 <= addremove_explicit)
 444                 addremove = addremove_explicit;
 445         else if (take_worktree_changes && ADDREMOVE_DEFAULT)
 446                 addremove = 0; /* "-u" was given but not "-A" */
 447
 448         if (addremove && take_worktree_changes)
 449                 die(_("-A and -u are mutually incompatible"));
 450
 451         /*
 452          * Warn when "git add pathspec..." was given without "-u" or "-A"
 453          * and pathspec... covers a removed path.
 454          */
 455         memset(&update_data, 0, sizeof(update_data));
 456         if (!take_worktree_changes && addremove_explicit < 0)
 457                 update_data.warn_add_would_remove = 1;
 458
 459         if (!take_worktree_changes && addremove_explicit < 0 && argc)
 460                 /*
 461                  * Turn "git add pathspec..." to "git add -A pathspec..."
 462                  * in Git 2.0 but not yet
 463                  */
 464                 ; /* addremove = 1; */
 465
 466         if (!show_only && ignore_missing)
 467                 die(_("Option --ignore-missing can only be used together with --dry-run"));
 468         if (addremove) {
 469                 option_with_implicit_dot = "--all";
 470                 short_option_with_implicit_dot = "-A";
 471         }
 472         if (take_worktree_changes) {
 473                 option_with_implicit_dot = "--update";
 474                 short_option_with_implicit_dot = "-u";
 475         }
 476         if (option_with_implicit_dot && !argc) {
 477                 static const char *here[2] = { ".", NULL };
 478                 argc = 1;
 479                 argv = here;
 480                 implicit_dot = 1;
 481         }
 482
 483         add_new_files = !take_worktree_changes && !refresh_only;
 484         require_pathspec = !take_worktree_changes;
 485
 486         newfd = hold_locked_index(&lock_file, 1);
 487
 488         flags = ((verbose ? ADD_CACHE_VERBOSE : 0) |
 489                  (show_only ? ADD_CACHE_PRETEND : 0) |
 490                  (intent_to_add ? ADD_CACHE_INTENT : 0) |
 491                  (ignore_add_errors ? ADD_CACHE_IGNORE_ERRORS : 0) |
 492                  (!(addremove || take_worktree_changes)
 493                   ? ADD_CACHE_IGNORE_REMOVAL : 0)) |
 494                  (implicit_dot ? ADD_CACHE_IMPLICIT_DOT : 0);
 495
 496         if (require_pathspec && argc == 0) {
 497                 fprintf(stderr, _("Nothing specified, nothing added.\n"));
 498                 fprintf(stderr, _("Maybe you wanted to say 'git add .'?\n"));
 499                 return 0;
 500         }
 501
 502         if (read_cache() < 0)
 503                 die(_("index file corrupt"));
 504
 505         /*
 506          * Check the "pathspec '%s' did not match any files" block
 507          * below before enabling new magic.
 508          */
 509         parse_pathspec(&pathspec, 0,
 510                        PATHSPEC_PREFER_FULL |
 511                        PATHSPEC_SYMLINK_LEADING_PATH |
 512                        PATHSPEC_STRIP_SUBMODULE_SLASH_EXPENSIVE,
 513                        prefix, argv);
 514
 515         if (add_new_files) {
 516                 int baselen;
 517
 518                 /* Set up the default git porcelain excludes */
 519                 memset(&dir, 0, sizeof(dir));
 520                 if (!ignored_too) {
 521                         dir.flags |= DIR_COLLECT_IGNORED;
 522                         setup_standard_excludes(&dir);
 523                 }
 524
 525                 /* This picks up the paths that are not tracked */
 526                 baselen = fill_directory(&dir, implicit_dot ? NULL : pathspec.raw);
 527                 if (pathspec.nr)
 528                         seen = prune_directory(&dir, pathspec.raw, baselen,
 529                                         implicit_dot ? WARN_IMPLICIT_DOT : 0);
 530         }
 531
 532         if (refresh_only) {
 533                 refresh(verbose, pathspec.raw);
 534                 goto finish;
 535         }
 536         if (implicit_dot && prefix)
 537                 refresh_cache(REFRESH_QUIET);
 538
 539         if (pathspec.nr) {
 540                 int i;
 541
 542                 if (!seen)
 543                         seen = find_pathspecs_matching_against_index(pathspec.raw);
 544
 545                 /*
 546                  * file_exists() assumes exact match
 547                  */
 548                 GUARD_PATHSPEC(&pathspec, PATHSPEC_FROMTOP);
 549
 550                 for (i = 0; pathspec.raw[i]; i++) {
 551                         if (!seen[i] && pathspec.raw[i][0]
 552                             && !file_exists(pathspec.raw[i])) {
 553                                 if (ignore_missing) {
 554                                         int dtype = DT_UNKNOWN;
 555                                         if (is_excluded(&dir, pathspec.raw[i], &dtype))
 556                                                 dir_add_ignored(&dir, pathspec.raw[i], strlen(pathspec.raw[i]));
 557                                 } else
 558                                         die(_("pathspec '%s' did not match any files"),
 559                                             pathspec.raw[i]);
 560                         }
 561                 }
 562                 free(seen);
 563         }
 564
 565         plug_bulk_checkin();
 566
 567         if ((flags & ADD_CACHE_IMPLICIT_DOT) && prefix) {
 568                 /*
 569                  * Check for modified files throughout the worktree so
 570                  * update_callback has a chance to warn about changes
 571                  * outside the cwd.
 572                  */
 573                 update_data.implicit_dot = prefix;
 574                 update_data.implicit_dot_len = strlen(prefix);
 575                 free_pathspec(&pathspec);
 576                 memset(&pathspec, 0, sizeof(pathspec));
 577         }
 578         update_data.flags = flags & ~ADD_CACHE_IMPLICIT_DOT;
 579         update_files_in_cache(prefix, pathspec.raw, &update_data);
 580
 581         exit_status |= !!update_data.add_errors;
 582         if (add_new_files)
 583                 exit_status |= add_files(&dir, flags);
 584
 585         unplug_bulk_checkin();
 586
 587  finish:
 588         if (active_cache_changed) {
 589                 if (write_cache(newfd, active_cache, active_nr) ||
 590                     commit_locked_index(&lock_file))
 591                         die(_("Unable to write new index file"));
 592         }
 593
 594         return exit_status;
 595 }