]>
Commit | Line | Data |
---|---|---|
1 | /* | |
2 | * Builtin "git replace" | |
3 | * | |
4 | * Copyright (c) 2008 Christian Couder <chriscool@tuxfamily.org> | |
5 | * | |
6 | * Based on builtin/tag.c by Kristian Høgsberg <krh@redhat.com> | |
7 | * and Carlos Rica <jasampler@gmail.com> that was itself based on | |
8 | * git-tag.sh and mktag.c by Linus Torvalds. | |
9 | */ | |
10 | ||
11 | #include "cache.h" | |
12 | #include "config.h" | |
13 | #include "builtin.h" | |
14 | #include "refs.h" | |
15 | #include "parse-options.h" | |
16 | #include "run-command.h" | |
17 | #include "object-store.h" | |
18 | #include "repository.h" | |
19 | #include "tag.h" | |
20 | ||
21 | static const char * const git_replace_usage[] = { | |
22 | N_("git replace [-f] <object> <replacement>"), | |
23 | N_("git replace [-f] --edit <object>"), | |
24 | N_("git replace [-f] --graft <commit> [<parent>...]"), | |
25 | N_("git replace [-f] --convert-graft-file"), | |
26 | N_("git replace -d <object>..."), | |
27 | N_("git replace [--format=<format>] [-l [<pattern>]]"), | |
28 | NULL | |
29 | }; | |
30 | ||
31 | enum replace_format { | |
32 | REPLACE_FORMAT_SHORT, | |
33 | REPLACE_FORMAT_MEDIUM, | |
34 | REPLACE_FORMAT_LONG | |
35 | }; | |
36 | ||
37 | struct show_data { | |
38 | const char *pattern; | |
39 | enum replace_format format; | |
40 | }; | |
41 | ||
42 | static int show_reference(struct repository *r, const char *refname, | |
43 | const struct object_id *oid, | |
44 | int flag, void *cb_data) | |
45 | { | |
46 | struct show_data *data = cb_data; | |
47 | ||
48 | if (!wildmatch(data->pattern, refname, 0)) { | |
49 | if (data->format == REPLACE_FORMAT_SHORT) | |
50 | printf("%s\n", refname); | |
51 | else if (data->format == REPLACE_FORMAT_MEDIUM) | |
52 | printf("%s -> %s\n", refname, oid_to_hex(oid)); | |
53 | else { /* data->format == REPLACE_FORMAT_LONG */ | |
54 | struct object_id object; | |
55 | enum object_type obj_type, repl_type; | |
56 | ||
57 | if (get_oid(refname, &object)) | |
58 | return error(_("failed to resolve '%s' as a valid ref"), refname); | |
59 | ||
60 | obj_type = oid_object_info(r, &object, NULL); | |
61 | repl_type = oid_object_info(r, oid, NULL); | |
62 | ||
63 | printf("%s (%s) -> %s (%s)\n", refname, type_name(obj_type), | |
64 | oid_to_hex(oid), type_name(repl_type)); | |
65 | } | |
66 | } | |
67 | ||
68 | return 0; | |
69 | } | |
70 | ||
71 | static int list_replace_refs(const char *pattern, const char *format) | |
72 | { | |
73 | struct show_data data; | |
74 | ||
75 | if (pattern == NULL) | |
76 | pattern = "*"; | |
77 | data.pattern = pattern; | |
78 | ||
79 | if (format == NULL || *format == '\0' || !strcmp(format, "short")) | |
80 | data.format = REPLACE_FORMAT_SHORT; | |
81 | else if (!strcmp(format, "medium")) | |
82 | data.format = REPLACE_FORMAT_MEDIUM; | |
83 | else if (!strcmp(format, "long")) | |
84 | data.format = REPLACE_FORMAT_LONG; | |
85 | /* | |
86 | * Please update _git_replace() in git-completion.bash when | |
87 | * you add new format | |
88 | */ | |
89 | else | |
90 | return error(_("invalid replace format '%s'\n" | |
91 | "valid formats are 'short', 'medium' and 'long'"), | |
92 | format); | |
93 | ||
94 | for_each_replace_ref(the_repository, show_reference, (void *)&data); | |
95 | ||
96 | return 0; | |
97 | } | |
98 | ||
99 | typedef int (*each_replace_name_fn)(const char *name, const char *ref, | |
100 | const struct object_id *oid); | |
101 | ||
102 | static int for_each_replace_name(const char **argv, each_replace_name_fn fn) | |
103 | { | |
104 | const char **p, *full_hex; | |
105 | struct strbuf ref = STRBUF_INIT; | |
106 | size_t base_len; | |
107 | int had_error = 0; | |
108 | struct object_id oid; | |
109 | ||
110 | strbuf_addstr(&ref, git_replace_ref_base); | |
111 | base_len = ref.len; | |
112 | ||
113 | for (p = argv; *p; p++) { | |
114 | if (get_oid(*p, &oid)) { | |
115 | error("failed to resolve '%s' as a valid ref", *p); | |
116 | had_error = 1; | |
117 | continue; | |
118 | } | |
119 | ||
120 | strbuf_setlen(&ref, base_len); | |
121 | strbuf_addstr(&ref, oid_to_hex(&oid)); | |
122 | full_hex = ref.buf + base_len; | |
123 | ||
124 | if (read_ref(ref.buf, &oid)) { | |
125 | error(_("replace ref '%s' not found"), full_hex); | |
126 | had_error = 1; | |
127 | continue; | |
128 | } | |
129 | if (fn(full_hex, ref.buf, &oid)) | |
130 | had_error = 1; | |
131 | } | |
132 | strbuf_release(&ref); | |
133 | return had_error; | |
134 | } | |
135 | ||
136 | static int delete_replace_ref(const char *name, const char *ref, | |
137 | const struct object_id *oid) | |
138 | { | |
139 | if (delete_ref(NULL, ref, oid, 0)) | |
140 | return 1; | |
141 | printf_ln(_("Deleted replace ref '%s'"), name); | |
142 | return 0; | |
143 | } | |
144 | ||
145 | static int check_ref_valid(struct object_id *object, | |
146 | struct object_id *prev, | |
147 | struct strbuf *ref, | |
148 | int force) | |
149 | { | |
150 | strbuf_reset(ref); | |
151 | strbuf_addf(ref, "%s%s", git_replace_ref_base, oid_to_hex(object)); | |
152 | if (check_refname_format(ref->buf, 0)) | |
153 | return error(_("'%s' is not a valid ref name"), ref->buf); | |
154 | ||
155 | if (read_ref(ref->buf, prev)) | |
156 | oidclr(prev); | |
157 | else if (!force) | |
158 | return error(_("replace ref '%s' already exists"), ref->buf); | |
159 | return 0; | |
160 | } | |
161 | ||
162 | static int replace_object_oid(const char *object_ref, | |
163 | struct object_id *object, | |
164 | const char *replace_ref, | |
165 | struct object_id *repl, | |
166 | int force) | |
167 | { | |
168 | struct object_id prev; | |
169 | enum object_type obj_type, repl_type; | |
170 | struct strbuf ref = STRBUF_INIT; | |
171 | struct ref_transaction *transaction; | |
172 | struct strbuf err = STRBUF_INIT; | |
173 | int res = 0; | |
174 | ||
175 | obj_type = oid_object_info(the_repository, object, NULL); | |
176 | repl_type = oid_object_info(the_repository, repl, NULL); | |
177 | if (!force && obj_type != repl_type) | |
178 | return error(_("Objects must be of the same type.\n" | |
179 | "'%s' points to a replaced object of type '%s'\n" | |
180 | "while '%s' points to a replacement object of " | |
181 | "type '%s'."), | |
182 | object_ref, type_name(obj_type), | |
183 | replace_ref, type_name(repl_type)); | |
184 | ||
185 | if (check_ref_valid(object, &prev, &ref, force)) { | |
186 | strbuf_release(&ref); | |
187 | return -1; | |
188 | } | |
189 | ||
190 | transaction = ref_transaction_begin(&err); | |
191 | if (!transaction || | |
192 | ref_transaction_update(transaction, ref.buf, repl, &prev, | |
193 | 0, NULL, &err) || | |
194 | ref_transaction_commit(transaction, &err)) | |
195 | res = error("%s", err.buf); | |
196 | ||
197 | ref_transaction_free(transaction); | |
198 | strbuf_release(&ref); | |
199 | return res; | |
200 | } | |
201 | ||
202 | static int replace_object(const char *object_ref, const char *replace_ref, int force) | |
203 | { | |
204 | struct object_id object, repl; | |
205 | ||
206 | if (get_oid(object_ref, &object)) | |
207 | return error(_("failed to resolve '%s' as a valid ref"), | |
208 | object_ref); | |
209 | if (get_oid(replace_ref, &repl)) | |
210 | return error(_("failed to resolve '%s' as a valid ref"), | |
211 | replace_ref); | |
212 | ||
213 | return replace_object_oid(object_ref, &object, replace_ref, &repl, force); | |
214 | } | |
215 | ||
216 | /* | |
217 | * Write the contents of the object named by "sha1" to the file "filename". | |
218 | * If "raw" is true, then the object's raw contents are printed according to | |
219 | * "type". Otherwise, we pretty-print the contents for human editing. | |
220 | */ | |
221 | static int export_object(const struct object_id *oid, enum object_type type, | |
222 | int raw, const char *filename) | |
223 | { | |
224 | struct child_process cmd = CHILD_PROCESS_INIT; | |
225 | int fd; | |
226 | ||
227 | fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666); | |
228 | if (fd < 0) | |
229 | return error_errno(_("unable to open %s for writing"), filename); | |
230 | ||
231 | argv_array_push(&cmd.args, "--no-replace-objects"); | |
232 | argv_array_push(&cmd.args, "cat-file"); | |
233 | if (raw) | |
234 | argv_array_push(&cmd.args, type_name(type)); | |
235 | else | |
236 | argv_array_push(&cmd.args, "-p"); | |
237 | argv_array_push(&cmd.args, oid_to_hex(oid)); | |
238 | cmd.git_cmd = 1; | |
239 | cmd.out = fd; | |
240 | ||
241 | if (run_command(&cmd)) | |
242 | return error(_("cat-file reported failure")); | |
243 | return 0; | |
244 | } | |
245 | ||
246 | /* | |
247 | * Read a previously-exported (and possibly edited) object back from "filename", | |
248 | * interpreting it as "type", and writing the result to the object database. | |
249 | * The sha1 of the written object is returned via sha1. | |
250 | */ | |
251 | static int import_object(struct object_id *oid, enum object_type type, | |
252 | int raw, const char *filename) | |
253 | { | |
254 | int fd; | |
255 | ||
256 | fd = open(filename, O_RDONLY); | |
257 | if (fd < 0) | |
258 | return error_errno(_("unable to open %s for reading"), filename); | |
259 | ||
260 | if (!raw && type == OBJ_TREE) { | |
261 | const char *argv[] = { "mktree", NULL }; | |
262 | struct child_process cmd = CHILD_PROCESS_INIT; | |
263 | struct strbuf result = STRBUF_INIT; | |
264 | ||
265 | cmd.argv = argv; | |
266 | cmd.git_cmd = 1; | |
267 | cmd.in = fd; | |
268 | cmd.out = -1; | |
269 | ||
270 | if (start_command(&cmd)) { | |
271 | close(fd); | |
272 | return error(_("unable to spawn mktree")); | |
273 | } | |
274 | ||
275 | if (strbuf_read(&result, cmd.out, the_hash_algo->hexsz + 1) < 0) { | |
276 | error_errno(_("unable to read from mktree")); | |
277 | close(fd); | |
278 | close(cmd.out); | |
279 | return -1; | |
280 | } | |
281 | close(cmd.out); | |
282 | ||
283 | if (finish_command(&cmd)) { | |
284 | strbuf_release(&result); | |
285 | return error(_("mktree reported failure")); | |
286 | } | |
287 | if (get_oid_hex(result.buf, oid) < 0) { | |
288 | strbuf_release(&result); | |
289 | return error(_("mktree did not return an object name")); | |
290 | } | |
291 | ||
292 | strbuf_release(&result); | |
293 | } else { | |
294 | struct stat st; | |
295 | int flags = HASH_FORMAT_CHECK | HASH_WRITE_OBJECT; | |
296 | ||
297 | if (fstat(fd, &st) < 0) { | |
298 | error_errno(_("unable to fstat %s"), filename); | |
299 | close(fd); | |
300 | return -1; | |
301 | } | |
302 | if (index_fd(the_repository->index, oid, fd, &st, type, NULL, flags) < 0) | |
303 | return error(_("unable to write object to database")); | |
304 | /* index_fd close()s fd for us */ | |
305 | } | |
306 | ||
307 | /* | |
308 | * No need to close(fd) here; both run-command and index-fd | |
309 | * will have done it for us. | |
310 | */ | |
311 | return 0; | |
312 | } | |
313 | ||
314 | static int edit_and_replace(const char *object_ref, int force, int raw) | |
315 | { | |
316 | char *tmpfile; | |
317 | enum object_type type; | |
318 | struct object_id old_oid, new_oid, prev; | |
319 | struct strbuf ref = STRBUF_INIT; | |
320 | ||
321 | if (get_oid(object_ref, &old_oid) < 0) | |
322 | return error(_("not a valid object name: '%s'"), object_ref); | |
323 | ||
324 | type = oid_object_info(the_repository, &old_oid, NULL); | |
325 | if (type < 0) | |
326 | return error(_("unable to get object type for %s"), | |
327 | oid_to_hex(&old_oid)); | |
328 | ||
329 | if (check_ref_valid(&old_oid, &prev, &ref, force)) { | |
330 | strbuf_release(&ref); | |
331 | return -1; | |
332 | } | |
333 | strbuf_release(&ref); | |
334 | ||
335 | tmpfile = git_pathdup("REPLACE_EDITOBJ"); | |
336 | if (export_object(&old_oid, type, raw, tmpfile)) { | |
337 | free(tmpfile); | |
338 | return -1; | |
339 | } | |
340 | if (launch_editor(tmpfile, NULL, NULL) < 0) { | |
341 | free(tmpfile); | |
342 | return error(_("editing object file failed")); | |
343 | } | |
344 | if (import_object(&new_oid, type, raw, tmpfile)) { | |
345 | free(tmpfile); | |
346 | return -1; | |
347 | } | |
348 | free(tmpfile); | |
349 | ||
350 | if (oideq(&old_oid, &new_oid)) | |
351 | return error(_("new object is the same as the old one: '%s'"), oid_to_hex(&old_oid)); | |
352 | ||
353 | return replace_object_oid(object_ref, &old_oid, "replacement", &new_oid, force); | |
354 | } | |
355 | ||
356 | static int replace_parents(struct strbuf *buf, int argc, const char **argv) | |
357 | { | |
358 | struct strbuf new_parents = STRBUF_INIT; | |
359 | const char *parent_start, *parent_end; | |
360 | int i; | |
361 | const unsigned hexsz = the_hash_algo->hexsz; | |
362 | ||
363 | /* find existing parents */ | |
364 | parent_start = buf->buf; | |
365 | parent_start += hexsz + 6; /* "tree " + "hex sha1" + "\n" */ | |
366 | parent_end = parent_start; | |
367 | ||
368 | while (starts_with(parent_end, "parent ")) | |
369 | parent_end += hexsz + 8; /* "parent " + "hex sha1" + "\n" */ | |
370 | ||
371 | /* prepare new parents */ | |
372 | for (i = 0; i < argc; i++) { | |
373 | struct object_id oid; | |
374 | struct commit *commit; | |
375 | ||
376 | if (get_oid(argv[i], &oid) < 0) { | |
377 | strbuf_release(&new_parents); | |
378 | return error(_("not a valid object name: '%s'"), | |
379 | argv[i]); | |
380 | } | |
381 | commit = lookup_commit_reference(the_repository, &oid); | |
382 | if (!commit) { | |
383 | strbuf_release(&new_parents); | |
384 | return error(_("could not parse %s as a commit"), argv[i]); | |
385 | } | |
386 | strbuf_addf(&new_parents, "parent %s\n", oid_to_hex(&commit->object.oid)); | |
387 | } | |
388 | ||
389 | /* replace existing parents with new ones */ | |
390 | strbuf_splice(buf, parent_start - buf->buf, parent_end - parent_start, | |
391 | new_parents.buf, new_parents.len); | |
392 | ||
393 | strbuf_release(&new_parents); | |
394 | return 0; | |
395 | } | |
396 | ||
397 | struct check_mergetag_data { | |
398 | int argc; | |
399 | const char **argv; | |
400 | }; | |
401 | ||
402 | static int check_one_mergetag(struct commit *commit, | |
403 | struct commit_extra_header *extra, | |
404 | void *data) | |
405 | { | |
406 | struct check_mergetag_data *mergetag_data = (struct check_mergetag_data *)data; | |
407 | const char *ref = mergetag_data->argv[0]; | |
408 | struct object_id tag_oid; | |
409 | struct tag *tag; | |
410 | int i; | |
411 | ||
412 | hash_object_file(extra->value, extra->len, type_name(OBJ_TAG), &tag_oid); | |
413 | tag = lookup_tag(the_repository, &tag_oid); | |
414 | if (!tag) | |
415 | return error(_("bad mergetag in commit '%s'"), ref); | |
416 | if (parse_tag_buffer(the_repository, tag, extra->value, extra->len)) | |
417 | return error(_("malformed mergetag in commit '%s'"), ref); | |
418 | ||
419 | /* iterate over new parents */ | |
420 | for (i = 1; i < mergetag_data->argc; i++) { | |
421 | struct object_id oid; | |
422 | if (get_oid(mergetag_data->argv[i], &oid) < 0) | |
423 | return error(_("not a valid object name: '%s'"), | |
424 | mergetag_data->argv[i]); | |
425 | if (oideq(get_tagged_oid(tag), &oid)) | |
426 | return 0; /* found */ | |
427 | } | |
428 | ||
429 | return error(_("original commit '%s' contains mergetag '%s' that is " | |
430 | "discarded; use --edit instead of --graft"), ref, | |
431 | oid_to_hex(&tag_oid)); | |
432 | } | |
433 | ||
434 | static int check_mergetags(struct commit *commit, int argc, const char **argv) | |
435 | { | |
436 | struct check_mergetag_data mergetag_data; | |
437 | ||
438 | mergetag_data.argc = argc; | |
439 | mergetag_data.argv = argv; | |
440 | return for_each_mergetag(check_one_mergetag, commit, &mergetag_data); | |
441 | } | |
442 | ||
443 | static int create_graft(int argc, const char **argv, int force, int gentle) | |
444 | { | |
445 | struct object_id old_oid, new_oid; | |
446 | const char *old_ref = argv[0]; | |
447 | struct commit *commit; | |
448 | struct strbuf buf = STRBUF_INIT; | |
449 | const char *buffer; | |
450 | unsigned long size; | |
451 | ||
452 | if (get_oid(old_ref, &old_oid) < 0) | |
453 | return error(_("not a valid object name: '%s'"), old_ref); | |
454 | commit = lookup_commit_reference(the_repository, &old_oid); | |
455 | if (!commit) | |
456 | return error(_("could not parse %s"), old_ref); | |
457 | ||
458 | buffer = get_commit_buffer(commit, &size); | |
459 | strbuf_add(&buf, buffer, size); | |
460 | unuse_commit_buffer(commit, buffer); | |
461 | ||
462 | if (replace_parents(&buf, argc - 1, &argv[1]) < 0) { | |
463 | strbuf_release(&buf); | |
464 | return -1; | |
465 | } | |
466 | ||
467 | if (remove_signature(&buf)) { | |
468 | warning(_("the original commit '%s' has a gpg signature"), old_ref); | |
469 | warning(_("the signature will be removed in the replacement commit!")); | |
470 | } | |
471 | ||
472 | if (check_mergetags(commit, argc, argv)) { | |
473 | strbuf_release(&buf); | |
474 | return -1; | |
475 | } | |
476 | ||
477 | if (write_object_file(buf.buf, buf.len, commit_type, &new_oid)) { | |
478 | strbuf_release(&buf); | |
479 | return error(_("could not write replacement commit for: '%s'"), | |
480 | old_ref); | |
481 | } | |
482 | ||
483 | strbuf_release(&buf); | |
484 | ||
485 | if (oideq(&commit->object.oid, &new_oid)) { | |
486 | if (gentle) { | |
487 | warning(_("graft for '%s' unnecessary"), | |
488 | oid_to_hex(&commit->object.oid)); | |
489 | return 0; | |
490 | } | |
491 | return error(_("new commit is the same as the old one: '%s'"), | |
492 | oid_to_hex(&commit->object.oid)); | |
493 | } | |
494 | ||
495 | return replace_object_oid(old_ref, &commit->object.oid, | |
496 | "replacement", &new_oid, force); | |
497 | } | |
498 | ||
499 | static int convert_graft_file(int force) | |
500 | { | |
501 | const char *graft_file = get_graft_file(the_repository); | |
502 | FILE *fp = fopen_or_warn(graft_file, "r"); | |
503 | struct strbuf buf = STRBUF_INIT, err = STRBUF_INIT; | |
504 | struct argv_array args = ARGV_ARRAY_INIT; | |
505 | ||
506 | if (!fp) | |
507 | return -1; | |
508 | ||
509 | advice_graft_file_deprecated = 0; | |
510 | while (strbuf_getline(&buf, fp) != EOF) { | |
511 | if (*buf.buf == '#') | |
512 | continue; | |
513 | ||
514 | argv_array_split(&args, buf.buf); | |
515 | if (args.argc && create_graft(args.argc, args.argv, force, 1)) | |
516 | strbuf_addf(&err, "\n\t%s", buf.buf); | |
517 | argv_array_clear(&args); | |
518 | } | |
519 | fclose(fp); | |
520 | ||
521 | strbuf_release(&buf); | |
522 | ||
523 | if (!err.len) | |
524 | return unlink_or_warn(graft_file); | |
525 | ||
526 | warning(_("could not convert the following graft(s):\n%s"), err.buf); | |
527 | strbuf_release(&err); | |
528 | ||
529 | return -1; | |
530 | } | |
531 | ||
532 | int cmd_replace(int argc, const char **argv, const char *prefix) | |
533 | { | |
534 | int force = 0; | |
535 | int raw = 0; | |
536 | const char *format = NULL; | |
537 | enum { | |
538 | MODE_UNSPECIFIED = 0, | |
539 | MODE_LIST, | |
540 | MODE_DELETE, | |
541 | MODE_EDIT, | |
542 | MODE_GRAFT, | |
543 | MODE_CONVERT_GRAFT_FILE, | |
544 | MODE_REPLACE | |
545 | } cmdmode = MODE_UNSPECIFIED; | |
546 | struct option options[] = { | |
547 | OPT_CMDMODE('l', "list", &cmdmode, N_("list replace refs"), MODE_LIST), | |
548 | OPT_CMDMODE('d', "delete", &cmdmode, N_("delete replace refs"), MODE_DELETE), | |
549 | OPT_CMDMODE('e', "edit", &cmdmode, N_("edit existing object"), MODE_EDIT), | |
550 | OPT_CMDMODE('g', "graft", &cmdmode, N_("change a commit's parents"), MODE_GRAFT), | |
551 | OPT_CMDMODE(0, "convert-graft-file", &cmdmode, N_("convert existing graft file"), MODE_CONVERT_GRAFT_FILE), | |
552 | OPT_BOOL_F('f', "force", &force, N_("replace the ref if it exists"), | |
553 | PARSE_OPT_NOCOMPLETE), | |
554 | OPT_BOOL(0, "raw", &raw, N_("do not pretty-print contents for --edit")), | |
555 | OPT_STRING(0, "format", &format, N_("format"), N_("use this format")), | |
556 | OPT_END() | |
557 | }; | |
558 | ||
559 | read_replace_refs = 0; | |
560 | git_config(git_default_config, NULL); | |
561 | ||
562 | argc = parse_options(argc, argv, prefix, options, git_replace_usage, 0); | |
563 | ||
564 | if (!cmdmode) | |
565 | cmdmode = argc ? MODE_REPLACE : MODE_LIST; | |
566 | ||
567 | if (format && cmdmode != MODE_LIST) | |
568 | usage_msg_opt(_("--format cannot be used when not listing"), | |
569 | git_replace_usage, options); | |
570 | ||
571 | if (force && | |
572 | cmdmode != MODE_REPLACE && | |
573 | cmdmode != MODE_EDIT && | |
574 | cmdmode != MODE_GRAFT && | |
575 | cmdmode != MODE_CONVERT_GRAFT_FILE) | |
576 | usage_msg_opt(_("-f only makes sense when writing a replacement"), | |
577 | git_replace_usage, options); | |
578 | ||
579 | if (raw && cmdmode != MODE_EDIT) | |
580 | usage_msg_opt(_("--raw only makes sense with --edit"), | |
581 | git_replace_usage, options); | |
582 | ||
583 | switch (cmdmode) { | |
584 | case MODE_DELETE: | |
585 | if (argc < 1) | |
586 | usage_msg_opt(_("-d needs at least one argument"), | |
587 | git_replace_usage, options); | |
588 | return for_each_replace_name(argv, delete_replace_ref); | |
589 | ||
590 | case MODE_REPLACE: | |
591 | if (argc != 2) | |
592 | usage_msg_opt(_("bad number of arguments"), | |
593 | git_replace_usage, options); | |
594 | return replace_object(argv[0], argv[1], force); | |
595 | ||
596 | case MODE_EDIT: | |
597 | if (argc != 1) | |
598 | usage_msg_opt(_("-e needs exactly one argument"), | |
599 | git_replace_usage, options); | |
600 | return edit_and_replace(argv[0], force, raw); | |
601 | ||
602 | case MODE_GRAFT: | |
603 | if (argc < 1) | |
604 | usage_msg_opt(_("-g needs at least one argument"), | |
605 | git_replace_usage, options); | |
606 | return create_graft(argc, argv, force, 0); | |
607 | ||
608 | case MODE_CONVERT_GRAFT_FILE: | |
609 | if (argc != 0) | |
610 | usage_msg_opt(_("--convert-graft-file takes no argument"), | |
611 | git_replace_usage, options); | |
612 | return !!convert_graft_file(force); | |
613 | ||
614 | case MODE_LIST: | |
615 | if (argc > 1) | |
616 | usage_msg_opt(_("only one pattern can be given with -l"), | |
617 | git_replace_usage, options); | |
618 | return list_replace_refs(argv[0], format); | |
619 | ||
620 | default: | |
621 | BUG("invalid cmdmode %d", (int)cmdmode); | |
622 | } | |
623 | } |