git.oblomov.eu Git - git/blob - builtin/add.c

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