Merge branch 'ag/rebase-p'
[git.git] / branch.c
blobf967c98f6324c49d9ab7f94f973230512af13707
1 #include "git-compat-util.h"
2 #include "cache.h"
3 #include "config.h"
4 #include "branch.h"
5 #include "refs.h"
6 #include "refspec.h"
7 #include "remote.h"
8 #include "commit.h"
9 #include "worktree.h"
11 struct tracking {
12 struct refspec_item spec;
13 char *src;
14 const char *remote;
15 int matches;
18 static int find_tracked_branch(struct remote *remote, void *priv)
20 struct tracking *tracking = priv;
22 if (!remote_find_tracking(remote, &tracking->spec)) {
23 if (++tracking->matches == 1) {
24 tracking->src = tracking->spec.src;
25 tracking->remote = remote->name;
26 } else {
27 free(tracking->spec.src);
28 if (tracking->src) {
29 FREE_AND_NULL(tracking->src);
32 tracking->spec.src = NULL;
35 return 0;
38 static int should_setup_rebase(const char *origin)
40 switch (autorebase) {
41 case AUTOREBASE_NEVER:
42 return 0;
43 case AUTOREBASE_LOCAL:
44 return origin == NULL;
45 case AUTOREBASE_REMOTE:
46 return origin != NULL;
47 case AUTOREBASE_ALWAYS:
48 return 1;
50 return 0;
53 static const char tracking_advice[] =
54 N_("\n"
55 "After fixing the error cause you may try to fix up\n"
56 "the remote tracking information by invoking\n"
57 "\"git branch --set-upstream-to=%s%s%s\".");
59 int install_branch_config(int flag, const char *local, const char *origin, const char *remote)
61 const char *shortname = NULL;
62 struct strbuf key = STRBUF_INIT;
63 int rebasing = should_setup_rebase(origin);
65 if (skip_prefix(remote, "refs/heads/", &shortname)
66 && !strcmp(local, shortname)
67 && !origin) {
68 warning(_("Not setting branch %s as its own upstream."),
69 local);
70 return 0;
73 strbuf_addf(&key, "branch.%s.remote", local);
74 if (git_config_set_gently(key.buf, origin ? origin : ".") < 0)
75 goto out_err;
77 strbuf_reset(&key);
78 strbuf_addf(&key, "branch.%s.merge", local);
79 if (git_config_set_gently(key.buf, remote) < 0)
80 goto out_err;
82 if (rebasing) {
83 strbuf_reset(&key);
84 strbuf_addf(&key, "branch.%s.rebase", local);
85 if (git_config_set_gently(key.buf, "true") < 0)
86 goto out_err;
88 strbuf_release(&key);
90 if (flag & BRANCH_CONFIG_VERBOSE) {
91 if (shortname) {
92 if (origin)
93 printf_ln(rebasing ?
94 _("Branch '%s' set up to track remote branch '%s' from '%s' by rebasing.") :
95 _("Branch '%s' set up to track remote branch '%s' from '%s'."),
96 local, shortname, origin);
97 else
98 printf_ln(rebasing ?
99 _("Branch '%s' set up to track local branch '%s' by rebasing.") :
100 _("Branch '%s' set up to track local branch '%s'."),
101 local, shortname);
102 } else {
103 if (origin)
104 printf_ln(rebasing ?
105 _("Branch '%s' set up to track remote ref '%s' by rebasing.") :
106 _("Branch '%s' set up to track remote ref '%s'."),
107 local, remote);
108 else
109 printf_ln(rebasing ?
110 _("Branch '%s' set up to track local ref '%s' by rebasing.") :
111 _("Branch '%s' set up to track local ref '%s'."),
112 local, remote);
116 return 0;
118 out_err:
119 strbuf_release(&key);
120 error(_("Unable to write upstream branch configuration"));
122 advise(_(tracking_advice),
123 origin ? origin : "",
124 origin ? "/" : "",
125 shortname ? shortname : remote);
127 return -1;
131 * This is called when new_ref is branched off of orig_ref, and tries
132 * to infer the settings for branch.<new_ref>.{remote,merge} from the
133 * config.
135 static void setup_tracking(const char *new_ref, const char *orig_ref,
136 enum branch_track track, int quiet)
138 struct tracking tracking;
139 int config_flags = quiet ? 0 : BRANCH_CONFIG_VERBOSE;
141 memset(&tracking, 0, sizeof(tracking));
142 tracking.spec.dst = (char *)orig_ref;
143 if (for_each_remote(find_tracked_branch, &tracking))
144 return;
146 if (!tracking.matches)
147 switch (track) {
148 case BRANCH_TRACK_ALWAYS:
149 case BRANCH_TRACK_EXPLICIT:
150 case BRANCH_TRACK_OVERRIDE:
151 break;
152 default:
153 return;
156 if (tracking.matches > 1)
157 die(_("Not tracking: ambiguous information for ref %s"),
158 orig_ref);
160 if (install_branch_config(config_flags, new_ref, tracking.remote,
161 tracking.src ? tracking.src : orig_ref) < 0)
162 exit(-1);
164 free(tracking.src);
167 int read_branch_desc(struct strbuf *buf, const char *branch_name)
169 char *v = NULL;
170 struct strbuf name = STRBUF_INIT;
171 strbuf_addf(&name, "branch.%s.description", branch_name);
172 if (git_config_get_string(name.buf, &v)) {
173 strbuf_release(&name);
174 return -1;
176 strbuf_addstr(buf, v);
177 free(v);
178 strbuf_release(&name);
179 return 0;
183 * Check if 'name' can be a valid name for a branch; die otherwise.
184 * Return 1 if the named branch already exists; return 0 otherwise.
185 * Fill ref with the full refname for the branch.
187 int validate_branchname(const char *name, struct strbuf *ref)
189 if (strbuf_check_branch_ref(ref, name))
190 die(_("'%s' is not a valid branch name."), name);
192 return ref_exists(ref->buf);
196 * Check if a branch 'name' can be created as a new branch; die otherwise.
197 * 'force' can be used when it is OK for the named branch already exists.
198 * Return 1 if the named branch already exists; return 0 otherwise.
199 * Fill ref with the full refname for the branch.
201 int validate_new_branchname(const char *name, struct strbuf *ref, int force)
203 const char *head;
205 if (!validate_branchname(name, ref))
206 return 0;
208 if (!force)
209 die(_("A branch named '%s' already exists."),
210 ref->buf + strlen("refs/heads/"));
212 head = resolve_ref_unsafe("HEAD", 0, NULL, NULL);
213 if (!is_bare_repository() && head && !strcmp(head, ref->buf))
214 die(_("Cannot force update the current branch."));
216 return 1;
219 static int check_tracking_branch(struct remote *remote, void *cb_data)
221 char *tracking_branch = cb_data;
222 struct refspec_item query;
223 memset(&query, 0, sizeof(struct refspec_item));
224 query.dst = tracking_branch;
225 return !remote_find_tracking(remote, &query);
228 static int validate_remote_tracking_branch(char *ref)
230 return !for_each_remote(check_tracking_branch, ref);
233 static const char upstream_not_branch[] =
234 N_("Cannot setup tracking information; starting point '%s' is not a branch.");
235 static const char upstream_missing[] =
236 N_("the requested upstream branch '%s' does not exist");
237 static const char upstream_advice[] =
238 N_("\n"
239 "If you are planning on basing your work on an upstream\n"
240 "branch that already exists at the remote, you may need to\n"
241 "run \"git fetch\" to retrieve it.\n"
242 "\n"
243 "If you are planning to push out a new local branch that\n"
244 "will track its remote counterpart, you may want to use\n"
245 "\"git push -u\" to set the upstream config as you push.");
247 void create_branch(const char *name, const char *start_name,
248 int force, int clobber_head_ok, int reflog,
249 int quiet, enum branch_track track)
251 struct commit *commit;
252 struct object_id oid;
253 char *real_ref;
254 struct strbuf ref = STRBUF_INIT;
255 int forcing = 0;
256 int dont_change_ref = 0;
257 int explicit_tracking = 0;
259 if (track == BRANCH_TRACK_EXPLICIT || track == BRANCH_TRACK_OVERRIDE)
260 explicit_tracking = 1;
262 if ((track == BRANCH_TRACK_OVERRIDE || clobber_head_ok)
263 ? validate_branchname(name, &ref)
264 : validate_new_branchname(name, &ref, force)) {
265 if (!force)
266 dont_change_ref = 1;
267 else
268 forcing = 1;
271 real_ref = NULL;
272 if (get_oid(start_name, &oid)) {
273 if (explicit_tracking) {
274 if (advice_set_upstream_failure) {
275 error(_(upstream_missing), start_name);
276 advise(_(upstream_advice));
277 exit(1);
279 die(_(upstream_missing), start_name);
281 die(_("Not a valid object name: '%s'."), start_name);
284 switch (dwim_ref(start_name, strlen(start_name), &oid, &real_ref)) {
285 case 0:
286 /* Not branching from any existing branch */
287 if (explicit_tracking)
288 die(_(upstream_not_branch), start_name);
289 break;
290 case 1:
291 /* Unique completion -- good, only if it is a real branch */
292 if (!starts_with(real_ref, "refs/heads/") &&
293 validate_remote_tracking_branch(real_ref)) {
294 if (explicit_tracking)
295 die(_(upstream_not_branch), start_name);
296 else
297 real_ref = NULL;
299 break;
300 default:
301 die(_("Ambiguous object name: '%s'."), start_name);
302 break;
305 if ((commit = lookup_commit_reference(&oid)) == NULL)
306 die(_("Not a valid branch point: '%s'."), start_name);
307 oidcpy(&oid, &commit->object.oid);
309 if (reflog)
310 log_all_ref_updates = LOG_REFS_NORMAL;
312 if (!dont_change_ref) {
313 struct ref_transaction *transaction;
314 struct strbuf err = STRBUF_INIT;
315 char *msg;
317 if (forcing)
318 msg = xstrfmt("branch: Reset to %s", start_name);
319 else
320 msg = xstrfmt("branch: Created from %s", start_name);
322 transaction = ref_transaction_begin(&err);
323 if (!transaction ||
324 ref_transaction_update(transaction, ref.buf,
325 &oid, forcing ? NULL : &null_oid,
326 0, msg, &err) ||
327 ref_transaction_commit(transaction, &err))
328 die("%s", err.buf);
329 ref_transaction_free(transaction);
330 strbuf_release(&err);
331 free(msg);
334 if (real_ref && track)
335 setup_tracking(ref.buf + 11, real_ref, track, quiet);
337 strbuf_release(&ref);
338 free(real_ref);
341 void remove_branch_state(void)
343 unlink(git_path_cherry_pick_head());
344 unlink(git_path_revert_head());
345 unlink(git_path_merge_head());
346 unlink(git_path_merge_rr());
347 unlink(git_path_merge_msg());
348 unlink(git_path_merge_mode());
349 unlink(git_path_squash_msg());
352 void die_if_checked_out(const char *branch, int ignore_current_worktree)
354 const struct worktree *wt;
356 wt = find_shared_symref("HEAD", branch);
357 if (!wt || (ignore_current_worktree && wt->is_current))
358 return;
359 skip_prefix(branch, "refs/heads/", &branch);
360 die(_("'%s' is already checked out at '%s'"),
361 branch, wt->path);
364 int replace_each_worktree_head_symref(const char *oldref, const char *newref,
365 const char *logmsg)
367 int ret = 0;
368 struct worktree **worktrees = get_worktrees(0);
369 int i;
371 for (i = 0; worktrees[i]; i++) {
372 struct ref_store *refs;
374 if (worktrees[i]->is_detached)
375 continue;
376 if (!worktrees[i]->head_ref)
377 continue;
378 if (strcmp(oldref, worktrees[i]->head_ref))
379 continue;
381 refs = get_worktree_ref_store(worktrees[i]);
382 if (refs_create_symref(refs, "HEAD", newref, logmsg))
383 ret = error(_("HEAD of working tree %s is not updated"),
384 worktrees[i]->path);
387 free_worktrees(worktrees);
388 return ret;