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