convert add_files_to_cache 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,
170 const struct pathspec *pathspec,
171 struct update_callback_data *data)
172 {
173 struct rev_info rev;
174
175 init_revisions(&rev, prefix);
176 setup_revisions(0, NULL, &rev, NULL);
177 if (pathspec)
178 copy_pathspec(&rev.prune_data, pathspec);
179 rev.diffopt.output_format = DIFF_FORMAT_CALLBACK;
180 rev.diffopt.format_callback = update_callback;
181 rev.diffopt.format_callback_data = data;
182 rev.max_count = 0; /* do not compare unmerged paths with stage #2 */
183 run_diff_files(&rev, DIFF_RACY_IS_MODIFIED);
184 }
185
186 int add_files_to_cache(const char *prefix,
187 const struct pathspec *pathspec, int flags)
188 {
189 struct update_callback_data data;
190
191 memset(&data, 0, sizeof(data));
192 data.flags = flags;
193 update_files_in_cache(prefix, pathspec, &data);
194 return !!data.add_errors;
195 }
196
197 #define WARN_IMPLICIT_DOT (1u << 0)
198 static char *prune_directory(struct dir_struct *dir, const char **pathspec,
199 int prefix, unsigned flag)
200 {
201 char *seen;
202 int i, specs;
203 struct dir_entry **src, **dst;
204
205 for (specs = 0; pathspec[specs]; specs++)
206 /* nothing */;
207 seen = xcalloc(specs, 1);
208
209 src = dst = dir->entries;
210 i = dir->nr;
211 while (--i >= 0) {
212 struct dir_entry *entry = *src++;
213 if (match_pathspec(pathspec, entry->name, entry->len,
214 prefix, seen))
215 *dst++ = entry;
216 else if (flag & WARN_IMPLICIT_DOT)
217 /*
218 * "git add -A" was run from a subdirectory with a
219 * new file outside that directory.
220 *
221 * "git add -A" will behave like "git add -A :/"
222 * instead of "git add -A ." in the future.
223 * Warn about the coming behavior change.
224 */
225 warn_pathless_add();
226 }
227 dir->nr = dst - dir->entries;
228 add_pathspec_matches_against_index(pathspec, seen, specs);
229 return seen;
230 }
231
232 static void refresh(int verbose, const struct pathspec *pathspec)
233 {
234 char *seen;
235 int i;
236
237 seen = xcalloc(pathspec->nr, 1);
238 refresh_index(&the_index, verbose ? REFRESH_IN_PORCELAIN : REFRESH_QUIET,
239 pathspec, seen, _("Unstaged changes after refreshing the index:"));
240 for (i = 0; i < pathspec->nr; i++) {
241 if (!seen[i])
242 die(_("pathspec '%s' did not match any files"),
243 pathspec->items[i].match);
244 }
245 free(seen);
246 }
247
248 int run_add_interactive(const char *revision, const char *patch_mode,
249 const struct pathspec *pathspec)
250 {
251 int status, ac, i;
252 const char **args;
253
254 args = xcalloc(sizeof(const char *), (pathspec->nr + 6));
255 ac = 0;
256 args[ac++] = "add--interactive";
257 if (patch_mode)
258 args[ac++] = patch_mode;
259 if (revision)
260 args[ac++] = revision;
261 args[ac++] = "--";
262 for (i = 0; i < pathspec->nr; i++)
263 /* pass original pathspec, to be re-parsed */
264 args[ac++] = pathspec->items[i].original;
265
266 status = run_command_v_opt(args, RUN_GIT_CMD);
267 free(args);
268 return status;
269 }
270
271 int interactive_add(int argc, const char **argv, const char *prefix, int patch)
272 {
273 struct pathspec pathspec;
274
275 /*
276 * git-add--interactive itself does not parse pathspec. It
277 * simply passes the pathspec to other builtin commands. Let's
278 * hope all of them support all magic, or we'll need to limit
279 * the magic here.
280 */
281 parse_pathspec(&pathspec, PATHSPEC_ALL_MAGIC & ~PATHSPEC_FROMTOP,
282 PATHSPEC_PREFER_FULL |
283 PATHSPEC_SYMLINK_LEADING_PATH |
284 PATHSPEC_PREFIX_ORIGIN,
285 prefix, argv);
286
287 return run_add_interactive(NULL,
288 patch ? "--patch" : NULL,
289 &pathspec);
290 }
291
292 static int edit_patch(int argc, const char **argv, const char *prefix)
293 {
294 char *file = git_pathdup("ADD_EDIT.patch");
295 const char *apply_argv[] = { "apply", "--recount", "--cached",
296 NULL, NULL };
297 struct child_process child;
298 struct rev_info rev;
299 int out;
300 struct stat st;
301
302 apply_argv[3] = file;
303
304 git_config(git_diff_basic_config, NULL); /* no "diff" UI options */
305
306 if (read_cache() < 0)
307 die (_("Could not read the index"));
308
309 init_revisions(&rev, prefix);
310 rev.diffopt.context = 7;
311
312 argc = setup_revisions(argc, argv, &rev, NULL);
313 rev.diffopt.output_format = DIFF_FORMAT_PATCH;
314 DIFF_OPT_SET(&rev.diffopt, IGNORE_DIRTY_SUBMODULES);
315 out = open(file, O_CREAT | O_WRONLY, 0666);
316 if (out < 0)
317 die (_("Could not open '%s' for writing."), file);
318 rev.diffopt.file = xfdopen(out, "w");
319 rev.diffopt.close_file = 1;
320 if (run_diff_files(&rev, 0))
321 die (_("Could not write patch"));
322
323 launch_editor(file, NULL, NULL);
324
325 if (stat(file, &st))
326 die_errno(_("Could not stat '%s'"), file);
327 if (!st.st_size)
328 die(_("Empty patch. Aborted."));
329
330 memset(&child, 0, sizeof(child));
331 child.git_cmd = 1;
332 child.argv = apply_argv;
333 if (run_command(&child))
334 die (_("Could not apply '%s'"), file);
335
336 unlink(file);
337 free(file);
338 return 0;
339 }
340
341 static struct lock_file lock_file;
342
343 static const char ignore_error[] =
344 N_("The following paths are ignored by one of your .gitignore files:\n");
345
346 static int verbose, show_only, ignored_too, refresh_only;
347 static int ignore_add_errors, intent_to_add, ignore_missing;
348
349 #define ADDREMOVE_DEFAULT 0 /* Change to 1 in Git 2.0 */
350 static int addremove = ADDREMOVE_DEFAULT;
351 static int addremove_explicit = -1; /* unspecified */
352
353 static int ignore_removal_cb(const struct option *opt, const char *arg, int unset)
354 {
355 /* if we are told to ignore, we are not adding removals */
356 *(int *)opt->value = !unset ? 0 : 1;
357 return 0;
358 }
359
360 static struct option builtin_add_options[] = {
361 OPT__DRY_RUN(&show_only, N_("dry run")),
362 OPT__VERBOSE(&verbose, N_("be verbose")),
363 OPT_GROUP(""),
364 OPT_BOOL('i', "interactive", &add_interactive, N_("interactive picking")),
365 OPT_BOOL('p', "patch", &patch_interactive, N_("select hunks interactively")),
366 OPT_BOOL('e', "edit", &edit_interactive, N_("edit current diff and apply")),
367 OPT__FORCE(&ignored_too, N_("allow adding otherwise ignored files")),
368 OPT_BOOL('u', "update", &take_worktree_changes, N_("update tracked files")),
369 OPT_BOOL('N', "intent-to-add", &intent_to_add, N_("record only the fact that the path will be added later")),
370 OPT_BOOL('A', "all", &addremove_explicit, N_("add changes from all tracked and untracked files")),
371 { OPTION_CALLBACK, 0, "ignore-removal", &addremove_explicit,
372 NULL /* takes no arguments */,
373 N_("ignore paths removed in the working tree (same as --no-all)"),
374 PARSE_OPT_NOARG, ignore_removal_cb },
375 OPT_BOOL( 0 , "refresh", &refresh_only, N_("don't add, only refresh the index")),
376 OPT_BOOL( 0 , "ignore-errors", &ignore_add_errors, N_("just skip files which cannot be added because of errors")),
377 OPT_BOOL( 0 , "ignore-missing", &ignore_missing, N_("check if - even missing - files are ignored in dry run")),
378 OPT_END(),
379 };
380
381 static int add_config(const char *var, const char *value, void *cb)
382 {
383 if (!strcmp(var, "add.ignoreerrors") ||
384 !strcmp(var, "add.ignore-errors")) {
385 ignore_add_errors = git_config_bool(var, value);
386 return 0;
387 }
388 return git_default_config(var, value, cb);
389 }
390
391 static int add_files(struct dir_struct *dir, int flags)
392 {
393 int i, exit_status = 0;
394
395 if (dir->ignored_nr) {
396 fprintf(stderr, _(ignore_error));
397 for (i = 0; i < dir->ignored_nr; i++)
398 fprintf(stderr, "%s\n", dir->ignored[i]->name);
399 fprintf(stderr, _("Use -f if you really want to add them.\n"));
400 die(_("no files added"));
401 }
402
403 for (i = 0; i < dir->nr; i++)
404 if (add_file_to_cache(dir->entries[i]->name, flags)) {
405 if (!ignore_add_errors)
406 die(_("adding files failed"));
407 exit_status = 1;
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 int newfd;
416 struct pathspec pathspec;
417 struct dir_struct dir;
418 int flags;
419 int add_new_files;
420 int require_pathspec;
421 char *seen = NULL;
422 int implicit_dot = 0;
423 struct update_callback_data update_data;
424
425 git_config(add_config, NULL);
426
427 argc = parse_options(argc, argv, prefix, builtin_add_options,
428 builtin_add_usage, PARSE_OPT_KEEP_ARGV0);
429 if (patch_interactive)
430 add_interactive = 1;
431 if (add_interactive)
432 exit(interactive_add(argc - 1, argv + 1, prefix, patch_interactive));
433
434 if (edit_interactive)
435 return(edit_patch(argc, argv, prefix));
436 argc--;
437 argv++;
438
439 if (0 <= addremove_explicit)
440 addremove = addremove_explicit;
441 else if (take_worktree_changes && ADDREMOVE_DEFAULT)
442 addremove = 0; /* "-u" was given but not "-A" */
443
444 if (addremove && take_worktree_changes)
445 die(_("-A and -u are mutually incompatible"));
446
447 /*
448 * Warn when "git add pathspec..." was given without "-u" or "-A"
449 * and pathspec... covers a removed path.
450 */
451 memset(&update_data, 0, sizeof(update_data));
452 if (!take_worktree_changes && addremove_explicit < 0)
453 update_data.warn_add_would_remove = 1;
454
455 if (!take_worktree_changes && addremove_explicit < 0 && argc)
456 /*
457 * Turn "git add pathspec..." to "git add -A pathspec..."
458 * in Git 2.0 but not yet
459 */
460 ; /* addremove = 1; */
461
462 if (!show_only && ignore_missing)
463 die(_("Option --ignore-missing can only be used together with --dry-run"));
464 if (addremove) {
465 option_with_implicit_dot = "--all";
466 short_option_with_implicit_dot = "-A";
467 }
468 if (take_worktree_changes) {
469 option_with_implicit_dot = "--update";
470 short_option_with_implicit_dot = "-u";
471 }
472 if (option_with_implicit_dot && !argc) {
473 static const char *here[2] = { ".", NULL };
474 argc = 1;
475 argv = here;
476 implicit_dot = 1;
477 }
478
479 add_new_files = !take_worktree_changes && !refresh_only;
480 require_pathspec = !take_worktree_changes;
481
482 newfd = hold_locked_index(&lock_file, 1);
483
484 flags = ((verbose ? ADD_CACHE_VERBOSE : 0) |
485 (show_only ? ADD_CACHE_PRETEND : 0) |
486 (intent_to_add ? ADD_CACHE_INTENT : 0) |
487 (ignore_add_errors ? ADD_CACHE_IGNORE_ERRORS : 0) |
488 (!(addremove || take_worktree_changes)
489 ? ADD_CACHE_IGNORE_REMOVAL : 0)) |
490 (implicit_dot ? ADD_CACHE_IMPLICIT_DOT : 0);
491
492 if (require_pathspec && argc == 0) {
493 fprintf(stderr, _("Nothing specified, nothing added.\n"));
494 fprintf(stderr, _("Maybe you wanted to say 'git add .'?\n"));
495 return 0;
496 }
497
498 if (read_cache() < 0)
499 die(_("index file corrupt"));
500
501 /*
502 * Check the "pathspec '%s' did not match any files" block
503 * below before enabling new magic.
504 */
505 parse_pathspec(&pathspec, 0,
506 PATHSPEC_PREFER_FULL |
507 PATHSPEC_SYMLINK_LEADING_PATH |
508 PATHSPEC_STRIP_SUBMODULE_SLASH_EXPENSIVE,
509 prefix, argv);
510
511 if (add_new_files) {
512 int baselen;
513 struct pathspec empty_pathspec;
514
515 /* Set up the default git porcelain excludes */
516 memset(&dir, 0, sizeof(dir));
517 if (!ignored_too) {
518 dir.flags |= DIR_COLLECT_IGNORED;
519 setup_standard_excludes(&dir);
520 }
521
522 memset(&empty_pathspec, 0, sizeof(empty_pathspec));
523 /* This picks up the paths that are not tracked */
524 baselen = fill_directory(&dir, implicit_dot ? &empty_pathspec : &pathspec);
525 if (pathspec.nr)
526 seen = prune_directory(&dir, pathspec.raw, baselen,
527 implicit_dot ? WARN_IMPLICIT_DOT : 0);
528 }
529
530 if (refresh_only) {
531 refresh(verbose, &pathspec);
532 goto finish;
533 }
534 if (implicit_dot && prefix)
535 refresh_cache(REFRESH_QUIET);
536
537 if (pathspec.nr) {
538 int i;
539
540 if (!seen)
541 seen = find_pathspecs_matching_against_index(pathspec.raw);
542
543 /*
544 * file_exists() assumes exact match
545 */
546 GUARD_PATHSPEC(&pathspec, PATHSPEC_FROMTOP);
547
548 for (i = 0; pathspec.raw[i]; i++) {
549 if (!seen[i] && pathspec.raw[i][0]
550 && !file_exists(pathspec.raw[i])) {
551 if (ignore_missing) {
552 int dtype = DT_UNKNOWN;
553 if (is_excluded(&dir, pathspec.raw[i], &dtype))
554 dir_add_ignored(&dir, pathspec.raw[i], strlen(pathspec.raw[i]));
555 } else
556 die(_("pathspec '%s' did not match any files"),
557 pathspec.raw[i]);
558 }
559 }
560 free(seen);
561 }
562
563 plug_bulk_checkin();
564
565 if ((flags & ADD_CACHE_IMPLICIT_DOT) && prefix) {
566 /*
567 * Check for modified files throughout the worktree so
568 * update_callback has a chance to warn about changes
569 * outside the cwd.
570 */
571 update_data.implicit_dot = prefix;
572 update_data.implicit_dot_len = strlen(prefix);
573 free_pathspec(&pathspec);
574 memset(&pathspec, 0, sizeof(pathspec));
575 }
576 update_data.flags = flags & ~ADD_CACHE_IMPLICIT_DOT;
577 update_files_in_cache(prefix, &pathspec, &update_data);
578
579 exit_status |= !!update_data.add_errors;
580 if (add_new_files)
581 exit_status |= add_files(&dir, flags);
582
583 unplug_bulk_checkin();
584
585 finish:
586 if (active_cache_changed) {
587 if (write_cache(newfd, active_cache, active_nr) ||
588 commit_locked_index(&lock_file))
589 die(_("Unable to write new index file"));
590 }
591
592 return exit_status;
593 }