Andrew's git / gitweb.git / builtin/add.c
?
builtin / add.con commit path: add repo_git_path and strbuf_repo_git_path (3181d86)
   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
  23static const char * const builtin_add_usage[] = {
  24        N_("git add [<options>] [--] <pathspec>..."),
  25        NULL
  26};
  27static int patch_interactive, add_interactive, edit_interactive;
  28static int take_worktree_changes;
  29
  30struct update_callback_data {
  31        int flags;
  32        int add_errors;
  33};
  34
  35static void chmod_pathspec(struct pathspec *pathspec, int force_mode)
  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, force_mode) < 0)
  46                        fprintf(stderr, "cannot chmod '%s'", ce->name);
  47        }
  48}
  49
  50static 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
  71static 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
 103int 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.max_count = 0; /* do not compare unmerged paths with stage #2 */
 120        run_diff_files(&rev, DIFF_RACY_IS_MODIFIED);
 121        return !!data.add_errors;
 122}
 123
 124static char *prune_directory(struct dir_struct *dir, struct pathspec *pathspec, int prefix)
 125{
 126        char *seen;
 127        int i;
 128        struct dir_entry **src, **dst;
 129
 130        seen = xcalloc(pathspec->nr, 1);
 131
 132        src = dst = dir->entries;
 133        i = dir->nr;
 134        while (--i >= 0) {
 135                struct dir_entry *entry = *src++;
 136                if (dir_path_match(entry, pathspec, prefix, seen))
 137                        *dst++ = entry;
 138        }
 139        dir->nr = dst - dir->entries;
 140        add_pathspec_matches_against_index(pathspec, &the_index, seen);
 141        return seen;
 142}
 143
 144static void refresh(int verbose, const struct pathspec *pathspec)
 145{
 146        char *seen;
 147        int i;
 148
 149        seen = xcalloc(pathspec->nr, 1);
 150        refresh_index(&the_index, verbose ? REFRESH_IN_PORCELAIN : REFRESH_QUIET,
 151                      pathspec, seen, _("Unstaged changes after refreshing the index:"));
 152        for (i = 0; i < pathspec->nr; i++) {
 153                if (!seen[i])
 154                        die(_("pathspec '%s' did not match any files"),
 155                            pathspec->items[i].match);
 156        }
 157        free(seen);
 158}
 159
 160int run_add_interactive(const char *revision, const char *patch_mode,
 161                        const struct pathspec *pathspec)
 162{
 163        int status, i;
 164        struct argv_array argv = ARGV_ARRAY_INIT;
 165
 166        argv_array_push(&argv, "add--interactive");
 167        if (patch_mode)
 168                argv_array_push(&argv, patch_mode);
 169        if (revision)
 170                argv_array_push(&argv, revision);
 171        argv_array_push(&argv, "--");
 172        for (i = 0; i < pathspec->nr; i++)
 173                /* pass original pathspec, to be re-parsed */
 174                argv_array_push(&argv, pathspec->items[i].original);
 175
 176        status = run_command_v_opt(argv.argv, RUN_GIT_CMD);
 177        argv_array_clear(&argv);
 178        return status;
 179}
 180
 181int interactive_add(int argc, const char **argv, const char *prefix, int patch)
 182{
 183        struct pathspec pathspec;
 184
 185        parse_pathspec(&pathspec, 0,
 186                       PATHSPEC_PREFER_FULL |
 187                       PATHSPEC_SYMLINK_LEADING_PATH |
 188                       PATHSPEC_PREFIX_ORIGIN,
 189                       prefix, argv);
 190
 191        return run_add_interactive(NULL,
 192                                   patch ? "--patch" : NULL,
 193                                   &pathspec);
 194}
 195
 196static int edit_patch(int argc, const char **argv, const char *prefix)
 197{
 198        char *file = git_pathdup("ADD_EDIT.patch");
 199        const char *apply_argv[] = { "apply", "--recount", "--cached",
 200                NULL, NULL };
 201        struct child_process child = CHILD_PROCESS_INIT;
 202        struct rev_info rev;
 203        int out;
 204        struct stat st;
 205
 206        apply_argv[3] = file;
 207
 208        git_config(git_diff_basic_config, NULL); /* no "diff" UI options */
 209
 210        if (read_cache() < 0)
 211                die(_("Could not read the index"));
 212
 213        init_revisions(&rev, prefix);
 214        rev.diffopt.context = 7;
 215
 216        argc = setup_revisions(argc, argv, &rev, NULL);
 217        rev.diffopt.output_format = DIFF_FORMAT_PATCH;
 218        rev.diffopt.use_color = 0;
 219        DIFF_OPT_SET(&rev.diffopt, IGNORE_DIRTY_SUBMODULES);
 220        out = open(file, O_CREAT | O_WRONLY, 0666);
 221        if (out < 0)
 222                die(_("Could not open '%s' for writing."), file);
 223        rev.diffopt.file = xfdopen(out, "w");
 224        rev.diffopt.close_file = 1;
 225        if (run_diff_files(&rev, 0))
 226                die(_("Could not write patch"));
 227
 228        if (launch_editor(file, NULL, NULL))
 229                die(_("editing patch failed"));
 230
 231        if (stat(file, &st))
 232                die_errno(_("Could not stat '%s'"), file);
 233        if (!st.st_size)
 234                die(_("Empty patch. Aborted."));
 235
 236        child.git_cmd = 1;
 237        child.argv = apply_argv;
 238        if (run_command(&child))
 239                die(_("Could not apply '%s'"), file);
 240
 241        unlink(file);
 242        free(file);
 243        return 0;
 244}
 245
 246static struct lock_file lock_file;
 247
 248static const char ignore_error[] =
 249N_("The following paths are ignored by one of your .gitignore files:\n");
 250
 251static int verbose, show_only, ignored_too, refresh_only;
 252static int ignore_add_errors, intent_to_add, ignore_missing;
 253
 254#define ADDREMOVE_DEFAULT 1
 255static int addremove = ADDREMOVE_DEFAULT;
 256static int addremove_explicit = -1; /* unspecified */
 257
 258static char *chmod_arg;
 259
 260static int ignore_removal_cb(const struct option *opt, const char *arg, int unset)
 261{
 262        /* if we are told to ignore, we are not adding removals */
 263        *(int *)opt->value = !unset ? 0 : 1;
 264        return 0;
 265}
 266
 267static struct option builtin_add_options[] = {
 268        OPT__DRY_RUN(&show_only, N_("dry run")),
 269        OPT__VERBOSE(&verbose, N_("be verbose")),
 270        OPT_GROUP(""),
 271        OPT_BOOL('i', "interactive", &add_interactive, N_("interactive picking")),
 272        OPT_BOOL('p', "patch", &patch_interactive, N_("select hunks interactively")),
 273        OPT_BOOL('e', "edit", &edit_interactive, N_("edit current diff and apply")),
 274        OPT__FORCE(&ignored_too, N_("allow adding otherwise ignored files")),
 275        OPT_BOOL('u', "update", &take_worktree_changes, N_("update tracked files")),
 276        OPT_BOOL('N', "intent-to-add", &intent_to_add, N_("record only the fact that the path will be added later")),
 277        OPT_BOOL('A', "all", &addremove_explicit, N_("add changes from all tracked and untracked files")),
 278        { OPTION_CALLBACK, 0, "ignore-removal", &addremove_explicit,
 279          NULL /* takes no arguments */,
 280          N_("ignore paths removed in the working tree (same as --no-all)"),
 281          PARSE_OPT_NOARG, ignore_removal_cb },
 282        OPT_BOOL( 0 , "refresh", &refresh_only, N_("don't add, only refresh the index")),
 283        OPT_BOOL( 0 , "ignore-errors", &ignore_add_errors, N_("just skip files which cannot be added because of errors")),
 284        OPT_BOOL( 0 , "ignore-missing", &ignore_missing, N_("check if - even missing - files are ignored in dry run")),
 285        OPT_STRING( 0 , "chmod", &chmod_arg, N_("(+/-)x"), N_("override the executable bit of the listed files")),
 286        OPT_END(),
 287};
 288
 289static int add_config(const char *var, const char *value, void *cb)
 290{
 291        if (!strcmp(var, "add.ignoreerrors") ||
 292            !strcmp(var, "add.ignore-errors")) {
 293                ignore_add_errors = git_config_bool(var, value);
 294                return 0;
 295        }
 296        return git_default_config(var, value, cb);
 297}
 298
 299static int add_files(struct dir_struct *dir, int flags)
 300{
 301        int i, exit_status = 0;
 302
 303        if (dir->ignored_nr) {
 304                fprintf(stderr, _(ignore_error));
 305                for (i = 0; i < dir->ignored_nr; i++)
 306                        fprintf(stderr, "%s\n", dir->ignored[i]->name);
 307                fprintf(stderr, _("Use -f if you really want to add them.\n"));
 308                exit_status = 1;
 309        }
 310
 311        for (i = 0; i < dir->nr; i++)
 312                if (add_file_to_index(&the_index, dir->entries[i]->name, flags)) {
 313                        if (!ignore_add_errors)
 314                                die(_("adding files failed"));
 315                        exit_status = 1;
 316                }
 317        return exit_status;
 318}
 319
 320int cmd_add(int argc, const char **argv, const char *prefix)
 321{
 322        int exit_status = 0;
 323        struct pathspec pathspec;
 324        struct dir_struct dir;
 325        int flags;
 326        int add_new_files;
 327        int require_pathspec;
 328        char *seen = NULL;
 329
 330        git_config(add_config, NULL);
 331
 332        argc = parse_options(argc, argv, prefix, builtin_add_options,
 333                          builtin_add_usage, PARSE_OPT_KEEP_ARGV0);
 334        if (patch_interactive)
 335                add_interactive = 1;
 336        if (add_interactive)
 337                exit(interactive_add(argc - 1, argv + 1, prefix, patch_interactive));
 338
 339        if (edit_interactive)
 340                return(edit_patch(argc, argv, prefix));
 341        argc--;
 342        argv++;
 343
 344        if (0 <= addremove_explicit)
 345                addremove = addremove_explicit;
 346        else if (take_worktree_changes && ADDREMOVE_DEFAULT)
 347                addremove = 0; /* "-u" was given but not "-A" */
 348
 349        if (addremove && take_worktree_changes)
 350                die(_("-A and -u are mutually incompatible"));
 351
 352        if (!take_worktree_changes && addremove_explicit < 0 && argc)
 353                /* Turn "git add pathspec..." to "git add -A pathspec..." */
 354                addremove = 1;
 355
 356        if (!show_only && ignore_missing)
 357                die(_("Option --ignore-missing can only be used together with --dry-run"));
 358
 359        if (chmod_arg && ((chmod_arg[0] != '-' && chmod_arg[0] != '+') ||
 360                          chmod_arg[1] != 'x' || chmod_arg[2]))
 361                die(_("--chmod param '%s' must be either -x or +x"), chmod_arg);
 362
 363        add_new_files = !take_worktree_changes && !refresh_only;
 364        require_pathspec = !(take_worktree_changes || (0 < addremove_explicit));
 365
 366        hold_locked_index(&lock_file, LOCK_DIE_ON_ERROR);
 367
 368        flags = ((verbose ? ADD_CACHE_VERBOSE : 0) |
 369                 (show_only ? ADD_CACHE_PRETEND : 0) |
 370                 (intent_to_add ? ADD_CACHE_INTENT : 0) |
 371                 (ignore_add_errors ? ADD_CACHE_IGNORE_ERRORS : 0) |
 372                 (!(addremove || take_worktree_changes)
 373                  ? ADD_CACHE_IGNORE_REMOVAL : 0));
 374
 375        if (require_pathspec && argc == 0) {
 376                fprintf(stderr, _("Nothing specified, nothing added.\n"));
 377                fprintf(stderr, _("Maybe you wanted to say 'git add .'?\n"));
 378                return 0;
 379        }
 380
 381        if (read_cache() < 0)
 382                die(_("index file corrupt"));
 383
 384        die_in_unpopulated_submodule(&the_index, prefix);
 385
 386        /*
 387         * Check the "pathspec '%s' did not match any files" block
 388         * below before enabling new magic.
 389         */
 390        parse_pathspec(&pathspec, 0,
 391                       PATHSPEC_PREFER_FULL |
 392                       PATHSPEC_SYMLINK_LEADING_PATH,
 393                       prefix, argv);
 394
 395        die_path_inside_submodule(&the_index, &pathspec);
 396
 397        if (add_new_files) {
 398                int baselen;
 399
 400                /* Set up the default git porcelain excludes */
 401                memset(&dir, 0, sizeof(dir));
 402                if (!ignored_too) {
 403                        dir.flags |= DIR_COLLECT_IGNORED;
 404                        setup_standard_excludes(&dir);
 405                }
 406
 407                /* This picks up the paths that are not tracked */
 408                baselen = fill_directory(&dir, &the_index, &pathspec);
 409                if (pathspec.nr)
 410                        seen = prune_directory(&dir, &pathspec, baselen);
 411        }
 412
 413        if (refresh_only) {
 414                refresh(verbose, &pathspec);
 415                goto finish;
 416        }
 417
 418        if (pathspec.nr) {
 419                int i;
 420
 421                if (!seen)
 422                        seen = find_pathspecs_matching_against_index(&pathspec, &the_index);
 423
 424                /*
 425                 * file_exists() assumes exact match
 426                 */
 427                GUARD_PATHSPEC(&pathspec,
 428                               PATHSPEC_FROMTOP |
 429                               PATHSPEC_LITERAL |
 430                               PATHSPEC_GLOB |
 431                               PATHSPEC_ICASE |
 432                               PATHSPEC_EXCLUDE);
 433
 434                for (i = 0; i < pathspec.nr; i++) {
 435                        const char *path = pathspec.items[i].match;
 436                        if (pathspec.items[i].magic & PATHSPEC_EXCLUDE)
 437                                continue;
 438                        if (!seen[i] && path[0] &&
 439                            ((pathspec.items[i].magic &
 440                              (PATHSPEC_GLOB | PATHSPEC_ICASE)) ||
 441                             !file_exists(path))) {
 442                                if (ignore_missing) {
 443                                        int dtype = DT_UNKNOWN;
 444                                        if (is_excluded(&dir, &the_index, path, &dtype))
 445                                                dir_add_ignored(&dir, &the_index,
 446                                                                path, pathspec.items[i].len);
 447                                } else
 448                                        die(_("pathspec '%s' did not match any files"),
 449                                            pathspec.items[i].original);
 450                        }
 451                }
 452                free(seen);
 453        }
 454
 455        plug_bulk_checkin();
 456
 457        exit_status |= add_files_to_cache(prefix, &pathspec, flags);
 458
 459        if (add_new_files)
 460                exit_status |= add_files(&dir, flags);
 461
 462        if (chmod_arg && pathspec.nr)
 463                chmod_pathspec(&pathspec, chmod_arg[0]);
 464        unplug_bulk_checkin();
 465
 466finish:
 467        if (active_cache_changed) {
 468                if (write_locked_index(&the_index, &lock_file, COMMIT_LOCK))
 469                        die(_("Unable to write new index file"));
 470        }
 471
 472        return exit_status;
 473}