Merge branch 'master' of git://github.com/alshopov/git-po
[git/raj.git] / builtin / add.c
blobdd18e5c9b67038307401e8d33970d5c424c03cb7
1 /*
2 * "git add" builtin command
4 * Copyright (C) 2006 Linus Torvalds
5 */
6 #define USE_THE_INDEX_COMPATIBILITY_MACROS
7 #include "cache.h"
8 #include "config.h"
9 #include "builtin.h"
10 #include "lockfile.h"
11 #include "dir.h"
12 #include "pathspec.h"
13 #include "exec-cmd.h"
14 #include "cache-tree.h"
15 #include "run-command.h"
16 #include "parse-options.h"
17 #include "diff.h"
18 #include "diffcore.h"
19 #include "revision.h"
20 #include "bulk-checkin.h"
21 #include "argv-array.h"
22 #include "submodule.h"
24 static const char * const builtin_add_usage[] = {
25 N_("git add [<options>] [--] <pathspec>..."),
26 NULL
28 static int patch_interactive, add_interactive, edit_interactive;
29 static int take_worktree_changes;
30 static int add_renormalize;
32 struct update_callback_data {
33 int flags;
34 int add_errors;
37 static void chmod_pathspec(struct pathspec *pathspec, char flip)
39 int i;
41 for (i = 0; i < active_nr; i++) {
42 struct cache_entry *ce = active_cache[i];
44 if (pathspec && !ce_path_match(&the_index, ce, pathspec, NULL))
45 continue;
47 if (chmod_cache_entry(ce, flip) < 0)
48 fprintf(stderr, "cannot chmod %cx '%s'\n", flip, ce->name);
52 static int fix_unmerged_status(struct diff_filepair *p,
53 struct update_callback_data *data)
55 if (p->status != DIFF_STATUS_UNMERGED)
56 return p->status;
57 if (!(data->flags & ADD_CACHE_IGNORE_REMOVAL) && !p->two->mode)
59 * This is not an explicit add request, and the
60 * path is missing from the working tree (deleted)
62 return DIFF_STATUS_DELETED;
63 else
65 * Either an explicit add request, or path exists
66 * in the working tree. An attempt to explicitly
67 * add a path that does not exist in the working tree
68 * will be caught as an error by the caller immediately.
70 return DIFF_STATUS_MODIFIED;
73 static void update_callback(struct diff_queue_struct *q,
74 struct diff_options *opt, void *cbdata)
76 int i;
77 struct update_callback_data *data = cbdata;
79 for (i = 0; i < q->nr; i++) {
80 struct diff_filepair *p = q->queue[i];
81 const char *path = p->one->path;
82 switch (fix_unmerged_status(p, data)) {
83 default:
84 die(_("unexpected diff status %c"), p->status);
85 case DIFF_STATUS_MODIFIED:
86 case DIFF_STATUS_TYPE_CHANGED:
87 if (add_file_to_index(&the_index, path, data->flags)) {
88 if (!(data->flags & ADD_CACHE_IGNORE_ERRORS))
89 die(_("updating files failed"));
90 data->add_errors++;
92 break;
93 case DIFF_STATUS_DELETED:
94 if (data->flags & ADD_CACHE_IGNORE_REMOVAL)
95 break;
96 if (!(data->flags & ADD_CACHE_PRETEND))
97 remove_file_from_index(&the_index, path);
98 if (data->flags & (ADD_CACHE_PRETEND|ADD_CACHE_VERBOSE))
99 printf(_("remove '%s'\n"), path);
100 break;
105 int add_files_to_cache(const char *prefix,
106 const struct pathspec *pathspec, int flags)
108 struct update_callback_data data;
109 struct rev_info rev;
111 memset(&data, 0, sizeof(data));
112 data.flags = flags;
114 repo_init_revisions(the_repository, &rev, prefix);
115 setup_revisions(0, NULL, &rev, NULL);
116 if (pathspec)
117 copy_pathspec(&rev.prune_data, pathspec);
118 rev.diffopt.output_format = DIFF_FORMAT_CALLBACK;
119 rev.diffopt.format_callback = update_callback;
120 rev.diffopt.format_callback_data = &data;
121 rev.diffopt.flags.override_submodule_config = 1;
122 rev.max_count = 0; /* do not compare unmerged paths with stage #2 */
123 run_diff_files(&rev, DIFF_RACY_IS_MODIFIED);
124 clear_pathspec(&rev.prune_data);
125 return !!data.add_errors;
128 static int renormalize_tracked_files(const struct pathspec *pathspec, int flags)
130 int i, retval = 0;
132 for (i = 0; i < active_nr; i++) {
133 struct cache_entry *ce = active_cache[i];
135 if (ce_stage(ce))
136 continue; /* do not touch unmerged paths */
137 if (!S_ISREG(ce->ce_mode) && !S_ISLNK(ce->ce_mode))
138 continue; /* do not touch non blobs */
139 if (pathspec && !ce_path_match(&the_index, ce, pathspec, NULL))
140 continue;
141 retval |= add_file_to_cache(ce->name, flags | ADD_CACHE_RENORMALIZE);
144 return retval;
147 static char *prune_directory(struct dir_struct *dir, struct pathspec *pathspec, int prefix)
149 char *seen;
150 int i;
151 struct dir_entry **src, **dst;
153 seen = xcalloc(pathspec->nr, 1);
155 src = dst = dir->entries;
156 i = dir->nr;
157 while (--i >= 0) {
158 struct dir_entry *entry = *src++;
159 if (dir_path_match(&the_index, entry, pathspec, prefix, seen))
160 *dst++ = entry;
162 dir->nr = dst - dir->entries;
163 add_pathspec_matches_against_index(pathspec, &the_index, seen);
164 return seen;
167 static void refresh(int verbose, const struct pathspec *pathspec)
169 char *seen;
170 int i;
172 seen = xcalloc(pathspec->nr, 1);
173 refresh_index(&the_index, verbose ? REFRESH_IN_PORCELAIN : REFRESH_QUIET,
174 pathspec, seen, _("Unstaged changes after refreshing the index:"));
175 for (i = 0; i < pathspec->nr; i++) {
176 if (!seen[i])
177 die(_("pathspec '%s' did not match any files"),
178 pathspec->items[i].match);
180 free(seen);
183 int run_add_interactive(const char *revision, const char *patch_mode,
184 const struct pathspec *pathspec)
186 int status, i;
187 struct argv_array argv = ARGV_ARRAY_INIT;
189 argv_array_push(&argv, "add--interactive");
190 if (patch_mode)
191 argv_array_push(&argv, patch_mode);
192 if (revision)
193 argv_array_push(&argv, revision);
194 argv_array_push(&argv, "--");
195 for (i = 0; i < pathspec->nr; i++)
196 /* pass original pathspec, to be re-parsed */
197 argv_array_push(&argv, pathspec->items[i].original);
199 status = run_command_v_opt(argv.argv, RUN_GIT_CMD);
200 argv_array_clear(&argv);
201 return status;
204 int interactive_add(int argc, const char **argv, const char *prefix, int patch)
206 struct pathspec pathspec;
208 parse_pathspec(&pathspec, 0,
209 PATHSPEC_PREFER_FULL |
210 PATHSPEC_SYMLINK_LEADING_PATH |
211 PATHSPEC_PREFIX_ORIGIN,
212 prefix, argv);
214 return run_add_interactive(NULL,
215 patch ? "--patch" : NULL,
216 &pathspec);
219 static int edit_patch(int argc, const char **argv, const char *prefix)
221 char *file = git_pathdup("ADD_EDIT.patch");
222 const char *apply_argv[] = { "apply", "--recount", "--cached",
223 NULL, NULL };
224 struct child_process child = CHILD_PROCESS_INIT;
225 struct rev_info rev;
226 int out;
227 struct stat st;
229 apply_argv[3] = file;
231 git_config(git_diff_basic_config, NULL); /* no "diff" UI options */
233 if (read_cache() < 0)
234 die(_("Could not read the index"));
236 repo_init_revisions(the_repository, &rev, prefix);
237 rev.diffopt.context = 7;
239 argc = setup_revisions(argc, argv, &rev, NULL);
240 rev.diffopt.output_format = DIFF_FORMAT_PATCH;
241 rev.diffopt.use_color = 0;
242 rev.diffopt.flags.ignore_dirty_submodules = 1;
243 out = open(file, O_CREAT | O_WRONLY | O_TRUNC, 0666);
244 if (out < 0)
245 die(_("Could not open '%s' for writing."), file);
246 rev.diffopt.file = xfdopen(out, "w");
247 rev.diffopt.close_file = 1;
248 if (run_diff_files(&rev, 0))
249 die(_("Could not write patch"));
251 if (launch_editor(file, NULL, NULL))
252 die(_("editing patch failed"));
254 if (stat(file, &st))
255 die_errno(_("Could not stat '%s'"), file);
256 if (!st.st_size)
257 die(_("Empty patch. Aborted."));
259 child.git_cmd = 1;
260 child.argv = apply_argv;
261 if (run_command(&child))
262 die(_("Could not apply '%s'"), file);
264 unlink(file);
265 free(file);
266 return 0;
269 static const char ignore_error[] =
270 N_("The following paths are ignored by one of your .gitignore files:\n");
272 static int verbose, show_only, ignored_too, refresh_only;
273 static int ignore_add_errors, intent_to_add, ignore_missing;
274 static int warn_on_embedded_repo = 1;
276 #define ADDREMOVE_DEFAULT 1
277 static int addremove = ADDREMOVE_DEFAULT;
278 static int addremove_explicit = -1; /* unspecified */
280 static char *chmod_arg;
282 static int ignore_removal_cb(const struct option *opt, const char *arg, int unset)
284 /* if we are told to ignore, we are not adding removals */
285 *(int *)opt->value = !unset ? 0 : 1;
286 return 0;
289 static struct option builtin_add_options[] = {
290 OPT__DRY_RUN(&show_only, N_("dry run")),
291 OPT__VERBOSE(&verbose, N_("be verbose")),
292 OPT_GROUP(""),
293 OPT_BOOL('i', "interactive", &add_interactive, N_("interactive picking")),
294 OPT_BOOL('p', "patch", &patch_interactive, N_("select hunks interactively")),
295 OPT_BOOL('e', "edit", &edit_interactive, N_("edit current diff and apply")),
296 OPT__FORCE(&ignored_too, N_("allow adding otherwise ignored files"), 0),
297 OPT_BOOL('u', "update", &take_worktree_changes, N_("update tracked files")),
298 OPT_BOOL(0, "renormalize", &add_renormalize, N_("renormalize EOL of tracked files (implies -u)")),
299 OPT_BOOL('N', "intent-to-add", &intent_to_add, N_("record only the fact that the path will be added later")),
300 OPT_BOOL('A', "all", &addremove_explicit, N_("add changes from all tracked and untracked files")),
301 { OPTION_CALLBACK, 0, "ignore-removal", &addremove_explicit,
302 NULL /* takes no arguments */,
303 N_("ignore paths removed in the working tree (same as --no-all)"),
304 PARSE_OPT_NOARG, ignore_removal_cb },
305 OPT_BOOL( 0 , "refresh", &refresh_only, N_("don't add, only refresh the index")),
306 OPT_BOOL( 0 , "ignore-errors", &ignore_add_errors, N_("just skip files which cannot be added because of errors")),
307 OPT_BOOL( 0 , "ignore-missing", &ignore_missing, N_("check if - even missing - files are ignored in dry run")),
308 OPT_STRING(0, "chmod", &chmod_arg, "(+|-)x",
309 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 if (add_file_to_index(&the_index, dir->entries[i]->name, flags)) {
378 if (!ignore_add_errors)
379 die(_("adding files failed"));
380 exit_status = 1;
381 } else {
382 check_embedded_repo(dir->entries[i]->name);
385 return exit_status;
388 int cmd_add(int argc, const char **argv, const char *prefix)
390 int exit_status = 0;
391 struct pathspec pathspec;
392 struct dir_struct dir;
393 int flags;
394 int add_new_files;
395 int require_pathspec;
396 char *seen = NULL;
397 struct lock_file lock_file = LOCK_INIT;
399 git_config(add_config, NULL);
401 argc = parse_options(argc, argv, prefix, builtin_add_options,
402 builtin_add_usage, PARSE_OPT_KEEP_ARGV0);
403 if (patch_interactive)
404 add_interactive = 1;
405 if (add_interactive)
406 exit(interactive_add(argc - 1, argv + 1, prefix, patch_interactive));
408 if (edit_interactive)
409 return(edit_patch(argc, argv, prefix));
410 argc--;
411 argv++;
413 if (0 <= addremove_explicit)
414 addremove = addremove_explicit;
415 else if (take_worktree_changes && ADDREMOVE_DEFAULT)
416 addremove = 0; /* "-u" was given but not "-A" */
418 if (addremove && take_worktree_changes)
419 die(_("-A and -u are mutually incompatible"));
421 if (!take_worktree_changes && addremove_explicit < 0 && argc)
422 /* Turn "git add pathspec..." to "git add -A pathspec..." */
423 addremove = 1;
425 if (!show_only && ignore_missing)
426 die(_("Option --ignore-missing can only be used together with --dry-run"));
428 if (chmod_arg && ((chmod_arg[0] != '-' && chmod_arg[0] != '+') ||
429 chmod_arg[1] != 'x' || chmod_arg[2]))
430 die(_("--chmod param '%s' must be either -x or +x"), chmod_arg);
432 add_new_files = !take_worktree_changes && !refresh_only && !add_renormalize;
433 require_pathspec = !(take_worktree_changes || (0 < addremove_explicit));
435 hold_locked_index(&lock_file, LOCK_DIE_ON_ERROR);
437 flags = ((verbose ? ADD_CACHE_VERBOSE : 0) |
438 (show_only ? ADD_CACHE_PRETEND : 0) |
439 (intent_to_add ? ADD_CACHE_INTENT : 0) |
440 (ignore_add_errors ? ADD_CACHE_IGNORE_ERRORS : 0) |
441 (!(addremove || take_worktree_changes)
442 ? ADD_CACHE_IGNORE_REMOVAL : 0));
444 if (require_pathspec && argc == 0) {
445 fprintf(stderr, _("Nothing specified, nothing added.\n"));
446 fprintf(stderr, _("Maybe you wanted to say 'git add .'?\n"));
447 return 0;
451 * Check the "pathspec '%s' did not match any files" block
452 * below before enabling new magic.
454 parse_pathspec(&pathspec, PATHSPEC_ATTR,
455 PATHSPEC_PREFER_FULL |
456 PATHSPEC_SYMLINK_LEADING_PATH,
457 prefix, argv);
459 if (read_cache_preload(&pathspec) < 0)
460 die(_("index file corrupt"));
462 die_in_unpopulated_submodule(&the_index, prefix);
463 die_path_inside_submodule(&the_index, &pathspec);
465 if (add_new_files) {
466 int baselen;
468 /* Set up the default git porcelain excludes */
469 memset(&dir, 0, sizeof(dir));
470 if (!ignored_too) {
471 dir.flags |= DIR_COLLECT_IGNORED;
472 setup_standard_excludes(&dir);
475 /* This picks up the paths that are not tracked */
476 baselen = fill_directory(&dir, &the_index, &pathspec);
477 if (pathspec.nr)
478 seen = prune_directory(&dir, &pathspec, baselen);
481 if (refresh_only) {
482 refresh(verbose, &pathspec);
483 goto finish;
486 if (pathspec.nr) {
487 int i;
489 if (!seen)
490 seen = find_pathspecs_matching_against_index(&pathspec, &the_index);
493 * file_exists() assumes exact match
495 GUARD_PATHSPEC(&pathspec,
496 PATHSPEC_FROMTOP |
497 PATHSPEC_LITERAL |
498 PATHSPEC_GLOB |
499 PATHSPEC_ICASE |
500 PATHSPEC_EXCLUDE);
502 for (i = 0; i < pathspec.nr; i++) {
503 const char *path = pathspec.items[i].match;
504 if (pathspec.items[i].magic & PATHSPEC_EXCLUDE)
505 continue;
506 if (!seen[i] && path[0] &&
507 ((pathspec.items[i].magic &
508 (PATHSPEC_GLOB | PATHSPEC_ICASE)) ||
509 !file_exists(path))) {
510 if (ignore_missing) {
511 int dtype = DT_UNKNOWN;
512 if (is_excluded(&dir, &the_index, path, &dtype))
513 dir_add_ignored(&dir, &the_index,
514 path, pathspec.items[i].len);
515 } else
516 die(_("pathspec '%s' did not match any files"),
517 pathspec.items[i].original);
520 free(seen);
523 plug_bulk_checkin();
525 if (add_renormalize)
526 exit_status |= renormalize_tracked_files(&pathspec, flags);
527 else
528 exit_status |= add_files_to_cache(prefix, &pathspec, flags);
530 if (add_new_files)
531 exit_status |= add_files(&dir, flags);
533 if (chmod_arg && pathspec.nr)
534 chmod_pathspec(&pathspec, chmod_arg[0]);
535 unplug_bulk_checkin();
537 finish:
538 if (write_locked_index(&the_index, &lock_file,
539 COMMIT_LOCK | SKIP_IF_UNCHANGED))
540 die(_("Unable to write new index file"));
542 UNLEAK(pathspec);
543 UNLEAK(dir);
544 return exit_status;