2 * "git add" builtin command
4 * Copyright (C) 2006 Linus Torvalds
11 #include "cache-tree.h"
12 #include "run-command.h"
13 #include "parse-options.h"
17 #include "bulk-checkin.h"
19 static const char * const builtin_add_usage
[] = {
20 N_("git add [options] [--] <pathspec>..."),
23 static int patch_interactive
, add_interactive
, edit_interactive
;
24 static int take_worktree_changes
;
26 struct update_callback_data
{
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)
42 assert(option_with_implicit_dot
&& short_option_with_implicit_dot
);
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"
63 " (or git add %s :/)\n"
65 "To restrict the command to the current directory, run:\n"
68 " (or git add %s .)\n"
70 "With the current Git version, the command is restricted to "
71 "the current directory.\n"
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
)
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
;
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"
105 "* 'git add --ignore-removal <pathspec>', which is the current default,\n"
106 " ignores paths you removed from your working tree.\n"
108 "* 'git add --all <pathspec>' will let you also record the removals.\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
)
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,
133 * "git add -u" will behave like "git add -u :/" instead of
134 * "git add -u ." in the future. This warning prepares for
138 strncmp_icase(path
, implicit_dot
, implicit_dot_len
)) {
142 switch (fix_unmerged_status(p
, data
)) {
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"));
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
)
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
);
169 static void update_files_in_cache(const char *prefix
,
170 const struct pathspec
*pathspec
,
171 struct update_callback_data
*data
)
175 init_revisions(&rev
, prefix
);
176 setup_revisions(0, NULL
, &rev
, NULL
);
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
));
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
, const char **pathspec
,
199 int prefix
, unsigned flag
)
203 struct dir_entry
**src
, **dst
;
205 for (specs
= 0; pathspec
[specs
]; specs
++)
207 seen
= xcalloc(specs
, 1);
209 src
= dst
= dir
->entries
;
212 struct dir_entry
*entry
= *src
++;
213 if (match_pathspec(pathspec
, entry
->name
, entry
->len
,
216 else if (flag
& WARN_IMPLICIT_DOT
)
218 * "git add -A" was run from a subdirectory with a
219 * new file outside that directory.
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.
227 dir
->nr
= dst
- dir
->entries
;
228 add_pathspec_matches_against_index(pathspec
, seen
, specs
);
232 static void refresh(int verbose
, const struct pathspec
*pathspec
)
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
++) {
242 die(_("pathspec '%s' did not match any files"),
243 pathspec
->items
[i
].match
);
248 int run_add_interactive(const char *revision
, const char *patch_mode
,
249 const struct pathspec
*pathspec
)
254 args
= xcalloc(sizeof(const char *), (pathspec
->nr
+ 6));
256 args
[ac
++] = "add--interactive";
258 args
[ac
++] = patch_mode
;
260 args
[ac
++] = revision
;
262 for (i
= 0; i
< pathspec
->nr
; i
++)
263 /* pass original pathspec, to be re-parsed */
264 args
[ac
++] = pathspec
->items
[i
].original
;
266 status
= run_command_v_opt(args
, RUN_GIT_CMD
);
271 int interactive_add(int argc
, const char **argv
, const char *prefix
, int patch
)
273 struct pathspec pathspec
;
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
281 parse_pathspec(&pathspec
, PATHSPEC_ALL_MAGIC
& ~PATHSPEC_FROMTOP
,
282 PATHSPEC_PREFER_FULL
|
283 PATHSPEC_SYMLINK_LEADING_PATH
|
284 PATHSPEC_PREFIX_ORIGIN
,
287 return run_add_interactive(NULL
,
288 patch
? "--patch" : NULL
,
292 static int edit_patch(int argc
, const char **argv
, const char *prefix
)
294 char *file
= git_pathdup("ADD_EDIT.patch");
295 const char *apply_argv
[] = { "apply", "--recount", "--cached",
297 struct child_process child
;
302 apply_argv
[3] = file
;
304 git_config(git_diff_basic_config
, NULL
); /* no "diff" UI options */
306 if (read_cache() < 0)
307 die (_("Could not read the index"));
309 init_revisions(&rev
, prefix
);
310 rev
.diffopt
.context
= 7;
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);
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"));
323 launch_editor(file
, NULL
, NULL
);
326 die_errno(_("Could not stat '%s'"), file
);
328 die(_("Empty patch. Aborted."));
330 memset(&child
, 0, sizeof(child
));
332 child
.argv
= apply_argv
;
333 if (run_command(&child
))
334 die (_("Could not apply '%s'"), file
);
341 static struct lock_file lock_file
;
343 static const char ignore_error
[] =
344 N_("The following paths are ignored by one of your .gitignore files:\n");
346 static int verbose
, show_only
, ignored_too
, refresh_only
;
347 static int ignore_add_errors
, intent_to_add
, ignore_missing
;
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 */
353 static int ignore_removal_cb(const struct option
*opt
, const char *arg
, int unset
)
355 /* if we are told to ignore, we are not adding removals */
356 *(int *)opt
->value
= !unset
? 0 : 1;
360 static struct option builtin_add_options
[] = {
361 OPT__DRY_RUN(&show_only
, N_("dry run")),
362 OPT__VERBOSE(&verbose
, N_("be verbose")),
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")),
381 static int add_config(const char *var
, const char *value
, void *cb
)
383 if (!strcmp(var
, "add.ignoreerrors") ||
384 !strcmp(var
, "add.ignore-errors")) {
385 ignore_add_errors
= git_config_bool(var
, value
);
388 return git_default_config(var
, value
, cb
);
391 static int add_files(struct dir_struct
*dir
, int flags
)
393 int i
, exit_status
= 0;
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"));
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"));
412 int cmd_add(int argc
, const char **argv
, const char *prefix
)
416 struct pathspec pathspec
;
417 struct dir_struct dir
;
420 int require_pathspec
;
422 int implicit_dot
= 0;
423 struct update_callback_data update_data
;
425 git_config(add_config
, NULL
);
427 argc
= parse_options(argc
, argv
, prefix
, builtin_add_options
,
428 builtin_add_usage
, PARSE_OPT_KEEP_ARGV0
);
429 if (patch_interactive
)
432 exit(interactive_add(argc
- 1, argv
+ 1, prefix
, patch_interactive
));
434 if (edit_interactive
)
435 return(edit_patch(argc
, argv
, prefix
));
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" */
444 if (addremove
&& take_worktree_changes
)
445 die(_("-A and -u are mutually incompatible"));
448 * Warn when "git add pathspec..." was given without "-u" or "-A"
449 * and pathspec... covers a removed path.
451 memset(&update_data
, 0, sizeof(update_data
));
452 if (!take_worktree_changes
&& addremove_explicit
< 0)
453 update_data
.warn_add_would_remove
= 1;
455 if (!take_worktree_changes
&& addremove_explicit
< 0 && argc
)
457 * Turn "git add pathspec..." to "git add -A pathspec..."
458 * in Git 2.0 but not yet
460 ; /* addremove = 1; */
462 if (!show_only
&& ignore_missing
)
463 die(_("Option --ignore-missing can only be used together with --dry-run"));
465 option_with_implicit_dot
= "--all";
466 short_option_with_implicit_dot
= "-A";
468 if (take_worktree_changes
) {
469 option_with_implicit_dot
= "--update";
470 short_option_with_implicit_dot
= "-u";
472 if (option_with_implicit_dot
&& !argc
) {
473 static const char *here
[2] = { ".", NULL
};
479 add_new_files
= !take_worktree_changes
&& !refresh_only
;
480 require_pathspec
= !take_worktree_changes
;
482 newfd
= hold_locked_index(&lock_file
, 1);
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);
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"));
498 if (read_cache() < 0)
499 die(_("index file corrupt"));
502 * Check the "pathspec '%s' did not match any files" block
503 * below before enabling new magic.
505 parse_pathspec(&pathspec
, 0,
506 PATHSPEC_PREFER_FULL
|
507 PATHSPEC_SYMLINK_LEADING_PATH
|
508 PATHSPEC_STRIP_SUBMODULE_SLASH_EXPENSIVE
,
513 struct pathspec empty_pathspec
;
515 /* Set up the default git porcelain excludes */
516 memset(&dir
, 0, sizeof(dir
));
518 dir
.flags
|= DIR_COLLECT_IGNORED
;
519 setup_standard_excludes(&dir
);
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
);
526 seen
= prune_directory(&dir
, pathspec
.raw
, baselen
,
527 implicit_dot
? WARN_IMPLICIT_DOT
: 0);
531 refresh(verbose
, &pathspec
);
534 if (implicit_dot
&& prefix
)
535 refresh_cache(REFRESH_QUIET
);
541 seen
= find_pathspecs_matching_against_index(pathspec
.raw
);
544 * file_exists() assumes exact match
546 GUARD_PATHSPEC(&pathspec
, PATHSPEC_FROMTOP
);
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
]));
556 die(_("pathspec '%s' did not match any files"),
565 if ((flags
& ADD_CACHE_IMPLICIT_DOT
) && prefix
) {
567 * Check for modified files throughout the worktree so
568 * update_callback has a chance to warn about changes
571 update_data
.implicit_dot
= prefix
;
572 update_data
.implicit_dot_len
= strlen(prefix
);
573 free_pathspec(&pathspec
);
574 memset(&pathspec
, 0, sizeof(pathspec
));
576 update_data
.flags
= flags
& ~ADD_CACHE_IMPLICIT_DOT
;
577 update_files_in_cache(prefix
, &pathspec
, &update_data
);
579 exit_status
|= !!update_data
.add_errors
;
581 exit_status
|= add_files(&dir
, flags
);
583 unplug_bulk_checkin();
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"));