builtin/add.c

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