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