replace.c 14.1 KB
Newer Older
1 2 3 4 5
/*
 * Builtin "git replace"
 *
 * Copyright (c) 2008 Christian Couder <chriscool@tuxfamily.org>
 *
6
 * Based on builtin/tag.c by Kristian Høgsberg <krh@redhat.com>
7 8 9 10 11
 * and Carlos Rica <jasampler@gmail.com> that was itself based on
 * git-tag.sh and mktag.c by Linus Torvalds.
 */

#include "cache.h"
12
#include "config.h"
13 14 15
#include "builtin.h"
#include "refs.h"
#include "parse-options.h"
Jeff King's avatar
Jeff King committed
16
#include "run-command.h"
17 18
#include "object-store.h"
#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 -d <object>..."),
26
	N_("git replace [--format=<format>] [-l [<pattern>]]"),
27 28 29
	NULL
};

30
enum replace_format {
31 32 33
	REPLACE_FORMAT_SHORT,
	REPLACE_FORMAT_MEDIUM,
	REPLACE_FORMAT_LONG
34
};
35 36 37

struct show_data {
	const char *pattern;
38
	enum replace_format format;
39 40
};

41
static int show_reference(const char *refname, const struct object_id *oid,
42 43
			  int flag, void *cb_data)
{
44 45
	struct show_data *data = cb_data;

46
	if (!wildmatch(data->pattern, refname, 0)) {
47
		if (data->format == REPLACE_FORMAT_SHORT)
48
			printf("%s\n", refname);
49
		else if (data->format == REPLACE_FORMAT_MEDIUM)
50
			printf("%s -> %s\n", refname, oid_to_hex(oid));
51
		else { /* data->format == REPLACE_FORMAT_LONG */
52
			struct object_id object;
53
			enum object_type obj_type, repl_type;
54

55
			if (get_oid(refname, &object))
56 57
				return error("Failed to resolve '%s' as a valid ref.", refname);

58 59 60
			obj_type = oid_object_info(the_repository, &object,
						   NULL);
			repl_type = oid_object_info(the_repository, oid, NULL);
61

62 63
			printf("%s (%s) -> %s (%s)\n", refname, type_name(obj_type),
			       oid_to_hex(oid), type_name(repl_type));
64 65
		}
	}
66 67 68 69

	return 0;
}

70
static int list_replace_refs(const char *pattern, const char *format)
71
{
72 73
	struct show_data data;

74 75
	if (pattern == NULL)
		pattern = "*";
76 77 78
	data.pattern = pattern;

	if (format == NULL || *format == '\0' || !strcmp(format, "short"))
79
		data.format = REPLACE_FORMAT_SHORT;
80
	else if (!strcmp(format, "medium"))
81 82 83
		data.format = REPLACE_FORMAT_MEDIUM;
	else if (!strcmp(format, "long"))
		data.format = REPLACE_FORMAT_LONG;
84 85
	else
		die("invalid replace format '%s'\n"
86
		    "valid formats are 'short', 'medium' and 'long'\n",
87
		    format);
88

89
	for_each_replace_ref(the_repository, show_reference, (void *)&data);
90 91 92 93 94

	return 0;
}

typedef int (*each_replace_name_fn)(const char *name, const char *ref,
95
				    const struct object_id *oid);
96 97 98

static int for_each_replace_name(const char **argv, each_replace_name_fn fn)
{
99
	const char **p, *full_hex;
100 101
	struct strbuf ref = STRBUF_INIT;
	size_t base_len;
102
	int had_error = 0;
103
	struct object_id oid;
104

105 106 107
	strbuf_addstr(&ref, git_replace_ref_base);
	base_len = ref.len;

108
	for (p = argv; *p; p++) {
109
		if (get_oid(*p, &oid)) {
110
			error("Failed to resolve '%s' as a valid ref.", *p);
111 112 113
			had_error = 1;
			continue;
		}
114 115 116 117 118

		strbuf_setlen(&ref, base_len);
		strbuf_addstr(&ref, oid_to_hex(&oid));
		full_hex = ref.buf + base_len;

119
		if (read_ref(ref.buf, &oid)) {
120
			error("replace ref '%s' not found.", full_hex);
121 122 123
			had_error = 1;
			continue;
		}
124
		if (fn(full_hex, ref.buf, &oid))
125 126
			had_error = 1;
	}
127
	strbuf_release(&ref);
128 129 130 131
	return had_error;
}

static int delete_replace_ref(const char *name, const char *ref,
132
			      const struct object_id *oid)
133
{
134
	if (delete_ref(NULL, ref, oid, 0))
135 136 137 138 139
		return 1;
	printf("Deleted replace ref '%s'\n", name);
	return 0;
}

140 141
static void check_ref_valid(struct object_id *object,
			    struct object_id *prev,
142
			    struct strbuf *ref,
143 144
			    int force)
{
145 146 147 148 149
	strbuf_reset(ref);
	strbuf_addf(ref, "%s%s", git_replace_ref_base, oid_to_hex(object));
	if (check_refname_format(ref->buf, 0))
		die("'%s' is not a valid ref name.", ref->buf);

150
	if (read_ref(ref->buf, prev))
151
		oidclr(prev);
152
	else if (!force)
153
		die("replace ref '%s' already exists", ref->buf);
154 155
}

156 157
static int replace_object_oid(const char *object_ref,
			       struct object_id *object,
158
			       const char *replace_ref,
159
			       struct object_id *repl,
160
			       int force)
161
{
162
	struct object_id prev;
163
	enum object_type obj_type, repl_type;
164
	struct strbuf ref = STRBUF_INIT;
165 166
	struct ref_transaction *transaction;
	struct strbuf err = STRBUF_INIT;
167

168 169
	obj_type = oid_object_info(the_repository, object, NULL);
	repl_type = oid_object_info(the_repository, repl, NULL);
170 171 172 173
	if (!force && obj_type != repl_type)
		die("Objects must be of the same type.\n"
		    "'%s' points to a replaced object of type '%s'\n"
		    "while '%s' points to a replacement object of type '%s'.",
174 175
		    object_ref, type_name(obj_type),
		    replace_ref, type_name(repl_type));
176

177
	check_ref_valid(object, &prev, &ref, force);
178

179 180
	transaction = ref_transaction_begin(&err);
	if (!transaction ||
181
	    ref_transaction_update(transaction, ref.buf, repl, &prev,
182
				   0, NULL, &err) ||
183
	    ref_transaction_commit(transaction, &err))
184
		die("%s", err.buf);
185

186
	ref_transaction_free(transaction);
187
	strbuf_release(&ref);
188 189 190
	return 0;
}

191 192
static int replace_object(const char *object_ref, const char *replace_ref, int force)
{
193
	struct object_id object, repl;
194

195
	if (get_oid(object_ref, &object))
196
		die("Failed to resolve '%s' as a valid ref.", object_ref);
197
	if (get_oid(replace_ref, &repl))
198 199
		die("Failed to resolve '%s' as a valid ref.", replace_ref);

200
	return replace_object_oid(object_ref, &object, replace_ref, &repl, force);
201 202
}

Jeff King's avatar
Jeff King committed
203
/*
204 205 206
 * Write the contents of the object named by "sha1" to the file "filename".
 * If "raw" is true, then the object's raw contents are printed according to
 * "type". Otherwise, we pretty-print the contents for human editing.
Jeff King's avatar
Jeff King committed
207
 */
208
static void export_object(const struct object_id *oid, enum object_type type,
209
			  int raw, const char *filename)
Jeff King's avatar
Jeff King committed
210
{
211
	struct child_process cmd = CHILD_PROCESS_INIT;
Jeff King's avatar
Jeff King committed
212 213 214 215 216 217
	int fd;

	fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
	if (fd < 0)
		die_errno("unable to open %s for writing", filename);

218 219
	argv_array_push(&cmd.args, "--no-replace-objects");
	argv_array_push(&cmd.args, "cat-file");
220
	if (raw)
221
		argv_array_push(&cmd.args, type_name(type));
222 223
	else
		argv_array_push(&cmd.args, "-p");
224
	argv_array_push(&cmd.args, oid_to_hex(oid));
Jeff King's avatar
Jeff King committed
225 226 227 228 229 230 231 232 233 234 235 236
	cmd.git_cmd = 1;
	cmd.out = fd;

	if (run_command(&cmd))
		die("cat-file reported failure");
}

/*
 * Read a previously-exported (and possibly edited) object back from "filename",
 * interpreting it as "type", and writing the result to the object database.
 * The sha1 of the written object is returned via sha1.
 */
237
static void import_object(struct object_id *oid, enum object_type type,
238
			  int raw, const char *filename)
Jeff King's avatar
Jeff King committed
239 240 241 242 243 244 245
{
	int fd;

	fd = open(filename, O_RDONLY);
	if (fd < 0)
		die_errno("unable to open %s for reading", filename);

246
	if (!raw && type == OBJ_TREE) {
Jeff King's avatar
Jeff King committed
247
		const char *argv[] = { "mktree", NULL };
248
		struct child_process cmd = CHILD_PROCESS_INIT;
Jeff King's avatar
Jeff King committed
249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264
		struct strbuf result = STRBUF_INIT;

		cmd.argv = argv;
		cmd.git_cmd = 1;
		cmd.in = fd;
		cmd.out = -1;

		if (start_command(&cmd))
			die("unable to spawn mktree");

		if (strbuf_read(&result, cmd.out, 41) < 0)
			die_errno("unable to read from mktree");
		close(cmd.out);

		if (finish_command(&cmd))
			die("mktree reported failure");
265
		if (get_oid_hex(result.buf, oid) < 0)
Jeff King's avatar
Jeff King committed
266 267 268 269 270 271 272 273 274
			die("mktree did not return an object name");

		strbuf_release(&result);
	} else {
		struct stat st;
		int flags = HASH_FORMAT_CHECK | HASH_WRITE_OBJECT;

		if (fstat(fd, &st) < 0)
			die_errno("unable to fstat %s", filename);
275
		if (index_fd(oid, fd, &st, type, NULL, flags) < 0)
Jeff King's avatar
Jeff King committed
276 277 278 279 280 281 282 283 284 285
			die("unable to write object to database");
		/* index_fd close()s fd for us */
	}

	/*
	 * No need to close(fd) here; both run-command and index-fd
	 * will have done it for us.
	 */
}

286
static int edit_and_replace(const char *object_ref, int force, int raw)
Jeff King's avatar
Jeff King committed
287 288 289
{
	char *tmpfile = git_pathdup("REPLACE_EDITOBJ");
	enum object_type type;
290
	struct object_id old_oid, new_oid, prev;
291
	struct strbuf ref = STRBUF_INIT;
Jeff King's avatar
Jeff King committed
292

293
	if (get_oid(object_ref, &old_oid) < 0)
Jeff King's avatar
Jeff King committed
294 295
		die("Not a valid object name: '%s'", object_ref);

296
	type = oid_object_info(the_repository, &old_oid, NULL);
Jeff King's avatar
Jeff King committed
297
	if (type < 0)
298
		die("unable to get object type for %s", oid_to_hex(&old_oid));
Jeff King's avatar
Jeff King committed
299

300
	check_ref_valid(&old_oid, &prev, &ref, force);
301
	strbuf_release(&ref);
302

303
	export_object(&old_oid, type, raw, tmpfile);
Jeff King's avatar
Jeff King committed
304 305
	if (launch_editor(tmpfile, NULL, NULL) < 0)
		die("editing object file failed");
306
	import_object(&new_oid, type, raw, tmpfile);
Jeff King's avatar
Jeff King committed
307 308 309

	free(tmpfile);

310 311
	if (!oidcmp(&old_oid, &new_oid))
		return error("new object is the same as the old one: '%s'", oid_to_hex(&old_oid));
312

313
	return replace_object_oid(object_ref, &old_oid, "replacement", &new_oid, force);
Jeff King's avatar
Jeff King committed
314 315
}

316 317 318 319 320 321 322 323
static void replace_parents(struct strbuf *buf, int argc, const char **argv)
{
	struct strbuf new_parents = STRBUF_INIT;
	const char *parent_start, *parent_end;
	int i;

	/* find existing parents */
	parent_start = buf->buf;
324
	parent_start += GIT_SHA1_HEXSZ + 6; /* "tree " + "hex sha1" + "\n" */
325 326 327 328 329 330 331
	parent_end = parent_start;

	while (starts_with(parent_end, "parent "))
		parent_end += 48; /* "parent " + "hex sha1" + "\n" */

	/* prepare new parents */
	for (i = 0; i < argc; i++) {
332 333
		struct object_id oid;
		if (get_oid(argv[i], &oid) < 0)
334
			die(_("Not a valid object name: '%s'"), argv[i]);
335
		lookup_commit_or_die(&oid, argv[i]);
336
		strbuf_addf(&new_parents, "parent %s\n", oid_to_hex(&oid));
337 338 339 340 341 342 343 344 345
	}

	/* replace existing parents with new ones */
	strbuf_splice(buf, parent_start - buf->buf, parent_end - parent_start,
		      new_parents.buf, new_parents.len);

	strbuf_release(&new_parents);
}

346 347 348 349 350 351 352 353 354 355 356
struct check_mergetag_data {
	int argc;
	const char **argv;
};

static void check_one_mergetag(struct commit *commit,
			       struct commit_extra_header *extra,
			       void *data)
{
	struct check_mergetag_data *mergetag_data = (struct check_mergetag_data *)data;
	const char *ref = mergetag_data->argv[0];
357
	struct object_id tag_oid;
358 359 360
	struct tag *tag;
	int i;

361
	hash_object_file(extra->value, extra->len, type_name(OBJ_TAG), &tag_oid);
362
	tag = lookup_tag(&tag_oid);
363 364 365 366 367 368 369
	if (!tag)
		die(_("bad mergetag in commit '%s'"), ref);
	if (parse_tag_buffer(tag, extra->value, extra->len))
		die(_("malformed mergetag in commit '%s'"), ref);

	/* iterate over new parents */
	for (i = 1; i < mergetag_data->argc; i++) {
370
		struct object_id oid;
371
		if (get_oid(mergetag_data->argv[i], &oid) < 0)
372
			die(_("Not a valid object name: '%s'"), mergetag_data->argv[i]);
373
		if (!oidcmp(&tag->tagged->oid, &oid))
374 375 376 377
			return; /* found */
	}

	die(_("original commit '%s' contains mergetag '%s' that is discarded; "
378
	      "use --edit instead of --graft"), ref, oid_to_hex(&tag_oid));
379 380 381 382 383 384 385 386 387 388 389
}

static void check_mergetags(struct commit *commit, int argc, const char **argv)
{
	struct check_mergetag_data mergetag_data;

	mergetag_data.argc = argc;
	mergetag_data.argv = argv;
	for_each_mergetag(check_one_mergetag, commit, &mergetag_data);
}

390 391
static int create_graft(int argc, const char **argv, int force)
{
392
	struct object_id old_oid, new_oid;
393 394 395 396 397 398
	const char *old_ref = argv[0];
	struct commit *commit;
	struct strbuf buf = STRBUF_INIT;
	const char *buffer;
	unsigned long size;

399
	if (get_oid(old_ref, &old_oid) < 0)
400
		die(_("Not a valid object name: '%s'"), old_ref);
401
	commit = lookup_commit_or_die(&old_oid, old_ref);
402 403 404 405 406 407 408

	buffer = get_commit_buffer(commit, &size);
	strbuf_add(&buf, buffer, size);
	unuse_commit_buffer(commit, buffer);

	replace_parents(&buf, argc - 1, &argv[1]);

409 410 411 412 413
	if (remove_signature(&buf)) {
		warning(_("the original commit '%s' has a gpg signature."), old_ref);
		warning(_("the signature will be removed in the replacement commit!"));
	}

414 415
	check_mergetags(commit, argc, argv);

416
	if (write_object_file(buf.buf, buf.len, commit_type, &new_oid))
417 418 419 420
		die(_("could not write replacement commit for: '%s'"), old_ref);

	strbuf_release(&buf);

421 422
	if (!oidcmp(&old_oid, &new_oid))
		return error("new commit is the same as the old one: '%s'", oid_to_hex(&old_oid));
423

424
	return replace_object_oid(old_ref, &old_oid, "replacement", &new_oid, force);
425 426
}

427 428
int cmd_replace(int argc, const char **argv, const char *prefix)
{
429
	int force = 0;
430
	int raw = 0;
431
	const char *format = NULL;
432 433 434 435
	enum {
		MODE_UNSPECIFIED = 0,
		MODE_LIST,
		MODE_DELETE,
Jeff King's avatar
Jeff King committed
436
		MODE_EDIT,
437
		MODE_GRAFT,
438 439
		MODE_REPLACE
	} cmdmode = MODE_UNSPECIFIED;
440
	struct option options[] = {
441 442
		OPT_CMDMODE('l', "list", &cmdmode, N_("list replace refs"), MODE_LIST),
		OPT_CMDMODE('d', "delete", &cmdmode, N_("delete replace refs"), MODE_DELETE),
Jeff King's avatar
Jeff King committed
443
		OPT_CMDMODE('e', "edit", &cmdmode, N_("edit existing object"), MODE_EDIT),
444
		OPT_CMDMODE('g', "graft", &cmdmode, N_("change a commit's parents"), MODE_GRAFT),
445 446
		OPT_BOOL_F('f', "force", &force, N_("replace the ref if it exists"),
			   PARSE_OPT_NOCOMPLETE),
447
		OPT_BOOL(0, "raw", &raw, N_("do not pretty-print contents for --edit")),
448
		OPT_STRING(0, "format", &format, N_("format"), N_("use this format")),
449 450 451
		OPT_END()
	};

452
	check_replace_refs = 0;
453
	git_config(git_default_config, NULL);
454

455
	argc = parse_options(argc, argv, prefix, options, git_replace_usage, 0);
456

457 458
	if (!cmdmode)
		cmdmode = argc ? MODE_REPLACE : MODE_LIST;
459

460
	if (format && cmdmode != MODE_LIST)
461
		usage_msg_opt("--format cannot be used when not listing",
462 463
			      git_replace_usage, options);

464 465 466 467
	if (force &&
	    cmdmode != MODE_REPLACE &&
	    cmdmode != MODE_EDIT &&
	    cmdmode != MODE_GRAFT)
468
		usage_msg_opt("-f only makes sense when writing a replacement",
469
			      git_replace_usage, options);
470

471 472 473 474
	if (raw && cmdmode != MODE_EDIT)
		usage_msg_opt("--raw only makes sense with --edit",
			      git_replace_usage, options);

475 476
	switch (cmdmode) {
	case MODE_DELETE:
477
		if (argc < 1)
478 479
			usage_msg_opt("-d needs at least one argument",
				      git_replace_usage, options);
480 481
		return for_each_replace_name(argv, delete_replace_ref);

482
	case MODE_REPLACE:
483
		if (argc != 2)
484 485
			usage_msg_opt("bad number of arguments",
				      git_replace_usage, options);
486 487
		return replace_object(argv[0], argv[1], force);

Jeff King's avatar
Jeff King committed
488 489 490 491
	case MODE_EDIT:
		if (argc != 1)
			usage_msg_opt("-e needs exactly one argument",
				      git_replace_usage, options);
492
		return edit_and_replace(argv[0], force, raw);
Jeff King's avatar
Jeff King committed
493

494 495 496 497 498 499
	case MODE_GRAFT:
		if (argc < 1)
			usage_msg_opt("-g needs at least one argument",
				      git_replace_usage, options);
		return create_graft(argc, argv, force);

500 501 502 503 504
	case MODE_LIST:
		if (argc > 1)
			usage_msg_opt("only one pattern can be given with -l",
				      git_replace_usage, options);
		return list_replace_refs(argv[0], format);
505

506 507 508
	default:
		die("BUG: invalid cmdmode %d", (int)cmdmode);
	}
509
}