4 * Copyright (c) 2006 Kristian Høgsberg <krh@redhat.com>
5 * Based on git-branch.sh by Junio C Hamano.
14 #include "parse-options.h"
18 #include "string-list.h"
21 #include "wt-status.h"
22 #include "ref-filter.h"
24 static const char * const builtin_branch_usage
[] = {
25 N_("git branch [<options>] [-r | -a] [--merged | --no-merged]"),
26 N_("git branch [<options>] [-l] [-f] <branch-name> [<start-point>]"),
27 N_("git branch [<options>] [-r] (-d | -D) <branch-name>..."),
28 N_("git branch [<options>] (-m | -M) [<old-branch>] <new-branch>"),
29 N_("git branch [<options>] [-r | -a] [--points-at]"),
33 static const char *head
;
34 static unsigned char head_sha1
[20];
36 static int branch_use_color
= -1;
37 static char branch_colors
[][COLOR_MAXLEN
] = {
39 GIT_COLOR_NORMAL
, /* PLAIN */
40 GIT_COLOR_RED
, /* REMOTE */
41 GIT_COLOR_NORMAL
, /* LOCAL */
42 GIT_COLOR_GREEN
, /* CURRENT */
43 GIT_COLOR_BLUE
, /* UPSTREAM */
46 BRANCH_COLOR_RESET
= 0,
47 BRANCH_COLOR_PLAIN
= 1,
48 BRANCH_COLOR_REMOTE
= 2,
49 BRANCH_COLOR_LOCAL
= 3,
50 BRANCH_COLOR_CURRENT
= 4,
51 BRANCH_COLOR_UPSTREAM
= 5
54 static struct string_list output
= STRING_LIST_INIT_DUP
;
55 static unsigned int colopts
;
57 static int parse_branch_color_slot(const char *slot
)
59 if (!strcasecmp(slot
, "plain"))
60 return BRANCH_COLOR_PLAIN
;
61 if (!strcasecmp(slot
, "reset"))
62 return BRANCH_COLOR_RESET
;
63 if (!strcasecmp(slot
, "remote"))
64 return BRANCH_COLOR_REMOTE
;
65 if (!strcasecmp(slot
, "local"))
66 return BRANCH_COLOR_LOCAL
;
67 if (!strcasecmp(slot
, "current"))
68 return BRANCH_COLOR_CURRENT
;
69 if (!strcasecmp(slot
, "upstream"))
70 return BRANCH_COLOR_UPSTREAM
;
74 static int git_branch_config(const char *var
, const char *value
, void *cb
)
76 const char *slot_name
;
78 if (starts_with(var
, "column."))
79 return git_column_config(var
, value
, "branch", &colopts
);
80 if (!strcmp(var
, "color.branch")) {
81 branch_use_color
= git_config_colorbool(var
, value
);
84 if (skip_prefix(var
, "color.branch.", &slot_name
)) {
85 int slot
= parse_branch_color_slot(slot_name
);
89 return config_error_nonbool(var
);
90 return color_parse(value
, branch_colors
[slot
]);
92 return git_color_default_config(var
, value
, cb
);
95 static const char *branch_get_color(enum color_branch ix
)
97 if (want_color(branch_use_color
))
98 return branch_colors
[ix
];
102 static int branch_merged(int kind
, const char *name
,
103 struct commit
*rev
, struct commit
*head_rev
)
106 * This checks whether the merge bases of branch and HEAD (or
107 * the other branch this branch builds upon) contains the
108 * branch, which means that the branch has already been merged
109 * safely to HEAD (or the other branch).
111 struct commit
*reference_rev
= NULL
;
112 const char *reference_name
= NULL
;
113 void *reference_name_to_free
= NULL
;
116 if (kind
== FILTER_REFS_BRANCHES
) {
117 struct branch
*branch
= branch_get(name
);
118 const char *upstream
= branch_get_upstream(branch
, NULL
);
119 unsigned char sha1
[20];
122 (reference_name
= reference_name_to_free
=
123 resolve_refdup(upstream
, RESOLVE_REF_READING
,
124 sha1
, NULL
)) != NULL
)
125 reference_rev
= lookup_commit_reference(sha1
);
128 reference_rev
= head_rev
;
130 merged
= in_merge_bases(rev
, reference_rev
);
133 * After the safety valve is fully redefined to "check with
134 * upstream, if any, otherwise with HEAD", we should just
135 * return the result of the in_merge_bases() above without
136 * any of the following code, but during the transition period,
137 * a gentle reminder is in order.
139 if ((head_rev
!= reference_rev
) &&
140 in_merge_bases(rev
, head_rev
) != merged
) {
142 warning(_("deleting branch '%s' that has been merged to\n"
143 " '%s', but not yet merged to HEAD."),
144 name
, reference_name
);
146 warning(_("not deleting branch '%s' that is not yet merged to\n"
147 " '%s', even though it is merged to HEAD."),
148 name
, reference_name
);
150 free(reference_name_to_free
);
154 static int check_branch_commit(const char *branchname
, const char *refname
,
155 const unsigned char *sha1
, struct commit
*head_rev
,
156 int kinds
, int force
)
158 struct commit
*rev
= lookup_commit_reference(sha1
);
160 error(_("Couldn't look up commit object for '%s'"), refname
);
163 if (!force
&& !branch_merged(kinds
, branchname
, rev
, head_rev
)) {
164 error(_("The branch '%s' is not fully merged.\n"
165 "If you are sure you want to delete it, "
166 "run 'git branch -D %s'."), branchname
, branchname
);
172 static void delete_branch_config(const char *branchname
)
174 struct strbuf buf
= STRBUF_INIT
;
175 strbuf_addf(&buf
, "branch.%s", branchname
);
176 if (git_config_rename_section(buf
.buf
, NULL
) < 0)
177 warning(_("Update of config-file failed"));
178 strbuf_release(&buf
);
181 static int delete_branches(int argc
, const char **argv
, int force
, int kinds
,
184 struct commit
*head_rev
= NULL
;
185 unsigned char sha1
[20];
190 int remote_branch
= 0;
191 struct strbuf bname
= STRBUF_INIT
;
194 case FILTER_REFS_REMOTES
:
195 fmt
= "refs/remotes/%s";
196 /* For subsequent UI messages */
201 case FILTER_REFS_BRANCHES
:
202 fmt
= "refs/heads/%s";
205 die(_("cannot use -a with -d"));
209 head_rev
= lookup_commit_reference(head_sha1
);
211 die(_("Couldn't look up commit object for HEAD"));
213 for (i
= 0; i
< argc
; i
++, strbuf_release(&bname
)) {
217 strbuf_branchname(&bname
, argv
[i
]);
218 if (kinds
== FILTER_REFS_BRANCHES
&& !strcmp(head
, bname
.buf
)) {
219 error(_("Cannot delete the branch '%s' "
220 "which you are currently on."), bname
.buf
);
227 name
= mkpathdup(fmt
, bname
.buf
);
228 target
= resolve_ref_unsafe(name
,
230 | RESOLVE_REF_NO_RECURSE
231 | RESOLVE_REF_ALLOW_BAD_NAME
,
235 ? _("remote-tracking branch '%s' not found.")
236 : _("branch '%s' not found."), bname
.buf
);
241 if (!(flags
& (REF_ISSYMREF
|REF_ISBROKEN
)) &&
242 check_branch_commit(bname
.buf
, name
, sha1
, head_rev
, kinds
,
248 if (delete_ref(name
, is_null_sha1(sha1
) ? NULL
: sha1
,
251 ? _("Error deleting remote-tracking branch '%s'")
252 : _("Error deleting branch '%s'"),
259 ? _("Deleted remote-tracking branch %s (was %s).\n")
260 : _("Deleted branch %s (was %s).\n"),
262 (flags
& REF_ISBROKEN
) ? "broken"
263 : (flags
& REF_ISSYMREF
) ? target
264 : find_unique_abbrev(sha1
, DEFAULT_ABBREV
));
266 delete_branch_config(bname
.buf
);
274 static void fill_tracking_info(struct strbuf
*stat
, const char *branch_name
,
275 int show_upstream_ref
)
279 struct branch
*branch
= branch_get(branch_name
);
280 const char *upstream
;
281 struct strbuf fancy
= STRBUF_INIT
;
282 int upstream_is_gone
= 0;
283 int added_decoration
= 1;
285 if (stat_tracking_info(branch
, &ours
, &theirs
, &upstream
) < 0) {
288 upstream_is_gone
= 1;
291 if (show_upstream_ref
) {
292 ref
= shorten_unambiguous_ref(upstream
, 0);
293 if (want_color(branch_use_color
))
294 strbuf_addf(&fancy
, "%s%s%s",
295 branch_get_color(BRANCH_COLOR_UPSTREAM
),
296 ref
, branch_get_color(BRANCH_COLOR_RESET
));
298 strbuf_addstr(&fancy
, ref
);
301 if (upstream_is_gone
) {
302 if (show_upstream_ref
)
303 strbuf_addf(stat
, _("[%s: gone]"), fancy
.buf
);
305 added_decoration
= 0;
306 } else if (!ours
&& !theirs
) {
307 if (show_upstream_ref
)
308 strbuf_addf(stat
, _("[%s]"), fancy
.buf
);
310 added_decoration
= 0;
312 if (show_upstream_ref
)
313 strbuf_addf(stat
, _("[%s: behind %d]"), fancy
.buf
, theirs
);
315 strbuf_addf(stat
, _("[behind %d]"), theirs
);
317 } else if (!theirs
) {
318 if (show_upstream_ref
)
319 strbuf_addf(stat
, _("[%s: ahead %d]"), fancy
.buf
, ours
);
321 strbuf_addf(stat
, _("[ahead %d]"), ours
);
323 if (show_upstream_ref
)
324 strbuf_addf(stat
, _("[%s: ahead %d, behind %d]"),
325 fancy
.buf
, ours
, theirs
);
327 strbuf_addf(stat
, _("[ahead %d, behind %d]"),
330 strbuf_release(&fancy
);
331 if (added_decoration
)
332 strbuf_addch(stat
, ' ');
336 static void add_verbose_info(struct strbuf
*out
, struct ref_array_item
*item
,
337 struct ref_filter
*filter
, const char *refname
)
339 struct strbuf subject
= STRBUF_INIT
, stat
= STRBUF_INIT
;
340 const char *sub
= _(" **** invalid ref ****");
341 struct commit
*commit
= item
->commit
;
343 if (!parse_commit(commit
)) {
344 pp_commit_easy(CMIT_FMT_ONELINE
, commit
, &subject
);
348 if (item
->kind
== FILTER_REFS_BRANCHES
)
349 fill_tracking_info(&stat
, refname
, filter
->verbose
> 1);
351 strbuf_addf(out
, " %s %s%s",
352 find_unique_abbrev(item
->commit
->object
.oid
.hash
, filter
->abbrev
),
354 strbuf_release(&stat
);
355 strbuf_release(&subject
);
358 static char *get_head_description(void)
360 struct strbuf desc
= STRBUF_INIT
;
361 struct wt_status_state state
;
362 memset(&state
, 0, sizeof(state
));
363 wt_status_get_state(&state
, 1);
364 if (state
.rebase_in_progress
||
365 state
.rebase_interactive_in_progress
)
366 strbuf_addf(&desc
, _("(no branch, rebasing %s)"),
368 else if (state
.bisect_in_progress
)
369 strbuf_addf(&desc
, _("(no branch, bisect started on %s)"),
371 else if (state
.detached_from
) {
372 /* TRANSLATORS: make sure these match _("HEAD detached at ")
373 and _("HEAD detached from ") in wt-status.c */
374 if (state
.detached_at
)
375 strbuf_addf(&desc
, _("(HEAD detached at %s)"),
376 state
.detached_from
);
378 strbuf_addf(&desc
, _("(HEAD detached from %s)"),
379 state
.detached_from
);
382 strbuf_addstr(&desc
, _("(no branch)"));
385 free(state
.detached_from
);
386 return strbuf_detach(&desc
, NULL
);
389 static void format_and_print_ref_item(struct ref_array_item
*item
, int maxwidth
,
390 struct ref_filter
*filter
, const char *remote_prefix
)
395 struct strbuf out
= STRBUF_INIT
, name
= STRBUF_INIT
;
396 const char *prefix
= "";
397 const char *desc
= item
->refname
;
398 char *to_free
= NULL
;
400 switch (item
->kind
) {
401 case FILTER_REFS_BRANCHES
:
402 skip_prefix(desc
, "refs/heads/", &desc
);
403 if (!filter
->detached
&& !strcmp(desc
, head
))
406 color
= BRANCH_COLOR_LOCAL
;
408 case FILTER_REFS_REMOTES
:
409 skip_prefix(desc
, "refs/remotes/", &desc
);
410 color
= BRANCH_COLOR_REMOTE
;
411 prefix
= remote_prefix
;
413 case FILTER_REFS_DETACHED_HEAD
:
414 desc
= to_free
= get_head_description();
418 color
= BRANCH_COLOR_PLAIN
;
425 color
= BRANCH_COLOR_CURRENT
;
428 strbuf_addf(&name
, "%s%s", prefix
, desc
);
429 if (filter
->verbose
) {
430 int utf8_compensation
= strlen(name
.buf
) - utf8_strwidth(name
.buf
);
431 strbuf_addf(&out
, "%c %s%-*s%s", c
, branch_get_color(color
),
432 maxwidth
+ utf8_compensation
, name
.buf
,
433 branch_get_color(BRANCH_COLOR_RESET
));
435 strbuf_addf(&out
, "%c %s%s%s", c
, branch_get_color(color
),
436 name
.buf
, branch_get_color(BRANCH_COLOR_RESET
));
439 skip_prefix(item
->symref
, "refs/remotes/", &desc
);
440 strbuf_addf(&out
, " -> %s", desc
);
442 else if (filter
->verbose
)
443 /* " f7c0c00 [ahead 58, behind 197] vcs-svn: drop obj_pool.h" */
444 add_verbose_info(&out
, item
, filter
, desc
);
445 if (column_active(colopts
)) {
446 assert(!filter
->verbose
&& "--column and --verbose are incompatible");
447 string_list_append(&output
, out
.buf
);
449 printf("%s\n", out
.buf
);
451 strbuf_release(&name
);
452 strbuf_release(&out
);
456 static int calc_maxwidth(struct ref_array
*refs
, int remote_bonus
)
459 for (i
= 0; i
< refs
->nr
; i
++) {
460 struct ref_array_item
*it
= refs
->items
[i
];
461 const char *desc
= it
->refname
;
464 skip_prefix(it
->refname
, "refs/heads/", &desc
);
465 skip_prefix(it
->refname
, "refs/remotes/", &desc
);
466 w
= utf8_strwidth(desc
);
468 if (it
->kind
== FILTER_REFS_REMOTES
)
476 static void print_ref_list(struct ref_filter
*filter
, struct ref_sorting
*sorting
)
479 struct ref_array array
;
481 const char *remote_prefix
= "";
484 * If we are listing more than just remote branches,
485 * then remote branches will have a "remotes/" prefix.
486 * We need to account for this in the width.
488 if (filter
->kind
!= FILTER_REFS_REMOTES
)
489 remote_prefix
= "remotes/";
491 memset(&array
, 0, sizeof(array
));
493 verify_ref_format("%(refname)%(symref)");
494 filter_refs(&array
, filter
, filter
->kind
| FILTER_REFS_INCLUDE_BROKEN
);
497 maxwidth
= calc_maxwidth(&array
, strlen(remote_prefix
));
500 * If no sorting parameter is given then we default to sorting
501 * by 'refname'. This would give us an alphabetically sorted
502 * array with the 'HEAD' ref at the beginning followed by
503 * local branches 'refs/heads/...' and finally remote-tacking
504 * branches 'refs/remotes/...'.
507 sorting
= ref_default_sorting();
508 ref_array_sort(sorting
, &array
);
510 for (i
= 0; i
< array
.nr
; i
++)
511 format_and_print_ref_item(array
.items
[i
], maxwidth
, filter
, remote_prefix
);
513 ref_array_clear(&array
);
516 static void rename_branch(const char *oldname
, const char *newname
, int force
)
518 struct strbuf oldref
= STRBUF_INIT
, newref
= STRBUF_INIT
, logmsg
= STRBUF_INIT
;
519 struct strbuf oldsection
= STRBUF_INIT
, newsection
= STRBUF_INIT
;
524 die(_("cannot rename the current branch while not on any."));
526 if (strbuf_check_branch_ref(&oldref
, oldname
)) {
528 * Bad name --- this could be an attempt to rename a
529 * ref that we used to allow to be created by accident.
531 if (ref_exists(oldref
.buf
))
534 die(_("Invalid branch name: '%s'"), oldname
);
538 * A command like "git branch -M currentbranch currentbranch" cannot
539 * cause the worktree to become inconsistent with HEAD, so allow it.
541 clobber_head_ok
= !strcmp(oldname
, newname
);
543 validate_new_branchname(newname
, &newref
, force
, clobber_head_ok
);
545 strbuf_addf(&logmsg
, "Branch: renamed %s to %s",
546 oldref
.buf
, newref
.buf
);
548 if (rename_ref(oldref
.buf
, newref
.buf
, logmsg
.buf
))
549 die(_("Branch rename failed"));
550 strbuf_release(&logmsg
);
553 warning(_("Renamed a misnamed branch '%s' away"), oldref
.buf
+ 11);
555 /* no need to pass logmsg here as HEAD didn't really move */
556 if (!strcmp(oldname
, head
) && create_symref("HEAD", newref
.buf
, NULL
))
557 die(_("Branch renamed to %s, but HEAD is not updated!"), newname
);
559 strbuf_addf(&oldsection
, "branch.%s", oldref
.buf
+ 11);
560 strbuf_release(&oldref
);
561 strbuf_addf(&newsection
, "branch.%s", newref
.buf
+ 11);
562 strbuf_release(&newref
);
563 if (git_config_rename_section(oldsection
.buf
, newsection
.buf
) < 0)
564 die(_("Branch is renamed, but update of config-file failed"));
565 strbuf_release(&oldsection
);
566 strbuf_release(&newsection
);
569 static const char edit_description
[] = "BRANCH_DESCRIPTION";
571 static int edit_branch_description(const char *branch_name
)
573 struct strbuf buf
= STRBUF_INIT
;
574 struct strbuf name
= STRBUF_INIT
;
576 read_branch_desc(&buf
, branch_name
);
577 if (!buf
.len
|| buf
.buf
[buf
.len
-1] != '\n')
578 strbuf_addch(&buf
, '\n');
579 strbuf_commented_addf(&buf
,
580 "Please edit the description for the branch\n"
582 "Lines starting with '%c' will be stripped.\n",
583 branch_name
, comment_line_char
);
584 if (write_file_gently(git_path(edit_description
), "%s", buf
.buf
)) {
585 strbuf_release(&buf
);
586 return error_errno(_("could not write branch description template"));
589 if (launch_editor(git_path(edit_description
), &buf
, NULL
)) {
590 strbuf_release(&buf
);
593 strbuf_stripspace(&buf
, 1);
595 strbuf_addf(&name
, "branch.%s.description", branch_name
);
596 git_config_set(name
.buf
, buf
.len
? buf
.buf
: NULL
);
597 strbuf_release(&name
);
598 strbuf_release(&buf
);
603 int cmd_branch(int argc
, const char **argv
, const char *prefix
)
605 int delete = 0, rename
= 0, force
= 0, list
= 0;
606 int reflog
= 0, edit_description
= 0;
607 int quiet
= 0, unset_upstream
= 0;
608 const char *new_upstream
= NULL
;
609 enum branch_track track
;
610 struct ref_filter filter
;
611 static struct ref_sorting
*sorting
= NULL
, **sorting_tail
= &sorting
;
613 struct option options
[] = {
614 OPT_GROUP(N_("Generic options")),
615 OPT__VERBOSE(&filter
.verbose
,
616 N_("show hash and subject, give twice for upstream branch")),
617 OPT__QUIET(&quiet
, N_("suppress informational messages")),
618 OPT_SET_INT('t', "track", &track
, N_("set up tracking mode (see git-pull(1))"),
619 BRANCH_TRACK_EXPLICIT
),
620 OPT_SET_INT( 0, "set-upstream", &track
, N_("change upstream info"),
621 BRANCH_TRACK_OVERRIDE
),
622 OPT_STRING('u', "set-upstream-to", &new_upstream
, "upstream", "change the upstream info"),
623 OPT_BOOL(0, "unset-upstream", &unset_upstream
, "Unset the upstream info"),
624 OPT__COLOR(&branch_use_color
, N_("use colored output")),
625 OPT_SET_INT('r', "remotes", &filter
.kind
, N_("act on remote-tracking branches"),
626 FILTER_REFS_REMOTES
),
627 OPT_CONTAINS(&filter
.with_commit
, N_("print only branches that contain the commit")),
628 OPT_WITH(&filter
.with_commit
, N_("print only branches that contain the commit")),
629 OPT__ABBREV(&filter
.abbrev
),
631 OPT_GROUP(N_("Specific git-branch actions:")),
632 OPT_SET_INT('a', "all", &filter
.kind
, N_("list both remote-tracking and local branches"),
633 FILTER_REFS_REMOTES
| FILTER_REFS_BRANCHES
),
634 OPT_BIT('d', "delete", &delete, N_("delete fully merged branch"), 1),
635 OPT_BIT('D', NULL
, &delete, N_("delete branch (even if not merged)"), 2),
636 OPT_BIT('m', "move", &rename
, N_("move/rename a branch and its reflog"), 1),
637 OPT_BIT('M', NULL
, &rename
, N_("move/rename a branch, even if target exists"), 2),
638 OPT_BOOL(0, "list", &list
, N_("list branch names")),
639 OPT_BOOL('l', "create-reflog", &reflog
, N_("create the branch's reflog")),
640 OPT_BOOL(0, "edit-description", &edit_description
,
641 N_("edit the description for the branch")),
642 OPT__FORCE(&force
, N_("force creation, move/rename, deletion")),
643 OPT_MERGED(&filter
, N_("print only branches that are merged")),
644 OPT_NO_MERGED(&filter
, N_("print only branches that are not merged")),
645 OPT_COLUMN(0, "column", &colopts
, N_("list branches in columns")),
646 OPT_CALLBACK(0 , "sort", sorting_tail
, N_("key"),
647 N_("field name to sort on"), &parse_opt_ref_sorting
),
649 OPTION_CALLBACK
, 0, "points-at", &filter
.points_at
, N_("object"),
650 N_("print only branches of the object"), 0, parse_opt_object_name
655 memset(&filter
, 0, sizeof(filter
));
656 filter
.kind
= FILTER_REFS_BRANCHES
;
659 if (argc
== 2 && !strcmp(argv
[1], "-h"))
660 usage_with_options(builtin_branch_usage
, options
);
662 git_config(git_branch_config
, NULL
);
664 track
= git_branch_track
;
666 head
= resolve_refdup("HEAD", 0, head_sha1
, NULL
);
668 die(_("Failed to resolve HEAD as a valid ref."));
669 if (!strcmp(head
, "HEAD"))
671 else if (!skip_prefix(head
, "refs/heads/", &head
))
672 die(_("HEAD not found below refs/heads!"));
674 argc
= parse_options(argc
, argv
, prefix
, options
, builtin_branch_usage
,
677 if (!delete && !rename
&& !edit_description
&& !new_upstream
&& !unset_upstream
&& argc
== 0)
680 if (filter
.with_commit
|| filter
.merge
!= REF_FILTER_MERGED_NONE
|| filter
.points_at
.nr
)
683 if (!!delete + !!rename
+ !!new_upstream
+
684 list
+ unset_upstream
> 1)
685 usage_with_options(builtin_branch_usage
, options
);
687 if (filter
.abbrev
== -1)
688 filter
.abbrev
= DEFAULT_ABBREV
;
689 finalize_colopts(&colopts
, -1);
690 if (filter
.verbose
) {
691 if (explicitly_enable_column(colopts
))
692 die(_("--column and --verbose are incompatible"));
703 die(_("branch name required"));
704 return delete_branches(argc
, argv
, delete > 1, filter
.kind
, quiet
);
706 /* git branch --local also shows HEAD when it is detached */
707 if ((filter
.kind
& FILTER_REFS_BRANCHES
) && filter
.detached
)
708 filter
.kind
|= FILTER_REFS_DETACHED_HEAD
;
709 filter
.name_patterns
= argv
;
710 print_ref_list(&filter
, sorting
);
711 print_columns(&output
, colopts
, NULL
);
712 string_list_clear(&output
, 0);
715 else if (edit_description
) {
716 const char *branch_name
;
717 struct strbuf branch_ref
= STRBUF_INIT
;
721 die(_("Cannot give description to detached HEAD"));
723 } else if (argc
== 1)
724 branch_name
= argv
[0];
726 die(_("cannot edit description of more than one branch"));
728 strbuf_addf(&branch_ref
, "refs/heads/%s", branch_name
);
729 if (!ref_exists(branch_ref
.buf
)) {
730 strbuf_release(&branch_ref
);
733 return error(_("No commit on branch '%s' yet."),
736 return error(_("No branch named '%s'."),
739 strbuf_release(&branch_ref
);
741 if (edit_branch_description(branch_name
))
745 die(_("branch name required"));
747 rename_branch(head
, argv
[0], rename
> 1);
749 rename_branch(argv
[0], argv
[1], rename
> 1);
751 die(_("too many branches for a rename operation"));
752 } else if (new_upstream
) {
753 struct branch
*branch
= branch_get(argv
[0]);
756 die(_("too many branches to set new upstream"));
759 if (!argc
|| !strcmp(argv
[0], "HEAD"))
760 die(_("could not set upstream of HEAD to %s when "
761 "it does not point to any branch."),
763 die(_("no such branch '%s'"), argv
[0]);
766 if (!ref_exists(branch
->refname
))
767 die(_("branch '%s' does not exist"), branch
->name
);
770 * create_branch takes care of setting up the tracking
771 * info and making sure new_upstream is correct
773 create_branch(head
, branch
->name
, new_upstream
, 0, 0, 0, quiet
, BRANCH_TRACK_OVERRIDE
);
774 } else if (unset_upstream
) {
775 struct branch
*branch
= branch_get(argv
[0]);
776 struct strbuf buf
= STRBUF_INIT
;
779 die(_("too many branches to unset upstream"));
782 if (!argc
|| !strcmp(argv
[0], "HEAD"))
783 die(_("could not unset upstream of HEAD when "
784 "it does not point to any branch."));
785 die(_("no such branch '%s'"), argv
[0]);
788 if (!branch_has_merge_config(branch
))
789 die(_("Branch '%s' has no upstream information"), branch
->name
);
791 strbuf_addf(&buf
, "branch.%s.remote", branch
->name
);
792 git_config_set_multivar(buf
.buf
, NULL
, NULL
, 1);
794 strbuf_addf(&buf
, "branch.%s.merge", branch
->name
);
795 git_config_set_multivar(buf
.buf
, NULL
, NULL
, 1);
796 strbuf_release(&buf
);
797 } else if (argc
> 0 && argc
<= 2) {
798 struct branch
*branch
= branch_get(argv
[0]);
799 int branch_existed
= 0, remote_tracking
= 0;
800 struct strbuf buf
= STRBUF_INIT
;
802 if (!strcmp(argv
[0], "HEAD"))
803 die(_("it does not make sense to create 'HEAD' manually"));
806 die(_("no such branch '%s'"), argv
[0]);
808 if (filter
.kind
!= FILTER_REFS_BRANCHES
)
809 die(_("-a and -r options to 'git branch' do not make sense with a branch name"));
811 if (track
== BRANCH_TRACK_OVERRIDE
)
812 fprintf(stderr
, _("The --set-upstream flag is deprecated and will be removed. Consider using --track or --set-upstream-to\n"));
814 strbuf_addf(&buf
, "refs/remotes/%s", branch
->name
);
815 remote_tracking
= ref_exists(buf
.buf
);
816 strbuf_release(&buf
);
818 branch_existed
= ref_exists(branch
->refname
);
819 create_branch(head
, argv
[0], (argc
== 2) ? argv
[1] : head
,
820 force
, reflog
, 0, quiet
, track
);
823 * We only show the instructions if the user gave us
824 * one branch which doesn't exist locally, but is the
825 * name of a remote-tracking branch.
827 if (argc
== 1 && track
== BRANCH_TRACK_OVERRIDE
&&
828 !branch_existed
&& remote_tracking
) {
829 fprintf(stderr
, _("\nIf you wanted to make '%s' track '%s', do this:\n\n"), head
, branch
->name
);
830 fprintf(stderr
, _(" git branch -d %s\n"), branch
->name
);
831 fprintf(stderr
, _(" git branch --set-upstream-to %s\n"), branch
->name
);
835 usage_with_options(builtin_branch_usage
, options
);