l10n: remove 2 blank translations on Danish, Dutch
[git/gitweb.git] / builtin / add.c
blob2a2722fa10aa981695b21984e7c425c35b4f18d0
1 /*
2 * "git add" builtin command
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"
19 static const char * const builtin_add_usage[] = {
20 N_("git add [options] [--] <pathspec>..."),
21 NULL
23 static int patch_interactive, add_interactive, edit_interactive;
24 static int take_worktree_changes;
26 struct update_callback_data {
27 int flags;
28 int add_errors;
29 const char *implicit_dot;
30 size_t implicit_dot_len;
32 /* only needed for 2.0 transition preparation */
33 int warn_add_would_remove;
36 static const char *option_with_implicit_dot;
37 static const char *short_option_with_implicit_dot;
39 static void warn_pathless_add(void)
41 static int shown;
42 assert(option_with_implicit_dot && short_option_with_implicit_dot);
44 if (shown)
45 return;
46 shown = 1;
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.
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);
78 static int fix_unmerged_status(struct diff_filepair *p,
79 struct update_callback_data *data)
81 if (p->status != DIFF_STATUS_UNMERGED)
82 return p->status;
83 if (!(data->flags & ADD_CACHE_IGNORE_REMOVAL) && !p->two->mode)
85 * This is not an explicit add request, and the
86 * path is missing from the working tree (deleted)
88 return DIFF_STATUS_DELETED;
89 else
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.
96 return DIFF_STATUS_MODIFIED;
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");
112 static void warn_add_would_remove(const char *path)
114 warning(_(add_would_remove_warning), path);
117 static void update_callback(struct diff_queue_struct *q,
118 struct diff_options *opt, void *cbdata)
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;
125 for (i = 0; i < q->nr; i++) {
126 struct diff_filepair *p = q->queue[i];
127 const char *path = p->one->path;
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.
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.
137 if (implicit_dot &&
138 strncmp_icase(path, implicit_dot, implicit_dot_len)) {
139 warn_pathless_add();
140 continue;
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++;
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;
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;
169 static void update_files_in_cache(const char *prefix,
170 const struct pathspec *pathspec,
171 struct update_callback_data *data)
173 struct rev_info rev;
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);
186 int add_files_to_cache(const char *prefix,
187 const struct pathspec *pathspec, int flags)
189 struct update_callback_data data;
191 memset(&data, 0, sizeof(data));
192 data.flags = flags;
193 update_files_in_cache(prefix, pathspec, &data);
194 return !!data.add_errors;
197 #define WARN_IMPLICIT_DOT (1u << 0)
198 static char *prune_directory(struct dir_struct *dir, struct pathspec *pathspec,
199 int prefix, unsigned flag)
201 char *seen;
202 int i;
203 struct dir_entry **src, **dst;
205 seen = xcalloc(pathspec->nr, 1);
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)
216 * "git add -A" was run from a subdirectory with a
217 * new file outside that directory.
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.
223 warn_pathless_add();
225 dir->nr = dst - dir->entries;
226 add_pathspec_matches_against_index(pathspec, seen);
227 return seen;
230 static void refresh(int verbose, const struct pathspec *pathspec)
232 char *seen;
233 int i;
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);
243 free(seen);
246 int run_add_interactive(const char *revision, const char *patch_mode,
247 const struct pathspec *pathspec)
249 int status, ac, i;
250 const char **args;
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;
264 status = run_command_v_opt(args, RUN_GIT_CMD);
265 free(args);
266 return status;
269 int interactive_add(int argc, const char **argv, const char *prefix, int patch)
271 struct pathspec pathspec;
273 parse_pathspec(&pathspec, 0,
274 PATHSPEC_PREFER_FULL |
275 PATHSPEC_SYMLINK_LEADING_PATH |
276 PATHSPEC_PREFIX_ORIGIN,
277 prefix, argv);
279 return run_add_interactive(NULL,
280 patch ? "--patch" : NULL,
281 &pathspec);
284 static int edit_patch(int argc, const char **argv, const char *prefix)
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;
294 apply_argv[3] = file;
296 git_config(git_diff_basic_config, NULL); /* no "diff" UI options */
298 if (read_cache() < 0)
299 die(_("Could not read the index"));
301 init_revisions(&rev, prefix);
302 rev.diffopt.context = 7;
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"));
316 launch_editor(file, NULL, NULL);
318 if (stat(file, &st))
319 die_errno(_("Could not stat '%s'"), file);
320 if (!st.st_size)
321 die(_("Empty patch. Aborted."));
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);
329 unlink(file);
330 free(file);
331 return 0;
334 static struct lock_file lock_file;
336 static const char ignore_error[] =
337 N_("The following paths are ignored by one of your .gitignore files:\n");
339 static int verbose, show_only, ignored_too, refresh_only;
340 static int ignore_add_errors, intent_to_add, ignore_missing;
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 */
346 static int ignore_removal_cb(const struct option *opt, const char *arg, int unset)
348 /* if we are told to ignore, we are not adding removals */
349 *(int *)opt->value = !unset ? 0 : 1;
350 return 0;
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(),
374 static int add_config(const char *var, const char *value, void *cb)
376 if (!strcmp(var, "add.ignoreerrors") ||
377 !strcmp(var, "add.ignore-errors")) {
378 ignore_add_errors = git_config_bool(var, value);
379 return 0;
381 return git_default_config(var, value, cb);
384 static int add_files(struct dir_struct *dir, int flags)
386 int i, exit_status = 0;
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"));
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;
402 return exit_status;
405 int cmd_add(int argc, const char **argv, const char *prefix)
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;
418 git_config(add_config, NULL);
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));
427 if (edit_interactive)
428 return(edit_patch(argc, argv, prefix));
429 argc--;
430 argv++;
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" */
437 if (addremove && take_worktree_changes)
438 die(_("-A and -u are mutually incompatible"));
441 * Warn when "git add pathspec..." was given without "-u" or "-A"
442 * and pathspec... covers a removed path.
444 memset(&update_data, 0, sizeof(update_data));
445 if (!take_worktree_changes && addremove_explicit < 0)
446 update_data.warn_add_would_remove = 1;
448 if (!take_worktree_changes && addremove_explicit < 0 && argc)
450 * Turn "git add pathspec..." to "git add -A pathspec..."
451 * in Git 2.0 but not yet
453 ; /* addremove = 1; */
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";
461 if (take_worktree_changes) {
462 option_with_implicit_dot = "--update";
463 short_option_with_implicit_dot = "-u";
465 if (option_with_implicit_dot && !argc) {
466 static const char *here[2] = { ".", NULL };
467 argc = 1;
468 argv = here;
469 implicit_dot = 1;
472 add_new_files = !take_worktree_changes && !refresh_only;
473 require_pathspec = !take_worktree_changes;
475 newfd = hold_locked_index(&lock_file, 1);
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);
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;
491 if (read_cache() < 0)
492 die(_("index file corrupt"));
495 * Check the "pathspec '%s' did not match any files" block
496 * below before enabling new magic.
498 parse_pathspec(&pathspec, 0,
499 PATHSPEC_PREFER_FULL |
500 PATHSPEC_SYMLINK_LEADING_PATH |
501 PATHSPEC_STRIP_SUBMODULE_SLASH_EXPENSIVE,
502 prefix, argv);
504 if (add_new_files) {
505 int baselen;
506 struct pathspec empty_pathspec;
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);
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);
523 if (refresh_only) {
524 refresh(verbose, &pathspec);
525 goto finish;
527 if (implicit_dot && prefix)
528 refresh_cache(REFRESH_QUIET);
530 if (pathspec.nr) {
531 int i;
533 if (!seen)
534 seen = find_pathspecs_matching_against_index(&pathspec);
537 * file_exists() assumes exact match
539 GUARD_PATHSPEC(&pathspec,
540 PATHSPEC_FROMTOP |
541 PATHSPEC_LITERAL |
542 PATHSPEC_GLOB |
543 PATHSPEC_ICASE |
544 PATHSPEC_EXCLUDE);
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);
563 free(seen);
566 plug_bulk_checkin();
568 if ((flags & ADD_CACHE_IMPLICIT_DOT) && prefix) {
570 * Check for modified files throughout the worktree so
571 * update_callback has a chance to warn about changes
572 * outside the cwd.
574 update_data.implicit_dot = prefix;
575 update_data.implicit_dot_len = strlen(prefix);
576 free_pathspec(&pathspec);
577 memset(&pathspec, 0, sizeof(pathspec));
579 update_data.flags = flags & ~ADD_CACHE_IMPLICIT_DOT;
580 update_files_in_cache(prefix, &pathspec, &update_data);
582 exit_status |= !!update_data.add_errors;
583 if (add_new_files)
584 exit_status |= add_files(&dir, flags);
586 unplug_bulk_checkin();
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"));
595 return exit_status;