Merge branch 'jt/http-redact-cookies' into maint
[git.git] / builtin / add.c
blobbf01d89e28eaef0f8113d42c6b9d4142b8e912e4
1 /*
2 * "git add" builtin command
4 * Copyright (C) 2006 Linus Torvalds
5 */
6 #include "cache.h"
7 #include "config.h"
8 #include "builtin.h"
9 #include "lockfile.h"
10 #include "dir.h"
11 #include "pathspec.h"
12 #include "exec_cmd.h"
13 #include "cache-tree.h"
14 #include "run-command.h"
15 #include "parse-options.h"
16 #include "diff.h"
17 #include "diffcore.h"
18 #include "revision.h"
19 #include "bulk-checkin.h"
20 #include "argv-array.h"
21 #include "submodule.h"
23 static const char * const builtin_add_usage[] = {
24 N_("git add [<options>] [--] <pathspec>..."),
25 NULL
27 static int patch_interactive, add_interactive, edit_interactive;
28 static int take_worktree_changes;
29 static int add_renormalize;
31 struct update_callback_data {
32 int flags;
33 int add_errors;
36 static void chmod_pathspec(struct pathspec *pathspec, char flip)
38 int i;
40 for (i = 0; i < active_nr; i++) {
41 struct cache_entry *ce = active_cache[i];
43 if (pathspec && !ce_path_match(ce, pathspec, NULL))
44 continue;
46 if (chmod_cache_entry(ce, flip) < 0)
47 fprintf(stderr, "cannot chmod %cx '%s'\n", flip, ce->name);
51 static int fix_unmerged_status(struct diff_filepair *p,
52 struct update_callback_data *data)
54 if (p->status != DIFF_STATUS_UNMERGED)
55 return p->status;
56 if (!(data->flags & ADD_CACHE_IGNORE_REMOVAL) && !p->two->mode)
58 * This is not an explicit add request, and the
59 * path is missing from the working tree (deleted)
61 return DIFF_STATUS_DELETED;
62 else
64 * Either an explicit add request, or path exists
65 * in the working tree. An attempt to explicitly
66 * add a path that does not exist in the working tree
67 * will be caught as an error by the caller immediately.
69 return DIFF_STATUS_MODIFIED;
72 static void update_callback(struct diff_queue_struct *q,
73 struct diff_options *opt, void *cbdata)
75 int i;
76 struct update_callback_data *data = cbdata;
78 for (i = 0; i < q->nr; i++) {
79 struct diff_filepair *p = q->queue[i];
80 const char *path = p->one->path;
81 switch (fix_unmerged_status(p, data)) {
82 default:
83 die(_("unexpected diff status %c"), p->status);
84 case DIFF_STATUS_MODIFIED:
85 case DIFF_STATUS_TYPE_CHANGED:
86 if (add_file_to_index(&the_index, path, data->flags)) {
87 if (!(data->flags & ADD_CACHE_IGNORE_ERRORS))
88 die(_("updating files failed"));
89 data->add_errors++;
91 break;
92 case DIFF_STATUS_DELETED:
93 if (data->flags & ADD_CACHE_IGNORE_REMOVAL)
94 break;
95 if (!(data->flags & ADD_CACHE_PRETEND))
96 remove_file_from_index(&the_index, path);
97 if (data->flags & (ADD_CACHE_PRETEND|ADD_CACHE_VERBOSE))
98 printf(_("remove '%s'\n"), path);
99 break;
104 int add_files_to_cache(const char *prefix,
105 const struct pathspec *pathspec, int flags)
107 struct update_callback_data data;
108 struct rev_info rev;
110 memset(&data, 0, sizeof(data));
111 data.flags = flags;
113 init_revisions(&rev, prefix);
114 setup_revisions(0, NULL, &rev, NULL);
115 if (pathspec)
116 copy_pathspec(&rev.prune_data, pathspec);
117 rev.diffopt.output_format = DIFF_FORMAT_CALLBACK;
118 rev.diffopt.format_callback = update_callback;
119 rev.diffopt.format_callback_data = &data;
120 rev.diffopt.flags.override_submodule_config = 1;
121 rev.max_count = 0; /* do not compare unmerged paths with stage #2 */
122 run_diff_files(&rev, DIFF_RACY_IS_MODIFIED);
123 clear_pathspec(&rev.prune_data);
124 return !!data.add_errors;
127 static int renormalize_tracked_files(const struct pathspec *pathspec, int flags)
129 int i, retval = 0;
131 for (i = 0; i < active_nr; i++) {
132 struct cache_entry *ce = active_cache[i];
134 if (ce_stage(ce))
135 continue; /* do not touch unmerged paths */
136 if (!S_ISREG(ce->ce_mode) && !S_ISLNK(ce->ce_mode))
137 continue; /* do not touch non blobs */
138 if (pathspec && !ce_path_match(ce, pathspec, NULL))
139 continue;
140 retval |= add_file_to_cache(ce->name, flags | HASH_RENORMALIZE);
143 return retval;
146 static char *prune_directory(struct dir_struct *dir, struct pathspec *pathspec, int prefix)
148 char *seen;
149 int i;
150 struct dir_entry **src, **dst;
152 seen = xcalloc(pathspec->nr, 1);
154 src = dst = dir->entries;
155 i = dir->nr;
156 while (--i >= 0) {
157 struct dir_entry *entry = *src++;
158 if (dir_path_match(entry, pathspec, prefix, seen))
159 *dst++ = entry;
161 dir->nr = dst - dir->entries;
162 add_pathspec_matches_against_index(pathspec, &the_index, seen);
163 return seen;
166 static void refresh(int verbose, const struct pathspec *pathspec)
168 char *seen;
169 int i;
171 seen = xcalloc(pathspec->nr, 1);
172 refresh_index(&the_index, verbose ? REFRESH_IN_PORCELAIN : REFRESH_QUIET,
173 pathspec, seen, _("Unstaged changes after refreshing the index:"));
174 for (i = 0; i < pathspec->nr; i++) {
175 if (!seen[i])
176 die(_("pathspec '%s' did not match any files"),
177 pathspec->items[i].match);
179 free(seen);
182 int run_add_interactive(const char *revision, const char *patch_mode,
183 const struct pathspec *pathspec)
185 int status, i;
186 struct argv_array argv = ARGV_ARRAY_INIT;
188 argv_array_push(&argv, "add--interactive");
189 if (patch_mode)
190 argv_array_push(&argv, patch_mode);
191 if (revision)
192 argv_array_push(&argv, revision);
193 argv_array_push(&argv, "--");
194 for (i = 0; i < pathspec->nr; i++)
195 /* pass original pathspec, to be re-parsed */
196 argv_array_push(&argv, pathspec->items[i].original);
198 status = run_command_v_opt(argv.argv, RUN_GIT_CMD);
199 argv_array_clear(&argv);
200 return status;
203 int interactive_add(int argc, const char **argv, const char *prefix, int patch)
205 struct pathspec pathspec;
207 parse_pathspec(&pathspec, 0,
208 PATHSPEC_PREFER_FULL |
209 PATHSPEC_SYMLINK_LEADING_PATH |
210 PATHSPEC_PREFIX_ORIGIN,
211 prefix, argv);
213 return run_add_interactive(NULL,
214 patch ? "--patch" : NULL,
215 &pathspec);
218 static int edit_patch(int argc, const char **argv, const char *prefix)
220 char *file = git_pathdup("ADD_EDIT.patch");
221 const char *apply_argv[] = { "apply", "--recount", "--cached",
222 NULL, NULL };
223 struct child_process child = CHILD_PROCESS_INIT;
224 struct rev_info rev;
225 int out;
226 struct stat st;
228 apply_argv[3] = file;
230 git_config(git_diff_basic_config, NULL); /* no "diff" UI options */
232 if (read_cache() < 0)
233 die(_("Could not read the index"));
235 init_revisions(&rev, prefix);
236 rev.diffopt.context = 7;
238 argc = setup_revisions(argc, argv, &rev, NULL);
239 rev.diffopt.output_format = DIFF_FORMAT_PATCH;
240 rev.diffopt.use_color = 0;
241 rev.diffopt.flags.ignore_dirty_submodules = 1;
242 out = open(file, O_CREAT | O_WRONLY, 0666);
243 if (out < 0)
244 die(_("Could not open '%s' for writing."), file);
245 rev.diffopt.file = xfdopen(out, "w");
246 rev.diffopt.close_file = 1;
247 if (run_diff_files(&rev, 0))
248 die(_("Could not write patch"));
250 if (launch_editor(file, NULL, NULL))
251 die(_("editing patch failed"));
253 if (stat(file, &st))
254 die_errno(_("Could not stat '%s'"), file);
255 if (!st.st_size)
256 die(_("Empty patch. Aborted."));
258 child.git_cmd = 1;
259 child.argv = apply_argv;
260 if (run_command(&child))
261 die(_("Could not apply '%s'"), file);
263 unlink(file);
264 free(file);
265 return 0;
268 static struct lock_file lock_file;
270 static const char ignore_error[] =
271 N_("The following paths are ignored by one of your .gitignore files:\n");
273 static int verbose, show_only, ignored_too, refresh_only;
274 static int ignore_add_errors, intent_to_add, ignore_missing;
275 static int warn_on_embedded_repo = 1;
277 #define ADDREMOVE_DEFAULT 1
278 static int addremove = ADDREMOVE_DEFAULT;
279 static int addremove_explicit = -1; /* unspecified */
281 static char *chmod_arg;
283 static int ignore_removal_cb(const struct option *opt, const char *arg, int unset)
285 /* if we are told to ignore, we are not adding removals */
286 *(int *)opt->value = !unset ? 0 : 1;
287 return 0;
290 static struct option builtin_add_options[] = {
291 OPT__DRY_RUN(&show_only, N_("dry run")),
292 OPT__VERBOSE(&verbose, N_("be verbose")),
293 OPT_GROUP(""),
294 OPT_BOOL('i', "interactive", &add_interactive, N_("interactive picking")),
295 OPT_BOOL('p', "patch", &patch_interactive, N_("select hunks interactively")),
296 OPT_BOOL('e', "edit", &edit_interactive, N_("edit current diff and apply")),
297 OPT__FORCE(&ignored_too, N_("allow adding otherwise ignored files")),
298 OPT_BOOL('u', "update", &take_worktree_changes, N_("update tracked files")),
299 OPT_BOOL(0, "renormalize", &add_renormalize, N_("renormalize EOL of tracked files (implies -u)")),
300 OPT_BOOL('N', "intent-to-add", &intent_to_add, N_("record only the fact that the path will be added later")),
301 OPT_BOOL('A', "all", &addremove_explicit, N_("add changes from all tracked and untracked files")),
302 { OPTION_CALLBACK, 0, "ignore-removal", &addremove_explicit,
303 NULL /* takes no arguments */,
304 N_("ignore paths removed in the working tree (same as --no-all)"),
305 PARSE_OPT_NOARG, ignore_removal_cb },
306 OPT_BOOL( 0 , "refresh", &refresh_only, N_("don't add, only refresh the index")),
307 OPT_BOOL( 0 , "ignore-errors", &ignore_add_errors, N_("just skip files which cannot be added because of errors")),
308 OPT_BOOL( 0 , "ignore-missing", &ignore_missing, N_("check if - even missing - files are ignored in dry run")),
309 OPT_STRING( 0 , "chmod", &chmod_arg, N_("(+/-)x"), N_("override the executable bit of the listed files")),
310 OPT_HIDDEN_BOOL(0, "warn-embedded-repo", &warn_on_embedded_repo,
311 N_("warn when adding an embedded repository")),
312 OPT_END(),
315 static int add_config(const char *var, const char *value, void *cb)
317 if (!strcmp(var, "add.ignoreerrors") ||
318 !strcmp(var, "add.ignore-errors")) {
319 ignore_add_errors = git_config_bool(var, value);
320 return 0;
322 return git_default_config(var, value, cb);
325 static const char embedded_advice[] = N_(
326 "You've added another git repository inside your current repository.\n"
327 "Clones of the outer repository will not contain the contents of\n"
328 "the embedded repository and will not know how to obtain it.\n"
329 "If you meant to add a submodule, use:\n"
330 "\n"
331 " git submodule add <url> %s\n"
332 "\n"
333 "If you added this path by mistake, you can remove it from the\n"
334 "index with:\n"
335 "\n"
336 " git rm --cached %s\n"
337 "\n"
338 "See \"git help submodule\" for more information."
341 static void check_embedded_repo(const char *path)
343 struct strbuf name = STRBUF_INIT;
345 if (!warn_on_embedded_repo)
346 return;
347 if (!ends_with(path, "/"))
348 return;
350 /* Drop trailing slash for aesthetics */
351 strbuf_addstr(&name, path);
352 strbuf_strip_suffix(&name, "/");
354 warning(_("adding embedded git repository: %s"), name.buf);
355 if (advice_add_embedded_repo) {
356 advise(embedded_advice, name.buf, name.buf);
357 /* there may be multiple entries; advise only once */
358 advice_add_embedded_repo = 0;
361 strbuf_release(&name);
364 static int add_files(struct dir_struct *dir, int flags)
366 int i, exit_status = 0;
368 if (dir->ignored_nr) {
369 fprintf(stderr, _(ignore_error));
370 for (i = 0; i < dir->ignored_nr; i++)
371 fprintf(stderr, "%s\n", dir->ignored[i]->name);
372 fprintf(stderr, _("Use -f if you really want to add them.\n"));
373 exit_status = 1;
376 for (i = 0; i < dir->nr; i++) {
377 check_embedded_repo(dir->entries[i]->name);
378 if (add_file_to_index(&the_index, dir->entries[i]->name, flags)) {
379 if (!ignore_add_errors)
380 die(_("adding files failed"));
381 exit_status = 1;
384 return exit_status;
387 int cmd_add(int argc, const char **argv, const char *prefix)
389 int exit_status = 0;
390 struct pathspec pathspec;
391 struct dir_struct dir;
392 int flags;
393 int add_new_files;
394 int require_pathspec;
395 char *seen = NULL;
397 git_config(add_config, NULL);
399 argc = parse_options(argc, argv, prefix, builtin_add_options,
400 builtin_add_usage, PARSE_OPT_KEEP_ARGV0);
401 if (patch_interactive)
402 add_interactive = 1;
403 if (add_interactive)
404 exit(interactive_add(argc - 1, argv + 1, prefix, patch_interactive));
406 if (edit_interactive)
407 return(edit_patch(argc, argv, prefix));
408 argc--;
409 argv++;
411 if (0 <= addremove_explicit)
412 addremove = addremove_explicit;
413 else if (take_worktree_changes && ADDREMOVE_DEFAULT)
414 addremove = 0; /* "-u" was given but not "-A" */
416 if (addremove && take_worktree_changes)
417 die(_("-A and -u are mutually incompatible"));
419 if (!take_worktree_changes && addremove_explicit < 0 && argc)
420 /* Turn "git add pathspec..." to "git add -A pathspec..." */
421 addremove = 1;
423 if (!show_only && ignore_missing)
424 die(_("Option --ignore-missing can only be used together with --dry-run"));
426 if (chmod_arg && ((chmod_arg[0] != '-' && chmod_arg[0] != '+') ||
427 chmod_arg[1] != 'x' || chmod_arg[2]))
428 die(_("--chmod param '%s' must be either -x or +x"), chmod_arg);
430 add_new_files = !take_worktree_changes && !refresh_only && !add_renormalize;
431 require_pathspec = !(take_worktree_changes || (0 < addremove_explicit));
433 hold_locked_index(&lock_file, LOCK_DIE_ON_ERROR);
435 flags = ((verbose ? ADD_CACHE_VERBOSE : 0) |
436 (show_only ? ADD_CACHE_PRETEND : 0) |
437 (intent_to_add ? ADD_CACHE_INTENT : 0) |
438 (ignore_add_errors ? ADD_CACHE_IGNORE_ERRORS : 0) |
439 (!(addremove || take_worktree_changes)
440 ? ADD_CACHE_IGNORE_REMOVAL : 0));
442 if (require_pathspec && argc == 0) {
443 fprintf(stderr, _("Nothing specified, nothing added.\n"));
444 fprintf(stderr, _("Maybe you wanted to say 'git add .'?\n"));
445 return 0;
448 if (read_cache() < 0)
449 die(_("index file corrupt"));
451 die_in_unpopulated_submodule(&the_index, prefix);
454 * Check the "pathspec '%s' did not match any files" block
455 * below before enabling new magic.
457 parse_pathspec(&pathspec, 0,
458 PATHSPEC_PREFER_FULL |
459 PATHSPEC_SYMLINK_LEADING_PATH,
460 prefix, argv);
462 die_path_inside_submodule(&the_index, &pathspec);
464 if (add_new_files) {
465 int baselen;
467 /* Set up the default git porcelain excludes */
468 memset(&dir, 0, sizeof(dir));
469 if (!ignored_too) {
470 dir.flags |= DIR_COLLECT_IGNORED;
471 setup_standard_excludes(&dir);
474 /* This picks up the paths that are not tracked */
475 baselen = fill_directory(&dir, &the_index, &pathspec);
476 if (pathspec.nr)
477 seen = prune_directory(&dir, &pathspec, baselen);
480 if (refresh_only) {
481 refresh(verbose, &pathspec);
482 goto finish;
485 if (pathspec.nr) {
486 int i;
488 if (!seen)
489 seen = find_pathspecs_matching_against_index(&pathspec, &the_index);
492 * file_exists() assumes exact match
494 GUARD_PATHSPEC(&pathspec,
495 PATHSPEC_FROMTOP |
496 PATHSPEC_LITERAL |
497 PATHSPEC_GLOB |
498 PATHSPEC_ICASE |
499 PATHSPEC_EXCLUDE);
501 for (i = 0; i < pathspec.nr; i++) {
502 const char *path = pathspec.items[i].match;
503 if (pathspec.items[i].magic & PATHSPEC_EXCLUDE)
504 continue;
505 if (!seen[i] && path[0] &&
506 ((pathspec.items[i].magic &
507 (PATHSPEC_GLOB | PATHSPEC_ICASE)) ||
508 !file_exists(path))) {
509 if (ignore_missing) {
510 int dtype = DT_UNKNOWN;
511 if (is_excluded(&dir, &the_index, path, &dtype))
512 dir_add_ignored(&dir, &the_index,
513 path, pathspec.items[i].len);
514 } else
515 die(_("pathspec '%s' did not match any files"),
516 pathspec.items[i].original);
519 free(seen);
522 plug_bulk_checkin();
524 if (add_renormalize)
525 exit_status |= renormalize_tracked_files(&pathspec, flags);
526 else
527 exit_status |= add_files_to_cache(prefix, &pathspec, flags);
529 if (add_new_files)
530 exit_status |= add_files(&dir, flags);
532 if (chmod_arg && pathspec.nr)
533 chmod_pathspec(&pathspec, chmod_arg[0]);
534 unplug_bulk_checkin();
536 finish:
537 if (active_cache_changed) {
538 if (write_locked_index(&the_index, &lock_file, COMMIT_LOCK))
539 die(_("Unable to write new index file"));
542 UNLEAK(pathspec);
543 UNLEAK(dir);
544 return exit_status;