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_to_show
= "";
397 const char *prefix_to_skip
= NULL
;
398 const char *desc
= item
->refname
;
399 char *to_free
= NULL
;
401 switch (item
->kind
) {
402 case FILTER_REFS_BRANCHES
:
403 prefix_to_skip
= "refs/heads/";
404 skip_prefix(desc
, prefix_to_skip
, &desc
);
405 if (!filter
->detached
&& !strcmp(desc
, head
))
408 color
= BRANCH_COLOR_LOCAL
;
410 case FILTER_REFS_REMOTES
:
411 prefix_to_skip
= "refs/remotes/";
412 skip_prefix(desc
, prefix_to_skip
, &desc
);
413 color
= BRANCH_COLOR_REMOTE
;
414 prefix_to_show
= remote_prefix
;
416 case FILTER_REFS_DETACHED_HEAD
:
417 desc
= to_free
= get_head_description();
421 color
= BRANCH_COLOR_PLAIN
;
428 color
= BRANCH_COLOR_CURRENT
;
431 strbuf_addf(&name
, "%s%s", prefix_to_show
, desc
);
432 if (filter
->verbose
) {
433 int utf8_compensation
= strlen(name
.buf
) - utf8_strwidth(name
.buf
);
434 strbuf_addf(&out
, "%c %s%-*s%s", c
, branch_get_color(color
),
435 maxwidth
+ utf8_compensation
, name
.buf
,
436 branch_get_color(BRANCH_COLOR_RESET
));
438 strbuf_addf(&out
, "%c %s%s%s", c
, branch_get_color(color
),
439 name
.buf
, branch_get_color(BRANCH_COLOR_RESET
));
442 const char *symref
= item
->symref
;
444 skip_prefix(symref
, prefix_to_skip
, &symref
);
445 strbuf_addf(&out
, " -> %s", symref
);
447 else if (filter
->verbose
)
448 /* " f7c0c00 [ahead 58, behind 197] vcs-svn: drop obj_pool.h" */
449 add_verbose_info(&out
, item
, filter
, desc
);
450 if (column_active(colopts
)) {
451 assert(!filter
->verbose
&& "--column and --verbose are incompatible");
452 string_list_append(&output
, out
.buf
);
454 printf("%s\n", out
.buf
);
456 strbuf_release(&name
);
457 strbuf_release(&out
);
461 static int calc_maxwidth(struct ref_array
*refs
, int remote_bonus
)
464 for (i
= 0; i
< refs
->nr
; i
++) {
465 struct ref_array_item
*it
= refs
->items
[i
];
466 const char *desc
= it
->refname
;
469 skip_prefix(it
->refname
, "refs/heads/", &desc
);
470 skip_prefix(it
->refname
, "refs/remotes/", &desc
);
471 w
= utf8_strwidth(desc
);
473 if (it
->kind
== FILTER_REFS_REMOTES
)
481 static void print_ref_list(struct ref_filter
*filter
, struct ref_sorting
*sorting
)
484 struct ref_array array
;
486 const char *remote_prefix
= "";
489 * If we are listing more than just remote branches,
490 * then remote branches will have a "remotes/" prefix.
491 * We need to account for this in the width.
493 if (filter
->kind
!= FILTER_REFS_REMOTES
)
494 remote_prefix
= "remotes/";
496 memset(&array
, 0, sizeof(array
));
498 verify_ref_format("%(refname)%(symref)");
499 filter_refs(&array
, filter
, filter
->kind
| FILTER_REFS_INCLUDE_BROKEN
);
502 maxwidth
= calc_maxwidth(&array
, strlen(remote_prefix
));
505 * If no sorting parameter is given then we default to sorting
506 * by 'refname'. This would give us an alphabetically sorted
507 * array with the 'HEAD' ref at the beginning followed by
508 * local branches 'refs/heads/...' and finally remote-tacking
509 * branches 'refs/remotes/...'.
512 sorting
= ref_default_sorting();
513 ref_array_sort(sorting
, &array
);
515 for (i
= 0; i
< array
.nr
; i
++)
516 format_and_print_ref_item(array
.items
[i
], maxwidth
, filter
, remote_prefix
);
518 ref_array_clear(&array
);
521 static void rename_branch(const char *oldname
, const char *newname
, int force
)
523 struct strbuf oldref
= STRBUF_INIT
, newref
= STRBUF_INIT
, logmsg
= STRBUF_INIT
;
524 struct strbuf oldsection
= STRBUF_INIT
, newsection
= STRBUF_INIT
;
529 die(_("cannot rename the current branch while not on any."));
531 if (strbuf_check_branch_ref(&oldref
, oldname
)) {
533 * Bad name --- this could be an attempt to rename a
534 * ref that we used to allow to be created by accident.
536 if (ref_exists(oldref
.buf
))
539 die(_("Invalid branch name: '%s'"), oldname
);
543 * A command like "git branch -M currentbranch currentbranch" cannot
544 * cause the worktree to become inconsistent with HEAD, so allow it.
546 clobber_head_ok
= !strcmp(oldname
, newname
);
548 validate_new_branchname(newname
, &newref
, force
, clobber_head_ok
);
550 strbuf_addf(&logmsg
, "Branch: renamed %s to %s",
551 oldref
.buf
, newref
.buf
);
553 if (rename_ref(oldref
.buf
, newref
.buf
, logmsg
.buf
))
554 die(_("Branch rename failed"));
555 strbuf_release(&logmsg
);
558 warning(_("Renamed a misnamed branch '%s' away"), oldref
.buf
+ 11);
560 /* no need to pass logmsg here as HEAD didn't really move */
561 if (!strcmp(oldname
, head
) && create_symref("HEAD", newref
.buf
, NULL
))
562 die(_("Branch renamed to %s, but HEAD is not updated!"), newname
);
564 strbuf_addf(&oldsection
, "branch.%s", oldref
.buf
+ 11);
565 strbuf_release(&oldref
);
566 strbuf_addf(&newsection
, "branch.%s", newref
.buf
+ 11);
567 strbuf_release(&newref
);
568 if (git_config_rename_section(oldsection
.buf
, newsection
.buf
) < 0)
569 die(_("Branch is renamed, but update of config-file failed"));
570 strbuf_release(&oldsection
);
571 strbuf_release(&newsection
);
574 static const char edit_description
[] = "BRANCH_DESCRIPTION";
576 static int edit_branch_description(const char *branch_name
)
578 struct strbuf buf
= STRBUF_INIT
;
579 struct strbuf name
= STRBUF_INIT
;
581 read_branch_desc(&buf
, branch_name
);
582 if (!buf
.len
|| buf
.buf
[buf
.len
-1] != '\n')
583 strbuf_addch(&buf
, '\n');
584 strbuf_commented_addf(&buf
,
585 "Please edit the description for the branch\n"
587 "Lines starting with '%c' will be stripped.\n",
588 branch_name
, comment_line_char
);
589 if (write_file_gently(git_path(edit_description
), "%s", buf
.buf
)) {
590 strbuf_release(&buf
);
591 return error(_("could not write branch description template: %s"),
595 if (launch_editor(git_path(edit_description
), &buf
, NULL
)) {
596 strbuf_release(&buf
);
599 strbuf_stripspace(&buf
, 1);
601 strbuf_addf(&name
, "branch.%s.description", branch_name
);
602 git_config_set(name
.buf
, buf
.len
? buf
.buf
: NULL
);
603 strbuf_release(&name
);
604 strbuf_release(&buf
);
609 int cmd_branch(int argc
, const char **argv
, const char *prefix
)
611 int delete = 0, rename
= 0, force
= 0, list
= 0;
612 int reflog
= 0, edit_description
= 0;
613 int quiet
= 0, unset_upstream
= 0;
614 const char *new_upstream
= NULL
;
615 enum branch_track track
;
616 struct ref_filter filter
;
617 static struct ref_sorting
*sorting
= NULL
, **sorting_tail
= &sorting
;
619 struct option options
[] = {
620 OPT_GROUP(N_("Generic options")),
621 OPT__VERBOSE(&filter
.verbose
,
622 N_("show hash and subject, give twice for upstream branch")),
623 OPT__QUIET(&quiet
, N_("suppress informational messages")),
624 OPT_SET_INT('t', "track", &track
, N_("set up tracking mode (see git-pull(1))"),
625 BRANCH_TRACK_EXPLICIT
),
626 OPT_SET_INT( 0, "set-upstream", &track
, N_("change upstream info"),
627 BRANCH_TRACK_OVERRIDE
),
628 OPT_STRING('u', "set-upstream-to", &new_upstream
, "upstream", "change the upstream info"),
629 OPT_BOOL(0, "unset-upstream", &unset_upstream
, "Unset the upstream info"),
630 OPT__COLOR(&branch_use_color
, N_("use colored output")),
631 OPT_SET_INT('r', "remotes", &filter
.kind
, N_("act on remote-tracking branches"),
632 FILTER_REFS_REMOTES
),
633 OPT_CONTAINS(&filter
.with_commit
, N_("print only branches that contain the commit")),
634 OPT_WITH(&filter
.with_commit
, N_("print only branches that contain the commit")),
635 OPT__ABBREV(&filter
.abbrev
),
637 OPT_GROUP(N_("Specific git-branch actions:")),
638 OPT_SET_INT('a', "all", &filter
.kind
, N_("list both remote-tracking and local branches"),
639 FILTER_REFS_REMOTES
| FILTER_REFS_BRANCHES
),
640 OPT_BIT('d', "delete", &delete, N_("delete fully merged branch"), 1),
641 OPT_BIT('D', NULL
, &delete, N_("delete branch (even if not merged)"), 2),
642 OPT_BIT('m', "move", &rename
, N_("move/rename a branch and its reflog"), 1),
643 OPT_BIT('M', NULL
, &rename
, N_("move/rename a branch, even if target exists"), 2),
644 OPT_BOOL(0, "list", &list
, N_("list branch names")),
645 OPT_BOOL('l', "create-reflog", &reflog
, N_("create the branch's reflog")),
646 OPT_BOOL(0, "edit-description", &edit_description
,
647 N_("edit the description for the branch")),
648 OPT__FORCE(&force
, N_("force creation, move/rename, deletion")),
649 OPT_MERGED(&filter
, N_("print only branches that are merged")),
650 OPT_NO_MERGED(&filter
, N_("print only branches that are not merged")),
651 OPT_COLUMN(0, "column", &colopts
, N_("list branches in columns")),
652 OPT_CALLBACK(0 , "sort", sorting_tail
, N_("key"),
653 N_("field name to sort on"), &parse_opt_ref_sorting
),
655 OPTION_CALLBACK
, 0, "points-at", &filter
.points_at
, N_("object"),
656 N_("print only branches of the object"), 0, parse_opt_object_name
661 memset(&filter
, 0, sizeof(filter
));
662 filter
.kind
= FILTER_REFS_BRANCHES
;
665 if (argc
== 2 && !strcmp(argv
[1], "-h"))
666 usage_with_options(builtin_branch_usage
, options
);
668 git_config(git_branch_config
, NULL
);
670 track
= git_branch_track
;
672 head
= resolve_refdup("HEAD", 0, head_sha1
, NULL
);
674 die(_("Failed to resolve HEAD as a valid ref."));
675 if (!strcmp(head
, "HEAD"))
677 else if (!skip_prefix(head
, "refs/heads/", &head
))
678 die(_("HEAD not found below refs/heads!"));
680 argc
= parse_options(argc
, argv
, prefix
, options
, builtin_branch_usage
,
683 if (!delete && !rename
&& !edit_description
&& !new_upstream
&& !unset_upstream
&& argc
== 0)
686 if (filter
.with_commit
|| filter
.merge
!= REF_FILTER_MERGED_NONE
|| filter
.points_at
.nr
)
689 if (!!delete + !!rename
+ !!new_upstream
+
690 list
+ unset_upstream
> 1)
691 usage_with_options(builtin_branch_usage
, options
);
693 if (filter
.abbrev
== -1)
694 filter
.abbrev
= DEFAULT_ABBREV
;
695 finalize_colopts(&colopts
, -1);
696 if (filter
.verbose
) {
697 if (explicitly_enable_column(colopts
))
698 die(_("--column and --verbose are incompatible"));
709 die(_("branch name required"));
710 return delete_branches(argc
, argv
, delete > 1, filter
.kind
, quiet
);
712 /* git branch --local also shows HEAD when it is detached */
713 if ((filter
.kind
& FILTER_REFS_BRANCHES
) && filter
.detached
)
714 filter
.kind
|= FILTER_REFS_DETACHED_HEAD
;
715 filter
.name_patterns
= argv
;
716 print_ref_list(&filter
, sorting
);
717 print_columns(&output
, colopts
, NULL
);
718 string_list_clear(&output
, 0);
721 else if (edit_description
) {
722 const char *branch_name
;
723 struct strbuf branch_ref
= STRBUF_INIT
;
727 die(_("Cannot give description to detached HEAD"));
729 } else if (argc
== 1)
730 branch_name
= argv
[0];
732 die(_("cannot edit description of more than one branch"));
734 strbuf_addf(&branch_ref
, "refs/heads/%s", branch_name
);
735 if (!ref_exists(branch_ref
.buf
)) {
736 strbuf_release(&branch_ref
);
739 return error(_("No commit on branch '%s' yet."),
742 return error(_("No branch named '%s'."),
745 strbuf_release(&branch_ref
);
747 if (edit_branch_description(branch_name
))
751 die(_("branch name required"));
753 rename_branch(head
, argv
[0], rename
> 1);
755 rename_branch(argv
[0], argv
[1], rename
> 1);
757 die(_("too many branches for a rename operation"));
758 } else if (new_upstream
) {
759 struct branch
*branch
= branch_get(argv
[0]);
762 die(_("too many branches to set new upstream"));
765 if (!argc
|| !strcmp(argv
[0], "HEAD"))
766 die(_("could not set upstream of HEAD to %s when "
767 "it does not point to any branch."),
769 die(_("no such branch '%s'"), argv
[0]);
772 if (!ref_exists(branch
->refname
))
773 die(_("branch '%s' does not exist"), branch
->name
);
776 * create_branch takes care of setting up the tracking
777 * info and making sure new_upstream is correct
779 create_branch(head
, branch
->name
, new_upstream
, 0, 0, 0, quiet
, BRANCH_TRACK_OVERRIDE
);
780 } else if (unset_upstream
) {
781 struct branch
*branch
= branch_get(argv
[0]);
782 struct strbuf buf
= STRBUF_INIT
;
785 die(_("too many branches to unset upstream"));
788 if (!argc
|| !strcmp(argv
[0], "HEAD"))
789 die(_("could not unset upstream of HEAD when "
790 "it does not point to any branch."));
791 die(_("no such branch '%s'"), argv
[0]);
794 if (!branch_has_merge_config(branch
))
795 die(_("Branch '%s' has no upstream information"), branch
->name
);
797 strbuf_addf(&buf
, "branch.%s.remote", branch
->name
);
798 git_config_set_multivar(buf
.buf
, NULL
, NULL
, 1);
800 strbuf_addf(&buf
, "branch.%s.merge", branch
->name
);
801 git_config_set_multivar(buf
.buf
, NULL
, NULL
, 1);
802 strbuf_release(&buf
);
803 } else if (argc
> 0 && argc
<= 2) {
804 struct branch
*branch
= branch_get(argv
[0]);
805 int branch_existed
= 0, remote_tracking
= 0;
806 struct strbuf buf
= STRBUF_INIT
;
808 if (!strcmp(argv
[0], "HEAD"))
809 die(_("it does not make sense to create 'HEAD' manually"));
812 die(_("no such branch '%s'"), argv
[0]);
814 if (filter
.kind
!= FILTER_REFS_BRANCHES
)
815 die(_("-a and -r options to 'git branch' do not make sense with a branch name"));
817 if (track
== BRANCH_TRACK_OVERRIDE
)
818 fprintf(stderr
, _("The --set-upstream flag is deprecated and will be removed. Consider using --track or --set-upstream-to\n"));
820 strbuf_addf(&buf
, "refs/remotes/%s", branch
->name
);
821 remote_tracking
= ref_exists(buf
.buf
);
822 strbuf_release(&buf
);
824 branch_existed
= ref_exists(branch
->refname
);
825 create_branch(head
, argv
[0], (argc
== 2) ? argv
[1] : head
,
826 force
, reflog
, 0, quiet
, track
);
829 * We only show the instructions if the user gave us
830 * one branch which doesn't exist locally, but is the
831 * name of a remote-tracking branch.
833 if (argc
== 1 && track
== BRANCH_TRACK_OVERRIDE
&&
834 !branch_existed
&& remote_tracking
) {
835 fprintf(stderr
, _("\nIf you wanted to make '%s' track '%s', do this:\n\n"), head
, branch
->name
);
836 fprintf(stderr
, _(" git branch -d %s\n"), branch
->name
);
837 fprintf(stderr
, _(" git branch --set-upstream-to %s\n"), branch
->name
);
841 usage_with_options(builtin_branch_usage
, options
);