builtin-rm.con commit Library function to check for unmerged index entries (94a5728)
   1/*
   2 * "git rm" builtin command
   3 *
   4 * Copyright (C) Linus Torvalds 2006
   5 */
   6#include "cache.h"
   7#include "builtin.h"
   8#include "dir.h"
   9#include "cache-tree.h"
  10#include "tree-walk.h"
  11#include "parse-options.h"
  12
  13static const char * const builtin_rm_usage[] = {
  14        "git-rm [options] [--] <file>...",
  15        NULL
  16};
  17
  18static struct {
  19        int nr, alloc;
  20        const char **name;
  21} list;
  22
  23static void add_list(const char *name)
  24{
  25        if (list.nr >= list.alloc) {
  26                list.alloc = alloc_nr(list.alloc);
  27                list.name = xrealloc(list.name, list.alloc * sizeof(const char *));
  28        }
  29        list.name[list.nr++] = name;
  30}
  31
  32static int remove_file(const char *name)
  33{
  34        int ret;
  35        char *slash;
  36
  37        ret = unlink(name);
  38        if (ret && errno == ENOENT)
  39                /* The user has removed it from the filesystem by hand */
  40                ret = errno = 0;
  41
  42        if (!ret && (slash = strrchr(name, '/'))) {
  43                char *n = xstrdup(name);
  44                do {
  45                        n[slash - name] = 0;
  46                        name = n;
  47                } while (!rmdir(name) && (slash = strrchr(name, '/')));
  48        }
  49        return ret;
  50}
  51
  52static int check_local_mod(unsigned char *head, int index_only)
  53{
  54        /* items in list are already sorted in the cache order,
  55         * so we could do this a lot more efficiently by using
  56         * tree_desc based traversal if we wanted to, but I am
  57         * lazy, and who cares if removal of files is a tad
  58         * slower than the theoretical maximum speed?
  59         */
  60        int i, no_head;
  61        int errs = 0;
  62
  63        no_head = is_null_sha1(head);
  64        for (i = 0; i < list.nr; i++) {
  65                struct stat st;
  66                int pos;
  67                struct cache_entry *ce;
  68                const char *name = list.name[i];
  69                unsigned char sha1[20];
  70                unsigned mode;
  71                int local_changes = 0;
  72                int staged_changes = 0;
  73
  74                pos = cache_name_pos(name, strlen(name));
  75                if (pos < 0)
  76                        continue; /* removing unmerged entry */
  77                ce = active_cache[pos];
  78
  79                if (lstat(ce->name, &st) < 0) {
  80                        if (errno != ENOENT)
  81                                fprintf(stderr, "warning: '%s': %s",
  82                                        ce->name, strerror(errno));
  83                        /* It already vanished from the working tree */
  84                        continue;
  85                }
  86                else if (S_ISDIR(st.st_mode)) {
  87                        /* if a file was removed and it is now a
  88                         * directory, that is the same as ENOENT as
  89                         * far as git is concerned; we do not track
  90                         * directories.
  91                         */
  92                        continue;
  93                }
  94                if (ce_match_stat(ce, &st, 0))
  95                        local_changes = 1;
  96                if (no_head
  97                     || get_tree_entry(head, name, sha1, &mode)
  98                     || ce->ce_mode != create_ce_mode(mode)
  99                     || hashcmp(ce->sha1, sha1))
 100                        staged_changes = 1;
 101
 102                if (local_changes && staged_changes)
 103                        errs = error("'%s' has staged content different "
 104                                     "from both the file and the HEAD\n"
 105                                     "(use -f to force removal)", name);
 106                else if (!index_only) {
 107                        /* It's not dangerous to git-rm --cached a
 108                         * file if the index matches the file or the
 109                         * HEAD, since it means the deleted content is
 110                         * still available somewhere.
 111                         */
 112                        if (staged_changes)
 113                                errs = error("'%s' has changes staged in the index\n"
 114                                             "(use --cached to keep the file, "
 115                                             "or -f to force removal)", name);
 116                        if (local_changes)
 117                                errs = error("'%s' has local modifications\n"
 118                                             "(use --cached to keep the file, "
 119                                             "or -f to force removal)", name);
 120                }
 121        }
 122        return errs;
 123}
 124
 125static struct lock_file lock_file;
 126
 127static int show_only = 0, force = 0, index_only = 0, recursive = 0, quiet = 0;
 128static int ignore_unmatch = 0;
 129
 130static struct option builtin_rm_options[] = {
 131        OPT__DRY_RUN(&show_only),
 132        OPT__QUIET(&quiet),
 133        OPT_BOOLEAN( 0 , "cached",         &index_only, "only remove from the index"),
 134        OPT_BOOLEAN('f', NULL,             &force,      "override the up-to-date check"),
 135        OPT_BOOLEAN('r', NULL,             &recursive,  "allow recursive removal"),
 136        OPT_BOOLEAN( 0 , "ignore-unmatch", &ignore_unmatch,
 137                                "exit with a zero status even if nothing matched"),
 138        OPT_END(),
 139};
 140
 141int cmd_rm(int argc, const char **argv, const char *prefix)
 142{
 143        int i, newfd;
 144        const char **pathspec;
 145        char *seen;
 146
 147        git_config(git_default_config);
 148
 149        newfd = hold_locked_index(&lock_file, 1);
 150
 151        if (read_cache() < 0)
 152                die("index file corrupt");
 153
 154        argc = parse_options(argc, argv, builtin_rm_options, builtin_rm_usage, 0);
 155        if (!argc)
 156                usage_with_options(builtin_rm_usage, builtin_rm_options);
 157
 158        if (!index_only)
 159                setup_work_tree();
 160
 161        pathspec = get_pathspec(prefix, argv);
 162        seen = NULL;
 163        for (i = 0; pathspec[i] ; i++)
 164                /* nothing */;
 165        seen = xcalloc(i, 1);
 166
 167        for (i = 0; i < active_nr; i++) {
 168                struct cache_entry *ce = active_cache[i];
 169                if (!match_pathspec(pathspec, ce->name, ce_namelen(ce), 0, seen))
 170                        continue;
 171                add_list(ce->name);
 172        }
 173
 174        if (pathspec) {
 175                const char *match;
 176                int seen_any = 0;
 177                for (i = 0; (match = pathspec[i]) != NULL ; i++) {
 178                        if (!seen[i]) {
 179                                if (!ignore_unmatch) {
 180                                        die("pathspec '%s' did not match any files",
 181                                            match);
 182                                }
 183                        }
 184                        else {
 185                                seen_any = 1;
 186                        }
 187                        if (!recursive && seen[i] == MATCHED_RECURSIVELY)
 188                                die("not removing '%s' recursively without -r",
 189                                    *match ? match : ".");
 190                }
 191
 192                if (! seen_any)
 193                        exit(0);
 194        }
 195
 196        /*
 197         * If not forced, the file, the index and the HEAD (if exists)
 198         * must match; but the file can already been removed, since
 199         * this sequence is a natural "novice" way:
 200         *
 201         *      rm F; git rm F
 202         *
 203         * Further, if HEAD commit exists, "diff-index --cached" must
 204         * report no changes unless forced.
 205         */
 206        if (!force) {
 207                unsigned char sha1[20];
 208                if (get_sha1("HEAD", sha1))
 209                        hashclr(sha1);
 210                if (check_local_mod(sha1, index_only))
 211                        exit(1);
 212        }
 213
 214        /*
 215         * First remove the names from the index: we won't commit
 216         * the index unless all of them succeed.
 217         */
 218        for (i = 0; i < list.nr; i++) {
 219                const char *path = list.name[i];
 220                if (!quiet)
 221                        printf("rm '%s'\n", path);
 222
 223                if (remove_file_from_cache(path))
 224                        die("git-rm: unable to remove %s", path);
 225        }
 226
 227        if (show_only)
 228                return 0;
 229
 230        /*
 231         * Then, unless we used "--cached", remove the filenames from
 232         * the workspace. If we fail to remove the first one, we
 233         * abort the "git rm" (but once we've successfully removed
 234         * any file at all, we'll go ahead and commit to it all:
 235         * by then we've already committed ourselves and can't fail
 236         * in the middle)
 237         */
 238        if (!index_only) {
 239                int removed = 0;
 240                for (i = 0; i < list.nr; i++) {
 241                        const char *path = list.name[i];
 242                        if (!remove_file(path)) {
 243                                removed = 1;
 244                                continue;
 245                        }
 246                        if (!removed)
 247                                die("git-rm: %s: %s", path, strerror(errno));
 248                }
 249        }
 250
 251        if (active_cache_changed) {
 252                if (write_cache(newfd, active_cache, active_nr) ||
 253                    commit_locked_index(&lock_file))
 254                        die("Unable to write new index file");
 255        }
 256
 257        return 0;
 258}