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