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