Merge branch 'dl/cocci-everywhere'
[git/git.git] / branch.c
CommitLineData
303d1d0b 1#include "git-compat-util.h"
e496c003 2#include "cache.h"
b2141fc1 3#include "config.h"
e496c003
DB
4#include "branch.h"
5#include "refs.h"
ec0cb496 6#include "refspec.h"
e496c003 7#include "remote.h"
b07d9bfd 8#include "sequencer.h"
e496c003 9#include "commit.h"
ac6c561b 10#include "worktree.h"
e496c003
DB
11
12struct tracking {
0ad4a5ff 13 struct refspec_item spec;
e496c003
DB
14 char *src;
15 const char *remote;
16 int matches;
17};
18
19static int find_tracked_branch(struct remote *remote, void *priv)
20{
21 struct tracking *tracking = priv;
22
23 if (!remote_find_tracking(remote, &tracking->spec)) {
24 if (++tracking->matches == 1) {
25 tracking->src = tracking->spec.src;
26 tracking->remote = remote->name;
27 } else {
28 free(tracking->spec.src);
ce528de0 29 FREE_AND_NULL(tracking->src);
e496c003
DB
30 }
31 tracking->spec.src = NULL;
32 }
33
34 return 0;
35}
36
a9f2c136 37static int should_setup_rebase(const char *origin)
c998ae9b
DS
38{
39 switch (autorebase) {
40 case AUTOREBASE_NEVER:
41 return 0;
42 case AUTOREBASE_LOCAL:
a9f2c136 43 return origin == NULL;
c998ae9b 44 case AUTOREBASE_REMOTE:
a9f2c136 45 return origin != NULL;
c998ae9b
DS
46 case AUTOREBASE_ALWAYS:
47 return 1;
48 }
49 return 0;
50}
51
27852b2c
PS
52static const char tracking_advice[] =
53N_("\n"
54"After fixing the error cause you may try to fix up\n"
55"the remote tracking information by invoking\n"
56"\"git branch --set-upstream-to=%s%s%s\".");
57
58int install_branch_config(int flag, const char *local, const char *origin, const char *remote)
a9f2c136 59{
cf4fff57 60 const char *shortname = NULL;
a9f2c136
JH
61 struct strbuf key = STRBUF_INIT;
62 int rebasing = should_setup_rebase(origin);
63
cf4fff57 64 if (skip_prefix(remote, "refs/heads/", &shortname)
85e2233f
MM
65 && !strcmp(local, shortname)
66 && !origin) {
bc554df8 67 warning(_("Not setting branch %s as its own upstream."),
85e2233f 68 local);
27852b2c 69 return 0;
85e2233f
MM
70 }
71
a9f2c136 72 strbuf_addf(&key, "branch.%s.remote", local);
30598ad0 73 if (git_config_set_gently(key.buf, origin ? origin : ".") < 0)
27852b2c 74 goto out_err;
a9f2c136
JH
75
76 strbuf_reset(&key);
77 strbuf_addf(&key, "branch.%s.merge", local);
30598ad0 78 if (git_config_set_gently(key.buf, remote) < 0)
27852b2c 79 goto out_err;
a9f2c136
JH
80
81 if (rebasing) {
82 strbuf_reset(&key);
83 strbuf_addf(&key, "branch.%s.rebase", local);
30598ad0 84 if (git_config_set_gently(key.buf, "true") < 0)
27852b2c 85 goto out_err;
a9f2c136 86 }
d53a3503 87 strbuf_release(&key);
a9f2c136 88
72f60083 89 if (flag & BRANCH_CONFIG_VERBOSE) {
1d9aaed2 90 if (shortname) {
9fe0cf3a
A
91 if (origin)
92 printf_ln(rebasing ?
9c93ff7c
KS
93 _("Branch '%s' set up to track remote branch '%s' from '%s' by rebasing.") :
94 _("Branch '%s' set up to track remote branch '%s' from '%s'."),
9fe0cf3a
A
95 local, shortname, origin);
96 else
97 printf_ln(rebasing ?
9c93ff7c
KS
98 _("Branch '%s' set up to track local branch '%s' by rebasing.") :
99 _("Branch '%s' set up to track local branch '%s'."),
9fe0cf3a
A
100 local, shortname);
101 } else {
102 if (origin)
103 printf_ln(rebasing ?
9c93ff7c
KS
104 _("Branch '%s' set up to track remote ref '%s' by rebasing.") :
105 _("Branch '%s' set up to track remote ref '%s'."),
9fe0cf3a
A
106 local, remote);
107 else
108 printf_ln(rebasing ?
9c93ff7c
KS
109 _("Branch '%s' set up to track local ref '%s' by rebasing.") :
110 _("Branch '%s' set up to track local ref '%s'."),
9fe0cf3a
A
111 local, remote);
112 }
72f60083 113 }
27852b2c
PS
114
115 return 0;
116
117out_err:
118 strbuf_release(&key);
119 error(_("Unable to write upstream branch configuration"));
120
121 advise(_(tracking_advice),
122 origin ? origin : "",
123 origin ? "/" : "",
124 shortname ? shortname : remote);
125
126 return -1;
a9f2c136
JH
127}
128
e496c003
DB
129/*
130 * This is called when new_ref is branched off of orig_ref, and tries
131 * to infer the settings for branch.<new_ref>.{remote,merge} from the
132 * config.
133 */
27852b2c
PS
134static void setup_tracking(const char *new_ref, const char *orig_ref,
135 enum branch_track track, int quiet)
e496c003 136{
e496c003 137 struct tracking tracking;
f9a482e6 138 int config_flags = quiet ? 0 : BRANCH_CONFIG_VERBOSE;
e496c003 139
e496c003
DB
140 memset(&tracking, 0, sizeof(tracking));
141 tracking.spec.dst = (char *)orig_ref;
9ed36cfa 142 if (for_each_remote(find_tracked_branch, &tracking))
27852b2c 143 return;
e496c003 144
9ed36cfa
JS
145 if (!tracking.matches)
146 switch (track) {
147 case BRANCH_TRACK_ALWAYS:
148 case BRANCH_TRACK_EXPLICIT:
4fc50066 149 case BRANCH_TRACK_OVERRIDE:
9ed36cfa
JS
150 break;
151 default:
27852b2c 152 return;
9ed36cfa
JS
153 }
154
e496c003 155 if (tracking.matches > 1)
27852b2c
PS
156 die(_("Not tracking: ambiguous information for ref %s"),
157 orig_ref);
e496c003 158
27852b2c
PS
159 if (install_branch_config(config_flags, new_ref, tracking.remote,
160 tracking.src ? tracking.src : orig_ref) < 0)
161 exit(-1);
e496c003 162
a9f2c136 163 free(tracking.src);
e496c003
DB
164}
165
6f9a3321
JH
166int read_branch_desc(struct strbuf *buf, const char *branch_name)
167{
540b0f49 168 char *v = NULL;
6f9a3321
JH
169 struct strbuf name = STRBUF_INIT;
170 strbuf_addf(&name, "branch.%s.description", branch_name);
540b0f49
TA
171 if (git_config_get_string(name.buf, &v)) {
172 strbuf_release(&name);
173 return -1;
174 }
175 strbuf_addstr(buf, v);
176 free(v);
6f9a3321
JH
177 strbuf_release(&name);
178 return 0;
179}
180
bc1c9c0e
JH
181/*
182 * Check if 'name' can be a valid name for a branch; die otherwise.
183 * Return 1 if the named branch already exists; return 0 otherwise.
184 * Fill ref with the full refname for the branch.
185 */
186int validate_branchname(const char *name, struct strbuf *ref)
55c4a673 187{
55c4a673 188 if (strbuf_check_branch_ref(ref, name))
bc554df8 189 die(_("'%s' is not a valid branch name."), name);
55c4a673 190
bc1c9c0e
JH
191 return ref_exists(ref->buf);
192}
55c4a673 193
bc1c9c0e
JH
194/*
195 * Check if a branch 'name' can be created as a new branch; die otherwise.
196 * 'force' can be used when it is OK for the named branch already exists.
197 * Return 1 if the named branch already exists; return 0 otherwise.
198 * Fill ref with the full refname for the branch.
199 */
200int validate_new_branchname(const char *name, struct strbuf *ref, int force)
201{
202 const char *head;
203
204 if (!validate_branchname(name, ref))
55c4a673 205 return 0;
55c4a673 206
8280c4c1
JH
207 if (!force)
208 die(_("A branch named '%s' already exists."),
209 ref->buf + strlen("refs/heads/"));
210
211 head = resolve_ref_unsafe("HEAD", 0, NULL, NULL);
212 if (!is_bare_repository() && head && !strcmp(head, ref->buf))
213 die(_("Cannot force update the current branch."));
55c4a673
CI
214
215 return 1;
216}
217
41c21f22
JH
218static int check_tracking_branch(struct remote *remote, void *cb_data)
219{
220 char *tracking_branch = cb_data;
0ad4a5ff
BW
221 struct refspec_item query;
222 memset(&query, 0, sizeof(struct refspec_item));
41c21f22 223 query.dst = tracking_branch;
1d7358c5 224 return !remote_find_tracking(remote, &query);
41c21f22
JH
225}
226
227static int validate_remote_tracking_branch(char *ref)
228{
229 return !for_each_remote(check_tracking_branch, ref);
230}
231
e2b6aa5f 232static const char upstream_not_branch[] =
1a15d00b 233N_("Cannot setup tracking information; starting point '%s' is not a branch.");
a5e91c72 234static const char upstream_missing[] =
caa2036b
JK
235N_("the requested upstream branch '%s' does not exist");
236static const char upstream_advice[] =
237N_("\n"
238"If you are planning on basing your work on an upstream\n"
239"branch that already exists at the remote, you may need to\n"
240"run \"git fetch\" to retrieve it.\n"
241"\n"
242"If you are planning to push out a new local branch that\n"
243"will track its remote counterpart, you may want to use\n"
244"\"git push -u\" to set the upstream config as you push.");
e2b6aa5f 245
4edce172
NTND
246void create_branch(struct repository *r,
247 const char *name, const char *start_name,
e2bbd0cc 248 int force, int clobber_head_ok, int reflog,
f9a482e6 249 int quiet, enum branch_track track)
e496c003 250{
e496c003 251 struct commit *commit;
48713bfa 252 struct object_id oid;
3818b258 253 char *real_ref;
8415d5c7 254 struct strbuf ref = STRBUF_INIT;
e496c003 255 int forcing = 0;
4fc50066
IL
256 int dont_change_ref = 0;
257 int explicit_tracking = 0;
258
259 if (track == BRANCH_TRACK_EXPLICIT || track == BRANCH_TRACK_OVERRIDE)
260 explicit_tracking = 1;
e496c003 261
0faff988 262 if ((track == BRANCH_TRACK_OVERRIDE || clobber_head_ok)
bc1c9c0e
JH
263 ? validate_branchname(name, &ref)
264 : validate_new_branchname(name, &ref, force)) {
55c4a673 265 if (!force)
4fc50066 266 dont_change_ref = 1;
55c4a673
CI
267 else
268 forcing = 1;
e496c003
DB
269 }
270
271 real_ref = NULL;
e3d6539d 272 if (get_oid_mb(start_name, &oid)) {
caa2036b
JK
273 if (explicit_tracking) {
274 if (advice_set_upstream_failure) {
275 error(_(upstream_missing), start_name);
276 advise(_(upstream_advice));
277 exit(1);
278 }
1a15d00b 279 die(_(upstream_missing), start_name);
caa2036b 280 }
bc554df8 281 die(_("Not a valid object name: '%s'."), start_name);
a5e91c72 282 }
e496c003 283
cca5fa64 284 switch (dwim_ref(start_name, strlen(start_name), &oid, &real_ref)) {
e496c003
DB
285 case 0:
286 /* Not branching from any existing branch */
4fc50066 287 if (explicit_tracking)
1a15d00b 288 die(_(upstream_not_branch), start_name);
e496c003
DB
289 break;
290 case 1:
21b5b1e8 291 /* Unique completion -- good, only if it is a real branch */
59556548 292 if (!starts_with(real_ref, "refs/heads/") &&
41c21f22 293 validate_remote_tracking_branch(real_ref)) {
21b5b1e8 294 if (explicit_tracking)
1a15d00b 295 die(_(upstream_not_branch), start_name);
21b5b1e8
JH
296 else
297 real_ref = NULL;
298 }
e496c003
DB
299 break;
300 default:
bc554df8 301 die(_("Ambiguous object name: '%s'."), start_name);
e496c003
DB
302 break;
303 }
304
4edce172 305 if ((commit = lookup_commit_reference(r, &oid)) == NULL)
bc554df8 306 die(_("Not a valid branch point: '%s'."), start_name);
48713bfa 307 oidcpy(&oid, &commit->object.oid);
e496c003 308
d43f990f 309 if (reflog)
341fb286 310 log_all_ref_updates = LOG_REFS_NORMAL;
d43f990f
RS
311
312 if (!dont_change_ref) {
313 struct ref_transaction *transaction;
314 struct strbuf err = STRBUF_INIT;
cddac452 315 char *msg;
3818b258
JK
316
317 if (forcing)
cddac452 318 msg = xstrfmt("branch: Reset to %s", start_name);
3818b258 319 else
cddac452 320 msg = xstrfmt("branch: Created from %s", start_name);
d43f990f
RS
321
322 transaction = ref_transaction_begin(&err);
323 if (!transaction ||
1d147bdf 324 ref_transaction_update(transaction, ref.buf,
89f3bbdd 325 &oid, forcing ? NULL : &null_oid,
1d147bdf 326 0, msg, &err) ||
db7516ab 327 ref_transaction_commit(transaction, &err))
d43f990f
RS
328 die("%s", err.buf);
329 ref_transaction_free(transaction);
330 strbuf_release(&err);
cddac452 331 free(msg);
d43f990f
RS
332 }
333
e496c003 334 if (real_ref && track)
82a0672f 335 setup_tracking(ref.buf + 11, real_ref, track, quiet);
e496c003 336
8415d5c7 337 strbuf_release(&ref);
9ed36cfa 338 free(real_ref);
e496c003 339}
c369e7b8 340
b6433555 341void remove_merge_branch_state(struct repository *r)
c369e7b8 342{
4edce172
NTND
343 unlink(git_path_merge_head(r));
344 unlink(git_path_merge_rr(r));
345 unlink(git_path_merge_msg(r));
346 unlink(git_path_merge_mode(r));
b6433555
NTND
347}
348
f496b064 349void remove_branch_state(struct repository *r, int verbose)
b6433555 350{
f496b064 351 sequencer_post_commit_cleanup(r, verbose);
4edce172 352 unlink(git_path_squash_msg(r));
b6433555 353 remove_merge_branch_state(r);
c369e7b8 354}
ed89f84b 355
8d9fdd70 356void die_if_checked_out(const char *branch, int ignore_current_worktree)
41af6565 357{
d3b9ac07 358 const struct worktree *wt;
41af6565 359
d3b9ac07 360 wt = find_shared_symref("HEAD", branch);
8d9fdd70 361 if (!wt || (ignore_current_worktree && wt->is_current))
d3b9ac07
NTND
362 return;
363 skip_prefix(branch, "refs/heads/", &branch);
364 die(_("'%s' is already checked out at '%s'"),
365 branch, wt->path);
ed89f84b 366}
70999e9c 367
39ee4c6c
KM
368int replace_each_worktree_head_symref(const char *oldref, const char *newref,
369 const char *logmsg)
70999e9c
KY
370{
371 int ret = 0;
4fff1ef7 372 struct worktree **worktrees = get_worktrees(0);
70999e9c
KY
373 int i;
374
375 for (i = 0; worktrees[i]; i++) {
d026a256
NTND
376 struct ref_store *refs;
377
70999e9c
KY
378 if (worktrees[i]->is_detached)
379 continue;
31824d18
NTND
380 if (!worktrees[i]->head_ref)
381 continue;
382 if (strcmp(oldref, worktrees[i]->head_ref))
70999e9c
KY
383 continue;
384
d026a256
NTND
385 refs = get_worktree_ref_store(worktrees[i]);
386 if (refs_create_symref(refs, "HEAD", newref, logmsg))
387 ret = error(_("HEAD of working tree %s is not updated"),
388 worktrees[i]->path);
70999e9c
KY
389 }
390
391 free_worktrees(worktrees);
392 return ret;
393}