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