2 * "git add" builtin command
4 * Copyright (C) 2006 Linus Torvalds
10 #include "cache-tree.h"
11 #include "run-command.h"
12 #include "parse-options.h"
16 #include "bulk-checkin.h"
18 static const char * const builtin_add_usage
[] = {
19 N_("git add [options] [--] <filepattern>..."),
22 static int patch_interactive
, add_interactive
, edit_interactive
;
23 static int take_worktree_changes
;
25 struct update_callback_data
{
30 static int fix_unmerged_status(struct diff_filepair
*p
,
31 struct update_callback_data
*data
)
33 if (p
->status
!= DIFF_STATUS_UNMERGED
)
35 if (!(data
->flags
& ADD_CACHE_IGNORE_REMOVAL
) && !p
->two
->mode
)
37 * This is not an explicit add request, and the
38 * path is missing from the working tree (deleted)
40 return DIFF_STATUS_DELETED
;
43 * Either an explicit add request, or path exists
44 * in the working tree. An attempt to explicitly
45 * add a path that does not exist in the working tree
46 * will be caught as an error by the caller immediately.
48 return DIFF_STATUS_MODIFIED
;
51 static void update_callback(struct diff_queue_struct
*q
,
52 struct diff_options
*opt
, void *cbdata
)
55 struct update_callback_data
*data
= cbdata
;
57 for (i
= 0; i
< q
->nr
; i
++) {
58 struct diff_filepair
*p
= q
->queue
[i
];
59 const char *path
= p
->one
->path
;
60 switch (fix_unmerged_status(p
, data
)) {
62 die(_("unexpected diff status %c"), p
->status
);
63 case DIFF_STATUS_MODIFIED
:
64 case DIFF_STATUS_TYPE_CHANGED
:
65 if (add_file_to_index(&the_index
, path
, data
->flags
)) {
66 if (!(data
->flags
& ADD_CACHE_IGNORE_ERRORS
))
67 die(_("updating files failed"));
71 case DIFF_STATUS_DELETED
:
72 if (data
->flags
& ADD_CACHE_IGNORE_REMOVAL
)
74 if (!(data
->flags
& ADD_CACHE_PRETEND
))
75 remove_file_from_index(&the_index
, path
);
76 if (data
->flags
& (ADD_CACHE_PRETEND
|ADD_CACHE_VERBOSE
))
77 printf(_("remove '%s'\n"), path
);
83 int add_files_to_cache(const char *prefix
, const char **pathspec
, int flags
)
85 struct update_callback_data data
;
87 init_revisions(&rev
, prefix
);
88 setup_revisions(0, NULL
, &rev
, NULL
);
89 init_pathspec(&rev
.prune_data
, pathspec
);
90 rev
.diffopt
.output_format
= DIFF_FORMAT_CALLBACK
;
91 rev
.diffopt
.format_callback
= update_callback
;
94 rev
.diffopt
.format_callback_data
= &data
;
95 rev
.max_count
= 0; /* do not compare unmerged paths with stage #2 */
96 run_diff_files(&rev
, DIFF_RACY_IS_MODIFIED
);
97 return !!data
.add_errors
;
100 static void fill_pathspec_matches(const char **pathspec
, char *seen
, int specs
)
102 int num_unmatched
= 0, i
;
105 * Since we are walking the index as if we were walking the directory,
106 * we have to mark the matched pathspec as seen; otherwise we will
107 * mistakenly think that the user gave a pathspec that did not match
110 for (i
= 0; i
< specs
; i
++)
115 for (i
= 0; i
< active_nr
; i
++) {
116 struct cache_entry
*ce
= active_cache
[i
];
117 match_pathspec(pathspec
, ce
->name
, ce_namelen(ce
), 0, seen
);
121 static char *find_used_pathspec(const char **pathspec
)
126 for (i
= 0; pathspec
[i
]; i
++)
127 ; /* just counting */
128 seen
= xcalloc(i
, 1);
129 fill_pathspec_matches(pathspec
, seen
, i
);
133 static char *prune_directory(struct dir_struct
*dir
, const char **pathspec
, int prefix
)
137 struct dir_entry
**src
, **dst
;
139 for (specs
= 0; pathspec
[specs
]; specs
++)
141 seen
= xcalloc(specs
, 1);
143 src
= dst
= dir
->entries
;
146 struct dir_entry
*entry
= *src
++;
147 if (match_pathspec(pathspec
, entry
->name
, entry
->len
,
151 dir
->nr
= dst
- dir
->entries
;
152 fill_pathspec_matches(pathspec
, seen
, specs
);
156 static void treat_gitlinks(const char **pathspec
)
160 if (!pathspec
|| !*pathspec
)
163 for (i
= 0; i
< active_nr
; i
++) {
164 struct cache_entry
*ce
= active_cache
[i
];
165 if (S_ISGITLINK(ce
->ce_mode
)) {
166 int len
= ce_namelen(ce
), j
;
167 for (j
= 0; pathspec
[j
]; j
++) {
168 int len2
= strlen(pathspec
[j
]);
169 if (len2
<= len
|| pathspec
[j
][len
] != '/' ||
170 memcmp(ce
->name
, pathspec
[j
], len
))
173 /* strip trailing slash */
174 pathspec
[j
] = xstrndup(ce
->name
, len
);
176 die (_("Path '%s' is in submodule '%.*s'"),
177 pathspec
[j
], len
, ce
->name
);
183 static void refresh(int verbose
, const char **pathspec
)
188 for (specs
= 0; pathspec
[specs
]; specs
++)
190 seen
= xcalloc(specs
, 1);
191 refresh_index(&the_index
, verbose
? REFRESH_IN_PORCELAIN
: REFRESH_QUIET
,
192 pathspec
, seen
, _("Unstaged changes after refreshing the index:"));
193 for (i
= 0; i
< specs
; i
++) {
195 die(_("pathspec '%s' did not match any files"), pathspec
[i
]);
200 static const char **validate_pathspec(int argc
, const char **argv
, const char *prefix
)
202 const char **pathspec
= get_pathspec(prefix
, argv
);
206 for (p
= pathspec
; *p
; p
++) {
207 if (has_symlink_leading_path(*p
, strlen(*p
))) {
208 int len
= prefix
? strlen(prefix
) : 0;
209 die(_("'%s' is beyond a symbolic link"), *p
+ len
);
217 int run_add_interactive(const char *revision
, const char *patch_mode
,
218 const char **pathspec
)
220 int status
, ac
, pc
= 0;
227 args
= xcalloc(sizeof(const char *), (pc
+ 5));
229 args
[ac
++] = "add--interactive";
231 args
[ac
++] = patch_mode
;
233 args
[ac
++] = revision
;
236 memcpy(&(args
[ac
]), pathspec
, sizeof(const char *) * pc
);
241 status
= run_command_v_opt(args
, RUN_GIT_CMD
);
246 int interactive_add(int argc
, const char **argv
, const char *prefix
, int patch
)
248 const char **pathspec
= NULL
;
251 pathspec
= validate_pathspec(argc
, argv
, prefix
);
256 return run_add_interactive(NULL
,
257 patch
? "--patch" : NULL
,
261 static int edit_patch(int argc
, const char **argv
, const char *prefix
)
263 char *file
= git_pathdup("ADD_EDIT.patch");
264 const char *apply_argv
[] = { "apply", "--recount", "--cached",
266 struct child_process child
;
271 apply_argv
[3] = file
;
273 git_config(git_diff_basic_config
, NULL
); /* no "diff" UI options */
275 if (read_cache() < 0)
276 die (_("Could not read the index"));
278 init_revisions(&rev
, prefix
);
279 rev
.diffopt
.context
= 7;
281 argc
= setup_revisions(argc
, argv
, &rev
, NULL
);
282 rev
.diffopt
.output_format
= DIFF_FORMAT_PATCH
;
283 DIFF_OPT_SET(&rev
.diffopt
, IGNORE_DIRTY_SUBMODULES
);
284 out
= open(file
, O_CREAT
| O_WRONLY
, 0666);
286 die (_("Could not open '%s' for writing."), file
);
287 rev
.diffopt
.file
= xfdopen(out
, "w");
288 rev
.diffopt
.close_file
= 1;
289 if (run_diff_files(&rev
, 0))
290 die (_("Could not write patch"));
292 launch_editor(file
, NULL
, NULL
);
295 die_errno(_("Could not stat '%s'"), file
);
297 die(_("Empty patch. Aborted."));
299 memset(&child
, 0, sizeof(child
));
301 child
.argv
= apply_argv
;
302 if (run_command(&child
))
303 die (_("Could not apply '%s'"), file
);
310 static struct lock_file lock_file
;
312 static const char ignore_error
[] =
313 N_("The following paths are ignored by one of your .gitignore files:\n");
315 static int verbose
= 0, show_only
= 0, ignored_too
= 0, refresh_only
= 0;
316 static int ignore_add_errors
, addremove
, intent_to_add
, ignore_missing
= 0;
318 static struct option builtin_add_options
[] = {
319 OPT__DRY_RUN(&show_only
, N_("dry run")),
320 OPT__VERBOSE(&verbose
, N_("be verbose")),
322 OPT_BOOLEAN('i', "interactive", &add_interactive
, N_("interactive picking")),
323 OPT_BOOLEAN('p', "patch", &patch_interactive
, N_("select hunks interactively")),
324 OPT_BOOLEAN('e', "edit", &edit_interactive
, N_("edit current diff and apply")),
325 OPT__FORCE(&ignored_too
, N_("allow adding otherwise ignored files")),
326 OPT_BOOLEAN('u', "update", &take_worktree_changes
, N_("update tracked files")),
327 OPT_BOOLEAN('N', "intent-to-add", &intent_to_add
, N_("record only the fact that the path will be added later")),
328 OPT_BOOLEAN('A', "all", &addremove
, N_("add changes from all tracked and untracked files")),
329 OPT_BOOLEAN( 0 , "refresh", &refresh_only
, N_("don't add, only refresh the index")),
330 OPT_BOOLEAN( 0 , "ignore-errors", &ignore_add_errors
, N_("just skip files which cannot be added because of errors")),
331 OPT_BOOLEAN( 0 , "ignore-missing", &ignore_missing
, N_("check if - even missing - files are ignored in dry run")),
335 static int add_config(const char *var
, const char *value
, void *cb
)
337 if (!strcmp(var
, "add.ignoreerrors") ||
338 !strcmp(var
, "add.ignore-errors")) {
339 ignore_add_errors
= git_config_bool(var
, value
);
342 return git_default_config(var
, value
, cb
);
345 static int add_files(struct dir_struct
*dir
, int flags
)
347 int i
, exit_status
= 0;
349 if (dir
->ignored_nr
) {
350 fprintf(stderr
, _(ignore_error
));
351 for (i
= 0; i
< dir
->ignored_nr
; i
++)
352 fprintf(stderr
, "%s\n", dir
->ignored
[i
]->name
);
353 fprintf(stderr
, _("Use -f if you really want to add them.\n"));
354 die(_("no files added"));
357 for (i
= 0; i
< dir
->nr
; i
++)
358 if (add_file_to_cache(dir
->entries
[i
]->name
, flags
)) {
359 if (!ignore_add_errors
)
360 die(_("adding files failed"));
366 static void warn_pathless_add(const char *option_name
, const char *short_name
) {
368 * To be consistent with "git add -p" and most Git
369 * commands, we should default to being tree-wide, but
370 * this is not the original behavior and can't be
371 * changed until users trained themselves not to type
372 * "git add -u" or "git add -A". For now, we warn and
373 * keep the old behavior. Later, this warning can be
374 * turned into a die(...), and eventually we may
375 * reallow the command with a new behavior.
377 warning(_("The behavior of 'git add %s (or %s)' with no path argument from a\n"
378 "subdirectory of the tree will change in Git 2.0 and should not be used anymore.\n"
379 "To add content for the whole tree, run:\n"
382 " (or git add %s :/)\n"
384 "To restrict the command to the current directory, run:\n"
387 " (or git add %s .)\n"
389 "With the current Git version, the command is restricted to the current directory."),
390 option_name
, short_name
,
391 option_name
, short_name
,
392 option_name
, short_name
);
395 int cmd_add(int argc
, const char **argv
, const char *prefix
)
399 const char **pathspec
;
400 struct dir_struct dir
;
403 int require_pathspec
;
405 const char *option_with_implicit_dot
= NULL
;
406 const char *short_option_with_implicit_dot
= NULL
;
408 git_config(add_config
, NULL
);
410 argc
= parse_options(argc
, argv
, prefix
, builtin_add_options
,
411 builtin_add_usage
, PARSE_OPT_KEEP_ARGV0
);
412 if (patch_interactive
)
415 exit(interactive_add(argc
- 1, argv
+ 1, prefix
, patch_interactive
));
417 if (edit_interactive
)
418 return(edit_patch(argc
, argv
, prefix
));
422 if (addremove
&& take_worktree_changes
)
423 die(_("-A and -u are mutually incompatible"));
424 if (!show_only
&& ignore_missing
)
425 die(_("Option --ignore-missing can only be used together with --dry-run"));
427 option_with_implicit_dot
= "--all";
428 short_option_with_implicit_dot
= "-A";
430 if (take_worktree_changes
) {
431 option_with_implicit_dot
= "--update";
432 short_option_with_implicit_dot
= "-u";
434 if (option_with_implicit_dot
&& !argc
) {
435 static const char *here
[2] = { ".", NULL
};
437 warn_pathless_add(option_with_implicit_dot
,
438 short_option_with_implicit_dot
);
443 add_new_files
= !take_worktree_changes
&& !refresh_only
;
444 require_pathspec
= !take_worktree_changes
;
446 newfd
= hold_locked_index(&lock_file
, 1);
448 flags
= ((verbose
? ADD_CACHE_VERBOSE
: 0) |
449 (show_only
? ADD_CACHE_PRETEND
: 0) |
450 (intent_to_add
? ADD_CACHE_INTENT
: 0) |
451 (ignore_add_errors
? ADD_CACHE_IGNORE_ERRORS
: 0) |
452 (!(addremove
|| take_worktree_changes
)
453 ? ADD_CACHE_IGNORE_REMOVAL
: 0));
455 if (require_pathspec
&& argc
== 0) {
456 fprintf(stderr
, _("Nothing specified, nothing added.\n"));
457 fprintf(stderr
, _("Maybe you wanted to say 'git add .'?\n"));
460 pathspec
= validate_pathspec(argc
, argv
, prefix
);
462 if (read_cache() < 0)
463 die(_("index file corrupt"));
464 treat_gitlinks(pathspec
);
469 /* Set up the default git porcelain excludes */
470 memset(&dir
, 0, sizeof(dir
));
472 dir
.flags
|= DIR_COLLECT_IGNORED
;
473 setup_standard_excludes(&dir
);
476 /* This picks up the paths that are not tracked */
477 baselen
= fill_directory(&dir
, pathspec
);
479 seen
= prune_directory(&dir
, pathspec
, baselen
);
483 refresh(verbose
, pathspec
);
489 struct path_exclude_check check
;
491 path_exclude_check_init(&check
, &dir
);
493 seen
= find_used_pathspec(pathspec
);
494 for (i
= 0; pathspec
[i
]; i
++) {
495 if (!seen
[i
] && pathspec
[i
][0]
496 && !file_exists(pathspec
[i
])) {
497 if (ignore_missing
) {
498 int dtype
= DT_UNKNOWN
;
499 if (path_excluded(&check
, pathspec
[i
], -1, &dtype
))
500 dir_add_ignored(&dir
, pathspec
[i
], strlen(pathspec
[i
]));
502 die(_("pathspec '%s' did not match any files"),
507 path_exclude_check_clear(&check
);
512 exit_status
|= add_files_to_cache(prefix
, pathspec
, flags
);
515 exit_status
|= add_files(&dir
, flags
);
517 unplug_bulk_checkin();
520 if (active_cache_changed
) {
521 if (write_cache(newfd
, active_cache
, active_nr
) ||
522 commit_locked_index(&lock_file
))
523 die(_("Unable to write new index file"));