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