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 "git add [options] [--] <filepattern>...",
23 static int patch_interactive
, add_interactive
, edit_interactive
;
24 static int take_worktree_changes
;
26 struct update_callback_data
{
31 static int fix_unmerged_status(struct diff_filepair
*p
,
32 struct update_callback_data
*data
)
34 if (p
->status
!= DIFF_STATUS_UNMERGED
)
36 if (!(data
->flags
& ADD_CACHE_IGNORE_REMOVAL
) && !p
->two
->mode
)
38 * This is not an explicit add request, and the
39 * path is missing from the working tree (deleted)
41 return DIFF_STATUS_DELETED
;
44 * Either an explicit add request, or path exists
45 * in the working tree. An attempt to explicitly
46 * add a path that does not exist in the working tree
47 * will be caught as an error by the caller immediately.
49 return DIFF_STATUS_MODIFIED
;
52 static void update_callback(struct diff_queue_struct
*q
,
53 struct diff_options
*opt
, void *cbdata
)
56 struct update_callback_data
*data
= cbdata
;
58 for (i
= 0; i
< q
->nr
; i
++) {
59 struct diff_filepair
*p
= q
->queue
[i
];
60 const char *path
= p
->one
->path
;
61 switch (fix_unmerged_status(p
, data
)) {
63 die(_("unexpected diff status %c"), p
->status
);
64 case DIFF_STATUS_MODIFIED
:
65 case DIFF_STATUS_TYPE_CHANGED
:
66 if (add_file_to_index(&the_index
, path
, data
->flags
)) {
67 if (!(data
->flags
& ADD_CACHE_IGNORE_ERRORS
))
68 die(_("updating files failed"));
72 case DIFF_STATUS_DELETED
:
73 if (data
->flags
& ADD_CACHE_IGNORE_REMOVAL
)
75 if (!(data
->flags
& ADD_CACHE_PRETEND
))
76 remove_file_from_index(&the_index
, path
);
77 if (data
->flags
& (ADD_CACHE_PRETEND
|ADD_CACHE_VERBOSE
))
78 printf(_("remove '%s'\n"), path
);
84 int add_files_to_cache(const char *prefix
, const char **pathspec
, int flags
)
86 struct update_callback_data data
;
88 init_revisions(&rev
, prefix
);
89 setup_revisions(0, NULL
, &rev
, NULL
);
90 init_pathspec(&rev
.prune_data
, pathspec
);
91 rev
.diffopt
.output_format
= DIFF_FORMAT_CALLBACK
;
92 rev
.diffopt
.format_callback
= update_callback
;
95 rev
.diffopt
.format_callback_data
= &data
;
96 rev
.max_count
= 0; /* do not compare unmerged paths with stage #2 */
97 run_diff_files(&rev
, DIFF_RACY_IS_MODIFIED
);
98 return !!data
.add_errors
;
101 static char *prune_directory(struct dir_struct
*dir
, const char **pathspec
, int prefix
)
105 struct dir_entry
**src
, **dst
;
107 for (specs
= 0; pathspec
[specs
]; specs
++)
109 seen
= xcalloc(specs
, 1);
111 src
= dst
= dir
->entries
;
114 struct dir_entry
*entry
= *src
++;
115 if (match_pathspec(pathspec
, entry
->name
, entry
->len
,
119 dir
->nr
= dst
- dir
->entries
;
120 add_pathspec_matches_against_index(pathspec
, seen
, specs
);
125 * Checks the index to see whether any path in pathspec refers to
126 * something inside a submodule. If so, dies with an error message.
128 static void treat_gitlinks(const char **pathspec
)
132 if (!pathspec
|| !*pathspec
)
135 for (i
= 0; pathspec
[i
]; i
++)
136 pathspec
[i
] = check_path_for_gitlink(pathspec
[i
]);
139 static void refresh(int verbose
, const char **pathspec
)
144 for (specs
= 0; pathspec
[specs
]; specs
++)
146 seen
= xcalloc(specs
, 1);
147 refresh_index(&the_index
, verbose
? REFRESH_IN_PORCELAIN
: REFRESH_QUIET
,
148 pathspec
, seen
, _("Unstaged changes after refreshing the index:"));
149 for (i
= 0; i
< specs
; i
++) {
151 die(_("pathspec '%s' did not match any files"), pathspec
[i
]);
156 static const char **validate_pathspec(const char **argv
, const char *prefix
)
158 const char **pathspec
= get_pathspec(prefix
, argv
);
162 for (p
= pathspec
; *p
; p
++) {
163 if (has_symlink_leading_path(*p
, strlen(*p
))) {
164 int len
= prefix
? strlen(prefix
) : 0;
165 die(_("'%s' is beyond a symbolic link"), *p
+ len
);
173 int run_add_interactive(const char *revision
, const char *patch_mode
,
174 const char **pathspec
)
176 int status
, ac
, pc
= 0;
183 args
= xcalloc(sizeof(const char *), (pc
+ 5));
185 args
[ac
++] = "add--interactive";
187 args
[ac
++] = patch_mode
;
189 args
[ac
++] = revision
;
192 memcpy(&(args
[ac
]), pathspec
, sizeof(const char *) * pc
);
197 status
= run_command_v_opt(args
, RUN_GIT_CMD
);
202 int interactive_add(int argc
, const char **argv
, const char *prefix
, int patch
)
204 const char **pathspec
= NULL
;
207 pathspec
= validate_pathspec(argv
, prefix
);
212 return run_add_interactive(NULL
,
213 patch
? "--patch" : NULL
,
217 static int edit_patch(int argc
, const char **argv
, const char *prefix
)
219 char *file
= xstrdup(git_path("ADD_EDIT.patch"));
220 const char *apply_argv
[] = { "apply", "--recount", "--cached",
222 struct child_process child
;
227 apply_argv
[3] = file
;
229 git_config(git_diff_basic_config
, NULL
); /* no "diff" UI options */
231 if (read_cache() < 0)
232 die (_("Could not read the index"));
234 init_revisions(&rev
, prefix
);
235 rev
.diffopt
.context
= 7;
237 argc
= setup_revisions(argc
, argv
, &rev
, NULL
);
238 rev
.diffopt
.output_format
= DIFF_FORMAT_PATCH
;
239 DIFF_OPT_SET(&rev
.diffopt
, IGNORE_DIRTY_SUBMODULES
);
240 out
= open(file
, O_CREAT
| O_WRONLY
, 0666);
242 die (_("Could not open '%s' for writing."), file
);
243 rev
.diffopt
.file
= xfdopen(out
, "w");
244 rev
.diffopt
.close_file
= 1;
245 if (run_diff_files(&rev
, 0))
246 die (_("Could not write patch"));
248 launch_editor(file
, NULL
, NULL
);
251 die_errno(_("Could not stat '%s'"), file
);
253 die(_("Empty patch. Aborted."));
255 memset(&child
, 0, sizeof(child
));
257 child
.argv
= apply_argv
;
258 if (run_command(&child
))
259 die (_("Could not apply '%s'"), file
);
265 static struct lock_file lock_file
;
267 static const char ignore_error
[] =
268 N_("The following paths are ignored by one of your .gitignore files:\n");
270 static int verbose
= 0, show_only
= 0, ignored_too
= 0, refresh_only
= 0;
271 static int ignore_add_errors
, addremove
, intent_to_add
, ignore_missing
= 0;
273 static struct option builtin_add_options
[] = {
274 OPT__DRY_RUN(&show_only
, "dry run"),
275 OPT__VERBOSE(&verbose
, "be verbose"),
277 OPT_BOOLEAN('i', "interactive", &add_interactive
, "interactive picking"),
278 OPT_BOOLEAN('p', "patch", &patch_interactive
, "select hunks interactively"),
279 OPT_BOOLEAN('e', "edit", &edit_interactive
, "edit current diff and apply"),
280 OPT__FORCE(&ignored_too
, "allow adding otherwise ignored files"),
281 OPT_BOOLEAN('u', "update", &take_worktree_changes
, "update tracked files"),
282 OPT_BOOLEAN('N', "intent-to-add", &intent_to_add
, "record only the fact that the path will be added later"),
283 OPT_BOOLEAN('A', "all", &addremove
, "add changes from all tracked and untracked files"),
284 OPT_BOOLEAN( 0 , "refresh", &refresh_only
, "don't add, only refresh the index"),
285 OPT_BOOLEAN( 0 , "ignore-errors", &ignore_add_errors
, "just skip files which cannot be added because of errors"),
286 OPT_BOOLEAN( 0 , "ignore-missing", &ignore_missing
, "check if - even missing - files are ignored in dry run"),
290 static int add_config(const char *var
, const char *value
, void *cb
)
292 if (!strcmp(var
, "add.ignoreerrors") ||
293 !strcmp(var
, "add.ignore-errors")) {
294 ignore_add_errors
= git_config_bool(var
, value
);
297 return git_default_config(var
, value
, cb
);
300 static int add_files(struct dir_struct
*dir
, int flags
)
302 int i
, exit_status
= 0;
304 if (dir
->ignored_nr
) {
305 fprintf(stderr
, _(ignore_error
));
306 for (i
= 0; i
< dir
->ignored_nr
; i
++)
307 fprintf(stderr
, "%s\n", dir
->ignored
[i
]->name
);
308 fprintf(stderr
, _("Use -f if you really want to add them.\n"));
309 die(_("no files added"));
312 for (i
= 0; i
< dir
->nr
; i
++)
313 if (add_file_to_cache(dir
->entries
[i
]->name
, flags
)) {
314 if (!ignore_add_errors
)
315 die(_("adding files failed"));
321 int cmd_add(int argc
, const char **argv
, const char *prefix
)
325 const char **pathspec
;
326 struct dir_struct dir
;
329 int require_pathspec
;
332 git_config(add_config
, NULL
);
334 argc
= parse_options(argc
, argv
, prefix
, builtin_add_options
,
335 builtin_add_usage
, PARSE_OPT_KEEP_ARGV0
);
336 if (patch_interactive
)
339 exit(interactive_add(argc
- 1, argv
+ 1, prefix
, patch_interactive
));
341 if (edit_interactive
)
342 return(edit_patch(argc
, argv
, prefix
));
346 if (addremove
&& take_worktree_changes
)
347 die(_("-A and -u are mutually incompatible"));
348 if (!show_only
&& ignore_missing
)
349 die(_("Option --ignore-missing can only be used together with --dry-run"));
350 if ((addremove
|| take_worktree_changes
) && !argc
) {
351 static const char *here
[2] = { ".", NULL
};
356 add_new_files
= !take_worktree_changes
&& !refresh_only
;
357 require_pathspec
= !take_worktree_changes
;
359 newfd
= hold_locked_index(&lock_file
, 1);
361 flags
= ((verbose
? ADD_CACHE_VERBOSE
: 0) |
362 (show_only
? ADD_CACHE_PRETEND
: 0) |
363 (intent_to_add
? ADD_CACHE_INTENT
: 0) |
364 (ignore_add_errors
? ADD_CACHE_IGNORE_ERRORS
: 0) |
365 (!(addremove
|| take_worktree_changes
)
366 ? ADD_CACHE_IGNORE_REMOVAL
: 0));
368 if (require_pathspec
&& argc
== 0) {
369 fprintf(stderr
, _("Nothing specified, nothing added.\n"));
370 fprintf(stderr
, _("Maybe you wanted to say 'git add .'?\n"));
373 pathspec
= validate_pathspec(argv
, prefix
);
375 if (read_cache() < 0)
376 die(_("index file corrupt"));
377 treat_gitlinks(pathspec
);
382 /* Set up the default git porcelain excludes */
383 memset(&dir
, 0, sizeof(dir
));
385 dir
.flags
|= DIR_COLLECT_IGNORED
;
386 setup_standard_excludes(&dir
);
389 /* This picks up the paths that are not tracked */
390 baselen
= fill_directory(&dir
, pathspec
);
392 seen
= prune_directory(&dir
, pathspec
, baselen
);
396 refresh(verbose
, pathspec
);
402 struct path_exclude_check check
;
404 path_exclude_check_init(&check
, &dir
);
406 seen
= find_pathspecs_matching_against_index(pathspec
);
407 for (i
= 0; pathspec
[i
]; i
++) {
408 if (!seen
[i
] && pathspec
[i
][0]
409 && !file_exists(pathspec
[i
])) {
410 if (ignore_missing
) {
411 int dtype
= DT_UNKNOWN
;
412 if (is_path_excluded(&check
, pathspec
[i
], -1, &dtype
))
413 dir_add_ignored(&dir
, pathspec
[i
], strlen(pathspec
[i
]));
415 die(_("pathspec '%s' did not match any files"),
420 path_exclude_check_clear(&check
);
425 exit_status
|= add_files_to_cache(prefix
, pathspec
, flags
);
428 exit_status
|= add_files(&dir
, flags
);
430 unplug_bulk_checkin();
433 if (active_cache_changed
) {
434 if (write_cache(newfd
, active_cache
, active_nr
) ||
435 commit_locked_index(&lock_file
))
436 die(_("Unable to write new index file"));