commit.c 13.6 KB
Newer Older
1
/*
Edward Thomson committed
2
 * Copyright (C) the libgit2 contributors. All rights reserved.
3
 *
Vicent Marti committed
4 5
 * This file is part of libgit2, distributed under the GNU GPL v2 with
 * a Linking Exception. For full terms see the included COPYING file.
6 7
 */

8 9 10
#include "git2/common.h"
#include "git2/object.h"
#include "git2/repository.h"
11
#include "git2/signature.h"
12
#include "git2/sys/commit.h"
13

14
#include "common.h"
Vicent Marti committed
15
#include "odb.h"
16
#include "commit.h"
17
#include "signature.h"
18
#include "message.h"
19
#include "refs.h"
20

21
void git_commit__free(void *_commit)
22
{
23 24
	git_commit *commit = _commit;

25
	git_array_clear(commit->parent_ids);
26

27 28
	git_signature_free(commit->author);
	git_signature_free(commit->committer);
29

30
	git__free(commit->raw_header);
31
	git__free(commit->raw_message);
32
	git__free(commit->message_encoding);
33
	git__free(commit->summary);
34

35
	git__free(commit);
36 37
}

38 39
int git_commit_create_from_callback(
	git_oid *id,
40 41 42 43 44 45 46
	git_repository *repo,
	const char *update_ref,
	const git_signature *author,
	const git_signature *committer,
	const char *message_encoding,
	const char *message,
	const git_oid *tree,
47 48
	git_commit_parent_callback parent_cb,
	void *parent_payload)
Vicent Marti committed
49
{
50 51 52
	git_reference *ref = NULL;
	int error = 0, matched_parent = 0;
	const git_oid *current_id = NULL;
53
	git_buf commit = GIT_BUF_INIT;
54
	size_t i = 0;
55
	git_odb *odb;
56
	const git_oid *parent;
Vicent Marti committed
57

58
	assert(id && repo && tree && parent_cb);
59

60 61 62 63 64 65 66 67 68 69
	if (update_ref) {
		error = git_reference_lookup_resolved(&ref, repo, update_ref, 10);
		if (error < 0 && error != GIT_ENOTFOUND)
			return error;
	}
	giterr_clear();

	if (ref)
		current_id = git_reference_target(ref);

70
	git_oid__writebuf(&commit, "tree ", tree);
71

72
	while ((parent = parent_cb(i, parent_payload)) != NULL) {
73
		git_oid__writebuf(&commit, "parent ", parent);
74 75 76 77 78 79 80 81 82 83 84
		if (i == 0 && current_id && git_oid_equal(current_id, parent))
			matched_parent = 1;
		i++;
	}

	if (ref && !matched_parent) {
		git_reference_free(ref);
		git_buf_free(&commit);
		giterr_set(GITERR_OBJECT, "failed to create commit: current tip is not the first parent");
		return GIT_EMODIFIED;
	}
85

86 87
	git_signature__writebuf(&commit, "author ", author);
	git_signature__writebuf(&commit, "committer ", committer);
88

89 90 91
	if (message_encoding != NULL)
		git_buf_printf(&commit, "encoding %s\n", message_encoding);

92
	git_buf_putc(&commit, '\n');
93

94
	if (git_buf_puts(&commit, message) < 0)
95 96
		goto on_error;

97 98
	if (git_repository_odb__weakptr(&odb, repo) < 0)
		goto on_error;
99

100
	if (git_odb_write(id, odb, commit.ptr, commit.size, GIT_OBJ_COMMIT) < 0)
101
		goto on_error;
Vicent Marti committed
102

103
	git_buf_free(&commit);
104

105
	if (update_ref != NULL) {
106
		error = git_reference__update_for_commit(
107
			repo, ref, update_ref, id, "commit");
108
		git_reference_free(ref);
109 110
		return error;
	}
Vicent Marti committed
111

112
	return 0;
113

114
on_error:
115
	git_buf_free(&commit);
116
	giterr_set(GITERR_OBJECT, "Failed to create commit.");
117
	return -1;
118 119
}

120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212
typedef struct {
	size_t total;
	va_list args;
} commit_parent_varargs;

static const git_oid *commit_parent_from_varargs(size_t curr, void *payload)
{
	commit_parent_varargs *data = payload;
	const git_commit *commit;
	if (curr >= data->total)
		return NULL;
	commit = va_arg(data->args, const git_commit *);
	return commit ? git_commit_id(commit) : NULL;
}

int git_commit_create_v(
	git_oid *id,
	git_repository *repo,
	const char *update_ref,
	const git_signature *author,
	const git_signature *committer,
	const char *message_encoding,
	const char *message,
	const git_tree *tree,
	size_t parent_count,
	...)
{
	int error = 0;
	commit_parent_varargs data;

	assert(tree && git_tree_owner(tree) == repo);

	data.total = parent_count;
	va_start(data.args, parent_count);

	error = git_commit_create_from_callback(
		id, repo, update_ref, author, committer,
		message_encoding, message, git_tree_id(tree),
		commit_parent_from_varargs, &data);

	va_end(data.args);
	return error;
}

typedef struct {
	size_t total;
	const git_oid **parents;
} commit_parent_oids;

static const git_oid *commit_parent_from_ids(size_t curr, void *payload)
{
	commit_parent_oids *data = payload;
	return (curr < data->total) ? data->parents[curr] : NULL;
}

int git_commit_create_from_ids(
	git_oid *id,
	git_repository *repo,
	const char *update_ref,
	const git_signature *author,
	const git_signature *committer,
	const char *message_encoding,
	const char *message,
	const git_oid *tree,
	size_t parent_count,
	const git_oid *parents[])
{
	commit_parent_oids data = { parent_count, parents };

	return git_commit_create_from_callback(
		id, repo, update_ref, author, committer,
		message_encoding, message, tree,
		commit_parent_from_ids, &data);
}

typedef struct {
	size_t total;
	const git_commit **parents;
	git_repository *repo;
} commit_parent_data;

static const git_oid *commit_parent_from_array(size_t curr, void *payload)
{
	commit_parent_data *data = payload;
	const git_commit *commit;
	if (curr >= data->total)
		return NULL;
	commit = data->parents[curr];
	if (git_commit_owner(commit) != data->repo)
		return NULL;
	return git_commit_id(commit);
}

213
int git_commit_create(
214
	git_oid *id,
215 216 217 218 219 220 221
	git_repository *repo,
	const char *update_ref,
	const git_signature *author,
	const git_signature *committer,
	const char *message_encoding,
	const char *message,
	const git_tree *tree,
222
	size_t parent_count,
223
	const git_commit *parents[])
224
{
225
	commit_parent_data data = { parent_count, parents, repo };
226

227
	assert(tree && git_tree_owner(tree) == repo);
228

229 230 231 232 233
	return git_commit_create_from_callback(
		id, repo, update_ref, author, committer,
		message_encoding, message, git_tree_id(tree),
		commit_parent_from_array, &data);
}
234

235 236 237 238 239 240 241
static const git_oid *commit_parent_for_amend(size_t curr, void *payload)
{
	const git_commit *commit_to_amend = payload;
	if (curr >= git_array_size(commit_to_amend->parent_ids))
		return NULL;
	return git_array_get(commit_to_amend->parent_ids, curr);
}
242

243 244 245 246 247 248 249 250 251 252 253 254
int git_commit_amend(
	git_oid *id,
	const git_commit *commit_to_amend,
	const char *update_ref,
	const git_signature *author,
	const git_signature *committer,
	const char *message_encoding,
	const char *message,
	const git_tree *tree)
{
	git_repository *repo;
	git_oid tree_id;
255 256
	git_reference *ref;
	int error;
257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279

	assert(id && commit_to_amend);

	repo = git_commit_owner(commit_to_amend);

	if (!author)
		author = git_commit_author(commit_to_amend);
	if (!committer)
		committer = git_commit_committer(commit_to_amend);
	if (!message_encoding)
		message_encoding = git_commit_message_encoding(commit_to_amend);
	if (!message)
		message = git_commit_message(commit_to_amend);

	if (!tree) {
		git_tree *old_tree;
		GITERR_CHECK_ERROR( git_commit_tree(&old_tree, commit_to_amend) );
		git_oid_cpy(&tree_id, git_tree_id(old_tree));
		git_tree_free(old_tree);
	} else {
		assert(git_tree_owner(tree) == repo);
		git_oid_cpy(&tree_id, git_tree_id(tree));
	}
280

281 282 283 284 285 286 287 288 289 290 291 292 293
	if (update_ref) {
		if ((error = git_reference_lookup_resolved(&ref, repo, update_ref, 5)) < 0)
			return error;

		if (git_oid_cmp(git_commit_id(commit_to_amend), git_reference_target(ref))) {
			git_reference_free(ref);
			giterr_set(GITERR_REFERENCE, "commit to amend is not the tip of the given branch");
			return -1;
		}
	}

	error = git_commit_create_from_callback(
		id, repo, NULL, author, committer, message_encoding, message,
294
		&tree_id, commit_parent_for_amend, (void *)commit_to_amend);
295 296

	if (!error && update_ref) {
297
		error = git_reference__update_for_commit(
298
			repo, ref, NULL, id, "commit");
299 300 301 302
		git_reference_free(ref);
	}

	return error;
303 304
}

305
int git_commit__parse(void *_commit, git_odb_object *odb_obj)
306
{
307
	git_commit *commit = _commit;
308 309
	const char *buffer_start = git_odb_object_data(odb_obj), *buffer;
	const char *buffer_end = buffer_start + git_odb_object_size(odb_obj);
Vicent Marti committed
310
	git_oid parent_id;
Russell Belfer committed
311
	size_t header_len;
312
	git_signature dummy_sig;
313

314
	buffer = buffer_start;
315

316 317
	/* Allocate for one, which will allow not to realloc 90% of the time  */
	git_array_init_to_size(commit->parent_ids, 1);
318
	GITERR_CHECK_ARRAY(commit->parent_ids);
319

320
	/* The tree is always the first field */
Vicent Marti committed
321
	if (git_oid__parse(&commit->tree_id, &buffer, buffer_end, "tree ") < 0)
322
		goto bad_buffer;
323

324 325 326
	/*
	 * TODO: commit grafts!
	 */
327

Vicent Marti committed
328
	while (git_oid__parse(&parent_id, &buffer, buffer_end, "parent ") == 0) {
329
		git_oid *new_id = git_array_alloc(commit->parent_ids);
Vicent Marti committed
330
		GITERR_CHECK_ALLOC(new_id);
331

Vicent Marti committed
332
		git_oid_cpy(new_id, &parent_id);
333
	}
334

335
	commit->author = git__malloc(sizeof(git_signature));
336 337 338 339
	GITERR_CHECK_ALLOC(commit->author);

	if (git_signature__parse(commit->author, &buffer, buffer_end, "author ", '\n') < 0)
		return -1;
340

341 342 343 344 345 346 347 348 349
	/* Some tools create multiple author fields, ignore the extra ones */
	while ((size_t)(buffer_end - buffer) >= strlen("author ") && !git__prefixcmp(buffer, "author ")) {
		if (git_signature__parse(&dummy_sig, &buffer, buffer_end, "author ", '\n') < 0)
			return -1;

		git__free(dummy_sig.name);
		git__free(dummy_sig.email);
	}

350
	/* Always parse the committer; we need the commit time */
351
	commit->committer = git__malloc(sizeof(git_signature));
352 353 354 355
	GITERR_CHECK_ALLOC(commit->committer);

	if (git_signature__parse(commit->committer, &buffer, buffer_end, "committer ", '\n') < 0)
		return -1;
356

357 358
	/* Parse add'l header entries */
	while (buffer < buffer_end) {
359
		const char *eoln = buffer;
360 361 362
		if (buffer[-1] == '\n' && buffer[0] == '\n')
			break;

363 364
		while (eoln < buffer_end && *eoln != '\n')
			++eoln;
365

366 367
		if (git__prefixcmp(buffer, "encoding ") == 0) {
			buffer += strlen("encoding ");
368

369 370 371
			commit->message_encoding = git__strndup(buffer, eoln - buffer);
			GITERR_CHECK_ALLOC(commit->message_encoding);
		}
372

373 374
		if (eoln < buffer_end && *eoln == '\n')
			++eoln;
375
		buffer = eoln;
376
	}
377

378 379 380
	header_len = buffer - buffer_start;
	commit->raw_header = git__strndup(buffer_start, header_len);
	GITERR_CHECK_ALLOC(commit->raw_header);
381

382 383
	/* point "buffer" to data after header, +1 for the final LF */
	buffer = buffer_start + header_len + 1;
384

385
	/* extract commit message */
386
	if (buffer <= buffer_end) {
387 388
		commit->raw_message = git__strndup(buffer, buffer_end - buffer);
		GITERR_CHECK_ALLOC(commit->raw_message);
389
	}
390

391 392 393 394 395
	return 0;

bad_buffer:
	giterr_set(GITERR_OBJECT, "Failed to parse bad commit object");
	return -1;
396
}
397

398
#define GIT_COMMIT_GETTER(_rvalue, _name, _return) \
Vicent Marti committed
399
	_rvalue git_commit_##_name(const git_commit *commit) \
400
	{\
401
		assert(commit); \
402
		return _return; \
403 404
	}

405 406
GIT_COMMIT_GETTER(const git_signature *, author, commit->author)
GIT_COMMIT_GETTER(const git_signature *, committer, commit->committer)
407
GIT_COMMIT_GETTER(const char *, message_raw, commit->raw_message)
408
GIT_COMMIT_GETTER(const char *, message_encoding, commit->message_encoding)
409
GIT_COMMIT_GETTER(const char *, raw_header, commit->raw_header)
410
GIT_COMMIT_GETTER(git_time_t, time, commit->committer->when.time)
411
GIT_COMMIT_GETTER(int, time_offset, commit->committer->when.offset)
412
GIT_COMMIT_GETTER(unsigned int, parentcount, (unsigned int)git_array_size(commit->parent_ids))
413
GIT_COMMIT_GETTER(const git_oid *, tree_id, &commit->tree_id)
414

415 416
const char *git_commit_message(const git_commit *commit)
{
417
	const char *message;
418 419 420

	assert(commit);

421 422
	message = commit->raw_message;

423 424 425 426 427 428 429
	/* trim leading newlines from raw message */
	while (*message && *message == '\n')
		++message;

	return message;
}

430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451
const char *git_commit_summary(git_commit *commit)
{
	git_buf summary = GIT_BUF_INIT;
	const char *msg, *space;

	assert(commit);

	if (!commit->summary) {
		for (msg = git_commit_message(commit), space = NULL; *msg; ++msg) {
			if (msg[0] == '\n' && (!msg[1] || msg[1] == '\n'))
				break;
			else if (msg[0] == '\n')
				git_buf_putc(&summary, ' ');
			else if (git__isspace(msg[0]))
				space = space ? space : msg;
			else if (space) {
				git_buf_put(&summary, space, (msg - space) + 1);
				space = NULL;
			} else
				git_buf_putc(&summary, *msg);
		}

452 453
		commit->summary = git_buf_detach(&summary);
		if (!commit->summary)
454
			commit->summary = git__strdup("");
455 456 457 458 459
	}

	return commit->summary;
}

Vicent Marti committed
460
int git_commit_tree(git_tree **tree_out, const git_commit *commit)
461 462
{
	assert(commit);
Vicent Marti committed
463
	return git_tree_lookup(tree_out, commit->object.repo, &commit->tree_id);
464
}
465

466 467
const git_oid *git_commit_parent_id(
	const git_commit *commit, unsigned int n)
468 469 470
{
	assert(commit);

471
	return git_array_get(commit->parent_ids, n);
472 473
}

474 475
int git_commit_parent(
	git_commit **parent, const git_commit *commit, unsigned int n)
476
{
Vicent Marti committed
477
	const git_oid *parent_id;
478 479
	assert(commit);

Vicent Marti committed
480 481
	parent_id = git_commit_parent_id(commit, n);
	if (parent_id == NULL) {
482 483 484
		giterr_set(GITERR_INVALID, "Parent %u does not exist", n);
		return GIT_ENOTFOUND;
	}
485

Vicent Marti committed
486
	return git_commit_lookup(parent, commit->object.repo, parent_id);
487
}
488 489 490 491 492 493

int git_commit_nth_gen_ancestor(
	git_commit **ancestor,
	const git_commit *commit,
	unsigned int n)
{
494
	git_commit *current, *parent = NULL;
495 496 497 498
	int error;

	assert(ancestor && commit);

499 500
	if (git_object_dup((git_object **) &current, (git_object *) commit) < 0)
		return -1;
501

502 503 504 505
	if (n == 0) {
		*ancestor = current;
		return 0;
	}
506 507

	while (n--) {
508
		error = git_commit_parent(&parent, current, 0);
509

510
		git_commit_free(current);
511 512 513 514 515 516 517 518 519 520

		if (error < 0)
			return error;

		current = parent;
	}

	*ancestor = parent;
	return 0;
}
521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575

int git_commit_header_field(git_buf *out, const git_commit *commit, const char *field)
{
	const char *buf = commit->raw_header;
	const char *h, *eol;

	git_buf_sanitize(out);
	while ((h = strchr(buf, '\n')) && h[1] != '\0' && h[1] != '\n') {
		h++;
		if (git__prefixcmp(h, field)) {
			buf = h;
			continue;
		}

		h += strlen(field);
		eol = strchr(h, '\n');
		if (h[0] != ' ') {
			buf = h;
			continue;
		}
		if (!eol)
			goto malformed;

		h++; /* skip the SP */

		git_buf_put(out, h, eol - h);
		if (git_buf_oom(out))
			goto oom;

		/* If the next line starts with SP, it's multi-line, we must continue */
		while (eol[1] == ' ') {
			git_buf_putc(out, '\n');
			h = eol + 2;
			eol = strchr(h, '\n');
			if (!eol)
				goto malformed;

			git_buf_put(out, h, eol - h);
		}

		if (git_buf_oom(out))
			goto oom;

		return 0;
	}

	return GIT_ENOTFOUND;

malformed:
	giterr_set(GITERR_OBJECT, "malformed header");
	return -1;
oom:
	giterr_set_oom();
	return -1;
}