e1d83b69acef8d1499a507c8b21a1f62a7f40c21
[git/git.git] / builtin / add.c
1 /*
2 * "git add" builtin command
3 *
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"
22
23 static const char * const builtin_add_usage[] = {
24 N_("git add [<options>] [--] <pathspec>..."),
25 NULL
26 };
27 static int patch_interactive, add_interactive, edit_interactive;
28 static int take_worktree_changes;
29
30 struct update_callback_data {
31 int flags;
32 int add_errors;
33 };
34
35 static void chmod_pathspec(struct pathspec *pathspec, char flip)
36 {
37 int i;
38
39 for (i = 0; i < active_nr; i++) {
40 struct cache_entry *ce = active_cache[i];
41
42 if (pathspec && !ce_path_match(ce, pathspec, NULL))
43 continue;
44
45 if (chmod_cache_entry(ce, flip) < 0)
46 fprintf(stderr, "cannot chmod %cx '%s'\n", flip, ce->name);
47 }
48 }
49
50 static int fix_unmerged_status(struct diff_filepair *p,
51 struct update_callback_data *data)
52 {
53 if (p->status != DIFF_STATUS_UNMERGED)
54 return p->status;
55 if (!(data->flags & ADD_CACHE_IGNORE_REMOVAL) && !p->two->mode)
56 /*
57 * This is not an explicit add request, and the
58 * path is missing from the working tree (deleted)
59 */
60 return DIFF_STATUS_DELETED;
61 else
62 /*
63 * Either an explicit add request, or path exists
64 * in the working tree. An attempt to explicitly
65 * add a path that does not exist in the working tree
66 * will be caught as an error by the caller immediately.
67 */
68 return DIFF_STATUS_MODIFIED;
69 }
70
71 static void update_callback(struct diff_queue_struct *q,
72 struct diff_options *opt, void *cbdata)
73 {
74 int i;
75 struct update_callback_data *data = cbdata;
76
77 for (i = 0; i < q->nr; i++) {
78 struct diff_filepair *p = q->queue[i];
79 const char *path = p->one->path;
80 switch (fix_unmerged_status(p, data)) {
81 default:
82 die(_("unexpected diff status %c"), p->status);
83 case DIFF_STATUS_MODIFIED:
84 case DIFF_STATUS_TYPE_CHANGED:
85 if (add_file_to_index(&the_index, path, data->flags)) {
86 if (!(data->flags & ADD_CACHE_IGNORE_ERRORS))
87 die(_("updating files failed"));
88 data->add_errors++;
89 }
90 break;
91 case DIFF_STATUS_DELETED:
92 if (data->flags & ADD_CACHE_IGNORE_REMOVAL)
93 break;
94 if (!(data->flags & ADD_CACHE_PRETEND))
95 remove_file_from_index(&the_index, path);
96 if (data->flags & (ADD_CACHE_PRETEND|ADD_CACHE_VERBOSE))
97 printf(_("remove '%s'\n"), path);
98 break;
99 }
100 }
101 }
102
103 int add_files_to_cache(const char *prefix,
104 const struct pathspec *pathspec, int flags)
105 {
106 struct update_callback_data data;
107 struct rev_info rev;
108
109 memset(&data, 0, sizeof(data));
110 data.flags = flags;
111
112 init_revisions(&rev, prefix);
113 setup_revisions(0, NULL, &rev, NULL);
114 if (pathspec)
115 copy_pathspec(&rev.prune_data, pathspec);
116 rev.diffopt.output_format = DIFF_FORMAT_CALLBACK;
117 rev.diffopt.format_callback = update_callback;
118 rev.diffopt.format_callback_data = &data;
119 rev.diffopt.flags.OVERRIDE_SUBMODULE_CONFIG = 1;
120 rev.max_count = 0; /* do not compare unmerged paths with stage #2 */
121 run_diff_files(&rev, DIFF_RACY_IS_MODIFIED);
122 clear_pathspec(&rev.prune_data);
123 return !!data.add_errors;
124 }
125
126 static char *prune_directory(struct dir_struct *dir, struct pathspec *pathspec, int prefix)
127 {
128 char *seen;
129 int i;
130 struct dir_entry **src, **dst;
131
132 seen = xcalloc(pathspec->nr, 1);
133
134 src = dst = dir->entries;
135 i = dir->nr;
136 while (--i >= 0) {
137 struct dir_entry *entry = *src++;
138 if (dir_path_match(entry, pathspec, prefix, seen))
139 *dst++ = entry;
140 }
141 dir->nr = dst - dir->entries;
142 add_pathspec_matches_against_index(pathspec, &the_index, seen);
143 return seen;
144 }
145
146 static void refresh(int verbose, const struct pathspec *pathspec)
147 {
148 char *seen;
149 int i;
150
151 seen = xcalloc(pathspec->nr, 1);
152 refresh_index(&the_index, verbose ? REFRESH_IN_PORCELAIN : REFRESH_QUIET,
153 pathspec, seen, _("Unstaged changes after refreshing the index:"));
154 for (i = 0; i < pathspec->nr; i++) {
155 if (!seen[i])
156 die(_("pathspec '%s' did not match any files"),
157 pathspec->items[i].match);
158 }
159 free(seen);
160 }
161
162 int run_add_interactive(const char *revision, const char *patch_mode,
163 const struct pathspec *pathspec)
164 {
165 int status, i;
166 struct argv_array argv = ARGV_ARRAY_INIT;
167
168 argv_array_push(&argv, "add--interactive");
169 if (patch_mode)
170 argv_array_push(&argv, patch_mode);
171 if (revision)
172 argv_array_push(&argv, revision);
173 argv_array_push(&argv, "--");
174 for (i = 0; i < pathspec->nr; i++)
175 /* pass original pathspec, to be re-parsed */
176 argv_array_push(&argv, pathspec->items[i].original);
177
178 status = run_command_v_opt(argv.argv, RUN_GIT_CMD);
179 argv_array_clear(&argv);
180 return status;
181 }
182
183 int interactive_add(int argc, const char **argv, const char *prefix, int patch)
184 {
185 struct pathspec pathspec;
186
187 parse_pathspec(&pathspec, 0,
188 PATHSPEC_PREFER_FULL |
189 PATHSPEC_SYMLINK_LEADING_PATH |
190 PATHSPEC_PREFIX_ORIGIN,
191 prefix, argv);
192
193 return run_add_interactive(NULL,
194 patch ? "--patch" : NULL,
195 &pathspec);
196 }
197
198 static int edit_patch(int argc, const char **argv, const char *prefix)
199 {
200 char *file = git_pathdup("ADD_EDIT.patch");
201 const char *apply_argv[] = { "apply", "--recount", "--cached",
202 NULL, NULL };
203 struct child_process child = CHILD_PROCESS_INIT;
204 struct rev_info rev;
205 int out;
206 struct stat st;
207
208 apply_argv[3] = file;
209
210 git_config(git_diff_basic_config, NULL); /* no "diff" UI options */
211
212 if (read_cache() < 0)
213 die(_("Could not read the index"));
214
215 init_revisions(&rev, prefix);
216 rev.diffopt.context = 7;
217
218 argc = setup_revisions(argc, argv, &rev, NULL);
219 rev.diffopt.output_format = DIFF_FORMAT_PATCH;
220 rev.diffopt.use_color = 0;
221 rev.diffopt.flags.IGNORE_DIRTY_SUBMODULES = 1;
222 out = open(file, O_CREAT | O_WRONLY, 0666);
223 if (out < 0)
224 die(_("Could not open '%s' for writing."), file);
225 rev.diffopt.file = xfdopen(out, "w");
226 rev.diffopt.close_file = 1;
227 if (run_diff_files(&rev, 0))
228 die(_("Could not write patch"));
229
230 if (launch_editor(file, NULL, NULL))
231 die(_("editing patch failed"));
232
233 if (stat(file, &st))
234 die_errno(_("Could not stat '%s'"), file);
235 if (!st.st_size)
236 die(_("Empty patch. Aborted."));
237
238 child.git_cmd = 1;
239 child.argv = apply_argv;
240 if (run_command(&child))
241 die(_("Could not apply '%s'"), file);
242
243 unlink(file);
244 free(file);
245 return 0;
246 }
247
248 static struct lock_file lock_file;
249
250 static const char ignore_error[] =
251 N_("The following paths are ignored by one of your .gitignore files:\n");
252
253 static int verbose, show_only, ignored_too, refresh_only;
254 static int ignore_add_errors, intent_to_add, ignore_missing;
255 static int warn_on_embedded_repo = 1;
256
257 #define ADDREMOVE_DEFAULT 1
258 static int addremove = ADDREMOVE_DEFAULT;
259 static int addremove_explicit = -1; /* unspecified */
260
261 static char *chmod_arg;
262
263 static int ignore_removal_cb(const struct option *opt, const char *arg, int unset)
264 {
265 /* if we are told to ignore, we are not adding removals */
266 *(int *)opt->value = !unset ? 0 : 1;
267 return 0;
268 }
269
270 static struct option builtin_add_options[] = {
271 OPT__DRY_RUN(&show_only, N_("dry run")),
272 OPT__VERBOSE(&verbose, N_("be verbose")),
273 OPT_GROUP(""),
274 OPT_BOOL('i', "interactive", &add_interactive, N_("interactive picking")),
275 OPT_BOOL('p', "patch", &patch_interactive, N_("select hunks interactively")),
276 OPT_BOOL('e', "edit", &edit_interactive, N_("edit current diff and apply")),
277 OPT__FORCE(&ignored_too, N_("allow adding otherwise ignored files")),
278 OPT_BOOL('u', "update", &take_worktree_changes, N_("update tracked files")),
279 OPT_BOOL('N', "intent-to-add", &intent_to_add, N_("record only the fact that the path will be added later")),
280 OPT_BOOL('A', "all", &addremove_explicit, N_("add changes from all tracked and untracked files")),
281 { OPTION_CALLBACK, 0, "ignore-removal", &addremove_explicit,
282 NULL /* takes no arguments */,
283 N_("ignore paths removed in the working tree (same as --no-all)"),
284 PARSE_OPT_NOARG, ignore_removal_cb },
285 OPT_BOOL( 0 , "refresh", &refresh_only, N_("don't add, only refresh the index")),
286 OPT_BOOL( 0 , "ignore-errors", &ignore_add_errors, N_("just skip files which cannot be added because of errors")),
287 OPT_BOOL( 0 , "ignore-missing", &ignore_missing, N_("check if - even missing - files are ignored in dry run")),
288 OPT_STRING( 0 , "chmod", &chmod_arg, N_("(+/-)x"), N_("override the executable bit of the listed files")),
289 OPT_HIDDEN_BOOL(0, "warn-embedded-repo", &warn_on_embedded_repo,
290 N_("warn when adding an embedded repository")),
291 OPT_END(),
292 };
293
294 static int add_config(const char *var, const char *value, void *cb)
295 {
296 if (!strcmp(var, "add.ignoreerrors") ||
297 !strcmp(var, "add.ignore-errors")) {
298 ignore_add_errors = git_config_bool(var, value);
299 return 0;
300 }
301 return git_default_config(var, value, cb);
302 }
303
304 static const char embedded_advice[] = N_(
305 "You've added another git repository inside your current repository.\n"
306 "Clones of the outer repository will not contain the contents of\n"
307 "the embedded repository and will not know how to obtain it.\n"
308 "If you meant to add a submodule, use:\n"
309 "\n"
310 " git submodule add <url> %s\n"
311 "\n"
312 "If you added this path by mistake, you can remove it from the\n"
313 "index with:\n"
314 "\n"
315 " git rm --cached %s\n"
316 "\n"
317 "See \"git help submodule\" for more information."
318 );
319
320 static void check_embedded_repo(const char *path)
321 {
322 struct strbuf name = STRBUF_INIT;
323
324 if (!warn_on_embedded_repo)
325 return;
326 if (!ends_with(path, "/"))
327 return;
328
329 /* Drop trailing slash for aesthetics */
330 strbuf_addstr(&name, path);
331 strbuf_strip_suffix(&name, "/");
332
333 warning(_("adding embedded git repository: %s"), name.buf);
334 if (advice_add_embedded_repo) {
335 advise(embedded_advice, name.buf, name.buf);
336 /* there may be multiple entries; advise only once */
337 advice_add_embedded_repo = 0;
338 }
339
340 strbuf_release(&name);
341 }
342
343 static int add_files(struct dir_struct *dir, int flags)
344 {
345 int i, exit_status = 0;
346
347 if (dir->ignored_nr) {
348 fprintf(stderr, _(ignore_error));
349 for (i = 0; i < dir->ignored_nr; i++)
350 fprintf(stderr, "%s\n", dir->ignored[i]->name);
351 fprintf(stderr, _("Use -f if you really want to add them.\n"));
352 exit_status = 1;
353 }
354
355 for (i = 0; i < dir->nr; i++) {
356 check_embedded_repo(dir->entries[i]->name);
357 if (add_file_to_index(&the_index, dir->entries[i]->name, flags)) {
358 if (!ignore_add_errors)
359 die(_("adding files failed"));
360 exit_status = 1;
361 }
362 }
363 return exit_status;
364 }
365
366 int cmd_add(int argc, const char **argv, const char *prefix)
367 {
368 int exit_status = 0;
369 struct pathspec pathspec;
370 struct dir_struct dir;
371 int flags;
372 int add_new_files;
373 int require_pathspec;
374 char *seen = NULL;
375
376 git_config(add_config, NULL);
377
378 argc = parse_options(argc, argv, prefix, builtin_add_options,
379 builtin_add_usage, PARSE_OPT_KEEP_ARGV0);
380 if (patch_interactive)
381 add_interactive = 1;
382 if (add_interactive)
383 exit(interactive_add(argc - 1, argv + 1, prefix, patch_interactive));
384
385 if (edit_interactive)
386 return(edit_patch(argc, argv, prefix));
387 argc--;
388 argv++;
389
390 if (0 <= addremove_explicit)
391 addremove = addremove_explicit;
392 else if (take_worktree_changes && ADDREMOVE_DEFAULT)
393 addremove = 0; /* "-u" was given but not "-A" */
394
395 if (addremove && take_worktree_changes)
396 die(_("-A and -u are mutually incompatible"));
397
398 if (!take_worktree_changes && addremove_explicit < 0 && argc)
399 /* Turn "git add pathspec..." to "git add -A pathspec..." */
400 addremove = 1;
401
402 if (!show_only && ignore_missing)
403 die(_("Option --ignore-missing can only be used together with --dry-run"));
404
405 if (chmod_arg && ((chmod_arg[0] != '-' && chmod_arg[0] != '+') ||
406 chmod_arg[1] != 'x' || chmod_arg[2]))
407 die(_("--chmod param '%s' must be either -x or +x"), chmod_arg);
408
409 add_new_files = !take_worktree_changes && !refresh_only;
410 require_pathspec = !(take_worktree_changes || (0 < addremove_explicit));
411
412 hold_locked_index(&lock_file, LOCK_DIE_ON_ERROR);
413
414 flags = ((verbose ? ADD_CACHE_VERBOSE : 0) |
415 (show_only ? ADD_CACHE_PRETEND : 0) |
416 (intent_to_add ? ADD_CACHE_INTENT : 0) |
417 (ignore_add_errors ? ADD_CACHE_IGNORE_ERRORS : 0) |
418 (!(addremove || take_worktree_changes)
419 ? ADD_CACHE_IGNORE_REMOVAL : 0));
420
421 if (require_pathspec && argc == 0) {
422 fprintf(stderr, _("Nothing specified, nothing added.\n"));
423 fprintf(stderr, _("Maybe you wanted to say 'git add .'?\n"));
424 return 0;
425 }
426
427 if (read_cache() < 0)
428 die(_("index file corrupt"));
429
430 die_in_unpopulated_submodule(&the_index, prefix);
431
432 /*
433 * Check the "pathspec '%s' did not match any files" block
434 * below before enabling new magic.
435 */
436 parse_pathspec(&pathspec, 0,
437 PATHSPEC_PREFER_FULL |
438 PATHSPEC_SYMLINK_LEADING_PATH,
439 prefix, argv);
440
441 die_path_inside_submodule(&the_index, &pathspec);
442
443 if (add_new_files) {
444 int baselen;
445
446 /* Set up the default git porcelain excludes */
447 memset(&dir, 0, sizeof(dir));
448 if (!ignored_too) {
449 dir.flags |= DIR_COLLECT_IGNORED;
450 setup_standard_excludes(&dir);
451 }
452
453 /* This picks up the paths that are not tracked */
454 baselen = fill_directory(&dir, &the_index, &pathspec);
455 if (pathspec.nr)
456 seen = prune_directory(&dir, &pathspec, baselen);
457 }
458
459 if (refresh_only) {
460 refresh(verbose, &pathspec);
461 goto finish;
462 }
463
464 if (pathspec.nr) {
465 int i;
466
467 if (!seen)
468 seen = find_pathspecs_matching_against_index(&pathspec, &the_index);
469
470 /*
471 * file_exists() assumes exact match
472 */
473 GUARD_PATHSPEC(&pathspec,
474 PATHSPEC_FROMTOP |
475 PATHSPEC_LITERAL |
476 PATHSPEC_GLOB |
477 PATHSPEC_ICASE |
478 PATHSPEC_EXCLUDE);
479
480 for (i = 0; i < pathspec.nr; i++) {
481 const char *path = pathspec.items[i].match;
482 if (pathspec.items[i].magic & PATHSPEC_EXCLUDE)
483 continue;
484 if (!seen[i] && path[0] &&
485 ((pathspec.items[i].magic &
486 (PATHSPEC_GLOB | PATHSPEC_ICASE)) ||
487 !file_exists(path))) {
488 if (ignore_missing) {
489 int dtype = DT_UNKNOWN;
490 if (is_excluded(&dir, &the_index, path, &dtype))
491 dir_add_ignored(&dir, &the_index,
492 path, pathspec.items[i].len);
493 } else
494 die(_("pathspec '%s' did not match any files"),
495 pathspec.items[i].original);
496 }
497 }
498 free(seen);
499 }
500
501 plug_bulk_checkin();
502
503 exit_status |= add_files_to_cache(prefix, &pathspec, flags);
504
505 if (add_new_files)
506 exit_status |= add_files(&dir, flags);
507
508 if (chmod_arg && pathspec.nr)
509 chmod_pathspec(&pathspec, chmod_arg[0]);
510 unplug_bulk_checkin();
511
512 finish:
513 if (active_cache_changed) {
514 if (write_locked_index(&the_index, &lock_file, COMMIT_LOCK))
515 die(_("Unable to write new index file"));
516 }
517
518 UNLEAK(pathspec);
519 UNLEAK(dir);
520 return exit_status;
521 }