[thirdparty/git.git] / branch.c

#include "cache.h"
#include "branch.h"
#include "refs.h"
#include "remote.h"
#include "commit.h"

struct tracking {
	struct refspec spec;
	char *src;
	const char *remote;
	int matches;
};

static int find_tracked_branch(struct remote *remote, void *priv)
{
	struct tracking *tracking = priv;

	if (!remote_find_tracking(remote, &tracking->spec)) {
		if (++tracking->matches == 1) {
			tracking->src = tracking->spec.src;
			tracking->remote = remote->name;
		} else {
			free(tracking->spec.src);
			if (tracking->src) {
				free(tracking->src);
				tracking->src = NULL;
			}
		}
		tracking->spec.src = NULL;
	}

	return 0;
}

static int should_setup_rebase(const char *origin)
{
	switch (autorebase) {
	case AUTOREBASE_NEVER:
		return 0;
	case AUTOREBASE_LOCAL:
		return origin == NULL;
	case AUTOREBASE_REMOTE:
		return origin != NULL;
	case AUTOREBASE_ALWAYS:
		return 1;
	}
	return 0;
}

void install_branch_config(int flag, const char *local, const char *origin, const char *remote)
{
	const char *shortname = remote + 11;
	int remote_is_branch = !prefixcmp(remote, "refs/heads/");
	struct strbuf key = STRBUF_INIT;
	int rebasing = should_setup_rebase(origin);

	if (remote_is_branch
	    && !strcmp(local, shortname)
	    && !origin) {
		warning("Not setting branch %s as its own upstream.",
			local);
		return;
	}

	strbuf_addf(&key, "branch.%s.remote", local);
	git_config_set(key.buf, origin ? origin : ".");

	strbuf_reset(&key);
	strbuf_addf(&key, "branch.%s.merge", local);
	git_config_set(key.buf, remote);

	if (rebasing) {
		strbuf_reset(&key);
		strbuf_addf(&key, "branch.%s.rebase", local);
		git_config_set(key.buf, "true");
	}
	strbuf_release(&key);

	if (flag & BRANCH_CONFIG_VERBOSE) {
		if (remote_is_branch && origin)
			printf(rebasing ?
			       "Branch %s set up to track remote branch %s from %s by rebasing.\n" :
			       "Branch %s set up to track remote branch %s from %s.\n",
			       local, shortname, origin);
		else if (remote_is_branch && !origin)
			printf(rebasing ?
			       "Branch %s set up to track local branch %s by rebasing.\n" :
			       "Branch %s set up to track local branch %s.\n",
			       local, shortname);
		else if (!remote_is_branch && origin)
			printf(rebasing ?
			       "Branch %s set up to track remote ref %s by rebasing.\n" :
			       "Branch %s set up to track remote ref %s.\n",
			       local, remote);
		else if (!remote_is_branch && !origin)
			printf(rebasing ?
			       "Branch %s set up to track local ref %s by rebasing.\n" :
			       "Branch %s set up to track local ref %s.\n",
			       local, remote);
		else
			die("BUG: impossible combination of %d and %p",
			    remote_is_branch, origin);
	}
}

/*
 * This is called when new_ref is branched off of orig_ref, and tries
 * to infer the settings for branch.<new_ref>.{remote,merge} from the
 * config.
 */
static int setup_tracking(const char *new_ref, const char *orig_ref,
			  enum branch_track track, int quiet)
{
	struct tracking tracking;
	int config_flags = quiet ? 0 : BRANCH_CONFIG_VERBOSE;

	if (strlen(new_ref) > 1024 - 7 - 7 - 1)
		return error("Tracking not set up: name too long: %s",
				new_ref);

	memset(&tracking, 0, sizeof(tracking));
	tracking.spec.dst = (char *)orig_ref;
	if (for_each_remote(find_tracked_branch, &tracking))
		return 1;

	if (!tracking.matches)
		switch (track) {
		case BRANCH_TRACK_ALWAYS:
		case BRANCH_TRACK_EXPLICIT:
		case BRANCH_TRACK_OVERRIDE:
			break;
		default:
			return 1;
		}

	if (tracking.matches > 1)
		return error("Not tracking: ambiguous information for ref %s",
				orig_ref);

	install_branch_config(config_flags, new_ref, tracking.remote,
			      tracking.src ? tracking.src : orig_ref);

	free(tracking.src);
	return 0;
}

struct branch_desc_cb {
	const char *config_name;
	const char *value;
};

static int read_branch_desc_cb(const char *var, const char *value, void *cb)
{
	struct branch_desc_cb *desc = cb;
	if (strcmp(desc->config_name, var))
		return 0;
	free((char *)desc->value);
	return git_config_string(&desc->value, var, value);
}

int read_branch_desc(struct strbuf *buf, const char *branch_name)
{
	struct branch_desc_cb cb;
	struct strbuf name = STRBUF_INIT;
	strbuf_addf(&name, "branch.%s.description", branch_name);
	cb.config_name = name.buf;
	cb.value = NULL;
	if (git_config(read_branch_desc_cb, &cb) < 0) {
		strbuf_release(&name);
		return -1;
	}
	if (cb.value)
		strbuf_addstr(buf, cb.value);
	strbuf_release(&name);
	return 0;
}

int validate_new_branchname(const char *name, struct strbuf *ref,
			    int force, int attr_only)
{
	if (strbuf_check_branch_ref(ref, name))
		die("'%s' is not a valid branch name.", name);

	if (!ref_exists(ref->buf))
		return 0;
	else if (!force && !attr_only)
		die("A branch named '%s' already exists.", ref->buf + strlen("refs/heads/"));

	if (!attr_only) {
		const char *head;
		unsigned char sha1[20];

		head = resolve_ref_unsafe("HEAD", sha1, 0, NULL);
		if (!is_bare_repository() && head && !strcmp(head, ref->buf))
			die("Cannot force update the current branch.");
	}
	return 1;
}

static const char upstream_not_branch[] =
N_("Cannot setup tracking information; starting point is not a branch.");

void create_branch(const char *head,
		   const char *name, const char *start_name,
		   int force, int reflog, int clobber_head,
		   int quiet, enum branch_track track)
{
	struct ref_lock *lock = NULL;
	struct commit *commit;
	unsigned char sha1[20];
	char *real_ref, msg[PATH_MAX + 20];
	struct strbuf ref = STRBUF_INIT;
	int forcing = 0;
	int dont_change_ref = 0;
	int explicit_tracking = 0;

	if (track == BRANCH_TRACK_EXPLICIT || track == BRANCH_TRACK_OVERRIDE)
		explicit_tracking = 1;

	if (validate_new_branchname(name, &ref, force,
				    track == BRANCH_TRACK_OVERRIDE ||
				    clobber_head)) {
		if (!force)
			dont_change_ref = 1;
		else
			forcing = 1;
	}

	real_ref = NULL;
	if (get_sha1(start_name, sha1))
		die("Not a valid object name: '%s'.", start_name);

	switch (dwim_ref(start_name, strlen(start_name), sha1, &real_ref)) {
	case 0:
		/* Not branching from any existing branch */
		if (explicit_tracking)
			die(_(upstream_not_branch));
		break;
	case 1:
		/* Unique completion -- good, only if it is a real branch */
		if (prefixcmp(real_ref, "refs/heads/") &&
		    prefixcmp(real_ref, "refs/remotes/")) {
			if (explicit_tracking)
				die(_(upstream_not_branch));
			else
				real_ref = NULL;
		}
		break;
	default:
		die("Ambiguous object name: '%s'.", start_name);
		break;
	}

	if ((commit = lookup_commit_reference(sha1)) == NULL)
		die("Not a valid branch point: '%s'.", start_name);
	hashcpy(sha1, commit->object.sha1);

	if (!dont_change_ref) {
		lock = lock_any_ref_for_update(ref.buf, NULL, 0);
		if (!lock)
			die_errno("Failed to lock ref for update");
	}

	if (reflog)
		log_all_ref_updates = 1;

	if (forcing)
		snprintf(msg, sizeof msg, "branch: Reset to %s",
			 start_name);
	else if (!dont_change_ref)
		snprintf(msg, sizeof msg, "branch: Created from %s",
			 start_name);

	if (real_ref && track)
		setup_tracking(ref.buf+11, real_ref, track, quiet);

	if (!dont_change_ref)
		if (write_ref_sha1(lock, sha1, msg) < 0)
			die_errno("Failed to write ref");

	strbuf_release(&ref);
	free(real_ref);
}

void remove_branch_state(void)
{
	unlink(git_path("CHERRY_PICK_HEAD"));
	unlink(git_path("REVERT_HEAD"));
	unlink(git_path("MERGE_HEAD"));
	unlink(git_path("MERGE_RR"));
	unlink(git_path("MERGE_MSG"));
	unlink(git_path("MERGE_MODE"));
	unlink(git_path("SQUASH_MSG"));
}
Commit	Line	Data
e496c003 DB	1	#include "cache.h"
	2	#include "branch.h"
	3	#include "refs.h"
	4	#include "remote.h"
	5	#include "commit.h"
	6
	7	struct tracking {
	8	struct refspec spec;
	9	char *src;
	10	const char *remote;
	11	int matches;
	12	};
	13
	14	static int find_tracked_branch(struct remote remote, void priv)
	15	{
	16	struct tracking *tracking = priv;
	17
	18	if (!remote_find_tracking(remote, &tracking->spec)) {
	19	if (++tracking->matches == 1) {
	20	tracking->src = tracking->spec.src;
	21	tracking->remote = remote->name;
	22	} else {
	23	free(tracking->spec.src);
	24	if (tracking->src) {
	25	free(tracking->src);
	26	tracking->src = NULL;
	27	}
	28	}
	29	tracking->spec.src = NULL;
	30	}
	31
	32	return 0;
	33	}
	34
a9f2c136	35	static int should_setup_rebase(const char *origin)
c998ae9b DS	36	{
	37	switch (autorebase) {
	38	case AUTOREBASE_NEVER:
	39	return 0;
	40	case AUTOREBASE_LOCAL:
a9f2c136	41	return origin == NULL;
c998ae9b	42	case AUTOREBASE_REMOTE:
a9f2c136	43	return origin != NULL;
c998ae9b DS	44	case AUTOREBASE_ALWAYS:
	45	return 1;
	46	}
	47	return 0;
	48	}
	49
a9f2c136 JH	50	void install_branch_config(int flag, const char local, const char origin, const char *remote)
a9f2c136 JH	51	{
85e2233f MM	52	const char *shortname = remote + 11;
85e2233f MM	53	int remote_is_branch = !prefixcmp(remote, "refs/heads/");
a9f2c136 JH	54	struct strbuf key = STRBUF_INIT;
	55	int rebasing = should_setup_rebase(origin);
	56
85e2233f MM	57	if (remote_is_branch
	58	&& !strcmp(local, shortname)
	59	&& !origin) {
	60	warning("Not setting branch %s as its own upstream.",
	61	local);
	62	return;
	63	}
	64
a9f2c136 JH	65	strbuf_addf(&key, "branch.%s.remote", local);
	66	git_config_set(key.buf, origin ? origin : ".");
	67
	68	strbuf_reset(&key);
	69	strbuf_addf(&key, "branch.%s.merge", local);
	70	git_config_set(key.buf, remote);
	71
	72	if (rebasing) {
	73	strbuf_reset(&key);
	74	strbuf_addf(&key, "branch.%s.rebase", local);
	75	git_config_set(key.buf, "true");
	76	}
d53a3503	77	strbuf_release(&key);
a9f2c136	78
72f60083	79	if (flag & BRANCH_CONFIG_VERBOSE) {
d53a3503 NTND	80	if (remote_is_branch && origin)
	81	printf(rebasing ?
	82	"Branch %s set up to track remote branch %s from %s by rebasing.\n" :
	83	"Branch %s set up to track remote branch %s from %s.\n",
	84	local, shortname, origin);
	85	else if (remote_is_branch && !origin)
	86	printf(rebasing ?
	87	"Branch %s set up to track local branch %s by rebasing.\n" :
	88	"Branch %s set up to track local branch %s.\n",
	89	local, shortname);
	90	else if (!remote_is_branch && origin)
	91	printf(rebasing ?
	92	"Branch %s set up to track remote ref %s by rebasing.\n" :
	93	"Branch %s set up to track remote ref %s.\n",
	94	local, remote);
	95	else if (!remote_is_branch && !origin)
	96	printf(rebasing ?
	97	"Branch %s set up to track local ref %s by rebasing.\n" :
	98	"Branch %s set up to track local ref %s.\n",
	99	local, remote);
72f60083	100	else
d53a3503 NTND	101	die("BUG: impossible combination of %d and %p",
d53a3503 NTND	102	remote_is_branch, origin);
72f60083	103	}
a9f2c136 JH	104	}
a9f2c136 JH	105
e496c003 DB	106	/*
	107	* This is called when new_ref is branched off of orig_ref, and tries
	108	* to infer the settings for branch.<new_ref>.{remote,merge} from the
	109	* config.
	110	*/
9ed36cfa	111	static int setup_tracking(const char new_ref, const char orig_ref,
f9a482e6	112	enum branch_track track, int quiet)
e496c003	113	{
e496c003	114	struct tracking tracking;
f9a482e6	115	int config_flags = quiet ? 0 : BRANCH_CONFIG_VERBOSE;
e496c003 DB	116
	117	if (strlen(new_ref) > 1024 - 7 - 7 - 1)
	118	return error("Tracking not set up: name too long: %s",
	119	new_ref);
	120
	121	memset(&tracking, 0, sizeof(tracking));
	122	tracking.spec.dst = (char *)orig_ref;
9ed36cfa	123	if (for_each_remote(find_tracked_branch, &tracking))
e496c003 DB	124	return 1;
e496c003 DB	125
9ed36cfa JS	126	if (!tracking.matches)
	127	switch (track) {
	128	case BRANCH_TRACK_ALWAYS:
	129	case BRANCH_TRACK_EXPLICIT:
4fc50066	130	case BRANCH_TRACK_OVERRIDE:
9ed36cfa JS	131	break;
	132	default:
	133	return 1;
	134	}
	135
e496c003 DB	136	if (tracking.matches > 1)
	137	return error("Not tracking: ambiguous information for ref %s",
	138	orig_ref);
	139
f9a482e6	140	install_branch_config(config_flags, new_ref, tracking.remote,
a9f2c136	141	tracking.src ? tracking.src : orig_ref);
e496c003	142
a9f2c136	143	free(tracking.src);
e496c003 DB	144	return 0;
	145	}
	146
6f9a3321 JH	147	struct branch_desc_cb {
	148	const char *config_name;
	149	const char *value;
	150	};
	151
	152	static int read_branch_desc_cb(const char var, const char value, void *cb)
	153	{
	154	struct branch_desc_cb *desc = cb;
	155	if (strcmp(desc->config_name, var))
	156	return 0;
	157	free((char *)desc->value);
	158	return git_config_string(&desc->value, var, value);
	159	}
	160
	161	int read_branch_desc(struct strbuf buf, const char branch_name)
	162	{
	163	struct branch_desc_cb cb;
	164	struct strbuf name = STRBUF_INIT;
	165	strbuf_addf(&name, "branch.%s.description", branch_name);
	166	cb.config_name = name.buf;
	167	cb.value = NULL;
	168	if (git_config(read_branch_desc_cb, &cb) < 0) {
	169	strbuf_release(&name);
	170	return -1;
	171	}
	172	if (cb.value)
	173	strbuf_addstr(buf, cb.value);
	174	strbuf_release(&name);
	175	return 0;
	176	}
	177
fa799376 JH	178	int validate_new_branchname(const char name, struct strbuf ref,
fa799376 JH	179	int force, int attr_only)
55c4a673	180	{
55c4a673 CI	181	if (strbuf_check_branch_ref(ref, name))
	182	die("'%s' is not a valid branch name.", name);
	183
	184	if (!ref_exists(ref->buf))
	185	return 0;
fa799376	186	else if (!force && !attr_only)
587a9ee7	187	die("A branch named '%s' already exists.", ref->buf + strlen("refs/heads/"));
55c4a673	188
fa799376 JH	189	if (!attr_only) {
	190	const char *head;
	191	unsigned char sha1[20];
55c4a673	192
8cad4744	193	head = resolve_ref_unsafe("HEAD", sha1, 0, NULL);
fa799376 JH	194	if (!is_bare_repository() && head && !strcmp(head, ref->buf))
	195	die("Cannot force update the current branch.");
	196	}
55c4a673 CI	197	return 1;
	198	}
	199
e2b6aa5f JK	200	static const char upstream_not_branch[] =
	201	N_("Cannot setup tracking information; starting point is not a branch.");
	202
e496c003 DB	203	void create_branch(const char *head,
e496c003 DB	204	const char name, const char start_name,
39bd6f72	205	int force, int reflog, int clobber_head,
f9a482e6	206	int quiet, enum branch_track track)
e496c003	207	{
4fc50066	208	struct ref_lock *lock = NULL;
e496c003 DB	209	struct commit *commit;
e496c003 DB	210	unsigned char sha1[20];
8415d5c7 JH	211	char *real_ref, msg[PATH_MAX + 20];
8415d5c7 JH	212	struct strbuf ref = STRBUF_INIT;
e496c003	213	int forcing = 0;
4fc50066 IL	214	int dont_change_ref = 0;
	215	int explicit_tracking = 0;
	216
	217	if (track == BRANCH_TRACK_EXPLICIT \|\| track == BRANCH_TRACK_OVERRIDE)
	218	explicit_tracking = 1;
e496c003	219
fa799376	220	if (validate_new_branchname(name, &ref, force,
39bd6f72 JN	221	track == BRANCH_TRACK_OVERRIDE \|\|
39bd6f72 JN	222	clobber_head)) {
55c4a673	223	if (!force)
4fc50066	224	dont_change_ref = 1;
55c4a673 CI	225	else
55c4a673 CI	226	forcing = 1;
e496c003 DB	227	}
	228
	229	real_ref = NULL;
	230	if (get_sha1(start_name, sha1))
	231	die("Not a valid object name: '%s'.", start_name);
	232
	233	switch (dwim_ref(start_name, strlen(start_name), sha1, &real_ref)) {
	234	case 0:
	235	/* Not branching from any existing branch */
4fc50066	236	if (explicit_tracking)
e2b6aa5f	237	die(_(upstream_not_branch));
e496c003 DB	238	break;
e496c003 DB	239	case 1:
21b5b1e8 JH	240	/* Unique completion -- good, only if it is a real branch */
	241	if (prefixcmp(real_ref, "refs/heads/") &&
	242	prefixcmp(real_ref, "refs/remotes/")) {
	243	if (explicit_tracking)
e2b6aa5f	244	die(_(upstream_not_branch));
21b5b1e8 JH	245	else
	246	real_ref = NULL;
	247	}
e496c003 DB	248	break;
	249	default:
	250	die("Ambiguous object name: '%s'.", start_name);
	251	break;
	252	}
	253
	254	if ((commit = lookup_commit_reference(sha1)) == NULL)
	255	die("Not a valid branch point: '%s'.", start_name);
	256	hashcpy(sha1, commit->object.sha1);
	257
4fc50066 IL	258	if (!dont_change_ref) {
	259	lock = lock_any_ref_for_update(ref.buf, NULL, 0);
	260	if (!lock)
	261	die_errno("Failed to lock ref for update");
	262	}
e496c003 DB	263
	264	if (reflog)
	265	log_all_ref_updates = 1;
	266
	267	if (forcing)
da288e25	268	snprintf(msg, sizeof msg, "branch: Reset to %s",
e496c003	269	start_name);
4fc50066	270	else if (!dont_change_ref)
e496c003 DB	271	snprintf(msg, sizeof msg, "branch: Created from %s",
	272	start_name);
	273
e496c003	274	if (real_ref && track)
f9a482e6	275	setup_tracking(ref.buf+11, real_ref, track, quiet);
e496c003	276
4fc50066 IL	277	if (!dont_change_ref)
	278	if (write_ref_sha1(lock, sha1, msg) < 0)
	279	die_errno("Failed to write ref");
e496c003	280
8415d5c7	281	strbuf_release(&ref);
9ed36cfa	282	free(real_ref);
e496c003	283	}
c369e7b8 DB	284
	285	void remove_branch_state(void)
	286	{
d7e5c0cb	287	unlink(git_path("CHERRY_PICK_HEAD"));
82433cdf	288	unlink(git_path("REVERT_HEAD"));
c369e7b8	289	unlink(git_path("MERGE_HEAD"));
0af0ac7e	290	unlink(git_path("MERGE_RR"));
c369e7b8	291	unlink(git_path("MERGE_MSG"));
cf10f9fd	292	unlink(git_path("MERGE_MODE"));
c369e7b8 DB	293	unlink(git_path("SQUASH_MSG"));
c369e7b8 DB	294	}