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 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         DIFF_OPT_SET(&rev.diffopt, IGNORE_DIRTY_SUBMODULES);
 313         out = open(file, O_CREAT | O_WRONLY, 0666);
 314         if (out < 0)
 315                 die (_("Could not open '%s' for writing."), file);
 316         rev.diffopt.file = xfdopen(out, "w");
 317         rev.diffopt.close_file = 1;
 318         if (run_diff_files(&rev, 0))
 319                 die (_("Could not write patch"));
 320
 321         launch_editor(file, NULL, NULL);
 322
 323         if (stat(file, &st))
 324                 die_errno(_("Could not stat '%s'"), file);
 325         if (!st.st_size)
 326                 die(_("Empty patch. Aborted."));
 327
 328         memset(&child, 0, sizeof(child));
 329         child.git_cmd = 1;
 330         child.argv = apply_argv;
 331         if (run_command(&child))
 332                 die (_("Could not apply '%s'"), file);
 333
 334         unlink(file);
 335         free(file);
 336         return 0;
 337 }
 338
 339 static struct lock_file lock_file;
 340
 341 static const char ignore_error[] =
 342 N_("The following paths are ignored by one of your .gitignore files:\n");
 343
 344 static int verbose, show_only, ignored_too, refresh_only;
 345 static int ignore_add_errors, intent_to_add, ignore_missing;
 346
 347 #define ADDREMOVE_DEFAULT 0 /* Change to 1 in Git 2.0 */
 348 static int addremove = ADDREMOVE_DEFAULT;
 349 static int addremove_explicit = -1; /* unspecified */
 350
 351 static int ignore_removal_cb(const struct option *opt, const char *arg, int unset)
 352 {
 353         /* if we are told to ignore, we are not adding removals */
 354         *(int *)opt->value = !unset ? 0 : 1;
 355         return 0;
 356 }
 357
 358 static struct option builtin_add_options[] = {
 359         OPT__DRY_RUN(&show_only, N_("dry run")),
 360         OPT__VERBOSE(&verbose, N_("be verbose")),
 361         OPT_GROUP(""),
 362         OPT_BOOL('i', "interactive", &add_interactive, N_("interactive picking")),
 363         OPT_BOOL('p', "patch", &patch_interactive, N_("select hunks interactively")),
 364         OPT_BOOL('e', "edit", &edit_interactive, N_("edit current diff and apply")),
 365         OPT__FORCE(&ignored_too, N_("allow adding otherwise ignored files")),
 366         OPT_BOOL('u', "update", &take_worktree_changes, N_("update tracked files")),
 367         OPT_BOOL('N', "intent-to-add", &intent_to_add, N_("record only the fact that the path will be added later")),
 368         OPT_BOOL('A', "all", &addremove_explicit, N_("add changes from all tracked and untracked files")),
 369         { OPTION_CALLBACK, 0, "ignore-removal", &addremove_explicit,
 370           NULL /* takes no arguments */,
 371           N_("ignore paths removed in the working tree (same as --no-all)"),
 372           PARSE_OPT_NOARG, ignore_removal_cb },
 373         OPT_BOOL( 0 , "refresh", &refresh_only, N_("don't add, only refresh the index")),
 374         OPT_BOOL( 0 , "ignore-errors", &ignore_add_errors, N_("just skip files which cannot be added because of errors")),
 375         OPT_BOOL( 0 , "ignore-missing", &ignore_missing, N_("check if - even missing - files are ignored in dry run")),
 376         OPT_END(),
 377 };
 378
 379 static int add_config(const char *var, const char *value, void *cb)
 380 {
 381         if (!strcmp(var, "add.ignoreerrors") ||
 382             !strcmp(var, "add.ignore-errors")) {
 383                 ignore_add_errors = git_config_bool(var, value);
 384                 return 0;
 385         }
 386         return git_default_config(var, value, cb);
 387 }
 388
 389 static int add_files(struct dir_struct *dir, int flags)
 390 {
 391         int i, exit_status = 0;
 392
 393         if (dir->ignored_nr) {
 394                 fprintf(stderr, _(ignore_error));
 395                 for (i = 0; i < dir->ignored_nr; i++)
 396                         fprintf(stderr, "%s\n", dir->ignored[i]->name);
 397                 fprintf(stderr, _("Use -f if you really want to add them.\n"));
 398                 die(_("no files added"));
 399         }
 400
 401         for (i = 0; i < dir->nr; i++)
 402                 if (add_file_to_cache(dir->entries[i]->name, flags)) {
 403                         if (!ignore_add_errors)
 404                                 die(_("adding files failed"));
 405                         exit_status = 1;
 406                 }
 407         return exit_status;
 408 }
 409
 410 int cmd_add(int argc, const char **argv, const char *prefix)
 411 {
 412         int exit_status = 0;
 413         int newfd;
 414         struct pathspec pathspec;
 415         struct dir_struct dir;
 416         int flags;
 417         int add_new_files;
 418         int require_pathspec;
 419         char *seen = NULL;
 420         int implicit_dot = 0;
 421         struct update_callback_data update_data;
 422
 423         git_config(add_config, NULL);
 424
 425         argc = parse_options(argc, argv, prefix, builtin_add_options,
 426                           builtin_add_usage, PARSE_OPT_KEEP_ARGV0);
 427         if (patch_interactive)
 428                 add_interactive = 1;
 429         if (add_interactive)
 430                 exit(interactive_add(argc - 1, argv + 1, prefix, patch_interactive));
 431
 432         if (edit_interactive)
 433                 return(edit_patch(argc, argv, prefix));
 434         argc--;
 435         argv++;
 436
 437         if (0 <= addremove_explicit)
 438                 addremove = addremove_explicit;
 439         else if (take_worktree_changes && ADDREMOVE_DEFAULT)
 440                 addremove = 0; /* "-u" was given but not "-A" */
 441
 442         if (addremove && take_worktree_changes)
 443                 die(_("-A and -u are mutually incompatible"));
 444
 445         /*
 446          * Warn when "git add pathspec..." was given without "-u" or "-A"
 447          * and pathspec... covers a removed path.
 448          */
 449         memset(&update_data, 0, sizeof(update_data));
 450         if (!take_worktree_changes && addremove_explicit < 0)
 451                 update_data.warn_add_would_remove = 1;
 452
 453         if (!take_worktree_changes && addremove_explicit < 0 && argc)
 454                 /*
 455                  * Turn "git add pathspec..." to "git add -A pathspec..."
 456                  * in Git 2.0 but not yet
 457                  */
 458                 ; /* addremove = 1; */
 459
 460         if (!show_only && ignore_missing)
 461                 die(_("Option --ignore-missing can only be used together with --dry-run"));
 462         if (addremove) {
 463                 option_with_implicit_dot = "--all";
 464                 short_option_with_implicit_dot = "-A";
 465         }
 466         if (take_worktree_changes) {
 467                 option_with_implicit_dot = "--update";
 468                 short_option_with_implicit_dot = "-u";
 469         }
 470         if (option_with_implicit_dot && !argc) {
 471                 static const char *here[2] = { ".", NULL };
 472                 argc = 1;
 473                 argv = here;
 474                 implicit_dot = 1;
 475         }
 476
 477         add_new_files = !take_worktree_changes && !refresh_only;
 478         require_pathspec = !take_worktree_changes;
 479
 480         newfd = hold_locked_index(&lock_file, 1);
 481
 482         flags = ((verbose ? ADD_CACHE_VERBOSE : 0) |
 483                  (show_only ? ADD_CACHE_PRETEND : 0) |
 484                  (intent_to_add ? ADD_CACHE_INTENT : 0) |
 485                  (ignore_add_errors ? ADD_CACHE_IGNORE_ERRORS : 0) |
 486                  (!(addremove || take_worktree_changes)
 487                   ? ADD_CACHE_IGNORE_REMOVAL : 0)) |
 488                  (implicit_dot ? ADD_CACHE_IMPLICIT_DOT : 0);
 489
 490         if (require_pathspec && argc == 0) {
 491                 fprintf(stderr, _("Nothing specified, nothing added.\n"));
 492                 fprintf(stderr, _("Maybe you wanted to say 'git add .'?\n"));
 493                 return 0;
 494         }
 495
 496         if (read_cache() < 0)
 497                 die(_("index file corrupt"));
 498
 499         /*
 500          * Check the "pathspec '%s' did not match any files" block
 501          * below before enabling new magic.
 502          */
 503         parse_pathspec(&pathspec, 0,
 504                        PATHSPEC_PREFER_FULL |
 505                        PATHSPEC_SYMLINK_LEADING_PATH |
 506                        PATHSPEC_STRIP_SUBMODULE_SLASH_EXPENSIVE,
 507                        prefix, argv);
 508
 509         if (add_new_files) {
 510                 int baselen;
 511
 512                 /* Set up the default git porcelain excludes */
 513                 memset(&dir, 0, sizeof(dir));
 514                 if (!ignored_too) {
 515                         dir.flags |= DIR_COLLECT_IGNORED;
 516                         setup_standard_excludes(&dir);
 517                 }
 518
 519                 /* This picks up the paths that are not tracked */
 520                 baselen = fill_directory(&dir, implicit_dot ? NULL : pathspec.raw);
 521                 if (pathspec.nr)
 522                         seen = prune_directory(&dir, pathspec.raw, baselen,
 523                                         implicit_dot ? WARN_IMPLICIT_DOT : 0);
 524         }
 525
 526         if (refresh_only) {
 527                 refresh(verbose, pathspec.raw);
 528                 goto finish;
 529         }
 530         if (implicit_dot && prefix)
 531                 refresh_cache(REFRESH_QUIET);
 532
 533         if (pathspec.nr) {
 534                 int i;
 535
 536                 if (!seen)
 537                         seen = find_pathspecs_matching_against_index(pathspec.raw);
 538
 539                 /*
 540                  * file_exists() assumes exact match
 541                  */
 542                 GUARD_PATHSPEC(&pathspec, PATHSPEC_FROMTOP);
 543
 544                 for (i = 0; pathspec.raw[i]; i++) {
 545                         if (!seen[i] && pathspec.raw[i][0]
 546                             && !file_exists(pathspec.raw[i])) {
 547                                 if (ignore_missing) {
 548                                         int dtype = DT_UNKNOWN;
 549                                         if (is_excluded(&dir, pathspec.raw[i], &dtype))
 550                                                 dir_add_ignored(&dir, pathspec.raw[i], strlen(pathspec.raw[i]));
 551                                 } else
 552                                         die(_("pathspec '%s' did not match any files"),
 553                                             pathspec.raw[i]);
 554                         }
 555                 }
 556                 free(seen);
 557         }
 558
 559         plug_bulk_checkin();
 560
 561         if ((flags & ADD_CACHE_IMPLICIT_DOT) && prefix) {
 562                 /*
 563                  * Check for modified files throughout the worktree so
 564                  * update_callback has a chance to warn about changes
 565                  * outside the cwd.
 566                  */
 567                 update_data.implicit_dot = prefix;
 568                 update_data.implicit_dot_len = strlen(prefix);
 569                 free_pathspec(&pathspec);
 570                 memset(&pathspec, 0, sizeof(pathspec));
 571         }
 572         update_data.flags = flags & ~ADD_CACHE_IMPLICIT_DOT;
 573         update_files_in_cache(prefix, pathspec.raw, &update_data);
 574
 575         exit_status |= !!update_data.add_errors;
 576         if (add_new_files)
 577                 exit_status |= add_files(&dir, flags);
 578
 579         unplug_bulk_checkin();
 580
 581  finish:
 582         if (active_cache_changed) {
 583                 if (write_cache(newfd, active_cache, active_nr) ||
 584                     commit_locked_index(&lock_file))
 585                         die(_("Unable to write new index file"));
 586         }
 587
 588         return exit_status;
 589 }