convert read_cache_preload() to take struct pathspec
[git/git.git] / 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 "dir.h"
9 #include "pathspec.h"
10 #include "exec_cmd.h"
11 #include "cache-tree.h"
12 #include "run-command.h"
13 #include "parse-options.h"
14 #include "diff.h"
15 #include "diffcore.h"
16 #include "revision.h"
17 #include "bulk-checkin.h"
18
19 static const char * const builtin_add_usage[] = {
20 N_("git add [options] [--] <pathspec>..."),
21 NULL
22 };
23 static int patch_interactive, add_interactive, edit_interactive;
24 static int take_worktree_changes;
25
26 struct update_callback_data {
27 int flags;
28 int add_errors;
29 const char *implicit_dot;
30 size_t implicit_dot_len;
31
32 /* only needed for 2.0 transition preparation */
33 int warn_add_would_remove;
34 };
35
36 static const char *option_with_implicit_dot;
37 static const char *short_option_with_implicit_dot;
38
39 static void warn_pathless_add(void)
40 {
41 static int shown;
42 assert(option_with_implicit_dot && short_option_with_implicit_dot);
43
44 if (shown)
45 return;
46 shown = 1;
47
48 /*
49 * To be consistent with "git add -p" and most Git
50 * commands, we should default to being tree-wide, but
51 * this is not the original behavior and can't be
52 * changed until users trained themselves not to type
53 * "git add -u" or "git add -A". For now, we warn and
54 * keep the old behavior. Later, the behavior can be changed
55 * to tree-wide, keeping the warning for a while, and
56 * eventually we can drop the warning.
57 */
58 warning(_("The behavior of 'git add %s (or %s)' with no path argument from a\n"
59 "subdirectory of the tree will change in Git 2.0 and should not be used anymore.\n"
60 "To add content for the whole tree, run:\n"
61 "\n"
62 " git add %s :/\n"
63 " (or git add %s :/)\n"
64 "\n"
65 "To restrict the command to the current directory, run:\n"
66 "\n"
67 " git add %s .\n"
68 " (or git add %s .)\n"
69 "\n"
70 "With the current Git version, the command is restricted to "
71 "the current directory.\n"
72 ""),
73 option_with_implicit_dot, short_option_with_implicit_dot,
74 option_with_implicit_dot, short_option_with_implicit_dot,
75 option_with_implicit_dot, short_option_with_implicit_dot);
76 }
77
78 static int fix_unmerged_status(struct diff_filepair *p,
79 struct update_callback_data *data)
80 {
81 if (p->status != DIFF_STATUS_UNMERGED)
82 return p->status;
83 if (!(data->flags & ADD_CACHE_IGNORE_REMOVAL) && !p->two->mode)
84 /*
85 * This is not an explicit add request, and the
86 * path is missing from the working tree (deleted)
87 */
88 return DIFF_STATUS_DELETED;
89 else
90 /*
91 * Either an explicit add request, or path exists
92 * in the working tree. An attempt to explicitly
93 * add a path that does not exist in the working tree
94 * will be caught as an error by the caller immediately.
95 */
96 return DIFF_STATUS_MODIFIED;
97 }
98
99 static const char *add_would_remove_warning = N_(
100 "You ran 'git add' with neither '-A (--all)' or '--ignore-removal',\n"
101 "whose behaviour will change in Git 2.0 with respect to paths you removed.\n"
102 "Paths like '%s' that are\n"
103 "removed from your working tree are ignored with this version of Git.\n"
104 "\n"
105 "* 'git add --ignore-removal <pathspec>', which is the current default,\n"
106 " ignores paths you removed from your working tree.\n"
107 "\n"
108 "* 'git add --all <pathspec>' will let you also record the removals.\n"
109 "\n"
110 "Run 'git status' to check the paths you removed from your working tree.\n");
111
112 static void warn_add_would_remove(const char *path)
113 {
114 warning(_(add_would_remove_warning), path);
115 }
116
117 static void update_callback(struct diff_queue_struct *q,
118 struct diff_options *opt, void *cbdata)
119 {
120 int i;
121 struct update_callback_data *data = cbdata;
122 const char *implicit_dot = data->implicit_dot;
123 size_t implicit_dot_len = data->implicit_dot_len;
124
125 for (i = 0; i < q->nr; i++) {
126 struct diff_filepair *p = q->queue[i];
127 const char *path = p->one->path;
128 /*
129 * Check if "git add -A" or "git add -u" was run from a
130 * subdirectory with a modified file outside that directory,
131 * and warn if so.
132 *
133 * "git add -u" will behave like "git add -u :/" instead of
134 * "git add -u ." in the future. This warning prepares for
135 * that change.
136 */
137 if (implicit_dot &&
138 strncmp_icase(path, implicit_dot, implicit_dot_len)) {
139 warn_pathless_add();
140 continue;
141 }
142 switch (fix_unmerged_status(p, data)) {
143 default:
144 die(_("unexpected diff status %c"), p->status);
145 case DIFF_STATUS_MODIFIED:
146 case DIFF_STATUS_TYPE_CHANGED:
147 if (add_file_to_index(&the_index, path, data->flags)) {
148 if (!(data->flags & ADD_CACHE_IGNORE_ERRORS))
149 die(_("updating files failed"));
150 data->add_errors++;
151 }
152 break;
153 case DIFF_STATUS_DELETED:
154 if (data->warn_add_would_remove) {
155 warn_add_would_remove(path);
156 data->warn_add_would_remove = 0;
157 }
158 if (data->flags & ADD_CACHE_IGNORE_REMOVAL)
159 break;
160 if (!(data->flags & ADD_CACHE_PRETEND))
161 remove_file_from_index(&the_index, path);
162 if (data->flags & (ADD_CACHE_PRETEND|ADD_CACHE_VERBOSE))
163 printf(_("remove '%s'\n"), path);
164 break;
165 }
166 }
167 }
168
169 static void update_files_in_cache(const char *prefix, const char **pathspec,
170 struct update_callback_data *data)
171 {
172 struct rev_info rev;
173
174 init_revisions(&rev, prefix);
175 setup_revisions(0, NULL, &rev, NULL);
176 init_pathspec(&rev.prune_data, pathspec);
177 rev.diffopt.output_format = DIFF_FORMAT_CALLBACK;
178 rev.diffopt.format_callback = update_callback;
179 rev.diffopt.format_callback_data = data;
180 rev.max_count = 0; /* do not compare unmerged paths with stage #2 */
181 run_diff_files(&rev, DIFF_RACY_IS_MODIFIED);
182 }
183
184 int add_files_to_cache(const char *prefix, const char **pathspec, int flags)
185 {
186 struct update_callback_data data;
187
188 memset(&data, 0, sizeof(data));
189 data.flags = flags;
190 update_files_in_cache(prefix, pathspec, &data);
191 return !!data.add_errors;
192 }
193
194 #define WARN_IMPLICIT_DOT (1u << 0)
195 static char *prune_directory(struct dir_struct *dir, const char **pathspec,
196 int prefix, unsigned flag)
197 {
198 char *seen;
199 int i, specs;
200 struct dir_entry **src, **dst;
201
202 for (specs = 0; pathspec[specs]; specs++)
203 /* nothing */;
204 seen = xcalloc(specs, 1);
205
206 src = dst = dir->entries;
207 i = dir->nr;
208 while (--i >= 0) {
209 struct dir_entry *entry = *src++;
210 if (match_pathspec(pathspec, entry->name, entry->len,
211 prefix, seen))
212 *dst++ = entry;
213 else if (flag & WARN_IMPLICIT_DOT)
214 /*
215 * "git add -A" was run from a subdirectory with a
216 * new file outside that directory.
217 *
218 * "git add -A" will behave like "git add -A :/"
219 * instead of "git add -A ." in the future.
220 * Warn about the coming behavior change.
221 */
222 warn_pathless_add();
223 }
224 dir->nr = dst - dir->entries;
225 add_pathspec_matches_against_index(pathspec, seen, specs);
226 return seen;
227 }
228
229 static void refresh(int verbose, const char **pathspec)
230 {
231 char *seen;
232 int i, specs;
233
234 for (specs = 0; pathspec[specs]; specs++)
235 /* nothing */;
236 seen = xcalloc(specs, 1);
237 refresh_index(&the_index, verbose ? REFRESH_IN_PORCELAIN : REFRESH_QUIET,
238 pathspec, seen, _("Unstaged changes after refreshing the index:"));
239 for (i = 0; i < specs; i++) {
240 if (!seen[i])
241 die(_("pathspec '%s' did not match any files"), pathspec[i]);
242 }
243 free(seen);
244 }
245
246 int run_add_interactive(const char *revision, const char *patch_mode,
247 const char **pathspec)
248 {
249 int status, ac, pc = 0;
250 const char **args;
251
252 if (pathspec)
253 while (pathspec[pc])
254 pc++;
255
256 args = xcalloc(sizeof(const char *), (pc + 5));
257 ac = 0;
258 args[ac++] = "add--interactive";
259 if (patch_mode)
260 args[ac++] = patch_mode;
261 if (revision)
262 args[ac++] = revision;
263 args[ac++] = "--";
264 if (pc) {
265 memcpy(&(args[ac]), pathspec, sizeof(const char *) * pc);
266 ac += pc;
267 }
268 args[ac] = NULL;
269
270 status = run_command_v_opt(args, RUN_GIT_CMD);
271 free(args);
272 return status;
273 }
274
275 int interactive_add(int argc, const char **argv, const char *prefix, int patch)
276 {
277 struct pathspec pathspec;
278
279 /*
280 * git-add--interactive itself does not parse pathspec. It
281 * simply passes the pathspec to other builtin commands. Let's
282 * hope all of them support all magic, or we'll need to limit
283 * the magic here. There is still a problem with prefix. But
284 * that'll be worked on later on.
285 */
286 parse_pathspec(&pathspec, PATHSPEC_ALL_MAGIC & ~PATHSPEC_FROMTOP,
287 PATHSPEC_PREFER_FULL |
288 PATHSPEC_SYMLINK_LEADING_PATH,
289 prefix, argv);
290
291 return run_add_interactive(NULL,
292 patch ? "--patch" : NULL,
293 pathspec.raw);
294 }
295
296 static int edit_patch(int argc, const char **argv, const char *prefix)
297 {
298 char *file = git_pathdup("ADD_EDIT.patch");
299 const char *apply_argv[] = { "apply", "--recount", "--cached",
300 NULL, NULL };
301 struct child_process child;
302 struct rev_info rev;
303 int out;
304 struct stat st;
305
306 apply_argv[3] = file;
307
308 git_config(git_diff_basic_config, NULL); /* no "diff" UI options */
309
310 if (read_cache() < 0)
311 die (_("Could not read the index"));
312
313 init_revisions(&rev, prefix);
314 rev.diffopt.context = 7;
315
316 argc = setup_revisions(argc, argv, &rev, NULL);
317 rev.diffopt.output_format = DIFF_FORMAT_PATCH;
318 DIFF_OPT_SET(&rev.diffopt, IGNORE_DIRTY_SUBMODULES);
319 out = open(file, O_CREAT | O_WRONLY, 0666);
320 if (out < 0)
321 die (_("Could not open '%s' for writing."), file);
322 rev.diffopt.file = xfdopen(out, "w");
323 rev.diffopt.close_file = 1;
324 if (run_diff_files(&rev, 0))
325 die (_("Could not write patch"));
326
327 launch_editor(file, NULL, NULL);
328
329 if (stat(file, &st))
330 die_errno(_("Could not stat '%s'"), file);
331 if (!st.st_size)
332 die(_("Empty patch. Aborted."));
333
334 memset(&child, 0, sizeof(child));
335 child.git_cmd = 1;
336 child.argv = apply_argv;
337 if (run_command(&child))
338 die (_("Could not apply '%s'"), file);
339
340 unlink(file);
341 free(file);
342 return 0;
343 }
344
345 static struct lock_file lock_file;
346
347 static const char ignore_error[] =
348 N_("The following paths are ignored by one of your .gitignore files:\n");
349
350 static int verbose, show_only, ignored_too, refresh_only;
351 static int ignore_add_errors, intent_to_add, ignore_missing;
352
353 #define ADDREMOVE_DEFAULT 0 /* Change to 1 in Git 2.0 */
354 static int addremove = ADDREMOVE_DEFAULT;
355 static int addremove_explicit = -1; /* unspecified */
356
357 static int ignore_removal_cb(const struct option *opt, const char *arg, int unset)
358 {
359 /* if we are told to ignore, we are not adding removals */
360 *(int *)opt->value = !unset ? 0 : 1;
361 return 0;
362 }
363
364 static struct option builtin_add_options[] = {
365 OPT__DRY_RUN(&show_only, N_("dry run")),
366 OPT__VERBOSE(&verbose, N_("be verbose")),
367 OPT_GROUP(""),
368 OPT_BOOL('i', "interactive", &add_interactive, N_("interactive picking")),
369 OPT_BOOL('p', "patch", &patch_interactive, N_("select hunks interactively")),
370 OPT_BOOL('e', "edit", &edit_interactive, N_("edit current diff and apply")),
371 OPT__FORCE(&ignored_too, N_("allow adding otherwise ignored files")),
372 OPT_BOOL('u', "update", &take_worktree_changes, N_("update tracked files")),
373 OPT_BOOL('N', "intent-to-add", &intent_to_add, N_("record only the fact that the path will be added later")),
374 OPT_BOOL('A', "all", &addremove_explicit, N_("add changes from all tracked and untracked files")),
375 { OPTION_CALLBACK, 0, "ignore-removal", &addremove_explicit,
376 NULL /* takes no arguments */,
377 N_("ignore paths removed in the working tree (same as --no-all)"),
378 PARSE_OPT_NOARG, ignore_removal_cb },
379 OPT_BOOL( 0 , "refresh", &refresh_only, N_("don't add, only refresh the index")),
380 OPT_BOOL( 0 , "ignore-errors", &ignore_add_errors, N_("just skip files which cannot be added because of errors")),
381 OPT_BOOL( 0 , "ignore-missing", &ignore_missing, N_("check if - even missing - files are ignored in dry run")),
382 OPT_END(),
383 };
384
385 static int add_config(const char *var, const char *value, void *cb)
386 {
387 if (!strcmp(var, "add.ignoreerrors") ||
388 !strcmp(var, "add.ignore-errors")) {
389 ignore_add_errors = git_config_bool(var, value);
390 return 0;
391 }
392 return git_default_config(var, value, cb);
393 }
394
395 static int add_files(struct dir_struct *dir, int flags)
396 {
397 int i, exit_status = 0;
398
399 if (dir->ignored_nr) {
400 fprintf(stderr, _(ignore_error));
401 for (i = 0; i < dir->ignored_nr; i++)
402 fprintf(stderr, "%s\n", dir->ignored[i]->name);
403 fprintf(stderr, _("Use -f if you really want to add them.\n"));
404 die(_("no files added"));
405 }
406
407 for (i = 0; i < dir->nr; i++)
408 if (add_file_to_cache(dir->entries[i]->name, flags)) {
409 if (!ignore_add_errors)
410 die(_("adding files failed"));
411 exit_status = 1;
412 }
413 return exit_status;
414 }
415
416 int cmd_add(int argc, const char **argv, const char *prefix)
417 {
418 int exit_status = 0;
419 int newfd;
420 struct pathspec pathspec;
421 struct dir_struct dir;
422 int flags;
423 int add_new_files;
424 int require_pathspec;
425 char *seen = NULL;
426 int implicit_dot = 0;
427 struct update_callback_data update_data;
428
429 git_config(add_config, NULL);
430
431 argc = parse_options(argc, argv, prefix, builtin_add_options,
432 builtin_add_usage, PARSE_OPT_KEEP_ARGV0);
433 if (patch_interactive)
434 add_interactive = 1;
435 if (add_interactive)
436 exit(interactive_add(argc - 1, argv + 1, prefix, patch_interactive));
437
438 if (edit_interactive)
439 return(edit_patch(argc, argv, prefix));
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 /*
452 * Warn when "git add pathspec..." was given without "-u" or "-A"
453 * and pathspec... covers a removed path.
454 */
455 memset(&update_data, 0, sizeof(update_data));
456 if (!take_worktree_changes && addremove_explicit < 0)
457 update_data.warn_add_would_remove = 1;
458
459 if (!take_worktree_changes && addremove_explicit < 0 && argc)
460 /*
461 * Turn "git add pathspec..." to "git add -A pathspec..."
462 * in Git 2.0 but not yet
463 */
464 ; /* addremove = 1; */
465
466 if (!show_only && ignore_missing)
467 die(_("Option --ignore-missing can only be used together with --dry-run"));
468 if (addremove) {
469 option_with_implicit_dot = "--all";
470 short_option_with_implicit_dot = "-A";
471 }
472 if (take_worktree_changes) {
473 option_with_implicit_dot = "--update";
474 short_option_with_implicit_dot = "-u";
475 }
476 if (option_with_implicit_dot && !argc) {
477 static const char *here[2] = { ".", NULL };
478 argc = 1;
479 argv = here;
480 implicit_dot = 1;
481 }
482
483 add_new_files = !take_worktree_changes && !refresh_only;
484 require_pathspec = !take_worktree_changes;
485
486 newfd = hold_locked_index(&lock_file, 1);
487
488 flags = ((verbose ? ADD_CACHE_VERBOSE : 0) |
489 (show_only ? ADD_CACHE_PRETEND : 0) |
490 (intent_to_add ? ADD_CACHE_INTENT : 0) |
491 (ignore_add_errors ? ADD_CACHE_IGNORE_ERRORS : 0) |
492 (!(addremove || take_worktree_changes)
493 ? ADD_CACHE_IGNORE_REMOVAL : 0)) |
494 (implicit_dot ? ADD_CACHE_IMPLICIT_DOT : 0);
495
496 if (require_pathspec && argc == 0) {
497 fprintf(stderr, _("Nothing specified, nothing added.\n"));
498 fprintf(stderr, _("Maybe you wanted to say 'git add .'?\n"));
499 return 0;
500 }
501
502 if (read_cache() < 0)
503 die(_("index file corrupt"));
504
505 /*
506 * Check the "pathspec '%s' did not match any files" block
507 * below before enabling new magic.
508 */
509 parse_pathspec(&pathspec, 0,
510 PATHSPEC_PREFER_FULL |
511 PATHSPEC_SYMLINK_LEADING_PATH |
512 PATHSPEC_STRIP_SUBMODULE_SLASH_EXPENSIVE,
513 prefix, argv);
514
515 if (add_new_files) {
516 int baselen;
517
518 /* Set up the default git porcelain excludes */
519 memset(&dir, 0, sizeof(dir));
520 if (!ignored_too) {
521 dir.flags |= DIR_COLLECT_IGNORED;
522 setup_standard_excludes(&dir);
523 }
524
525 /* This picks up the paths that are not tracked */
526 baselen = fill_directory(&dir, implicit_dot ? NULL : pathspec.raw);
527 if (pathspec.nr)
528 seen = prune_directory(&dir, pathspec.raw, baselen,
529 implicit_dot ? WARN_IMPLICIT_DOT : 0);
530 }
531
532 if (refresh_only) {
533 refresh(verbose, pathspec.raw);
534 goto finish;
535 }
536 if (implicit_dot && prefix)
537 refresh_cache(REFRESH_QUIET);
538
539 if (pathspec.nr) {
540 int i;
541
542 if (!seen)
543 seen = find_pathspecs_matching_against_index(pathspec.raw);
544
545 /*
546 * file_exists() assumes exact match
547 */
548 GUARD_PATHSPEC(&pathspec, PATHSPEC_FROMTOP);
549
550 for (i = 0; pathspec.raw[i]; i++) {
551 if (!seen[i] && pathspec.raw[i][0]
552 && !file_exists(pathspec.raw[i])) {
553 if (ignore_missing) {
554 int dtype = DT_UNKNOWN;
555 if (is_excluded(&dir, pathspec.raw[i], &dtype))
556 dir_add_ignored(&dir, pathspec.raw[i], strlen(pathspec.raw[i]));
557 } else
558 die(_("pathspec '%s' did not match any files"),
559 pathspec.raw[i]);
560 }
561 }
562 free(seen);
563 }
564
565 plug_bulk_checkin();
566
567 if ((flags & ADD_CACHE_IMPLICIT_DOT) && prefix) {
568 /*
569 * Check for modified files throughout the worktree so
570 * update_callback has a chance to warn about changes
571 * outside the cwd.
572 */
573 update_data.implicit_dot = prefix;
574 update_data.implicit_dot_len = strlen(prefix);
575 free_pathspec(&pathspec);
576 memset(&pathspec, 0, sizeof(pathspec));
577 }
578 update_data.flags = flags & ~ADD_CACHE_IMPLICIT_DOT;
579 update_files_in_cache(prefix, pathspec.raw, &update_data);
580
581 exit_status |= !!update_data.add_errors;
582 if (add_new_files)
583 exit_status |= add_files(&dir, flags);
584
585 unplug_bulk_checkin();
586
587 finish:
588 if (active_cache_changed) {
589 if (write_cache(newfd, active_cache, active_nr) ||
590 commit_locked_index(&lock_file))
591 die(_("Unable to write new index file"));
592 }
593
594 return exit_status;
595 }