commit.c 12.3 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 107
		error = git_reference__update_for_commit(
			repo, ref, update_ref, id, committer, "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 298
		error = git_reference__update_for_commit(
			repo, ref, NULL, id, committer, "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

313
	buffer = buffer_start;
314

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

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

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

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

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

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

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

340
	/* Always parse the committer; we need the commit time */
341
	commit->committer = git__malloc(sizeof(git_signature));
342 343 344 345
	GITERR_CHECK_ALLOC(commit->committer);

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

347 348
	/* Parse add'l header entries */
	while (buffer < buffer_end) {
349
		const char *eoln = buffer;
350 351 352
		if (buffer[-1] == '\n' && buffer[0] == '\n')
			break;

353 354
		while (eoln < buffer_end && *eoln != '\n')
			++eoln;
355

356 357
		if (git__prefixcmp(buffer, "encoding ") == 0) {
			buffer += strlen("encoding ");
358

359 360 361
			commit->message_encoding = git__strndup(buffer, eoln - buffer);
			GITERR_CHECK_ALLOC(commit->message_encoding);
		}
362

363 364
		if (eoln < buffer_end && *eoln == '\n')
			++eoln;
365
		buffer = eoln;
366
	}
367

368 369 370
	header_len = buffer - buffer_start;
	commit->raw_header = git__strndup(buffer_start, header_len);
	GITERR_CHECK_ALLOC(commit->raw_header);
371

372 373
	/* point "buffer" to data after header, +1 for the final LF */
	buffer = buffer_start + header_len + 1;
374

375
	/* extract commit message */
376
	if (buffer <= buffer_end) {
377 378
		commit->raw_message = git__strndup(buffer, buffer_end - buffer);
		GITERR_CHECK_ALLOC(commit->raw_message);
379
	}
380

381 382 383 384 385
	return 0;

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

388
#define GIT_COMMIT_GETTER(_rvalue, _name, _return) \
Vicent Marti committed
389
	_rvalue git_commit_##_name(const git_commit *commit) \
390
	{\
391
		assert(commit); \
392
		return _return; \
393 394
	}

395 396
GIT_COMMIT_GETTER(const git_signature *, author, commit->author)
GIT_COMMIT_GETTER(const git_signature *, committer, commit->committer)
397
GIT_COMMIT_GETTER(const char *, message_raw, commit->raw_message)
398
GIT_COMMIT_GETTER(const char *, message_encoding, commit->message_encoding)
399
GIT_COMMIT_GETTER(const char *, raw_header, commit->raw_header)
400
GIT_COMMIT_GETTER(git_time_t, time, commit->committer->when.time)
401
GIT_COMMIT_GETTER(int, time_offset, commit->committer->when.offset)
402
GIT_COMMIT_GETTER(unsigned int, parentcount, (unsigned int)git_array_size(commit->parent_ids))
403
GIT_COMMIT_GETTER(const git_oid *, tree_id, &commit->tree_id)
404

405 406
const char *git_commit_message(const git_commit *commit)
{
407
	const char *message;
408 409 410

	assert(commit);

411 412
	message = commit->raw_message;

413 414 415 416 417 418 419
	/* trim leading newlines from raw message */
	while (*message && *message == '\n')
		++message;

	return message;
}

420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441
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);
		}

442 443
		commit->summary = git_buf_detach(&summary);
		if (!commit->summary)
444
			commit->summary = git__strdup("");
445 446 447 448 449
	}

	return commit->summary;
}

Vicent Marti committed
450
int git_commit_tree(git_tree **tree_out, const git_commit *commit)
451 452
{
	assert(commit);
Vicent Marti committed
453
	return git_tree_lookup(tree_out, commit->object.repo, &commit->tree_id);
454
}
455

456 457
const git_oid *git_commit_parent_id(
	const git_commit *commit, unsigned int n)
458 459 460
{
	assert(commit);

461
	return git_array_get(commit->parent_ids, n);
462 463
}

464 465
int git_commit_parent(
	git_commit **parent, const git_commit *commit, unsigned int n)
466
{
Vicent Marti committed
467
	const git_oid *parent_id;
468 469
	assert(commit);

Vicent Marti committed
470 471
	parent_id = git_commit_parent_id(commit, n);
	if (parent_id == NULL) {
472 473 474
		giterr_set(GITERR_INVALID, "Parent %u does not exist", n);
		return GIT_ENOTFOUND;
	}
475

Vicent Marti committed
476
	return git_commit_lookup(parent, commit->object.repo, parent_id);
477
}
478 479 480 481 482 483

int git_commit_nth_gen_ancestor(
	git_commit **ancestor,
	const git_commit *commit,
	unsigned int n)
{
484
	git_commit *current, *parent = NULL;
485 486 487 488
	int error;

	assert(ancestor && commit);

489 490
	if (git_object_dup((git_object **) &current, (git_object *) commit) < 0)
		return -1;
491

492 493 494 495
	if (n == 0) {
		*ancestor = current;
		return 0;
	}
496 497

	while (n--) {
498
		error = git_commit_parent(&parent, current, 0);
499

500
		git_commit_free(current);
501 502 503 504 505 506 507 508 509 510

		if (error < 0)
			return error;

		current = parent;
	}

	*ancestor = parent;
	return 0;
}