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
);
124 static void treat_gitlinks(const char **pathspec
)
128 if (!pathspec
|| !*pathspec
)
131 for (i
= 0; i
< active_nr
; i
++) {
132 struct cache_entry
*ce
= active_cache
[i
];
133 if (S_ISGITLINK(ce
->ce_mode
)) {
134 int len
= ce_namelen(ce
), j
;
135 for (j
= 0; pathspec
[j
]; j
++) {
136 int len2
= strlen(pathspec
[j
]);
137 if (len2
<= len
|| pathspec
[j
][len
] != '/' ||
138 memcmp(ce
->name
, pathspec
[j
], len
))
141 /* strip trailing slash */
142 pathspec
[j
] = xstrndup(ce
->name
, len
);
144 die (_("Path '%s' is in submodule '%.*s'"),
145 pathspec
[j
], len
, ce
->name
);
151 static void refresh(int verbose
, const char **pathspec
)
156 for (specs
= 0; pathspec
[specs
]; specs
++)
158 seen
= xcalloc(specs
, 1);
159 refresh_index(&the_index
, verbose
? REFRESH_IN_PORCELAIN
: REFRESH_QUIET
,
160 pathspec
, seen
, _("Unstaged changes after refreshing the index:"));
161 for (i
= 0; i
< specs
; i
++) {
163 die(_("pathspec '%s' did not match any files"), pathspec
[i
]);
168 static const char **validate_pathspec(const char **argv
, const char *prefix
)
170 const char **pathspec
= get_pathspec(prefix
, argv
);
174 for (p
= pathspec
; *p
; p
++) {
175 if (has_symlink_leading_path(*p
, strlen(*p
))) {
176 int len
= prefix
? strlen(prefix
) : 0;
177 die(_("'%s' is beyond a symbolic link"), *p
+ len
);
185 int run_add_interactive(const char *revision
, const char *patch_mode
,
186 const char **pathspec
)
188 int status
, ac
, pc
= 0;
195 args
= xcalloc(sizeof(const char *), (pc
+ 5));
197 args
[ac
++] = "add--interactive";
199 args
[ac
++] = patch_mode
;
201 args
[ac
++] = revision
;
204 memcpy(&(args
[ac
]), pathspec
, sizeof(const char *) * pc
);
209 status
= run_command_v_opt(args
, RUN_GIT_CMD
);
214 int interactive_add(int argc
, const char **argv
, const char *prefix
, int patch
)
216 const char **pathspec
= NULL
;
219 pathspec
= validate_pathspec(argv
, prefix
);
224 return run_add_interactive(NULL
,
225 patch
? "--patch" : NULL
,
229 static int edit_patch(int argc
, const char **argv
, const char *prefix
)
231 char *file
= xstrdup(git_path("ADD_EDIT.patch"));
232 const char *apply_argv
[] = { "apply", "--recount", "--cached",
234 struct child_process child
;
239 apply_argv
[3] = file
;
241 git_config(git_diff_basic_config
, NULL
); /* no "diff" UI options */
243 if (read_cache() < 0)
244 die (_("Could not read the index"));
246 init_revisions(&rev
, prefix
);
247 rev
.diffopt
.context
= 7;
249 argc
= setup_revisions(argc
, argv
, &rev
, NULL
);
250 rev
.diffopt
.output_format
= DIFF_FORMAT_PATCH
;
251 DIFF_OPT_SET(&rev
.diffopt
, IGNORE_DIRTY_SUBMODULES
);
252 out
= open(file
, O_CREAT
| O_WRONLY
, 0666);
254 die (_("Could not open '%s' for writing."), file
);
255 rev
.diffopt
.file
= xfdopen(out
, "w");
256 rev
.diffopt
.close_file
= 1;
257 if (run_diff_files(&rev
, 0))
258 die (_("Could not write patch"));
260 launch_editor(file
, NULL
, NULL
);
263 die_errno(_("Could not stat '%s'"), file
);
265 die(_("Empty patch. Aborted."));
267 memset(&child
, 0, sizeof(child
));
269 child
.argv
= apply_argv
;
270 if (run_command(&child
))
271 die (_("Could not apply '%s'"), file
);
277 static struct lock_file lock_file
;
279 static const char ignore_error
[] =
280 N_("The following paths are ignored by one of your .gitignore files:\n");
282 static int verbose
= 0, show_only
= 0, ignored_too
= 0, refresh_only
= 0;
283 static int ignore_add_errors
, addremove
, intent_to_add
, ignore_missing
= 0;
285 static struct option builtin_add_options
[] = {
286 OPT__DRY_RUN(&show_only
, "dry run"),
287 OPT__VERBOSE(&verbose
, "be verbose"),
289 OPT_BOOLEAN('i', "interactive", &add_interactive
, "interactive picking"),
290 OPT_BOOLEAN('p', "patch", &patch_interactive
, "select hunks interactively"),
291 OPT_BOOLEAN('e', "edit", &edit_interactive
, "edit current diff and apply"),
292 OPT__FORCE(&ignored_too
, "allow adding otherwise ignored files"),
293 OPT_BOOLEAN('u', "update", &take_worktree_changes
, "update tracked files"),
294 OPT_BOOLEAN('N', "intent-to-add", &intent_to_add
, "record only the fact that the path will be added later"),
295 OPT_BOOLEAN('A', "all", &addremove
, "add changes from all tracked and untracked files"),
296 OPT_BOOLEAN( 0 , "refresh", &refresh_only
, "don't add, only refresh the index"),
297 OPT_BOOLEAN( 0 , "ignore-errors", &ignore_add_errors
, "just skip files which cannot be added because of errors"),
298 OPT_BOOLEAN( 0 , "ignore-missing", &ignore_missing
, "check if - even missing - files are ignored in dry run"),
302 static int add_config(const char *var
, const char *value
, void *cb
)
304 if (!strcmp(var
, "add.ignoreerrors") ||
305 !strcmp(var
, "add.ignore-errors")) {
306 ignore_add_errors
= git_config_bool(var
, value
);
309 return git_default_config(var
, value
, cb
);
312 static int add_files(struct dir_struct
*dir
, int flags
)
314 int i
, exit_status
= 0;
316 if (dir
->ignored_nr
) {
317 fprintf(stderr
, _(ignore_error
));
318 for (i
= 0; i
< dir
->ignored_nr
; i
++)
319 fprintf(stderr
, "%s\n", dir
->ignored
[i
]->name
);
320 fprintf(stderr
, _("Use -f if you really want to add them.\n"));
321 die(_("no files added"));
324 for (i
= 0; i
< dir
->nr
; i
++)
325 if (add_file_to_cache(dir
->entries
[i
]->name
, flags
)) {
326 if (!ignore_add_errors
)
327 die(_("adding files failed"));
333 int cmd_add(int argc
, const char **argv
, const char *prefix
)
337 const char **pathspec
;
338 struct dir_struct dir
;
341 int require_pathspec
;
344 git_config(add_config
, NULL
);
346 argc
= parse_options(argc
, argv
, prefix
, builtin_add_options
,
347 builtin_add_usage
, PARSE_OPT_KEEP_ARGV0
);
348 if (patch_interactive
)
351 exit(interactive_add(argc
- 1, argv
+ 1, prefix
, patch_interactive
));
353 if (edit_interactive
)
354 return(edit_patch(argc
, argv
, prefix
));
358 if (addremove
&& take_worktree_changes
)
359 die(_("-A and -u are mutually incompatible"));
360 if (!show_only
&& ignore_missing
)
361 die(_("Option --ignore-missing can only be used together with --dry-run"));
362 if ((addremove
|| take_worktree_changes
) && !argc
) {
363 static const char *here
[2] = { ".", NULL
};
368 add_new_files
= !take_worktree_changes
&& !refresh_only
;
369 require_pathspec
= !take_worktree_changes
;
371 newfd
= hold_locked_index(&lock_file
, 1);
373 flags
= ((verbose
? ADD_CACHE_VERBOSE
: 0) |
374 (show_only
? ADD_CACHE_PRETEND
: 0) |
375 (intent_to_add
? ADD_CACHE_INTENT
: 0) |
376 (ignore_add_errors
? ADD_CACHE_IGNORE_ERRORS
: 0) |
377 (!(addremove
|| take_worktree_changes
)
378 ? ADD_CACHE_IGNORE_REMOVAL
: 0));
380 if (require_pathspec
&& argc
== 0) {
381 fprintf(stderr
, _("Nothing specified, nothing added.\n"));
382 fprintf(stderr
, _("Maybe you wanted to say 'git add .'?\n"));
385 pathspec
= validate_pathspec(argv
, prefix
);
387 if (read_cache() < 0)
388 die(_("index file corrupt"));
389 treat_gitlinks(pathspec
);
394 /* Set up the default git porcelain excludes */
395 memset(&dir
, 0, sizeof(dir
));
397 dir
.flags
|= DIR_COLLECT_IGNORED
;
398 setup_standard_excludes(&dir
);
401 /* This picks up the paths that are not tracked */
402 baselen
= fill_directory(&dir
, pathspec
);
404 seen
= prune_directory(&dir
, pathspec
, baselen
);
408 refresh(verbose
, pathspec
);
414 struct path_exclude_check check
;
416 path_exclude_check_init(&check
, &dir
);
418 seen
= find_pathspecs_matching_against_index(pathspec
);
419 for (i
= 0; pathspec
[i
]; i
++) {
420 if (!seen
[i
] && pathspec
[i
][0]
421 && !file_exists(pathspec
[i
])) {
422 if (ignore_missing
) {
423 int dtype
= DT_UNKNOWN
;
424 if (is_path_excluded(&check
, pathspec
[i
], -1, &dtype
))
425 dir_add_ignored(&dir
, pathspec
[i
], strlen(pathspec
[i
]));
427 die(_("pathspec '%s' did not match any files"),
432 path_exclude_check_clear(&check
);
437 exit_status
|= add_files_to_cache(prefix
, pathspec
, flags
);
440 exit_status
|= add_files(&dir
, flags
);
442 unplug_bulk_checkin();
445 if (active_cache_changed
) {
446 if (write_cache(newfd
, active_cache
, active_nr
) ||
447 commit_locked_index(&lock_file
))
448 die(_("Unable to write new index file"));