[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 struct tracking *tracking)
{
	switch (autorebase) {
	case AUTOREBASE_NEVER:
		return 0;
	case AUTOREBASE_LOCAL:
		return tracking->remote == NULL;
	case AUTOREBASE_REMOTE:
		return tracking->remote != NULL;
	case AUTOREBASE_ALWAYS:
		return 1;
	}
	return 0;
}

/*
 * 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)
{
	char key[1024];
	struct tracking tracking;

	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:
			break;
		default:
			return 1;
		}

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

	sprintf(key, "branch.%s.remote", new_ref);
	git_config_set(key, tracking.remote ?  tracking.remote : ".");
	sprintf(key, "branch.%s.merge", new_ref);
	git_config_set(key, tracking.src ? tracking.src : orig_ref);
	printf("Branch %s set up to track %s branch %s.\n", new_ref,
		tracking.remote ? "remote" : "local", orig_ref);
	if (should_setup_rebase(&tracking)) {
		sprintf(key, "branch.%s.rebase", new_ref);
		git_config_set(key, "true");
		printf("This branch will rebase on pull.\n");
	}
	free(tracking.src);

	return 0;
}

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

	snprintf(ref, sizeof ref, "refs/heads/%s", name);
	if (check_ref_format(ref))
		die("'%s' is not a valid branch name.", name);

	if (resolve_ref(ref, sha1, 1, NULL)) {
		if (!force)
			die("A branch named '%s' already exists.", name);
		else if (!is_bare_repository() && !strcmp(head, name))
			die("Cannot force update the current branch.");
		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 (track == BRANCH_TRACK_EXPLICIT)
			die("Cannot setup tracking information; starting point is not a branch.");
		break;
	case 1:
		/* Unique completion -- good, only if it is a real ref */
		if (track == BRANCH_TRACK_EXPLICIT && !strcmp(real_ref, "HEAD"))
			die("Cannot setup tracking information; starting point is not a branch.");
		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);

	lock = lock_any_ref_for_update(ref, NULL, 0);
	if (!lock)
		die("Failed to lock ref for update: %s.", strerror(errno));

	if (reflog)
		log_all_ref_updates = 1;

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

	if (real_ref && track)
		setup_tracking(name, real_ref, track);

	if (write_ref_sha1(lock, sha1, msg) < 0)
		die("Failed to write ref: %s.", strerror(errno));

	free(real_ref);
}

void remove_branch_state(void)
{
	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
c998ae9b DS	35	static int should_setup_rebase(const struct tracking *tracking)
	36	{
	37	switch (autorebase) {
	38	case AUTOREBASE_NEVER:
	39	return 0;
	40	case AUTOREBASE_LOCAL:
	41	return tracking->remote == NULL;
	42	case AUTOREBASE_REMOTE:
	43	return tracking->remote != NULL;
	44	case AUTOREBASE_ALWAYS:
	45	return 1;
	46	}
	47	return 0;
	48	}
	49
e496c003 DB	50	/*
	51	* This is called when new_ref is branched off of orig_ref, and tries
	52	* to infer the settings for branch.<new_ref>.{remote,merge} from the
	53	* config.
	54	*/
9ed36cfa JS	55	static int setup_tracking(const char new_ref, const char orig_ref,
9ed36cfa JS	56	enum branch_track track)
e496c003 DB	57	{
	58	char key[1024];
	59	struct tracking tracking;
	60
	61	if (strlen(new_ref) > 1024 - 7 - 7 - 1)
	62	return error("Tracking not set up: name too long: %s",
	63	new_ref);
	64
	65	memset(&tracking, 0, sizeof(tracking));
	66	tracking.spec.dst = (char *)orig_ref;
9ed36cfa	67	if (for_each_remote(find_tracked_branch, &tracking))
e496c003 DB	68	return 1;
e496c003 DB	69
9ed36cfa JS	70	if (!tracking.matches)
	71	switch (track) {
	72	case BRANCH_TRACK_ALWAYS:
	73	case BRANCH_TRACK_EXPLICIT:
	74	break;
	75	default:
	76	return 1;
	77	}
	78
e496c003 DB	79	if (tracking.matches > 1)
	80	return error("Not tracking: ambiguous information for ref %s",
	81	orig_ref);
	82
9ed36cfa JS	83	sprintf(key, "branch.%s.remote", new_ref);
	84	git_config_set(key, tracking.remote ? tracking.remote : ".");
	85	sprintf(key, "branch.%s.merge", new_ref);
	86	git_config_set(key, tracking.src ? tracking.src : orig_ref);
9ed36cfa JS	87	printf("Branch %s set up to track %s branch %s.\n", new_ref,
9ed36cfa JS	88	tracking.remote ? "remote" : "local", orig_ref);
c998ae9b DS	89	if (should_setup_rebase(&tracking)) {
	90	sprintf(key, "branch.%s.rebase", new_ref);
	91	git_config_set(key, "true");
	92	printf("This branch will rebase on pull.\n");
	93	}
	94	free(tracking.src);
e496c003 DB	95
	96	return 0;
	97	}
	98
	99	void create_branch(const char *head,
	100	const char name, const char start_name,
9ed36cfa	101	int force, int reflog, enum branch_track track)
e496c003 DB	102	{
	103	struct ref_lock *lock;
	104	struct commit *commit;
	105	unsigned char sha1[20];
	106	char *real_ref, ref[PATH_MAX], msg[PATH_MAX + 20];
	107	int forcing = 0;
	108
	109	snprintf(ref, sizeof ref, "refs/heads/%s", name);
	110	if (check_ref_format(ref))
	111	die("'%s' is not a valid branch name.", name);
	112
	113	if (resolve_ref(ref, sha1, 1, NULL)) {
	114	if (!force)
	115	die("A branch named '%s' already exists.", name);
	116	else if (!is_bare_repository() && !strcmp(head, name))
	117	die("Cannot force update the current branch.");
	118	forcing = 1;
	119	}
	120
	121	real_ref = NULL;
	122	if (get_sha1(start_name, sha1))
	123	die("Not a valid object name: '%s'.", start_name);
	124
	125	switch (dwim_ref(start_name, strlen(start_name), sha1, &real_ref)) {
	126	case 0:
	127	/* Not branching from any existing branch */
9ed36cfa JS	128	if (track == BRANCH_TRACK_EXPLICIT)
9ed36cfa JS	129	die("Cannot setup tracking information; starting point is not a branch.");
e496c003 DB	130	break;
e496c003 DB	131	case 1:
51a94af8 JH	132	/* Unique completion -- good, only if it is a real ref */
	133	if (track == BRANCH_TRACK_EXPLICIT && !strcmp(real_ref, "HEAD"))
	134	die("Cannot setup tracking information; starting point is not a branch.");
e496c003 DB	135	break;
	136	default:
	137	die("Ambiguous object name: '%s'.", start_name);
	138	break;
	139	}
	140
	141	if ((commit = lookup_commit_reference(sha1)) == NULL)
	142	die("Not a valid branch point: '%s'.", start_name);
	143	hashcpy(sha1, commit->object.sha1);
	144
	145	lock = lock_any_ref_for_update(ref, NULL, 0);
	146	if (!lock)
	147	die("Failed to lock ref for update: %s.", strerror(errno));
	148
	149	if (reflog)
	150	log_all_ref_updates = 1;
	151
	152	if (forcing)
	153	snprintf(msg, sizeof msg, "branch: Reset from %s",
	154	start_name);
	155	else
	156	snprintf(msg, sizeof msg, "branch: Created from %s",
	157	start_name);
	158
e496c003	159	if (real_ref && track)
9ed36cfa	160	setup_tracking(name, real_ref, track);
e496c003 DB	161
	162	if (write_ref_sha1(lock, sha1, msg) < 0)
	163	die("Failed to write ref: %s.", strerror(errno));
	164
9ed36cfa	165	free(real_ref);
e496c003	166	}
c369e7b8 DB	167
	168	void remove_branch_state(void)
	169	{
	170	unlink(git_path("MERGE_HEAD"));
0af0ac7e	171	unlink(git_path("MERGE_RR"));
c369e7b8	172	unlink(git_path("MERGE_MSG"));
cf10f9fd	173	unlink(git_path("MERGE_MODE"));
c369e7b8 DB	174	unlink(git_path("SQUASH_MSG"));
c369e7b8 DB	175	}