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

#include "common.h"
#include "commit.h"
#include "tag.h"
11 12
#include "config.h"
#include "refspec.h"
13
#include "refs.h"
14
#include "remote.h"
15

16 17
#include "git2/branch.h"

18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48
static int retrieve_branch_reference(
	git_reference **branch_reference_out,
	git_repository *repo,
	const char *branch_name,
	int is_remote)
{
	git_reference *branch;
	int error = -1;
	char *prefix;
	git_buf ref_name = GIT_BUF_INIT;

	*branch_reference_out = NULL;

	prefix = is_remote ? GIT_REFS_REMOTES_DIR : GIT_REFS_HEADS_DIR;

	if (git_buf_joinpath(&ref_name, prefix, branch_name) < 0)
		goto cleanup;

	if ((error = git_reference_lookup(&branch, repo, ref_name.ptr)) < 0) {
		giterr_set(GITERR_REFERENCE,
			"Cannot locate %s branch '%s'.", is_remote ? "remote-tracking" : "local", branch_name);
		goto cleanup;
	}

	*branch_reference_out = branch;

cleanup:
	git_buf_free(&ref_name);
	return error;
}

49
static int not_a_local_branch(const char *reference_name)
50
{
51 52 53
	giterr_set(
		GITERR_INVALID,
		"Reference '%s' is not a local branch.", reference_name);
54 55 56
	return -1;
}

57
int git_branch_create(
58 59 60 61 62
	git_reference **ref_out,
	git_repository *repository,
	const char *branch_name,
	const git_commit *commit,
	int force)
63 64 65 66 67
{
	git_reference *branch = NULL;
	git_buf canonical_branch_name = GIT_BUF_INIT;
	int error = -1;

Vicent Marti committed
68 69
	assert(branch_name && commit && ref_out);
	assert(git_object_owner((const git_object *)commit) == repository);
70 71 72 73

	if (git_buf_joinpath(&canonical_branch_name, GIT_REFS_HEADS_DIR, branch_name) < 0)
		goto cleanup;

74
	error = git_reference_create(&branch, repository,
Vicent Marti committed
75
		git_buf_cstr(&canonical_branch_name), git_commit_id(commit), force);
76

77 78
	if (!error)
		*ref_out = branch;
79 80 81 82 83 84

cleanup:
	git_buf_free(&canonical_branch_name);
	return error;
}

85
int git_branch_delete(git_reference *branch)
86
{
87
	int is_head;
88 89
	git_buf config_section = GIT_BUF_INIT;
	int error = -1;
90

91
	assert(branch);
92

93 94 95 96 97
	if (!git_reference_is_branch(branch) &&
		!git_reference_is_remote(branch)) {
		giterr_set(GITERR_INVALID, "Reference '%s' is not a valid branch.", git_reference_name(branch));
		return -1;
	}
98

99 100
	if ((is_head = git_branch_is_head(branch)) < 0)
		return is_head;
101

102 103 104 105
	if (is_head) {
		giterr_set(GITERR_REFERENCE,
				"Cannot delete branch '%s' as it is the current HEAD of the repository.", git_reference_name(branch));
		return -1;
106 107
	}

108 109 110 111
	if (git_buf_printf(&config_section, "branch.%s", git_reference_name(branch) + strlen(GIT_REFS_HEADS_DIR)) < 0)
		goto on_error;

	if (git_config_rename_section(
112
		git_reference_owner(branch), 
113
		git_buf_cstr(&config_section),
114
		NULL) < 0)
115 116
			goto on_error;

117 118 119 120 121 122 123 124
	if (git_reference_delete(branch) < 0)
		goto on_error;

	error = 0;

on_error:
	git_buf_free(&config_section);
	return error;
125 126
}

127
int git_branch_foreach(
128 129
	git_repository *repo,
	unsigned int list_flags,
130
	git_branch_foreach_cb callback,
131
	void *payload)
132
{
133
	git_reference_iterator *iter;
Vicent Marti committed
134
	git_reference *ref;
135
	int error = 0;
136

137 138
	if (git_reference_iterator_new(&iter, repo) < 0)
		return -1;
139

140
	while ((error = git_reference_next(&ref, iter)) == 0) {
141
		if (list_flags & GIT_BRANCH_LOCAL &&
Vicent Marti committed
142 143 144
		    git__prefixcmp(ref->name, GIT_REFS_HEADS_DIR) == 0) {
			if (callback(ref->name + strlen(GIT_REFS_HEADS_DIR),
					GIT_BRANCH_LOCAL, payload)) {
145 146 147 148 149
				error = GIT_EUSER;
			}
		}

		if (list_flags & GIT_BRANCH_REMOTE &&
Vicent Marti committed
150 151 152
		    git__prefixcmp(ref->name, GIT_REFS_REMOTES_DIR) == 0) {
			if (callback(ref->name + strlen(GIT_REFS_REMOTES_DIR),
					GIT_BRANCH_REMOTE, payload)) {
153 154 155
				error = GIT_EUSER;
			}
		}
Vicent Marti committed
156 157

		git_reference_free(ref);
158 159 160 161

		/* check if the callback has cancelled iteration */
		if (error == GIT_EUSER)
			break;
162 163 164 165 166 167 168
	}

	if (error == GIT_ITEROVER)
		error = 0;

	git_reference_iterator_free(iter);
	return error;
169 170
}

171
int git_branch_move(
172
	git_reference **out,
173 174 175 176
	git_reference *branch,
	const char *new_branch_name,
	int force)
{
177
	git_buf new_reference_name = GIT_BUF_INIT,
178 179
		old_config_section = GIT_BUF_INIT,
		new_config_section = GIT_BUF_INIT;
180
	int error;
181

182 183 184
	assert(branch && new_branch_name);

	if (!git_reference_is_branch(branch))
185
		return not_a_local_branch(git_reference_name(branch));
186

Vicent Marti committed
187 188
	error = git_buf_joinpath(&new_reference_name, GIT_REFS_HEADS_DIR, new_branch_name);
	if (error < 0)
189
		goto done;
190

Vicent Marti committed
191 192 193 194 195
	git_buf_printf(&old_config_section,
		"branch.%s", git_reference_name(branch) + strlen(GIT_REFS_HEADS_DIR));

	git_buf_printf(&new_config_section, "branch.%s", new_branch_name);

196
	if ((error = git_config_rename_section(git_reference_owner(branch),
197 198
		git_buf_cstr(&old_config_section),
		git_buf_cstr(&new_config_section))) < 0)
199
		goto done;
200

Vicent Marti committed
201
	error = git_reference_rename(out, branch, git_buf_cstr(&new_reference_name), force);
202

203
done:
204
	git_buf_free(&new_reference_name);
205 206
	git_buf_free(&old_config_section);
	git_buf_free(&new_config_section);
207

208
	return error;
209
}
210 211

int git_branch_lookup(
212 213 214 215
	git_reference **ref_out,
	git_repository *repo,
	const char *branch_name,
	git_branch_t branch_type)
216 217 218 219 220
{
	assert(ref_out && repo && branch_name);

	return retrieve_branch_reference(ref_out, repo, branch_name, branch_type == GIT_BRANCH_REMOTE);
}
221

222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242
int git_branch_name(const char **out, git_reference *ref)
{
	const char *branch_name;

	assert(out && ref);

	branch_name = ref->name;

	if (git_reference_is_branch(ref)) {
		branch_name += strlen(GIT_REFS_HEADS_DIR);
	} else if (git_reference_is_remote(ref)) {
		branch_name += strlen(GIT_REFS_REMOTES_DIR);
	} else {
		giterr_set(GITERR_INVALID,
				"Reference '%s' is neither a local nor a remote branch.", ref->name);
		return -1;
	}
	*out = branch_name;
	return 0;
}

243
static int retrieve_upstream_configuration(
244 245 246 247
	const char **out,
	git_repository *repo,
	const char *canonical_branch_name,
	const char *format)
248 249 250 251 252
{
	git_config *config;
	git_buf buf = GIT_BUF_INIT;
	int error;

253
	if (git_repository_config__weakptr(&config, repo) < 0)
254 255 256
		return -1;

	if (git_buf_printf(&buf, format,
257
		canonical_branch_name + strlen(GIT_REFS_HEADS_DIR)) < 0)
258 259 260 261 262 263 264
			return -1;

	error = git_config_get_string(out, config, git_buf_cstr(&buf));
	git_buf_free(&buf);
	return error;
}

265
int git_branch_upstream__name(
266 267 268
	git_buf *tracking_name,
	git_repository *repo,
	const char *canonical_branch_name)
269 270 271 272 273 274 275
{
	const char *remote_name, *merge_name;
	git_buf buf = GIT_BUF_INIT;
	int error = -1;
	git_remote *remote = NULL;
	const git_refspec *refspec;

276
	assert(tracking_name && canonical_branch_name);
277

278 279
	if (!git_reference__is_branch(canonical_branch_name))
		return not_a_local_branch(canonical_branch_name);
280

281
	if ((error = retrieve_upstream_configuration(
282 283
		&remote_name, repo, canonical_branch_name, "branch.%s.remote")) < 0)
			goto cleanup;
284

285
	if ((error = retrieve_upstream_configuration(
286 287
		&merge_name, repo, canonical_branch_name, "branch.%s.merge")) < 0)
			goto cleanup;
288

nulltoken committed
289
	if (!*remote_name || !*merge_name) {
290 291
		giterr_set(GITERR_REFERENCE,
			"branch '%s' does not have an upstream", canonical_branch_name);
nulltoken committed
292 293 294
		error = GIT_ENOTFOUND;
		goto cleanup;
	}
295 296

	if (strcmp(".", remote_name) != 0) {
297
		if ((error = git_remote_load(&remote, repo, remote_name)) < 0)
298 299
			goto cleanup;

300 301 302 303
		refspec = git_remote__matching_refspec(remote, merge_name);
		if (!refspec) {
			error = GIT_ENOTFOUND;
			goto cleanup;
304 305 306 307 308 309 310 311
		}

		if (git_refspec_transform_r(&buf, refspec, merge_name) < 0)
			goto cleanup;
	} else
		if (git_buf_sets(&buf, merge_name) < 0)
			goto cleanup;

312
	error = git_buf_set(tracking_name, git_buf_cstr(&buf), git_buf_len(&buf));
313 314 315 316 317 318

cleanup:
	git_remote_free(remote);
	git_buf_free(&buf);
	return error;
}
319

320
static int remote_name(git_buf *buf, git_repository *repo, const char *canonical_branch_name)
321 322
{
	git_strarray remote_list = {0};
323
	size_t i;
324 325 326 327 328
	git_remote *remote;
	const git_refspec *fetchspec;
	int error = 0;
	char *remote_name = NULL;

329
	assert(buf && repo && canonical_branch_name);
330 331

	/* Verify that this is a remote branch */
332 333 334
	if (!git_reference__is_remote(canonical_branch_name)) {
		giterr_set(GITERR_INVALID, "Reference '%s' is not a remote branch.",
			canonical_branch_name);
335 336 337 338 339 340 341 342 343 344 345
		error = GIT_ERROR;
		goto cleanup;
	}

	/* Get the remotes */
	if ((error = git_remote_list(&remote_list, repo)) < 0)
		goto cleanup;

	/* Find matching remotes */
	for (i = 0; i < remote_list.count; i++) {
		if ((error = git_remote_load(&remote, repo, remote_list.strings[i])) < 0)
346
			continue;
347

348 349
		fetchspec = git_remote__matching_dst_refspec(remote, canonical_branch_name);
		if (fetchspec) {
350 351 352 353 354 355 356 357
			/* If we have not already set out yet, then set
			 * it to the matching remote name. Otherwise
			 * multiple remotes match this reference, and it
			 * is ambiguous. */
			if (!remote_name) {
				remote_name = remote_list.strings[i];
			} else {
				git_remote_free(remote);
358 359 360

				giterr_set(GITERR_REFERENCE,
					"Reference '%s' is ambiguous", canonical_branch_name);
361 362 363 364 365 366 367 368 369
				error = GIT_EAMBIGUOUS;
				goto cleanup;
			}
		}

		git_remote_free(remote);
	}

	if (remote_name) {
370 371
		git_buf_clear(buf);
		error = git_buf_puts(buf, remote_name);
372
	} else {
373 374
		giterr_set(GITERR_REFERENCE,
			"Could not determine remote for '%s'", canonical_branch_name);
375 376 377 378 379 380 381 382
		error = GIT_ENOTFOUND;
	}

cleanup:
	git_strarray_free(&remote_list);
	return error;
}

383 384 385 386 387 388 389 390 391 392 393
int git_branch_remote_name(char *buffer, size_t buffer_len, git_repository *repo, const char *refname)
{
	int ret;
	git_buf buf = GIT_BUF_INIT;

	if ((ret = remote_name(&buf, repo, refname)) < 0)
		return ret;

	if (buffer)
		git_buf_copy_cstr(buffer, buffer_len, &buf);

Russell Belfer committed
394
	ret = (int)git_buf_len(&buf) + 1;
395 396 397 398 399
	git_buf_free(&buf);

	return ret;
}

400
int git_branch_upstream_name(
401 402 403 404 405 406 407 408 409 410 411 412 413
	char *tracking_branch_name_out,
	size_t buffer_size,
	git_repository *repo,
	const char *canonical_branch_name)
{
	git_buf buf = GIT_BUF_INIT;
	int error;

	assert(canonical_branch_name);

	if (tracking_branch_name_out && buffer_size)
		*tracking_branch_name_out = '\0';

414
	if ((error = git_branch_upstream__name(
415 416 417 418 419 420 421 422 423 424 425 426 427 428
		&buf, repo, canonical_branch_name)) < 0)
			goto cleanup;

	if (tracking_branch_name_out && buf.size + 1 > buffer_size) { /* +1 for NUL byte */
		giterr_set(
			GITERR_INVALID,
			"Buffer too short to hold the tracked reference name.");
		error = -1;
		goto cleanup;
	}

	if (tracking_branch_name_out)
		git_buf_copy_cstr(tracking_branch_name_out, buffer_size, &buf);

429
	error = (int)buf.size + 1;
430 431 432 433 434 435

cleanup:
	git_buf_free(&buf);
	return (int)error;
}

436
int git_branch_upstream(
437 438 439 440 441 442
		git_reference **tracking_out,
		git_reference *branch)
{
	int error;
	git_buf tracking_name = GIT_BUF_INIT;

443
	if ((error = git_branch_upstream__name(&tracking_name,
444 445 446 447 448 449 450 451 452 453 454 455
		git_reference_owner(branch), git_reference_name(branch))) < 0)
			return error;

	error = git_reference_lookup(
		tracking_out,
		git_reference_owner(branch),
		git_buf_cstr(&tracking_name));

	git_buf_free(&tracking_name);
	return error;
}

456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510
static int unset_upstream(git_config *config, const char *shortname)
{
	git_buf buf = GIT_BUF_INIT;

	if (git_buf_printf(&buf, "branch.%s.remote", shortname) < 0)
		return -1;

	if (git_config_delete_entry(config, git_buf_cstr(&buf)) < 0)
		goto on_error;

	git_buf_clear(&buf);
	if (git_buf_printf(&buf, "branch.%s.merge", shortname) < 0)
		goto on_error;

	if (git_config_delete_entry(config, git_buf_cstr(&buf)) < 0)
		goto on_error;

	git_buf_free(&buf);
	return 0;

on_error:
	git_buf_free(&buf);
	return -1;
}

int git_branch_set_upstream(git_reference *branch, const char *upstream_name)
{
	git_buf key = GIT_BUF_INIT, value = GIT_BUF_INIT;
	git_reference *upstream;
	git_repository *repo;
	git_remote *remote = NULL;
	git_config *config;
	const char *name, *shortname;
	int local;
	const git_refspec *fetchspec;

	name = git_reference_name(branch);
	if (!git_reference__is_branch(name))
		return not_a_local_branch(name);

	if (git_repository_config__weakptr(&config, git_reference_owner(branch)) < 0)
		return -1;

	shortname = name + strlen(GIT_REFS_HEADS_DIR);

	if (upstream_name == NULL)
		return unset_upstream(config, shortname);

	repo = git_reference_owner(branch);

	/* First we need to figure out whether it's a branch or remote-tracking */
	if (git_branch_lookup(&upstream, repo, upstream_name, GIT_BRANCH_LOCAL) == 0)
		local = 1;
	else if (git_branch_lookup(&upstream, repo, upstream_name, GIT_BRANCH_REMOTE) == 0)
		local = 0;
511 512 513
	else {
		giterr_set(GITERR_REFERENCE,
			"Cannot set upstream for branch '%s'", shortname);
514
		return GIT_ENOTFOUND;
515
	}
516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534

	/*
	 * If it's local, the remote is "." and the branch name is
	 * simply the refname. Otherwise we need to figure out what
	 * the remote-tracking branch's name on the remote is and use
	 * that.
	 */
	if (local)
		git_buf_puts(&value, ".");
	else
		remote_name(&value, repo, git_reference_name(upstream));

	if (git_buf_printf(&key, "branch.%s.remote", shortname) < 0)
		goto on_error;

	if (git_config_set_string(config, git_buf_cstr(&key), git_buf_cstr(&value)) < 0)
		goto on_error;

	if (local) {
535 536
		git_buf_clear(&value);
		if (git_buf_puts(&value, git_reference_name(upstream)) < 0)
537 538 539 540 541 542
			goto on_error;
	} else {
		/* Get the remoe-tracking branch's refname in its repo */
		if (git_remote_load(&remote, repo, git_buf_cstr(&value)) < 0)
			goto on_error;

543
		fetchspec = git_remote__matching_dst_refspec(remote, git_reference_name(upstream));
544
		git_buf_clear(&value);
545
		if (!fetchspec || git_refspec_transform_l(&value, fetchspec, git_reference_name(upstream)) < 0)
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
			goto on_error;

		git_remote_free(remote);
		remote = NULL;
	}

	git_buf_clear(&key);
	if (git_buf_printf(&key, "branch.%s.merge", shortname) < 0)
		goto on_error;

	if (git_config_set_string(config, git_buf_cstr(&key), git_buf_cstr(&value)) < 0)
		goto on_error;

	git_reference_free(upstream);
	git_buf_free(&key);
	git_buf_free(&value);

	return 0;

on_error:
	git_reference_free(upstream);
	git_buf_free(&key);
	git_buf_free(&value);
	git_remote_free(remote);

	return -1;
}

574 575 576 577 578
int git_branch_is_head(
		git_reference *branch)
{
	git_reference *head;
	bool is_same = false;
579
	int error;
580 581 582 583 584 585

	assert(branch);

	if (!git_reference_is_branch(branch))
		return false;

586 587
	error = git_repository_head(&head, git_reference_owner(branch));

588
	if (error == GIT_EUNBORNBRANCH || error == GIT_ENOTFOUND)
589 590 591
		return false;

	if (error < 0)
592 593 594 595 596 597 598 599 600 601
		return -1;

	is_same = strcmp(
		git_reference_name(branch),
		git_reference_name(head)) == 0;

	git_reference_free(head);

	return is_same;
}