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