builtin/add.c

   1 /*
   2  * "git add" builtin command
   3  *
   4  * Copyright (C) 2006 Linus Torvalds
   5  */
   6 #include "cache.h"
   7 #include "config.h"
   8 #include "builtin.h"
   9 #include "lockfile.h"
  10 #include "dir.h"
  11 #include "pathspec.h"
  12 #include "exec_cmd.h"
  13 #include "cache-tree.h"
  14 #include "run-command.h"
  15 #include "parse-options.h"
  16 #include "diff.h"
  17 #include "diffcore.h"
  18 #include "revision.h"
  19 #include "bulk-checkin.h"
  20 #include "argv-array.h"
  21 #include "submodule.h"
  22
  23 static const char * const builtin_add_usage[] = {
  24         N_("git add [<options>] [--] <pathspec>..."),
  25         NULL
  26 };
  27 static int patch_interactive, add_interactive, edit_interactive;
  28 static int take_worktree_changes;
  29
  30 struct update_callback_data {
  31         int flags;
  32         int add_errors;
  33 };
  34
  35 static void chmod_pathspec(struct pathspec *pathspec, int force_mode)
  36 {
  37         int i;
  38
  39         for (i = 0; i < active_nr; i++) {
  40                 struct cache_entry *ce = active_cache[i];
  41
  42                 if (pathspec && !ce_path_match(ce, pathspec, NULL))
  43                         continue;
  44
  45                 if (chmod_cache_entry(ce, force_mode) < 0)
  46                         fprintf(stderr, "cannot chmod '%s'", ce->name);
  47         }
  48 }
  49
  50 static int fix_unmerged_status(struct diff_filepair *p,
  51                                struct update_callback_data *data)
  52 {
  53         if (p->status != DIFF_STATUS_UNMERGED)
  54                 return p->status;
  55         if (!(data->flags & ADD_CACHE_IGNORE_REMOVAL) && !p->two->mode)
  56                 /*
  57                  * This is not an explicit add request, and the
  58                  * path is missing from the working tree (deleted)
  59                  */
  60                 return DIFF_STATUS_DELETED;
  61         else
  62                 /*
  63                  * Either an explicit add request, or path exists
  64                  * in the working tree.  An attempt to explicitly
  65                  * add a path that does not exist in the working tree
  66                  * will be caught as an error by the caller immediately.
  67                  */
  68                 return DIFF_STATUS_MODIFIED;
  69 }
  70
  71 static void update_callback(struct diff_queue_struct *q,
  72                             struct diff_options *opt, void *cbdata)
  73 {
  74         int i;
  75         struct update_callback_data *data = cbdata;
  76
  77         for (i = 0; i < q->nr; i++) {
  78                 struct diff_filepair *p = q->queue[i];
  79                 const char *path = p->one->path;
  80                 switch (fix_unmerged_status(p, data)) {
  81                 default:
  82                         die(_("unexpected diff status %c"), p->status);
  83                 case DIFF_STATUS_MODIFIED:
  84                 case DIFF_STATUS_TYPE_CHANGED:
  85                         if (add_file_to_index(&the_index, path, data->flags)) {
  86                                 if (!(data->flags & ADD_CACHE_IGNORE_ERRORS))
  87                                         die(_("updating files failed"));
  88                                 data->add_errors++;
  89                         }
  90                         break;
  91                 case DIFF_STATUS_DELETED:
  92                         if (data->flags & ADD_CACHE_IGNORE_REMOVAL)
  93                                 break;
  94                         if (!(data->flags & ADD_CACHE_PRETEND))
  95                                 remove_file_from_index(&the_index, path);
  96                         if (data->flags & (ADD_CACHE_PRETEND|ADD_CACHE_VERBOSE))
  97                                 printf(_("remove '%s'\n"), path);
  98                         break;
  99                 }
 100         }
 101 }
 102
 103 int add_files_to_cache(const char *prefix,
 104                        const struct pathspec *pathspec, int flags)
 105 {
 106         struct update_callback_data data;
 107         struct rev_info rev;
 108
 109         memset(&data, 0, sizeof(data));
 110         data.flags = flags;
 111
 112         init_revisions(&rev, prefix);
 113         setup_revisions(0, NULL, &rev, NULL);
 114         if (pathspec)
 115                 copy_pathspec(&rev.prune_data, pathspec);
 116         rev.diffopt.output_format = DIFF_FORMAT_CALLBACK;
 117         rev.diffopt.format_callback = update_callback;
 118         rev.diffopt.format_callback_data = &data;
 119         rev.max_count = 0; /* do not compare unmerged paths with stage #2 */
 120         run_diff_files(&rev, DIFF_RACY_IS_MODIFIED);
 121         return !!data.add_errors;
 122 }
 123
 124 static char *prune_directory(struct dir_struct *dir, struct pathspec *pathspec, int prefix)
 125 {
 126         char *seen;
 127         int i;
 128         struct dir_entry **src, **dst;
 129
 130         seen = xcalloc(pathspec->nr, 1);
 131
 132         src = dst = dir->entries;
 133         i = dir->nr;
 134         while (--i >= 0) {
 135                 struct dir_entry *entry = *src++;
 136                 if (dir_path_match(entry, pathspec, prefix, seen))
 137                         *dst++ = entry;
 138         }
 139         dir->nr = dst - dir->entries;
 140         add_pathspec_matches_against_index(pathspec, &the_index, seen);
 141         return seen;
 142 }
 143
 144 static void refresh(int verbose, const struct pathspec *pathspec)
 145 {
 146         char *seen;
 147         int i;
 148
 149         seen = xcalloc(pathspec->nr, 1);
 150         refresh_index(&the_index, verbose ? REFRESH_IN_PORCELAIN : REFRESH_QUIET,
 151                       pathspec, seen, _("Unstaged changes after refreshing the index:"));
 152         for (i = 0; i < pathspec->nr; i++) {
 153                 if (!seen[i])
 154                         die(_("pathspec '%s' did not match any files"),
 155                             pathspec->items[i].match);
 156         }
 157         free(seen);
 158 }
 159
 160 int run_add_interactive(const char *revision, const char *patch_mode,
 161                         const struct pathspec *pathspec)
 162 {
 163         int status, i;
 164         struct argv_array argv = ARGV_ARRAY_INIT;
 165
 166         argv_array_push(&argv, "add--interactive");
 167         if (patch_mode)
 168                 argv_array_push(&argv, patch_mode);
 169         if (revision)
 170                 argv_array_push(&argv, revision);
 171         argv_array_push(&argv, "--");
 172         for (i = 0; i < pathspec->nr; i++)
 173                 /* pass original pathspec, to be re-parsed */
 174                 argv_array_push(&argv, pathspec->items[i].original);
 175
 176         status = run_command_v_opt(argv.argv, RUN_GIT_CMD);
 177         argv_array_clear(&argv);
 178         return status;
 179 }
 180
 181 int interactive_add(int argc, const char **argv, const char *prefix, int patch)
 182 {
 183         struct pathspec pathspec;
 184
 185         parse_pathspec(&pathspec, 0,
 186                        PATHSPEC_PREFER_FULL |
 187                        PATHSPEC_SYMLINK_LEADING_PATH |
 188                        PATHSPEC_PREFIX_ORIGIN,
 189                        prefix, argv);
 190
 191         return run_add_interactive(NULL,
 192                                    patch ? "--patch" : NULL,
 193                                    &pathspec);
 194 }
 195
 196 static int edit_patch(int argc, const char **argv, const char *prefix)
 197 {
 198         char *file = git_pathdup("ADD_EDIT.patch");
 199         const char *apply_argv[] = { "apply", "--recount", "--cached",
 200                 NULL, NULL };
 201         struct child_process child = CHILD_PROCESS_INIT;
 202         struct rev_info rev;
 203         int out;
 204         struct stat st;
 205
 206         apply_argv[3] = file;
 207
 208         git_config(git_diff_basic_config, NULL); /* no "diff" UI options */
 209
 210         if (read_cache() < 0)
 211                 die(_("Could not read the index"));
 212
 213         init_revisions(&rev, prefix);
 214         rev.diffopt.context = 7;
 215
 216         argc = setup_revisions(argc, argv, &rev, NULL);
 217         rev.diffopt.output_format = DIFF_FORMAT_PATCH;
 218         rev.diffopt.use_color = 0;
 219         DIFF_OPT_SET(&rev.diffopt, IGNORE_DIRTY_SUBMODULES);
 220         out = open(file, O_CREAT | O_WRONLY, 0666);
 221         if (out < 0)
 222                 die(_("Could not open '%s' for writing."), file);
 223         rev.diffopt.file = xfdopen(out, "w");
 224         rev.diffopt.close_file = 1;
 225         if (run_diff_files(&rev, 0))
 226                 die(_("Could not write patch"));
 227
 228         if (launch_editor(file, NULL, NULL))
 229                 die(_("editing patch failed"));
 230
 231         if (stat(file, &st))
 232                 die_errno(_("Could not stat '%s'"), file);
 233         if (!st.st_size)
 234                 die(_("Empty patch. Aborted."));
 235
 236         child.git_cmd = 1;
 237         child.argv = apply_argv;
 238         if (run_command(&child))
 239                 die(_("Could not apply '%s'"), file);
 240
 241         unlink(file);
 242         free(file);
 243         return 0;
 244 }
 245
 246 static struct lock_file lock_file;
 247
 248 static const char ignore_error[] =
 249 N_("The following paths are ignored by one of your .gitignore files:\n");
 250
 251 static int verbose, show_only, ignored_too, refresh_only;
 252 static int ignore_add_errors, intent_to_add, ignore_missing;
 253
 254 #define ADDREMOVE_DEFAULT 1
 255 static int addremove = ADDREMOVE_DEFAULT;
 256 static int addremove_explicit = -1; /* unspecified */
 257
 258 static char *chmod_arg;
 259
 260 static int ignore_removal_cb(const struct option *opt, const char *arg, int unset)
 261 {
 262         /* if we are told to ignore, we are not adding removals */
 263         *(int *)opt->value = !unset ? 0 : 1;
 264         return 0;
 265 }
 266
 267 static struct option builtin_add_options[] = {
 268         OPT__DRY_RUN(&show_only, N_("dry run")),
 269         OPT__VERBOSE(&verbose, N_("be verbose")),
 270         OPT_GROUP(""),
 271         OPT_BOOL('i', "interactive", &add_interactive, N_("interactive picking")),
 272         OPT_BOOL('p', "patch", &patch_interactive, N_("select hunks interactively")),
 273         OPT_BOOL('e', "edit", &edit_interactive, N_("edit current diff and apply")),
 274         OPT__FORCE(&ignored_too, N_("allow adding otherwise ignored files")),
 275         OPT_BOOL('u', "update", &take_worktree_changes, N_("update tracked files")),
 276         OPT_BOOL('N', "intent-to-add", &intent_to_add, N_("record only the fact that the path will be added later")),
 277         OPT_BOOL('A', "all", &addremove_explicit, N_("add changes from all tracked and untracked files")),
 278         { OPTION_CALLBACK, 0, "ignore-removal", &addremove_explicit,
 279           NULL /* takes no arguments */,
 280           N_("ignore paths removed in the working tree (same as --no-all)"),
 281           PARSE_OPT_NOARG, ignore_removal_cb },
 282         OPT_BOOL( 0 , "refresh", &refresh_only, N_("don't add, only refresh the index")),
 283         OPT_BOOL( 0 , "ignore-errors", &ignore_add_errors, N_("just skip files which cannot be added because of errors")),
 284         OPT_BOOL( 0 , "ignore-missing", &ignore_missing, N_("check if - even missing - files are ignored in dry run")),
 285         OPT_STRING( 0 , "chmod", &chmod_arg, N_("(+/-)x"), N_("override the executable bit of the listed files")),
 286         OPT_END(),
 287 };
 288
 289 static int add_config(const char *var, const char *value, void *cb)
 290 {
 291         if (!strcmp(var, "add.ignoreerrors") ||
 292             !strcmp(var, "add.ignore-errors")) {
 293                 ignore_add_errors = git_config_bool(var, value);
 294                 return 0;
 295         }
 296         return git_default_config(var, value, cb);
 297 }
 298
 299 static int add_files(struct dir_struct *dir, int flags)
 300 {
 301         int i, exit_status = 0;
 302
 303         if (dir->ignored_nr) {
 304                 fprintf(stderr, _(ignore_error));
 305                 for (i = 0; i < dir->ignored_nr; i++)
 306                         fprintf(stderr, "%s\n", dir->ignored[i]->name);
 307                 fprintf(stderr, _("Use -f if you really want to add them.\n"));
 308                 exit_status = 1;
 309         }
 310
 311         for (i = 0; i < dir->nr; i++)
 312                 if (add_file_to_index(&the_index, dir->entries[i]->name, flags)) {
 313                         if (!ignore_add_errors)
 314                                 die(_("adding files failed"));
 315                         exit_status = 1;
 316                 }
 317         return exit_status;
 318 }
 319
 320 int cmd_add(int argc, const char **argv, const char *prefix)
 321 {
 322         int exit_status = 0;
 323         struct pathspec pathspec;
 324         struct dir_struct dir;
 325         int flags;
 326         int add_new_files;
 327         int require_pathspec;
 328         char *seen = NULL;
 329
 330         git_config(add_config, NULL);
 331
 332         argc = parse_options(argc, argv, prefix, builtin_add_options,
 333                           builtin_add_usage, PARSE_OPT_KEEP_ARGV0);
 334         if (patch_interactive)
 335                 add_interactive = 1;
 336         if (add_interactive)
 337                 exit(interactive_add(argc - 1, argv + 1, prefix, patch_interactive));
 338
 339         if (edit_interactive)
 340                 return(edit_patch(argc, argv, prefix));
 341         argc--;
 342         argv++;
 343
 344         if (0 <= addremove_explicit)
 345                 addremove = addremove_explicit;
 346         else if (take_worktree_changes && ADDREMOVE_DEFAULT)
 347                 addremove = 0; /* "-u" was given but not "-A" */
 348
 349         if (addremove && take_worktree_changes)
 350                 die(_("-A and -u are mutually incompatible"));
 351
 352         if (!take_worktree_changes && addremove_explicit < 0 && argc)
 353                 /* Turn "git add pathspec..." to "git add -A pathspec..." */
 354                 addremove = 1;
 355
 356         if (!show_only && ignore_missing)
 357                 die(_("Option --ignore-missing can only be used together with --dry-run"));
 358
 359         if (chmod_arg && ((chmod_arg[0] != '-' && chmod_arg[0] != '+') ||
 360                           chmod_arg[1] != 'x' || chmod_arg[2]))
 361                 die(_("--chmod param '%s' must be either -x or +x"), chmod_arg);
 362
 363         add_new_files = !take_worktree_changes && !refresh_only;
 364         require_pathspec = !(take_worktree_changes || (0 < addremove_explicit));
 365
 366         hold_locked_index(&lock_file, LOCK_DIE_ON_ERROR);
 367
 368         flags = ((verbose ? ADD_CACHE_VERBOSE : 0) |
 369                  (show_only ? ADD_CACHE_PRETEND : 0) |
 370                  (intent_to_add ? ADD_CACHE_INTENT : 0) |
 371                  (ignore_add_errors ? ADD_CACHE_IGNORE_ERRORS : 0) |
 372                  (!(addremove || take_worktree_changes)
 373                   ? ADD_CACHE_IGNORE_REMOVAL : 0));
 374
 375         if (require_pathspec && argc == 0) {
 376                 fprintf(stderr, _("Nothing specified, nothing added.\n"));
 377                 fprintf(stderr, _("Maybe you wanted to say 'git add .'?\n"));
 378                 return 0;
 379         }
 380
 381         if (read_cache() < 0)
 382                 die(_("index file corrupt"));
 383
 384         die_in_unpopulated_submodule(&the_index, prefix);
 385
 386         /*
 387          * Check the "pathspec '%s' did not match any files" block
 388          * below before enabling new magic.
 389          */
 390         parse_pathspec(&pathspec, 0,
 391                        PATHSPEC_PREFER_FULL |
 392                        PATHSPEC_SYMLINK_LEADING_PATH,
 393                        prefix, argv);
 394
 395         die_path_inside_submodule(&the_index, &pathspec);
 396
 397         if (add_new_files) {
 398                 int baselen;
 399
 400                 /* Set up the default git porcelain excludes */
 401                 memset(&dir, 0, sizeof(dir));
 402                 if (!ignored_too) {
 403                         dir.flags |= DIR_COLLECT_IGNORED;
 404                         setup_standard_excludes(&dir);
 405                 }
 406
 407                 /* This picks up the paths that are not tracked */
 408                 baselen = fill_directory(&dir, &the_index, &pathspec);
 409                 if (pathspec.nr)
 410                         seen = prune_directory(&dir, &pathspec, baselen);
 411         }
 412
 413         if (refresh_only) {
 414                 refresh(verbose, &pathspec);
 415                 goto finish;
 416         }
 417
 418         if (pathspec.nr) {
 419                 int i;
 420
 421                 if (!seen)
 422                         seen = find_pathspecs_matching_against_index(&pathspec, &the_index);
 423
 424                 /*
 425                  * file_exists() assumes exact match
 426                  */
 427                 GUARD_PATHSPEC(&pathspec,
 428                                PATHSPEC_FROMTOP |
 429                                PATHSPEC_LITERAL |
 430                                PATHSPEC_GLOB |
 431                                PATHSPEC_ICASE |
 432                                PATHSPEC_EXCLUDE);
 433
 434                 for (i = 0; i < pathspec.nr; i++) {
 435                         const char *path = pathspec.items[i].match;
 436                         if (pathspec.items[i].magic & PATHSPEC_EXCLUDE)
 437                                 continue;
 438                         if (!seen[i] && path[0] &&
 439                             ((pathspec.items[i].magic &
 440                               (PATHSPEC_GLOB | PATHSPEC_ICASE)) ||
 441                              !file_exists(path))) {
 442                                 if (ignore_missing) {
 443                                         int dtype = DT_UNKNOWN;
 444                                         if (is_excluded(&dir, &the_index, path, &dtype))
 445                                                 dir_add_ignored(&dir, &the_index,
 446                                                                 path, pathspec.items[i].len);
 447                                 } else
 448                                         die(_("pathspec '%s' did not match any files"),
 449                                             pathspec.items[i].original);
 450                         }
 451                 }
 452                 free(seen);
 453         }
 454
 455         plug_bulk_checkin();
 456
 457         exit_status |= add_files_to_cache(prefix, &pathspec, flags);
 458
 459         if (add_new_files)
 460                 exit_status |= add_files(&dir, flags);
 461
 462         if (chmod_arg && pathspec.nr)
 463                 chmod_pathspec(&pathspec, chmod_arg[0]);
 464         unplug_bulk_checkin();
 465
 466 finish:
 467         if (active_cache_changed) {
 468                 if (write_locked_index(&the_index, &lock_file, COMMIT_LOCK))
 469                         die(_("Unable to write new index file"));
 470         }
 471
 472         return exit_status;
 473 }