builtin/add.c

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