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                 advise_if_enabled(ADVICE_ADD_EMBEDDED_REPO,
 315                                   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                 advise_if_enabled(ADVICE_ADD_IGNORED_FILE,
 332                                   _("Use -f if you really want to add them."));
 333                 exit_status = 1;
 334         }
 335
 336         for (i = 0; i < dir->nr; i++) {
 337                 if (!include_sparse &&
 338                     !path_in_sparse_checkout(dir->entries[i]->name, &the_index)) {
 339                         string_list_append(&matched_sparse_paths,
 340                                            dir->entries[i]->name);
 341                         continue;
 342                 }
 343                 if (add_file_to_index(&the_index, dir->entries[i]->name, flags)) {
 344                         if (!ignore_add_errors)
 345                                 die(_("adding files failed"));
 346                         exit_status = 1;
 347                 } else {
 348                         check_embedded_repo(dir->entries[i]->name);
 349                 }
 350         }
 351
 352         if (matched_sparse_paths.nr) {
 353                 advise_on_updating_sparse_paths(&matched_sparse_paths);
 354                 exit_status = 1;
 355         }
 356
 357         string_list_clear(&matched_sparse_paths, 0);
 358
 359         return exit_status;
 360 }
 361
 362 int cmd_add(int argc, const char **argv, const char *prefix)
 363 {
 364         int exit_status = 0;
 365         struct pathspec pathspec;
 366         struct dir_struct dir = DIR_INIT;
 367         int flags;
 368         int add_new_files;
 369         int require_pathspec;
 370         char *seen = NULL;
 371         struct lock_file lock_file = LOCK_INIT;
 372
 373         git_config(add_config, NULL);
 374
 375         argc = parse_options(argc, argv, prefix, builtin_add_options,
 376                           builtin_add_usage, PARSE_OPT_KEEP_ARGV0);
 377         if (patch_interactive)
 378                 add_interactive = 1;
 379         if (add_interactive) {
 380                 if (show_only)
 381                         die(_("options '%s' and '%s' cannot be used together"), "--dry-run", "--interactive/--patch");
 382                 if (pathspec_from_file)
 383                         die(_("options '%s' and '%s' cannot be used together"), "--pathspec-from-file", "--interactive/--patch");
 384                 exit(interactive_add(argv + 1, prefix, patch_interactive));
 385         }
 386
 387         if (edit_interactive) {
 388                 if (pathspec_from_file)
 389                         die(_("options '%s' and '%s' cannot be used together"), "--pathspec-from-file", "--edit");
 390                 return(edit_patch(argc, argv, prefix));
 391         }
 392         argc--;
 393         argv++;
 394
 395         if (0 <= addremove_explicit)
 396                 addremove = addremove_explicit;
 397         else if (take_worktree_changes && ADDREMOVE_DEFAULT)
 398                 addremove = 0; /* "-u" was given but not "-A" */
 399
 400         if (addremove && take_worktree_changes)
 401                 die(_("options '%s' and '%s' cannot be used together"), "-A", "-u");
 402
 403         if (!show_only && ignore_missing)
 404                 die(_("the option '%s' requires '%s'"), "--ignore-missing", "--dry-run");
 405
 406         if (chmod_arg && ((chmod_arg[0] != '-' && chmod_arg[0] != '+') ||
 407                           chmod_arg[1] != 'x' || chmod_arg[2]))
 408                 die(_("--chmod param '%s' must be either -x or +x"), chmod_arg);
 409
 410         add_new_files = !take_worktree_changes && !refresh_only && !add_renormalize;
 411         require_pathspec = !(take_worktree_changes || (0 < addremove_explicit));
 412
 413         prepare_repo_settings(the_repository);
 414         the_repository->settings.command_requires_full_index = 0;
 415
 416         repo_hold_locked_index(the_repository, &lock_file, LOCK_DIE_ON_ERROR);
 417
 418         /*
 419          * Check the "pathspec '%s' did not match any files" block
 420          * below before enabling new magic.
 421          */
 422         parse_pathspec(&pathspec, 0,
 423                        PATHSPEC_PREFER_FULL |
 424                        PATHSPEC_SYMLINK_LEADING_PATH,
 425                        prefix, argv);
 426
 427         if (pathspec_from_file) {
 428                 if (pathspec.nr)
 429                         die(_("'%s' and pathspec arguments cannot be used together"), "--pathspec-from-file");
 430
 431                 parse_pathspec_file(&pathspec, 0,
 432                                     PATHSPEC_PREFER_FULL |
 433                                     PATHSPEC_SYMLINK_LEADING_PATH,
 434                                     prefix, pathspec_from_file, pathspec_file_nul);
 435         } else if (pathspec_file_nul) {
 436                 die(_("the option '%s' requires '%s'"), "--pathspec-file-nul", "--pathspec-from-file");
 437         }
 438
 439         if (require_pathspec && pathspec.nr == 0) {
 440                 fprintf(stderr, _("Nothing specified, nothing added.\n"));
 441                 advise_if_enabled(ADVICE_ADD_EMPTY_PATHSPEC,
 442                                   _("Maybe you wanted to say 'git add .'?"));
 443                 return 0;
 444         }
 445
 446         if (!take_worktree_changes && addremove_explicit < 0 && pathspec.nr)
 447                 /* Turn "git add pathspec..." to "git add -A pathspec..." */
 448                 addremove = 1;
 449
 450         flags = ((verbose ? ADD_CACHE_VERBOSE : 0) |
 451                  (show_only ? ADD_CACHE_PRETEND : 0) |
 452                  (intent_to_add ? ADD_CACHE_INTENT : 0) |
 453                  (ignore_add_errors ? ADD_CACHE_IGNORE_ERRORS : 0) |
 454                  (!(addremove || take_worktree_changes)
 455                   ? ADD_CACHE_IGNORE_REMOVAL : 0));
 456
 457         if (repo_read_index_preload(the_repository, &pathspec, 0) < 0)
 458                 die(_("index file corrupt"));
 459
 460         die_in_unpopulated_submodule(&the_index, prefix);
 461         die_path_inside_submodule(&the_index, &pathspec);
 462
 463         if (add_new_files) {
 464                 int baselen;
 465
 466                 /* Set up the default git porcelain excludes */
 467                 if (!ignored_too) {
 468                         dir.flags |= DIR_COLLECT_IGNORED;
 469                         setup_standard_excludes(&dir);
 470                 }
 471
 472                 /* This picks up the paths that are not tracked */
 473                 baselen = fill_directory(&dir, &the_index, &pathspec);
 474                 if (pathspec.nr)
 475                         seen = prune_directory(&dir, &pathspec, baselen);
 476         }
 477
 478         if (refresh_only) {
 479                 exit_status |= refresh(verbose, &pathspec);
 480                 goto finish;
 481         }
 482
 483         if (pathspec.nr) {
 484                 int i;
 485                 char *skip_worktree_seen = NULL;
 486                 struct string_list only_match_skip_worktree = STRING_LIST_INIT_NODUP;
 487
 488                 if (!seen)
 489                         seen = find_pathspecs_matching_against_index(&pathspec,
 490                                         &the_index, PS_IGNORE_SKIP_WORKTREE);
 491
 492                 /*
 493                  * file_exists() assumes exact match
 494                  */
 495                 GUARD_PATHSPEC(&pathspec,
 496                                PATHSPEC_FROMTOP |
 497                                PATHSPEC_LITERAL |
 498                                PATHSPEC_GLOB |
 499                                PATHSPEC_ICASE |
 500                                PATHSPEC_EXCLUDE |
 501                                PATHSPEC_ATTR);
 502
 503                 for (i = 0; i < pathspec.nr; i++) {
 504                         const char *path = pathspec.items[i].match;
 505
 506                         if (pathspec.items[i].magic & PATHSPEC_EXCLUDE)
 507                                 continue;
 508                         if (seen[i])
 509                                 continue;
 510
 511                         if (!include_sparse &&
 512                             matches_skip_worktree(&pathspec, i, &skip_worktree_seen)) {
 513                                 string_list_append(&only_match_skip_worktree,
 514                                                    pathspec.items[i].original);
 515                                 continue;
 516                         }
 517
 518                         /* Don't complain at 'git add .' on empty repo */
 519                         if (!path[0])
 520                                 continue;
 521
 522                         if ((pathspec.items[i].magic & (PATHSPEC_GLOB | PATHSPEC_ICASE)) ||
 523                             !file_exists(path)) {
 524                                 if (ignore_missing) {
 525                                         int dtype = DT_UNKNOWN;
 526                                         if (is_excluded(&dir, &the_index, path, &dtype))
 527                                                 dir_add_ignored(&dir, &the_index,
 528                                                                 path, pathspec.items[i].len);
 529                                 } else
 530                                         die(_("pathspec '%s' did not match any files"),
 531                                             pathspec.items[i].original);
 532                         }
 533                 }
 534
 535
 536                 if (only_match_skip_worktree.nr) {
 537                         advise_on_updating_sparse_paths(&only_match_skip_worktree);
 538                         exit_status = 1;
 539                 }
 540
 541                 free(seen);
 542                 free(skip_worktree_seen);
 543                 string_list_clear(&only_match_skip_worktree, 0);
 544         }
 545
 546         begin_odb_transaction();
 547
 548         if (add_renormalize)
 549                 exit_status |= renormalize_tracked_files(&pathspec, flags);
 550         else
 551                 exit_status |= add_files_to_cache(the_repository, prefix,
 552                                                   &pathspec, include_sparse,
 553                                                   flags);
 554
 555         if (add_new_files)
 556                 exit_status |= add_files(&dir, flags);
 557
 558         if (chmod_arg && pathspec.nr)
 559                 exit_status |= chmod_pathspec(&pathspec, chmod_arg[0], show_only);
 560         end_odb_transaction();
 561
 562 finish:
 563         if (write_locked_index(&the_index, &lock_file,
 564                                COMMIT_LOCK | SKIP_IF_UNCHANGED))
 565                 die(_("unable to write new index file"));
 566
 567         dir_clear(&dir);
 568         clear_pathspec(&pathspec);
 569         return exit_status;
 570 }