builtin/add.c

   1 /*
   2  * "git add" builtin command
   3  *
   4  * Copyright (C) 2006 Linus Torvalds
   5  */
   6 #define USE_THE_INDEX_COMPATIBILITY_MACROS
   7 #include "cache.h"
   8 #include "config.h"
   9 #include "builtin.h"
  10 #include "lockfile.h"
  11 #include "dir.h"
  12 #include "pathspec.h"
  13 #include "exec-cmd.h"
  14 #include "cache-tree.h"
  15 #include "run-command.h"
  16 #include "parse-options.h"
  17 #include "diff.h"
  18 #include "diffcore.h"
  19 #include "revision.h"
  20 #include "bulk-checkin.h"
  21 #include "argv-array.h"
  22 #include "submodule.h"
  23 #include "add-interactive.h"
  24
  25 static const char * const builtin_add_usage[] = {
  26         N_("git add [<options>] [--] <pathspec>..."),
  27         NULL
  28 };
  29 static int patch_interactive, add_interactive, edit_interactive;
  30 static int take_worktree_changes;
  31 static int add_renormalize;
  32 static int pathspec_file_nul;
  33 static const char *pathspec_from_file;
  34
  35 struct update_callback_data {
  36         int flags;
  37         int add_errors;
  38 };
  39
  40 static void chmod_pathspec(struct pathspec *pathspec, char flip)
  41 {
  42         int i;
  43
  44         for (i = 0; i < active_nr; i++) {
  45                 struct cache_entry *ce = active_cache[i];
  46
  47                 if (pathspec && !ce_path_match(&the_index, ce, pathspec, NULL))
  48                         continue;
  49
  50                 if (chmod_cache_entry(ce, flip) < 0)
  51                         fprintf(stderr, "cannot chmod %cx '%s'\n", flip, ce->name);
  52         }
  53 }
  54
  55 static int fix_unmerged_status(struct diff_filepair *p,
  56                                struct update_callback_data *data)
  57 {
  58         if (p->status != DIFF_STATUS_UNMERGED)
  59                 return p->status;
  60         if (!(data->flags & ADD_CACHE_IGNORE_REMOVAL) && !p->two->mode)
  61                 /*
  62                  * This is not an explicit add request, and the
  63                  * path is missing from the working tree (deleted)
  64                  */
  65                 return DIFF_STATUS_DELETED;
  66         else
  67                 /*
  68                  * Either an explicit add request, or path exists
  69                  * in the working tree.  An attempt to explicitly
  70                  * add a path that does not exist in the working tree
  71                  * will be caught as an error by the caller immediately.
  72                  */
  73                 return DIFF_STATUS_MODIFIED;
  74 }
  75
  76 static void update_callback(struct diff_queue_struct *q,
  77                             struct diff_options *opt, void *cbdata)
  78 {
  79         int i;
  80         struct update_callback_data *data = cbdata;
  81
  82         for (i = 0; i < q->nr; i++) {
  83                 struct diff_filepair *p = q->queue[i];
  84                 const char *path = p->one->path;
  85                 switch (fix_unmerged_status(p, data)) {
  86                 default:
  87                         die(_("unexpected diff status %c"), p->status);
  88                 case DIFF_STATUS_MODIFIED:
  89                 case DIFF_STATUS_TYPE_CHANGED:
  90                         if (add_file_to_index(&the_index, path, data->flags)) {
  91                                 if (!(data->flags & ADD_CACHE_IGNORE_ERRORS))
  92                                         die(_("updating files failed"));
  93                                 data->add_errors++;
  94                         }
  95                         break;
  96                 case DIFF_STATUS_DELETED:
  97                         if (data->flags & ADD_CACHE_IGNORE_REMOVAL)
  98                                 break;
  99                         if (!(data->flags & ADD_CACHE_PRETEND))
 100                                 remove_file_from_index(&the_index, path);
 101                         if (data->flags & (ADD_CACHE_PRETEND|ADD_CACHE_VERBOSE))
 102                                 printf(_("remove '%s'\n"), path);
 103                         break;
 104                 }
 105         }
 106 }
 107
 108 int add_files_to_cache(const char *prefix,
 109                        const struct pathspec *pathspec, int flags)
 110 {
 111         struct update_callback_data data;
 112         struct rev_info rev;
 113
 114         memset(&data, 0, sizeof(data));
 115         data.flags = flags;
 116
 117         repo_init_revisions(the_repository, &rev, prefix);
 118         setup_revisions(0, NULL, &rev, NULL);
 119         if (pathspec)
 120                 copy_pathspec(&rev.prune_data, pathspec);
 121         rev.diffopt.output_format = DIFF_FORMAT_CALLBACK;
 122         rev.diffopt.format_callback = update_callback;
 123         rev.diffopt.format_callback_data = &data;
 124         rev.diffopt.flags.override_submodule_config = 1;
 125         rev.max_count = 0; /* do not compare unmerged paths with stage #2 */
 126         run_diff_files(&rev, DIFF_RACY_IS_MODIFIED);
 127         clear_pathspec(&rev.prune_data);
 128         return !!data.add_errors;
 129 }
 130
 131 static int renormalize_tracked_files(const struct pathspec *pathspec, int flags)
 132 {
 133         int i, retval = 0;
 134
 135         for (i = 0; i < active_nr; i++) {
 136                 struct cache_entry *ce = active_cache[i];
 137
 138                 if (ce_stage(ce))
 139                         continue; /* do not touch unmerged paths */
 140                 if (!S_ISREG(ce->ce_mode) && !S_ISLNK(ce->ce_mode))
 141                         continue; /* do not touch non blobs */
 142                 if (pathspec && !ce_path_match(&the_index, ce, pathspec, NULL))
 143                         continue;
 144                 retval |= add_file_to_cache(ce->name, flags | ADD_CACHE_RENORMALIZE);
 145         }
 146
 147         return retval;
 148 }
 149
 150 static char *prune_directory(struct dir_struct *dir, struct pathspec *pathspec, int prefix)
 151 {
 152         char *seen;
 153         int i;
 154         struct dir_entry **src, **dst;
 155
 156         seen = xcalloc(pathspec->nr, 1);
 157
 158         src = dst = dir->entries;
 159         i = dir->nr;
 160         while (--i >= 0) {
 161                 struct dir_entry *entry = *src++;
 162                 if (dir_path_match(&the_index, entry, pathspec, prefix, seen))
 163                         *dst++ = entry;
 164         }
 165         dir->nr = dst - dir->entries;
 166         add_pathspec_matches_against_index(pathspec, &the_index, seen);
 167         return seen;
 168 }
 169
 170 static void refresh(int verbose, const struct pathspec *pathspec)
 171 {
 172         char *seen;
 173         int i;
 174
 175         seen = xcalloc(pathspec->nr, 1);
 176         refresh_index(&the_index, verbose ? REFRESH_IN_PORCELAIN : REFRESH_QUIET,
 177                       pathspec, seen, _("Unstaged changes after refreshing the index:"));
 178         for (i = 0; i < pathspec->nr; i++) {
 179                 if (!seen[i])
 180                         die(_("pathspec '%s' did not match any files"),
 181                             pathspec->items[i].match);
 182         }
 183         free(seen);
 184 }
 185
 186 int run_add_interactive(const char *revision, const char *patch_mode,
 187                         const struct pathspec *pathspec)
 188 {
 189         int status, i;
 190         struct argv_array argv = ARGV_ARRAY_INIT;
 191         int use_builtin_add_i =
 192                 git_env_bool("GIT_TEST_ADD_I_USE_BUILTIN", -1);
 193
 194         if (!patch_mode) {
 195                 if (use_builtin_add_i < 0)
 196                         git_config_get_bool("add.interactive.usebuiltin",
 197                                             &use_builtin_add_i);
 198                 if (use_builtin_add_i == 1)
 199                         return !!run_add_i(the_repository, pathspec);
 200         }
 201
 202         argv_array_push(&argv, "add--interactive");
 203         if (patch_mode)
 204                 argv_array_push(&argv, patch_mode);
 205         if (revision)
 206                 argv_array_push(&argv, revision);
 207         argv_array_push(&argv, "--");
 208         for (i = 0; i < pathspec->nr; i++)
 209                 /* pass original pathspec, to be re-parsed */
 210                 argv_array_push(&argv, pathspec->items[i].original);
 211
 212         status = run_command_v_opt(argv.argv, RUN_GIT_CMD);
 213         argv_array_clear(&argv);
 214         return status;
 215 }
 216
 217 int interactive_add(int argc, const char **argv, const char *prefix, int patch)
 218 {
 219         struct pathspec pathspec;
 220
 221         parse_pathspec(&pathspec, 0,
 222                        PATHSPEC_PREFER_FULL |
 223                        PATHSPEC_SYMLINK_LEADING_PATH |
 224                        PATHSPEC_PREFIX_ORIGIN,
 225                        prefix, argv);
 226
 227         return run_add_interactive(NULL,
 228                                    patch ? "--patch" : NULL,
 229                                    &pathspec);
 230 }
 231
 232 static int edit_patch(int argc, const char **argv, const char *prefix)
 233 {
 234         char *file = git_pathdup("ADD_EDIT.patch");
 235         const char *apply_argv[] = { "apply", "--recount", "--cached",
 236                 NULL, NULL };
 237         struct child_process child = CHILD_PROCESS_INIT;
 238         struct rev_info rev;
 239         int out;
 240         struct stat st;
 241
 242         apply_argv[3] = file;
 243
 244         git_config(git_diff_basic_config, NULL); /* no "diff" UI options */
 245
 246         if (read_cache() < 0)
 247                 die(_("Could not read the index"));
 248
 249         repo_init_revisions(the_repository, &rev, prefix);
 250         rev.diffopt.context = 7;
 251
 252         argc = setup_revisions(argc, argv, &rev, NULL);
 253         rev.diffopt.output_format = DIFF_FORMAT_PATCH;
 254         rev.diffopt.use_color = 0;
 255         rev.diffopt.flags.ignore_dirty_submodules = 1;
 256         out = open(file, O_CREAT | O_WRONLY | O_TRUNC, 0666);
 257         if (out < 0)
 258                 die(_("Could not open '%s' for writing."), file);
 259         rev.diffopt.file = xfdopen(out, "w");
 260         rev.diffopt.close_file = 1;
 261         if (run_diff_files(&rev, 0))
 262                 die(_("Could not write patch"));
 263
 264         if (launch_editor(file, NULL, NULL))
 265                 die(_("editing patch failed"));
 266
 267         if (stat(file, &st))
 268                 die_errno(_("Could not stat '%s'"), file);
 269         if (!st.st_size)
 270                 die(_("Empty patch. Aborted."));
 271
 272         child.git_cmd = 1;
 273         child.argv = apply_argv;
 274         if (run_command(&child))
 275                 die(_("Could not apply '%s'"), file);
 276
 277         unlink(file);
 278         free(file);
 279         return 0;
 280 }
 281
 282 static const char ignore_error[] =
 283 N_("The following paths are ignored by one of your .gitignore files:\n");
 284
 285 static int verbose, show_only, ignored_too, refresh_only;
 286 static int ignore_add_errors, intent_to_add, ignore_missing;
 287 static int warn_on_embedded_repo = 1;
 288
 289 #define ADDREMOVE_DEFAULT 1
 290 static int addremove = ADDREMOVE_DEFAULT;
 291 static int addremove_explicit = -1; /* unspecified */
 292
 293 static char *chmod_arg;
 294
 295 static int ignore_removal_cb(const struct option *opt, const char *arg, int unset)
 296 {
 297         /* if we are told to ignore, we are not adding removals */
 298         *(int *)opt->value = !unset ? 0 : 1;
 299         return 0;
 300 }
 301
 302 static struct option builtin_add_options[] = {
 303         OPT__DRY_RUN(&show_only, N_("dry run")),
 304         OPT__VERBOSE(&verbose, N_("be verbose")),
 305         OPT_GROUP(""),
 306         OPT_BOOL('i', "interactive", &add_interactive, N_("interactive picking")),
 307         OPT_BOOL('p', "patch", &patch_interactive, N_("select hunks interactively")),
 308         OPT_BOOL('e', "edit", &edit_interactive, N_("edit current diff and apply")),
 309         OPT__FORCE(&ignored_too, N_("allow adding otherwise ignored files"), 0),
 310         OPT_BOOL('u', "update", &take_worktree_changes, N_("update tracked files")),
 311         OPT_BOOL(0, "renormalize", &add_renormalize, N_("renormalize EOL of tracked files (implies -u)")),
 312         OPT_BOOL('N', "intent-to-add", &intent_to_add, N_("record only the fact that the path will be added later")),
 313         OPT_BOOL('A', "all", &addremove_explicit, N_("add changes from all tracked and untracked files")),
 314         { OPTION_CALLBACK, 0, "ignore-removal", &addremove_explicit,
 315           NULL /* takes no arguments */,
 316           N_("ignore paths removed in the working tree (same as --no-all)"),
 317           PARSE_OPT_NOARG, ignore_removal_cb },
 318         OPT_BOOL( 0 , "refresh", &refresh_only, N_("don't add, only refresh the index")),
 319         OPT_BOOL( 0 , "ignore-errors", &ignore_add_errors, N_("just skip files which cannot be added because of errors")),
 320         OPT_BOOL( 0 , "ignore-missing", &ignore_missing, N_("check if - even missing - files are ignored in dry run")),
 321         OPT_STRING(0, "chmod", &chmod_arg, "(+|-)x",
 322                    N_("override the executable bit of the listed files")),
 323         OPT_HIDDEN_BOOL(0, "warn-embedded-repo", &warn_on_embedded_repo,
 324                         N_("warn when adding an embedded repository")),
 325         OPT_PATHSPEC_FROM_FILE(&pathspec_from_file),
 326         OPT_PATHSPEC_FILE_NUL(&pathspec_file_nul),
 327         OPT_END(),
 328 };
 329
 330 static int add_config(const char *var, const char *value, void *cb)
 331 {
 332         if (!strcmp(var, "add.ignoreerrors") ||
 333             !strcmp(var, "add.ignore-errors")) {
 334                 ignore_add_errors = git_config_bool(var, value);
 335                 return 0;
 336         }
 337
 338         return git_default_config(var, value, cb);
 339 }
 340
 341 static const char embedded_advice[] = N_(
 342 "You've added another git repository inside your current repository.\n"
 343 "Clones of the outer repository will not contain the contents of\n"
 344 "the embedded repository and will not know how to obtain it.\n"
 345 "If you meant to add a submodule, use:\n"
 346 "\n"
 347 "       git submodule add <url> %s\n"
 348 "\n"
 349 "If you added this path by mistake, you can remove it from the\n"
 350 "index with:\n"
 351 "\n"
 352 "       git rm --cached %s\n"
 353 "\n"
 354 "See \"git help submodule\" for more information."
 355 );
 356
 357 static void check_embedded_repo(const char *path)
 358 {
 359         struct strbuf name = STRBUF_INIT;
 360
 361         if (!warn_on_embedded_repo)
 362                 return;
 363         if (!ends_with(path, "/"))
 364                 return;
 365
 366         /* Drop trailing slash for aesthetics */
 367         strbuf_addstr(&name, path);
 368         strbuf_strip_suffix(&name, "/");
 369
 370         warning(_("adding embedded git repository: %s"), name.buf);
 371         if (advice_add_embedded_repo) {
 372                 advise(embedded_advice, name.buf, name.buf);
 373                 /* there may be multiple entries; advise only once */
 374                 advice_add_embedded_repo = 0;
 375         }
 376
 377         strbuf_release(&name);
 378 }
 379
 380 static int add_files(struct dir_struct *dir, int flags)
 381 {
 382         int i, exit_status = 0;
 383
 384         if (dir->ignored_nr) {
 385                 fprintf(stderr, _(ignore_error));
 386                 for (i = 0; i < dir->ignored_nr; i++)
 387                         fprintf(stderr, "%s\n", dir->ignored[i]->name);
 388                 fprintf(stderr, _("Use -f if you really want to add them.\n"));
 389                 exit_status = 1;
 390         }
 391
 392         for (i = 0; i < dir->nr; i++) {
 393                 if (add_file_to_index(&the_index, dir->entries[i]->name, flags)) {
 394                         if (!ignore_add_errors)
 395                                 die(_("adding files failed"));
 396                         exit_status = 1;
 397                 } else {
 398                         check_embedded_repo(dir->entries[i]->name);
 399                 }
 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         struct pathspec pathspec;
 408         struct dir_struct dir;
 409         int flags;
 410         int add_new_files;
 411         int require_pathspec;
 412         char *seen = NULL;
 413         struct lock_file lock_file = LOCK_INIT;
 414
 415         git_config(add_config, NULL);
 416
 417         argc = parse_options(argc, argv, prefix, builtin_add_options,
 418                           builtin_add_usage, PARSE_OPT_KEEP_ARGV0);
 419         if (patch_interactive)
 420                 add_interactive = 1;
 421         if (add_interactive) {
 422                 if (pathspec_from_file)
 423                         die(_("--pathspec-from-file is incompatible with --interactive/--patch"));
 424                 exit(interactive_add(argc - 1, argv + 1, prefix, patch_interactive));
 425         }
 426
 427         if (edit_interactive) {
 428                 if (pathspec_from_file)
 429                         die(_("--pathspec-from-file is incompatible with --edit"));
 430                 return(edit_patch(argc, argv, prefix));
 431         }
 432         argc--;
 433         argv++;
 434
 435         if (0 <= addremove_explicit)
 436                 addremove = addremove_explicit;
 437         else if (take_worktree_changes && ADDREMOVE_DEFAULT)
 438                 addremove = 0; /* "-u" was given but not "-A" */
 439
 440         if (addremove && take_worktree_changes)
 441                 die(_("-A and -u are mutually incompatible"));
 442
 443         if (!show_only && ignore_missing)
 444                 die(_("Option --ignore-missing can only be used together with --dry-run"));
 445
 446         if (chmod_arg && ((chmod_arg[0] != '-' && chmod_arg[0] != '+') ||
 447                           chmod_arg[1] != 'x' || chmod_arg[2]))
 448                 die(_("--chmod param '%s' must be either -x or +x"), chmod_arg);
 449
 450         add_new_files = !take_worktree_changes && !refresh_only && !add_renormalize;
 451         require_pathspec = !(take_worktree_changes || (0 < addremove_explicit));
 452
 453         hold_locked_index(&lock_file, LOCK_DIE_ON_ERROR);
 454
 455         /*
 456          * Check the "pathspec '%s' did not match any files" block
 457          * below before enabling new magic.
 458          */
 459         parse_pathspec(&pathspec, PATHSPEC_ATTR,
 460                        PATHSPEC_PREFER_FULL |
 461                        PATHSPEC_SYMLINK_LEADING_PATH,
 462                        prefix, argv);
 463
 464         if (pathspec_from_file) {
 465                 if (pathspec.nr)
 466                         die(_("--pathspec-from-file is incompatible with pathspec arguments"));
 467
 468                 parse_pathspec_file(&pathspec, PATHSPEC_ATTR,
 469                                     PATHSPEC_PREFER_FULL |
 470                                     PATHSPEC_SYMLINK_LEADING_PATH,
 471                                     prefix, pathspec_from_file, pathspec_file_nul);
 472         } else if (pathspec_file_nul) {
 473                 die(_("--pathspec-file-nul requires --pathspec-from-file"));
 474         }
 475
 476         if (require_pathspec && pathspec.nr == 0) {
 477                 fprintf(stderr, _("Nothing specified, nothing added.\n"));
 478                 fprintf(stderr, _("Maybe you wanted to say 'git add .'?\n"));
 479                 return 0;
 480         }
 481
 482         if (!take_worktree_changes && addremove_explicit < 0 && pathspec.nr)
 483                 /* Turn "git add pathspec..." to "git add -A pathspec..." */
 484                 addremove = 1;
 485
 486         flags = ((verbose ? ADD_CACHE_VERBOSE : 0) |
 487                  (show_only ? ADD_CACHE_PRETEND : 0) |
 488                  (intent_to_add ? ADD_CACHE_INTENT : 0) |
 489                  (ignore_add_errors ? ADD_CACHE_IGNORE_ERRORS : 0) |
 490                  (!(addremove || take_worktree_changes)
 491                   ? ADD_CACHE_IGNORE_REMOVAL : 0));
 492
 493         if (read_cache_preload(&pathspec) < 0)
 494                 die(_("index file corrupt"));
 495
 496         die_in_unpopulated_submodule(&the_index, prefix);
 497         die_path_inside_submodule(&the_index, &pathspec);
 498
 499         if (add_new_files) {
 500                 int baselen;
 501
 502                 /* Set up the default git porcelain excludes */
 503                 memset(&dir, 0, sizeof(dir));
 504                 if (!ignored_too) {
 505                         dir.flags |= DIR_COLLECT_IGNORED;
 506                         setup_standard_excludes(&dir);
 507                 }
 508
 509                 /* This picks up the paths that are not tracked */
 510                 baselen = fill_directory(&dir, &the_index, &pathspec);
 511                 if (pathspec.nr)
 512                         seen = prune_directory(&dir, &pathspec, baselen);
 513         }
 514
 515         if (refresh_only) {
 516                 refresh(verbose, &pathspec);
 517                 goto finish;
 518         }
 519
 520         if (pathspec.nr) {
 521                 int i;
 522
 523                 if (!seen)
 524                         seen = find_pathspecs_matching_against_index(&pathspec, &the_index);
 525
 526                 /*
 527                  * file_exists() assumes exact match
 528                  */
 529                 GUARD_PATHSPEC(&pathspec,
 530                                PATHSPEC_FROMTOP |
 531                                PATHSPEC_LITERAL |
 532                                PATHSPEC_GLOB |
 533                                PATHSPEC_ICASE |
 534                                PATHSPEC_EXCLUDE);
 535
 536                 for (i = 0; i < pathspec.nr; i++) {
 537                         const char *path = pathspec.items[i].match;
 538                         if (pathspec.items[i].magic & PATHSPEC_EXCLUDE)
 539                                 continue;
 540                         if (!seen[i] && path[0] &&
 541                             ((pathspec.items[i].magic &
 542                               (PATHSPEC_GLOB | PATHSPEC_ICASE)) ||
 543                              !file_exists(path))) {
 544                                 if (ignore_missing) {
 545                                         int dtype = DT_UNKNOWN;
 546                                         if (is_excluded(&dir, &the_index, path, &dtype))
 547                                                 dir_add_ignored(&dir, &the_index,
 548                                                                 path, pathspec.items[i].len);
 549                                 } else
 550                                         die(_("pathspec '%s' did not match any files"),
 551                                             pathspec.items[i].original);
 552                         }
 553                 }
 554                 free(seen);
 555         }
 556
 557         plug_bulk_checkin();
 558
 559         if (add_renormalize)
 560                 exit_status |= renormalize_tracked_files(&pathspec, flags);
 561         else
 562                 exit_status |= add_files_to_cache(prefix, &pathspec, flags);
 563
 564         if (add_new_files)
 565                 exit_status |= add_files(&dir, flags);
 566
 567         if (chmod_arg && pathspec.nr)
 568                 chmod_pathspec(&pathspec, chmod_arg[0]);
 569         unplug_bulk_checkin();
 570
 571 finish:
 572         if (write_locked_index(&the_index, &lock_file,
 573                                COMMIT_LOCK | SKIP_IF_UNCHANGED))
 574                 die(_("Unable to write new index file"));
 575
 576         UNLEAK(pathspec);
 577         UNLEAK(dir);
 578         return exit_status;
 579 }