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