blob: 658c9f87414b61acf2072d75684f952f8565ff10 [file] [log] [blame]
Lars Hjemlic31820c2006-10-23 23:27:45 +02001/*
2 * Builtin "git branch"
3 *
Junio C Hamanod972cce2007-07-11 22:52:45 -07004 * Copyright (c) 2006 Kristian Høgsberg <krh@redhat.com>
Lars Hjemlic31820c2006-10-23 23:27:45 +02005 * Based on git-branch.sh by Junio C Hamano.
6 */
7
8#include "cache.h"
Brandon Williamsb2141fc2017-06-14 11:07:36 -07009#include "config.h"
Junio C Hamano85023572006-12-19 14:34:12 -080010#include "color.h"
Lars Hjemlic31820c2006-10-23 23:27:45 +020011#include "refs.h"
12#include "commit.h"
13#include "builtin.h"
Johannes Schindelin6f084a52007-07-10 18:50:44 +010014#include "remote.h"
Pierre Habouzita8dfd5e2007-10-07 18:26:21 +020015#include "parse-options.h"
Daniel Barkalowe496c002008-02-07 11:40:08 -050016#include "branch.h"
Junio C Hamano68067ca2008-07-23 15:13:41 -070017#include "diff.h"
18#include "revision.h"
Nguyễn Thái Ngọc Duyebe31ef2012-04-13 17:54:38 +070019#include "string-list.h"
20#include "column.h"
Nguyễn Thái Ngọc Duy1452bd62012-08-26 01:17:12 +070021#include "utf8.h"
Nguyễn Thái Ngọc Duyc8183cd2013-03-13 18:42:53 +070022#include "wt-status.h"
Karthik Nayak1511b222015-09-23 23:41:11 +053023#include "ref-filter.h"
Kazuki Yamaguchif2922442016-03-29 18:38:39 +090024#include "worktree.h"
Nguyễn Thái Ngọc Duy3ac68a92018-05-26 15:55:24 +020025#include "help.h"
Derrick Stolee64043552018-07-20 16:33:04 +000026#include "commit-reach.h"
Lars Hjemlic31820c2006-10-23 23:27:45 +020027
Pierre Habouzita8dfd5e2007-10-07 18:26:21 +020028static const char * const builtin_branch_usage[] = {
Aaron Lipman21bf9332020-09-15 22:08:40 -040029 N_("git branch [<options>] [-r | -a] [--merged] [--no-merged]"),
Glen Choo961b1302022-01-28 16:04:45 -080030 N_("git branch [<options>] [-f] [--recurse-submodules] <branch-name> [<start-point>]"),
31 N_("git branch [<options>] [-l] [<pattern>...]"),
Alex Henrie9c9b4f22015-01-13 00:44:47 -070032 N_("git branch [<options>] [-r] (-d | -D) <branch-name>..."),
33 N_("git branch [<options>] (-m | -M) [<old-branch>] <new-branch>"),
Sahil Dua52d59cc2017-06-18 23:19:16 +020034 N_("git branch [<options>] (-c | -C) [<old-branch>] <new-branch>"),
Karthik Nayakaa3bc552015-09-23 23:41:13 +053035 N_("git branch [<options>] [-r | -a] [--points-at]"),
Karthik Nayak3d9e4ce2017-01-10 14:19:53 +053036 N_("git branch [<options>] [-r | -a] [--format]"),
Pierre Habouzita8dfd5e2007-10-07 18:26:21 +020037 NULL
38};
Lars Hjemlic31820c2006-10-23 23:27:45 +020039
Lars Hjemlic31820c2006-10-23 23:27:45 +020040static const char *head;
brian m. carlson0c77cd22017-02-21 23:47:26 +000041static struct object_id head_oid;
Glen Choo961b1302022-01-28 16:04:45 -080042static int recurse_submodules = 0;
43static int submodule_propagate_branches = 0;
Lars Hjemlic31820c2006-10-23 23:27:45 +020044
Matthias Kestenholz6b2f2d92008-02-18 08:26:03 +010045static int branch_use_color = -1;
Andy Parkinsa1158ca2006-12-12 06:41:52 +000046static char branch_colors[][COLOR_MAXLEN] = {
Arjen Laarhovendc6ebd42009-02-13 22:53:40 +010047 GIT_COLOR_RESET,
Karthik Nayak949af062017-01-10 14:19:52 +053048 GIT_COLOR_NORMAL, /* PLAIN */
49 GIT_COLOR_RED, /* REMOTE */
50 GIT_COLOR_NORMAL, /* LOCAL */
51 GIT_COLOR_GREEN, /* CURRENT */
52 GIT_COLOR_BLUE, /* UPSTREAM */
Nickolai Belakovskiab313812019-04-28 22:19:43 -070053 GIT_COLOR_CYAN, /* WORKTREE */
Andy Parkinsa1158ca2006-12-12 06:41:52 +000054};
55enum color_branch {
Arjen Laarhoven74bb2df2009-02-13 22:53:41 +010056 BRANCH_COLOR_RESET = 0,
57 BRANCH_COLOR_PLAIN = 1,
58 BRANCH_COLOR_REMOTE = 2,
59 BRANCH_COLOR_LOCAL = 3,
Felipe Contrerasdbda21f2013-04-14 21:37:49 -050060 BRANCH_COLOR_CURRENT = 4,
Nickolai Belakovskiab313812019-04-28 22:19:43 -070061 BRANCH_COLOR_UPSTREAM = 5,
62 BRANCH_COLOR_WORKTREE = 6
Andy Parkinsa1158ca2006-12-12 06:41:52 +000063};
64
Nguyễn Thái Ngọc Duya73b3682018-05-26 15:55:21 +020065static const char *color_branch_slots[] = {
66 [BRANCH_COLOR_RESET] = "reset",
67 [BRANCH_COLOR_PLAIN] = "plain",
68 [BRANCH_COLOR_REMOTE] = "remote",
69 [BRANCH_COLOR_LOCAL] = "local",
70 [BRANCH_COLOR_CURRENT] = "current",
71 [BRANCH_COLOR_UPSTREAM] = "upstream",
Nickolai Belakovskiab313812019-04-28 22:19:43 -070072 [BRANCH_COLOR_WORKTREE] = "worktree",
Nguyễn Thái Ngọc Duya73b3682018-05-26 15:55:21 +020073};
74
Nguyễn Thái Ngọc Duyebe31ef2012-04-13 17:54:38 +070075static struct string_list output = STRING_LIST_INIT_DUP;
76static unsigned int colopts;
77
Nguyễn Thái Ngọc Duy3ac68a92018-05-26 15:55:24 +020078define_list_config_array(color_branch_slots);
Andy Parkinsa1158ca2006-12-12 06:41:52 +000079
Johannes Schindelinef90d6d2008-05-14 18:46:53 +010080static int git_branch_config(const char *var, const char *value, void *cb)
Andy Parkinsa1158ca2006-12-12 06:41:52 +000081{
René Scharfee3f1da92014-10-04 20:54:50 +020082 const char *slot_name;
Samuel Maftoul560ae1c2018-08-16 11:35:08 +020083
84 if (!strcmp(var, "branch.sort")) {
85 if (!value)
86 return config_error_nonbool(var);
Junio C Hamano98e7ab62021-10-20 12:23:53 -070087 string_list_append(cb, value);
Samuel Maftoul560ae1c2018-08-16 11:35:08 +020088 return 0;
89 }
René Scharfee3f1da92014-10-04 20:54:50 +020090
Christian Couder59556542013-11-30 21:55:40 +010091 if (starts_with(var, "column."))
Nguyễn Thái Ngọc Duyebe31ef2012-04-13 17:54:38 +070092 return git_column_config(var, value, "branch", &colopts);
Andy Parkinsa1158ca2006-12-12 06:41:52 +000093 if (!strcmp(var, "color.branch")) {
Jeff Kinge269eb72011-08-17 22:03:48 -070094 branch_use_color = git_config_colorbool(var, value);
Andy Parkinsa1158ca2006-12-12 06:41:52 +000095 return 0;
96 }
René Scharfee3f1da92014-10-04 20:54:50 +020097 if (skip_prefix(var, "color.branch.", &slot_name)) {
Nguyễn Thái Ngọc Duya73b3682018-05-26 15:55:21 +020098 int slot = LOOKUP_CONFIG(color_branch_slots, slot_name);
Jeff King8b8e8622009-12-12 07:25:24 -050099 if (slot < 0)
100 return 0;
Junio C Hamano5768c982008-02-11 10:45:50 -0800101 if (!value)
102 return config_error_nonbool(var);
Jeff Kingf6c5a292014-10-07 15:33:09 -0400103 return color_parse(value, branch_colors[slot]);
Andy Parkinsa1158ca2006-12-12 06:41:52 +0000104 }
Glen Choo961b1302022-01-28 16:04:45 -0800105 if (!strcmp(var, "submodule.recurse")) {
106 recurse_submodules = git_config_bool(var, value);
107 return 0;
108 }
109 if (!strcasecmp(var, "submodule.propagateBranches")) {
110 submodule_propagate_branches = git_config_bool(var, value);
111 return 0;
112 }
113
Jeff King33c643b2017-10-13 13:24:31 -0400114 return git_color_default_config(var, value, cb);
Andy Parkinsa1158ca2006-12-12 06:41:52 +0000115}
116
Pierre Habouzit52fae7d2007-06-07 22:45:00 +0200117static const char *branch_get_color(enum color_branch ix)
Andy Parkinsa1158ca2006-12-12 06:41:52 +0000118{
Jeff Kingdaa0c3d2011-08-17 22:04:23 -0700119 if (want_color(branch_use_color))
Andy Parkinsa1158ca2006-12-12 06:41:52 +0000120 return branch_colors[ix];
121 return "";
122}
123
Junio C Hamano99c419c2009-12-29 22:43:04 -0800124static int branch_merged(int kind, const char *name,
125 struct commit *rev, struct commit *head_rev)
126{
127 /*
128 * This checks whether the merge bases of branch and HEAD (or
129 * the other branch this branch builds upon) contains the
130 * branch, which means that the branch has already been merged
131 * safely to HEAD (or the other branch).
132 */
133 struct commit *reference_rev = NULL;
134 const char *reference_name = NULL;
Nguyễn Thái Ngọc Duy96ec7b12011-12-13 21:17:48 +0700135 void *reference_name_to_free = NULL;
Junio C Hamano99c419c2009-12-29 22:43:04 -0800136 int merged;
137
Karthik Nayak1511b222015-09-23 23:41:11 +0530138 if (kind == FILTER_REFS_BRANCHES) {
Junio C Hamano99c419c2009-12-29 22:43:04 -0800139 struct branch *branch = branch_get(name);
Jeff King3a429d02015-05-21 00:45:32 -0400140 const char *upstream = branch_get_upstream(branch, NULL);
brian m. carlson0c77cd22017-02-21 23:47:26 +0000141 struct object_id oid;
Junio C Hamano99c419c2009-12-29 22:43:04 -0800142
Jeff Kinga9f9f8c2015-05-21 00:45:28 -0400143 if (upstream &&
Nguyễn Thái Ngọc Duy96ec7b12011-12-13 21:17:48 +0700144 (reference_name = reference_name_to_free =
Jeff Kinga9f9f8c2015-05-21 00:45:28 -0400145 resolve_refdup(upstream, RESOLVE_REF_READING,
brian m. carlson0f2dc722017-10-15 22:06:55 +0000146 &oid, NULL)) != NULL)
Stefan Beller2122f672018-06-28 18:21:58 -0700147 reference_rev = lookup_commit_reference(the_repository,
148 &oid);
Junio C Hamano99c419c2009-12-29 22:43:04 -0800149 }
150 if (!reference_rev)
151 reference_rev = head_rev;
152
Junio C Hamanoa20efee2012-08-27 14:46:01 -0700153 merged = in_merge_bases(rev, reference_rev);
Junio C Hamano99c419c2009-12-29 22:43:04 -0800154
155 /*
156 * After the safety valve is fully redefined to "check with
157 * upstream, if any, otherwise with HEAD", we should just
158 * return the result of the in_merge_bases() above without
159 * any of the following code, but during the transition period,
160 * a gentle reminder is in order.
161 */
162 if ((head_rev != reference_rev) &&
Junio C Hamanoa20efee2012-08-27 14:46:01 -0700163 in_merge_bases(rev, head_rev) != merged) {
Junio C Hamano99c419c2009-12-29 22:43:04 -0800164 if (merged)
Ævar Arnfjörð Bjarmason49df4b02011-02-22 23:41:34 +0000165 warning(_("deleting branch '%s' that has been merged to\n"
Junio C Hamano6c80cd22011-04-01 17:55:55 -0700166 " '%s', but not yet merged to HEAD."),
Junio C Hamano99c419c2009-12-29 22:43:04 -0800167 name, reference_name);
168 else
Ævar Arnfjörð Bjarmason49df4b02011-02-22 23:41:34 +0000169 warning(_("not deleting branch '%s' that is not yet merged to\n"
170 " '%s', even though it is merged to HEAD."),
Junio C Hamano99c419c2009-12-29 22:43:04 -0800171 name, reference_name);
172 }
Nguyễn Thái Ngọc Duy96ec7b12011-12-13 21:17:48 +0700173 free(reference_name_to_free);
Junio C Hamano99c419c2009-12-29 22:43:04 -0800174 return merged;
175}
176
René Scharfef5d0e162012-10-18 14:02:51 +0200177static int check_branch_commit(const char *branchname, const char *refname,
brian m. carlson0c77cd22017-02-21 23:47:26 +0000178 const struct object_id *oid, struct commit *head_rev,
René Scharfef5d0e162012-10-18 14:02:51 +0200179 int kinds, int force)
180{
Stefan Beller2122f672018-06-28 18:21:58 -0700181 struct commit *rev = lookup_commit_reference(the_repository, oid);
René Scharfe597a9772021-08-27 20:35:35 +0200182 if (!force && !rev) {
René Scharfef5d0e162012-10-18 14:02:51 +0200183 error(_("Couldn't look up commit object for '%s'"), refname);
184 return -1;
185 }
186 if (!force && !branch_merged(kinds, branchname, rev, head_rev)) {
187 error(_("The branch '%s' is not fully merged.\n"
188 "If you are sure you want to delete it, "
189 "run 'git branch -D %s'."), branchname, branchname);
190 return -1;
191 }
192 return 0;
193}
194
René Scharfe22ed7922012-10-18 14:04:08 +0200195static void delete_branch_config(const char *branchname)
196{
197 struct strbuf buf = STRBUF_INIT;
198 strbuf_addf(&buf, "branch.%s", branchname);
199 if (git_config_rename_section(buf.buf, NULL) < 0)
200 warning(_("Update of config-file failed"));
201 strbuf_release(&buf);
202}
203
Jeff Kingd65ddf12012-03-26 19:51:06 -0400204static int delete_branches(int argc, const char **argv, int force, int kinds,
205 int quiet)
Lars Hjemlic31820c2006-10-23 23:27:45 +0200206{
René Scharfef5d0e162012-10-18 14:02:51 +0200207 struct commit *head_rev = NULL;
brian m. carlson0c77cd22017-02-21 23:47:26 +0000208 struct object_id oid;
Quy Tonthatb8e9a002006-12-19 09:42:16 +1100209 char *name = NULL;
Ævar Arnfjörð Bjarmasonc1798372012-04-30 15:33:12 +0000210 const char *fmt;
Lars Hjemlic31820c2006-10-23 23:27:45 +0200211 int i;
Quy Tonthatb8e9a002006-12-19 09:42:16 +1100212 int ret = 0;
Ævar Arnfjörð Bjarmasonc1798372012-04-30 15:33:12 +0000213 int remote_branch = 0;
Junio C Hamano8415d5c2009-02-13 23:08:05 -0800214 struct strbuf bname = STRBUF_INIT;
Jeff King6b145e02017-03-02 03:23:10 -0500215 unsigned allowed_interpret;
Phil Hord81989072021-01-20 19:23:32 -0800216 struct string_list refs_to_delete = STRING_LIST_INIT_DUP;
217 struct string_list_item *item;
218 int branch_name_pos;
Lars Hjemlic31820c2006-10-23 23:27:45 +0200219
Junio C Hamanof3d985c2006-12-17 23:58:16 -0800220 switch (kinds) {
Karthik Nayak1511b222015-09-23 23:41:11 +0530221 case FILTER_REFS_REMOTES:
Junio C Hamanof3d985c2006-12-17 23:58:16 -0800222 fmt = "refs/remotes/%s";
Ævar Arnfjörð Bjarmasonc1798372012-04-30 15:33:12 +0000223 /* For subsequent UI messages */
224 remote_branch = 1;
Jeff King6b145e02017-03-02 03:23:10 -0500225 allowed_interpret = INTERPRET_BRANCH_REMOTE;
Ævar Arnfjörð Bjarmasonc1798372012-04-30 15:33:12 +0000226
Junio C Hamanof3d985c2006-12-17 23:58:16 -0800227 force = 1;
228 break;
Karthik Nayak1511b222015-09-23 23:41:11 +0530229 case FILTER_REFS_BRANCHES:
Junio C Hamanof3d985c2006-12-17 23:58:16 -0800230 fmt = "refs/heads/%s";
Jeff King6b145e02017-03-02 03:23:10 -0500231 allowed_interpret = INTERPRET_BRANCH_LOCAL;
Junio C Hamanof3d985c2006-12-17 23:58:16 -0800232 break;
233 default:
Ævar Arnfjörð Bjarmason49df4b02011-02-22 23:41:34 +0000234 die(_("cannot use -a with -d"));
Junio C Hamanof3d985c2006-12-17 23:58:16 -0800235 }
Phil Hord81989072021-01-20 19:23:32 -0800236 branch_name_pos = strcspn(fmt, "%");
Lars Hjemlic31820c2006-10-23 23:27:45 +0200237
Junio C Hamano67affd52006-11-24 23:10:23 -0800238 if (!force) {
Stefan Beller2122f672018-06-28 18:21:58 -0700239 head_rev = lookup_commit_reference(the_repository, &head_oid);
Junio C Hamano67affd52006-11-24 23:10:23 -0800240 if (!head_rev)
Ævar Arnfjörð Bjarmason49df4b02011-02-22 23:41:34 +0000241 die(_("Couldn't look up commit object for HEAD"));
Junio C Hamano67affd52006-11-24 23:10:23 -0800242 }
Anders Kaseorgc8dd4912021-12-01 14:15:43 -0800243
Stefan Bellera9155c52017-10-03 15:17:40 -0700244 for (i = 0; i < argc; i++, strbuf_reset(&bname)) {
Michael Haggerty8bb04552016-04-25 10:42:19 +0200245 char *target = NULL;
René Scharfe0fe700e2012-10-18 14:07:11 +0200246 int flags = 0;
247
Jeff King6b145e02017-03-02 03:23:10 -0500248 strbuf_branchname(&bname, argv[i], allowed_interpret);
Kazuki Yamaguchif2922442016-03-29 18:38:39 +0900249 free(name);
250 name = mkpathdup(fmt, bname.buf);
251
252 if (kinds == FILTER_REFS_BRANCHES) {
Derrick Stoleeb489b9d2022-06-14 19:27:32 +0000253 const char *path;
254 if ((path = branch_checked_out(name))) {
Kazuki Yamaguchif2922442016-03-29 18:38:39 +0900255 error(_("Cannot delete branch '%s' "
256 "checked out at '%s'"),
Derrick Stoleeb489b9d2022-06-14 19:27:32 +0000257 bname.buf, path);
Kazuki Yamaguchif2922442016-03-29 18:38:39 +0900258 ret = 1;
259 continue;
260 }
Quy Tonthatb8e9a002006-12-19 09:42:16 +1100261 }
Lars Hjemlic31820c2006-10-23 23:27:45 +0200262
Michael Haggerty8bb04552016-04-25 10:42:19 +0200263 target = resolve_refdup(name,
264 RESOLVE_REF_READING
265 | RESOLVE_REF_NO_RECURSE
266 | RESOLVE_REF_ALLOW_BAD_NAME,
brian m. carlson0f2dc722017-10-15 22:06:55 +0000267 &oid, &flags);
Ronnie Sahlberg18f29fc2014-09-11 10:34:36 -0700268 if (!target) {
Ævar Arnfjörð Bjarmasonc1798372012-04-30 15:33:12 +0000269 error(remote_branch
Danny Linccd593c2015-05-07 03:01:55 +0800270 ? _("remote-tracking branch '%s' not found.")
Ævar Arnfjörð Bjarmasonc1798372012-04-30 15:33:12 +0000271 : _("branch '%s' not found."), bname.buf);
Quy Tonthatb8e9a002006-12-19 09:42:16 +1100272 ret = 1;
273 continue;
274 }
Lars Hjemlic31820c2006-10-23 23:27:45 +0200275
Ronnie Sahlbergd0f810f2014-09-03 11:45:43 -0700276 if (!(flags & (REF_ISSYMREF|REF_ISBROKEN)) &&
brian m. carlson0c77cd22017-02-21 23:47:26 +0000277 check_branch_commit(bname.buf, name, &oid, head_rev, kinds,
René Scharfef5d0e162012-10-18 14:02:51 +0200278 force)) {
Quy Tonthatb8e9a002006-12-19 09:42:16 +1100279 ret = 1;
Michael Haggerty8bb04552016-04-25 10:42:19 +0200280 goto next;
Lars Hjemlic31820c2006-10-23 23:27:45 +0200281 }
282
Phil Hord81989072021-01-20 19:23:32 -0800283 item = string_list_append(&refs_to_delete, name);
284 item->util = xstrdup((flags & REF_ISBROKEN) ? "broken"
285 : (flags & REF_ISSYMREF) ? target
286 : find_unique_abbrev(&oid, DEFAULT_ABBREV));
Michael Haggerty8bb04552016-04-25 10:42:19 +0200287
288 next:
289 free(target);
Lars Hjemlic31820c2006-10-23 23:27:45 +0200290 }
Lars Hjemlic31820c2006-10-23 23:27:45 +0200291
Phil Hord81989072021-01-20 19:23:32 -0800292 if (delete_refs(NULL, &refs_to_delete, REF_NO_DEREF))
293 ret = 1;
294
295 for_each_string_list_item(item, &refs_to_delete) {
296 char *describe_ref = item->util;
297 char *name = item->string;
298 if (!ref_exists(name)) {
299 char *refname = name + branch_name_pos;
300 if (!quiet)
301 printf(remote_branch
302 ? _("Deleted remote-tracking branch %s (was %s).\n")
303 : _("Deleted branch %s (was %s).\n"),
304 name + branch_name_pos, describe_ref);
305
306 delete_branch_config(refname);
307 }
308 free(describe_ref);
309 }
310 string_list_clear(&refs_to_delete, 0);
311
Jim Meyering8e0f7002008-01-31 18:26:32 +0100312 free(name);
Stefan Bellera9155c52017-10-03 15:17:40 -0700313 strbuf_release(&bname);
Quy Tonthatb8e9a002006-12-19 09:42:16 +1100314
Stefan Bellera9155c52017-10-03 15:17:40 -0700315 return ret;
Lars Hjemlic31820c2006-10-23 23:27:45 +0200316}
Lars Hjemlic31820c2006-10-23 23:27:45 +0200317
Karthik Nayak1511b222015-09-23 23:41:11 +0530318static int calc_maxwidth(struct ref_array *refs, int remote_bonus)
Lars Hjemlib6f637d2008-07-26 12:27:25 +0200319{
Karthik Nayak1051e402015-09-23 23:41:06 +0530320 int i, max = 0;
Karthik Nayak1511b222015-09-23 23:41:11 +0530321 for (i = 0; i < refs->nr; i++) {
322 struct ref_array_item *it = refs->items[i];
Karthik Nayakaedcb7d2015-09-23 23:41:12 +0530323 const char *desc = it->refname;
Karthik Nayak1051e402015-09-23 23:41:06 +0530324 int w;
325
Karthik Nayakaedcb7d2015-09-23 23:41:12 +0530326 skip_prefix(it->refname, "refs/heads/", &desc);
327 skip_prefix(it->refname, "refs/remotes/", &desc);
Karthik Nayak949af062017-01-10 14:19:52 +0530328 if (it->kind == FILTER_REFS_DETACHED_HEAD) {
329 char *head_desc = get_head_description();
330 w = utf8_strwidth(head_desc);
331 free(head_desc);
332 } else
333 w = utf8_strwidth(desc);
Karthik Nayakaedcb7d2015-09-23 23:41:12 +0530334
Karthik Nayak1511b222015-09-23 23:41:11 +0530335 if (it->kind == FILTER_REFS_REMOTES)
Karthik Nayak1051e402015-09-23 23:41:06 +0530336 w += remote_bonus;
337 if (w > max)
338 max = w;
Lars Hjemlib6f637d2008-07-26 12:27:25 +0200339 }
Karthik Nayak1051e402015-09-23 23:41:06 +0530340 return max;
Lars Hjemlib6f637d2008-07-26 12:27:25 +0200341}
342
Karthik Nayak949af062017-01-10 14:19:52 +0530343static const char *quote_literal_for_format(const char *s)
344{
345 static struct strbuf buf = STRBUF_INIT;
346
347 strbuf_reset(&buf);
348 while (*s) {
349 const char *ep = strchrnul(s, '%');
350 if (s < ep)
351 strbuf_add(&buf, s, ep - s);
352 if (*ep == '%') {
353 strbuf_addstr(&buf, "%%");
354 s = ep + 1;
355 } else {
356 s = ep;
357 }
358 }
359 return buf.buf;
360}
361
362static char *build_format(struct ref_filter *filter, int maxwidth, const char *remote_prefix)
363{
364 struct strbuf fmt = STRBUF_INIT;
365 struct strbuf local = STRBUF_INIT;
366 struct strbuf remote = STRBUF_INIT;
367
Nickolai Belakovskiab313812019-04-28 22:19:43 -0700368 strbuf_addf(&local, "%%(if)%%(HEAD)%%(then)* %s%%(else)%%(if)%%(worktreepath)%%(then)+ %s%%(else) %s%%(end)%%(end)",
369 branch_get_color(BRANCH_COLOR_CURRENT),
370 branch_get_color(BRANCH_COLOR_WORKTREE),
371 branch_get_color(BRANCH_COLOR_LOCAL));
Jeff King7ca260a2017-07-09 06:00:45 -0400372 strbuf_addf(&remote, " %s",
373 branch_get_color(BRANCH_COLOR_REMOTE));
Karthik Nayak949af062017-01-10 14:19:52 +0530374
375 if (filter->verbose) {
Junio C Hamanoac5bbc02017-03-08 14:13:09 -0800376 struct strbuf obname = STRBUF_INIT;
377
378 if (filter->abbrev < 0)
379 strbuf_addf(&obname, "%%(objectname:short)");
380 else if (!filter->abbrev)
381 strbuf_addf(&obname, "%%(objectname)");
382 else
383 strbuf_addf(&obname, "%%(objectname:short=%d)", filter->abbrev);
384
Karthik Nayak949af062017-01-10 14:19:52 +0530385 strbuf_addf(&local, "%%(align:%d,left)%%(refname:lstrip=2)%%(end)", maxwidth);
René Scharfe72d4a9a2017-10-01 16:44:20 +0200386 strbuf_addstr(&local, branch_get_color(BRANCH_COLOR_RESET));
Junio C Hamanoac5bbc02017-03-08 14:13:09 -0800387 strbuf_addf(&local, " %s ", obname.buf);
Karthik Nayak949af062017-01-10 14:19:52 +0530388
389 if (filter->verbose > 1)
Nickolai Belakovski6e938142019-04-28 22:19:44 -0700390 {
391 strbuf_addf(&local, "%%(if:notequals=*)%%(HEAD)%%(then)%%(if)%%(worktreepath)%%(then)(%s%%(worktreepath)%s) %%(end)%%(end)",
392 branch_get_color(BRANCH_COLOR_WORKTREE), branch_get_color(BRANCH_COLOR_RESET));
Karthik Nayak949af062017-01-10 14:19:52 +0530393 strbuf_addf(&local, "%%(if)%%(upstream)%%(then)[%s%%(upstream:short)%s%%(if)%%(upstream:track)"
394 "%%(then): %%(upstream:track,nobracket)%%(end)] %%(end)%%(contents:subject)",
395 branch_get_color(BRANCH_COLOR_UPSTREAM), branch_get_color(BRANCH_COLOR_RESET));
Nickolai Belakovski6e938142019-04-28 22:19:44 -0700396 }
Karthik Nayak949af062017-01-10 14:19:52 +0530397 else
398 strbuf_addf(&local, "%%(if)%%(upstream:track)%%(then)%%(upstream:track) %%(end)%%(contents:subject)");
399
Jeff King7ca260a2017-07-09 06:00:45 -0400400 strbuf_addf(&remote, "%%(align:%d,left)%s%%(refname:lstrip=2)%%(end)%s"
Junio C Hamanoac5bbc02017-03-08 14:13:09 -0800401 "%%(if)%%(symref)%%(then) -> %%(symref:short)"
402 "%%(else) %s %%(contents:subject)%%(end)",
Jeff King7ca260a2017-07-09 06:00:45 -0400403 maxwidth, quote_literal_for_format(remote_prefix),
Junio C Hamanoac5bbc02017-03-08 14:13:09 -0800404 branch_get_color(BRANCH_COLOR_RESET), obname.buf);
405 strbuf_release(&obname);
Karthik Nayak949af062017-01-10 14:19:52 +0530406 } else {
407 strbuf_addf(&local, "%%(refname:lstrip=2)%s%%(if)%%(symref)%%(then) -> %%(symref:short)%%(end)",
408 branch_get_color(BRANCH_COLOR_RESET));
Jeff King7ca260a2017-07-09 06:00:45 -0400409 strbuf_addf(&remote, "%s%%(refname:lstrip=2)%s%%(if)%%(symref)%%(then) -> %%(symref:short)%%(end)",
410 quote_literal_for_format(remote_prefix),
Karthik Nayak949af062017-01-10 14:19:52 +0530411 branch_get_color(BRANCH_COLOR_RESET));
412 }
413
414 strbuf_addf(&fmt, "%%(if:notequals=refs/remotes)%%(refname:rstrip=-2)%%(then)%s%%(else)%s%%(end)", local.buf, remote.buf);
415
416 strbuf_release(&local);
417 strbuf_release(&remote);
418 return strbuf_detach(&fmt, NULL);
419}
420
Ævar Arnfjörð Bjarmasond72d4f92021-10-20 20:27:21 +0200421static void print_ref_list(struct ref_filter *filter, struct ref_sorting *sorting,
422 struct ref_format *format, struct string_list *output)
Lars Hjemlic31820c2006-10-23 23:27:45 +0200423{
424 int i;
Karthik Nayak1511b222015-09-23 23:41:11 +0530425 struct ref_array array;
ZheNing Hu844c3f02021-04-20 16:52:11 +0000426 struct strbuf out = STRBUF_INIT;
427 struct strbuf err = STRBUF_INIT;
Karthik Nayak1051e402015-09-23 23:41:06 +0530428 int maxwidth = 0;
429 const char *remote_prefix = "";
Karthik Nayak3d9e4ce2017-01-10 14:19:53 +0530430 char *to_free = NULL;
Lars Hjemlic31820c2006-10-23 23:27:45 +0200431
Karthik Nayak35257aa2015-07-07 21:36:12 +0530432 /*
Karthik Nayak1051e402015-09-23 23:41:06 +0530433 * If we are listing more than just remote branches,
434 * then remote branches will have a "remotes/" prefix.
435 * We need to account for this in the width.
Karthik Nayak35257aa2015-07-07 21:36:12 +0530436 */
Karthik Nayak1511b222015-09-23 23:41:11 +0530437 if (filter->kind != FILTER_REFS_REMOTES)
Karthik Nayak1051e402015-09-23 23:41:06 +0530438 remote_prefix = "remotes/";
Carlos Martín Nieto6c41e972012-02-27 16:11:53 +0100439
Karthik Nayak1511b222015-09-23 23:41:11 +0530440 memset(&array, 0, sizeof(array));
Stefan Beller81c3ce32014-08-10 23:33:26 +0200441
Jeff King17633342021-09-24 14:48:05 -0400442 filter_refs(&array, filter, filter->kind);
Jeff King8376a702014-09-18 06:49:43 -0400443
Karthik Nayak1511b222015-09-23 23:41:11 +0530444 if (filter->verbose)
445 maxwidth = calc_maxwidth(&array, strlen(remote_prefix));
Jeff King8376a702014-09-18 06:49:43 -0400446
Jeff King4a68e362017-07-13 11:01:18 -0400447 if (!format->format)
448 format->format = to_free = build_format(filter, maxwidth, remote_prefix);
Jeff King11b087a2017-07-13 11:09:32 -0400449 format->use_color = branch_use_color;
Jeff King2eda0102017-07-13 10:56:10 -0400450
451 if (verify_ref_format(format))
452 die(_("unable to parse format string"));
Karthik Nayak949af062017-01-10 14:19:52 +0530453
Karthik Nayakaedcb7d2015-09-23 23:41:12 +0530454 ref_array_sort(sorting, &array);
Jeff King8376a702014-09-18 06:49:43 -0400455
Karthik Nayak949af062017-01-10 14:19:52 +0530456 for (i = 0; i < array.nr; i++) {
ZheNing Hu844c3f02021-04-20 16:52:11 +0000457 strbuf_reset(&err);
458 strbuf_reset(&out);
Olga Telezhnaya3019eca2018-03-29 12:49:45 +0000459 if (format_ref_array_item(array.items[i], format, &out, &err))
460 die("%s", err.buf);
Karthik Nayak949af062017-01-10 14:19:52 +0530461 if (column_active(colopts)) {
462 assert(!filter->verbose && "--column and --verbose are incompatible");
463 /* format to a string_list to let print_columns() do its job */
Ævar Arnfjörð Bjarmasond72d4f92021-10-20 20:27:21 +0200464 string_list_append(output, out.buf);
Karthik Nayak949af062017-01-10 14:19:52 +0530465 } else {
466 fwrite(out.buf, 1, out.len, stdout);
467 putchar('\n');
468 }
Karthik Nayak949af062017-01-10 14:19:52 +0530469 }
Lars Hjemlic31820c2006-10-23 23:27:45 +0200470
ZheNing Hu844c3f02021-04-20 16:52:11 +0000471 strbuf_release(&err);
472 strbuf_release(&out);
Karthik Nayak1511b222015-09-23 23:41:11 +0530473 ref_array_clear(&array);
Karthik Nayak3d9e4ce2017-01-10 14:19:53 +0530474 free(to_free);
Lars Hjemlic31820c2006-10-23 23:27:45 +0200475}
476
Daniels Umanovskis0ecb1fc2018-10-25 21:04:21 +0200477static void print_current_branch_name(void)
478{
479 int flags;
480 const char *refname = resolve_ref_unsafe("HEAD", 0, NULL, &flags);
481 const char *shortname;
482 if (!refname)
483 die(_("could not resolve HEAD"));
484 else if (!(flags & REF_ISSYMREF))
485 return;
486 else if (skip_prefix(refname, "refs/heads/", &shortname))
487 puts(shortname);
488 else
489 die(_("HEAD (%s) points outside of refs/heads/"), refname);
490}
491
Nguyễn Thái Ngọc Duy14ace5b2016-04-22 20:01:36 +0700492static void reject_rebase_or_bisect_branch(const char *target)
493{
Eric Sunshine03f24652020-06-19 19:35:44 -0400494 struct worktree **worktrees = get_worktrees();
Nguyễn Thái Ngọc Duy14ace5b2016-04-22 20:01:36 +0700495 int i;
496
497 for (i = 0; worktrees[i]; i++) {
498 struct worktree *wt = worktrees[i];
499
500 if (!wt->is_detached)
501 continue;
502
503 if (is_worktree_being_rebased(wt, target))
504 die(_("Branch %s is being rebased at %s"),
505 target, wt->path);
506
507 if (is_worktree_being_bisected(wt, target))
508 die(_("Branch %s is being bisected at %s"),
509 target, wt->path);
510 }
511
512 free_worktrees(worktrees);
513}
514
Sahil Dua52d59cc2017-06-18 23:19:16 +0200515static void copy_or_rename_branch(const char *oldname, const char *newname, int copy, int force)
Lars Hjemlic976d412006-11-28 15:47:40 +0100516{
Miklos Vajnada3f78a2008-11-17 21:48:37 +0100517 struct strbuf oldref = STRBUF_INIT, newref = STRBUF_INIT, logmsg = STRBUF_INIT;
Miklos Vajnada3f78a2008-11-17 21:48:37 +0100518 struct strbuf oldsection = STRBUF_INIT, newsection = STRBUF_INIT;
Kaartic Sivaraam255073c2017-12-01 11:29:33 +0530519 const char *interpreted_oldname = NULL;
520 const char *interpreted_newname = NULL;
Junio C Hamanocbdffe42009-03-21 13:27:31 -0700521 int recovery = 0;
Lars Hjemlic976d412006-11-28 15:47:40 +0100522
Sahil Dua52d59cc2017-06-18 23:19:16 +0200523 if (!oldname) {
524 if (copy)
525 die(_("cannot copy the current branch while not on any."));
526 else
527 die(_("cannot rename the current branch while not on any."));
528 }
Junio C Hamanoc847f532007-01-01 23:31:08 -0800529
Junio C Hamanocbdffe42009-03-21 13:27:31 -0700530 if (strbuf_check_branch_ref(&oldref, oldname)) {
531 /*
532 * Bad name --- this could be an attempt to rename a
533 * ref that we used to allow to be created by accident.
534 */
Nguyễn Thái Ngọc Duyc6893322011-11-13 17:22:14 +0700535 if (ref_exists(oldref.buf))
Junio C Hamanocbdffe42009-03-21 13:27:31 -0700536 recovery = 1;
537 else
Ævar Arnfjörð Bjarmason49df4b02011-02-22 23:41:34 +0000538 die(_("Invalid branch name: '%s'"), oldname);
Junio C Hamanocbdffe42009-03-21 13:27:31 -0700539 }
Lars Hjemlic976d412006-11-28 15:47:40 +0100540
Jonathan Nieder3f594812011-11-25 20:30:02 -0600541 /*
542 * A command like "git branch -M currentbranch currentbranch" cannot
543 * cause the worktree to become inconsistent with HEAD, so allow it.
544 */
Junio C Hamanobc1c9c02017-10-13 13:45:40 +0900545 if (!strcmp(oldname, newname))
546 validate_branchname(newname, &newref);
547 else
548 validate_new_branchname(newname, &newref, force);
Lars Hjemlic976d412006-11-28 15:47:40 +0100549
Nguyễn Thái Ngọc Duy14ace5b2016-04-22 20:01:36 +0700550 reject_rebase_or_bisect_branch(oldref.buf);
551
Kaartic Sivaraam255073c2017-12-01 11:29:33 +0530552 if (!skip_prefix(oldref.buf, "refs/heads/", &interpreted_oldname) ||
553 !skip_prefix(newref.buf, "refs/heads/", &interpreted_newname)) {
Johannes Schindelin033abf92018-05-02 11:38:39 +0200554 BUG("expected prefix missing for refs");
Kaartic Sivaraam255073c2017-12-01 11:29:33 +0530555 }
556
Sahil Dua52d59cc2017-06-18 23:19:16 +0200557 if (copy)
558 strbuf_addf(&logmsg, "Branch: copied %s to %s",
559 oldref.buf, newref.buf);
560 else
561 strbuf_addf(&logmsg, "Branch: renamed %s to %s",
562 oldref.buf, newref.buf);
Lars Hjemli678d0f42006-11-30 03:16:56 +0100563
Johannes Schindelincfaff3a2020-12-11 11:36:55 +0000564 if (!copy &&
565 (!head || strcmp(oldname, head) || !is_null_oid(&head_oid)) &&
566 rename_ref(oldref.buf, newref.buf, logmsg.buf))
Ævar Arnfjörð Bjarmason49df4b02011-02-22 23:41:34 +0000567 die(_("Branch rename failed"));
Sahil Dua52d59cc2017-06-18 23:19:16 +0200568 if (copy && copy_existing_ref(oldref.buf, newref.buf, logmsg.buf))
569 die(_("Branch copy failed"));
Lars Hjemlic976d412006-11-28 15:47:40 +0100570
Sahil Dua52d59cc2017-06-18 23:19:16 +0200571 if (recovery) {
572 if (copy)
Kaartic Sivaraama48ebe92017-11-18 22:56:47 +0530573 warning(_("Created a copy of a misnamed branch '%s'"),
Kaartic Sivaraam255073c2017-12-01 11:29:33 +0530574 interpreted_oldname);
Sahil Dua52d59cc2017-06-18 23:19:16 +0200575 else
576 warning(_("Renamed a misnamed branch '%s' away"),
Kaartic Sivaraam255073c2017-12-01 11:29:33 +0530577 interpreted_oldname);
Sahil Dua52d59cc2017-06-18 23:19:16 +0200578 }
Junio C Hamanocbdffe42009-03-21 13:27:31 -0700579
Junio C Hamanoe5435ff2017-09-22 12:24:50 +0900580 if (!copy &&
581 replace_each_worktree_head_symref(oldref.buf, newref.buf, logmsg.buf))
Ævar Arnfjörð Bjarmason49df4b02011-02-22 23:41:34 +0000582 die(_("Branch renamed to %s, but HEAD is not updated!"), newname);
Lars Hjemli19eba152007-04-06 14:13:00 +0200583
Kyle Meyer39ee4c62017-02-20 20:10:35 -0500584 strbuf_release(&logmsg);
585
Kaartic Sivaraam255073c2017-12-01 11:29:33 +0530586 strbuf_addf(&oldsection, "branch.%s", interpreted_oldname);
Miklos Vajnada3f78a2008-11-17 21:48:37 +0100587 strbuf_release(&oldref);
Kaartic Sivaraam255073c2017-12-01 11:29:33 +0530588 strbuf_addf(&newsection, "branch.%s", interpreted_newname);
Miklos Vajnada3f78a2008-11-17 21:48:37 +0100589 strbuf_release(&newref);
Sahil Dua52d59cc2017-06-18 23:19:16 +0200590 if (!copy && git_config_rename_section(oldsection.buf, newsection.buf) < 0)
Ævar Arnfjörð Bjarmason49df4b02011-02-22 23:41:34 +0000591 die(_("Branch is renamed, but update of config-file failed"));
Sahil Dua52d59cc2017-06-18 23:19:16 +0200592 if (copy && strcmp(oldname, newname) && git_config_copy_section(oldsection.buf, newsection.buf) < 0)
593 die(_("Branch is copied, but update of config-file failed"));
Miklos Vajnada3f78a2008-11-17 21:48:37 +0100594 strbuf_release(&oldsection);
595 strbuf_release(&newsection);
Lars Hjemlic976d412006-11-28 15:47:40 +0100596}
597
Jeff Kingc10388c2017-04-20 17:08:41 -0400598static GIT_PATH_FUNC(edit_description, "EDIT_DESCRIPTION")
Junio C Hamanob7200e82011-09-20 15:10:08 -0700599
600static int edit_branch_description(const char *branch_name)
601{
Junio C Hamanob7200e82011-09-20 15:10:08 -0700602 struct strbuf buf = STRBUF_INIT;
603 struct strbuf name = STRBUF_INIT;
604
605 read_branch_desc(&buf, branch_name);
606 if (!buf.len || buf.buf[buf.len-1] != '\n')
607 strbuf_addch(&buf, '\n');
Junio C Hamanoeff80a92013-01-16 20:18:48 +0100608 strbuf_commented_addf(&buf,
Vasco Almeidab18237f2016-06-17 21:54:15 +0000609 _("Please edit the description for the branch\n"
610 " %s\n"
611 "Lines starting with '%c' will be stripped.\n"),
Junio C Hamanoeff80a92013-01-16 20:18:48 +0100612 branch_name, comment_line_char);
Jeff Kingc10388c2017-04-20 17:08:41 -0400613 write_file_buf(edit_description(), buf.buf, buf.len);
Junio C Hamanob7200e82011-09-20 15:10:08 -0700614 strbuf_reset(&buf);
Jeff Kingc10388c2017-04-20 17:08:41 -0400615 if (launch_editor(edit_description(), &buf, NULL)) {
Junio C Hamanob7200e82011-09-20 15:10:08 -0700616 strbuf_release(&buf);
617 return -1;
618 }
Tobias Klauser63af4a82015-10-16 17:16:42 +0200619 strbuf_stripspace(&buf, 1);
Junio C Hamanob7200e82011-09-20 15:10:08 -0700620
621 strbuf_addf(&name, "branch.%s.description", branch_name);
Patrick Steinhardt3d180642016-02-22 12:23:36 +0100622 git_config_set(name.buf, buf.len ? buf.buf : NULL);
Junio C Hamanob7200e82011-09-20 15:10:08 -0700623 strbuf_release(&name);
624 strbuf_release(&buf);
625
Patrick Steinhardtbd25f892016-02-22 12:23:25 +0100626 return 0;
Junio C Hamanob7200e82011-09-20 15:10:08 -0700627}
628
Lars Hjemlic31820c2006-10-23 23:27:45 +0200629int cmd_branch(int argc, const char **argv, const char *prefix)
630{
Glen Choo6e0a2ca2022-01-28 16:04:44 -0800631 /* possible actions */
632 int delete = 0, rename = 0, copy = 0, list = 0,
633 unset_upstream = 0, show_current = 0, edit_description = 0;
Carlos Martín Nieto6183d822012-08-20 15:47:38 +0200634 const char *new_upstream = NULL;
Glen Choo6e0a2ca2022-01-28 16:04:44 -0800635 int noncreate_actions = 0;
636 /* possible options */
Glen Choo961b1302022-01-28 16:04:45 -0800637 int reflog = 0, quiet = 0, icase = 0, force = 0,
638 recurse_submodules_explicit = 0;
Jay Soffian9ed36cf2008-02-19 11:24:37 -0500639 enum branch_track track;
Karthik Nayak1511b222015-09-23 23:41:11 +0530640 struct ref_filter filter;
Junio C Hamano98e7ab62021-10-20 12:23:53 -0700641 static struct ref_sorting *sorting;
642 struct string_list sorting_options = STRING_LIST_INIT_DUP;
Jeff King4a68e362017-07-13 11:01:18 -0400643 struct ref_format format = REF_FORMAT_INIT;
Pierre Habouzita8dfd5e2007-10-07 18:26:21 +0200644
645 struct option options[] = {
Nguyễn Thái Ngọc Duy24a85212012-08-20 19:31:55 +0700646 OPT_GROUP(N_("Generic options")),
Karthik Nayak1511b222015-09-23 23:41:11 +0530647 OPT__VERBOSE(&filter.verbose,
Nguyễn Thái Ngọc Duy24a85212012-08-20 19:31:55 +0700648 N_("show hash and subject, give twice for upstream branch")),
649 OPT__QUIET(&quiet, N_("suppress informational messages")),
René Scharfe6327f0e2022-01-20 13:35:54 +0100650 OPT_CALLBACK_F('t', "track", &track, "(direct|inherit)",
Josh Steadmond3115662021-12-20 19:30:23 -0800651 N_("set branch tracking configuration"),
Josh Steadmon15f00282022-01-18 12:49:46 -0800652 PARSE_OPT_OPTARG,
Josh Steadmond3115662021-12-20 19:30:23 -0800653 parse_opt_tracking_mode),
Nguyễn Thái Ngọc Duy3e4a67b2018-05-20 17:42:58 +0200654 OPT_SET_INT_F(0, "set-upstream", &track, N_("do not use"),
655 BRANCH_TRACK_OVERRIDE, PARSE_OPT_HIDDEN),
Vasco Almeidaab868852016-04-08 20:02:45 +0000656 OPT_STRING('u', "set-upstream-to", &new_upstream, N_("upstream"), N_("change the upstream info")),
Dimitriy Ryazantcev11de8dd2019-12-08 11:26:47 +0200657 OPT_BOOL(0, "unset-upstream", &unset_upstream, N_("unset the upstream info")),
Nguyễn Thái Ngọc Duy24a85212012-08-20 19:31:55 +0700658 OPT__COLOR(&branch_use_color, N_("use colored output")),
Karthik Nayak1511b222015-09-23 23:41:11 +0530659 OPT_SET_INT('r', "remotes", &filter.kind, N_("act on remote-tracking branches"),
660 FILTER_REFS_REMOTES),
661 OPT_CONTAINS(&filter.with_commit, N_("print only branches that contain the commit")),
Ævar Arnfjörð Bjarmasonac3f5a32017-03-24 18:40:57 +0000662 OPT_NO_CONTAINS(&filter.no_commit, N_("print only branches that don't contain the commit")),
Karthik Nayak1511b222015-09-23 23:41:11 +0530663 OPT_WITH(&filter.with_commit, N_("print only branches that contain the commit")),
Ævar Arnfjörð Bjarmasonac3f5a32017-03-24 18:40:57 +0000664 OPT_WITHOUT(&filter.no_commit, N_("print only branches that don't contain the commit")),
Karthik Nayak1511b222015-09-23 23:41:11 +0530665 OPT__ABBREV(&filter.abbrev),
Pierre Habouzita8dfd5e2007-10-07 18:26:21 +0200666
Nguyễn Thái Ngọc Duy24a85212012-08-20 19:31:55 +0700667 OPT_GROUP(N_("Specific git-branch actions:")),
Karthik Nayak1511b222015-09-23 23:41:11 +0530668 OPT_SET_INT('a', "all", &filter.kind, N_("list both remote-tracking and local branches"),
669 FILTER_REFS_REMOTES | FILTER_REFS_BRANCHES),
Nguyễn Thái Ngọc Duy24a85212012-08-20 19:31:55 +0700670 OPT_BIT('d', "delete", &delete, N_("delete fully merged branch"), 1),
671 OPT_BIT('D', NULL, &delete, N_("delete branch (even if not merged)"), 2),
672 OPT_BIT('m', "move", &rename, N_("move/rename a branch and its reflog"), 1),
673 OPT_BIT('M', NULL, &rename, N_("move/rename a branch, even if target exists"), 2),
Sahil Dua52d59cc2017-06-18 23:19:16 +0200674 OPT_BIT('c', "copy", &copy, N_("copy a branch and its reflog"), 1),
675 OPT_BIT('C', NULL, &copy, N_("copy a branch, even if target exists"), 2),
Jeff Kinga15d5982018-06-22 05:24:59 -0400676 OPT_BOOL('l', "list", &list, N_("list branch names")),
Daniels Umanovskis0ecb1fc2018-10-25 21:04:21 +0200677 OPT_BOOL(0, "show-current", &show_current, N_("show current branch name")),
Jeff King055930b2018-06-22 05:24:14 -0400678 OPT_BOOL(0, "create-reflog", &reflog, N_("create the branch's reflog")),
Stefan Bellerd5d09d42013-08-03 13:51:19 +0200679 OPT_BOOL(0, "edit-description", &edit_description,
680 N_("edit the description for the branch")),
Nguyễn Thái Ngọc Duyc01b56a2018-02-09 18:01:47 +0700681 OPT__FORCE(&force, N_("force creation, move/rename, deletion"), PARSE_OPT_NOCOMPLETE),
Karthik Nayak1511b222015-09-23 23:41:11 +0530682 OPT_MERGED(&filter, N_("print only branches that are merged")),
683 OPT_NO_MERGED(&filter, N_("print only branches that are not merged")),
Nguyễn Thái Ngọc Duy24a85212012-08-20 19:31:55 +0700684 OPT_COLUMN(0, "column", &colopts, N_("list branches in columns")),
Junio C Hamano98e7ab62021-10-20 12:23:53 -0700685 OPT_REF_SORT(&sorting_options),
Denton Liu203c8532020-04-28 04:36:28 -0400686 OPT_CALLBACK(0, "points-at", &filter.points_at, N_("object"),
687 N_("print only branches of the object"), parse_opt_object_name),
Nguyễn Thái Ngọc Duy3bb16a82016-12-04 09:52:25 +0700688 OPT_BOOL('i', "ignore-case", &icase, N_("sorting and filtering are case insensitive")),
Glen Choo961b1302022-01-28 16:04:45 -0800689 OPT_BOOL(0, "recurse-submodules", &recurse_submodules_explicit, N_("recurse through submodules")),
Jeff King4a68e362017-07-13 11:01:18 -0400690 OPT_STRING( 0 , "format", &format.format, N_("format"), N_("format to use for the output")),
Pierre Habouzita8dfd5e2007-10-07 18:26:21 +0200691 OPT_END(),
692 };
Lars Hjemlic31820c2006-10-23 23:27:45 +0200693
Karthik Nayak56b43602017-01-10 14:19:51 +0530694 setup_ref_filter_porcelain_msg();
695
Karthik Nayak1511b222015-09-23 23:41:11 +0530696 memset(&filter, 0, sizeof(filter));
697 filter.kind = FILTER_REFS_BRANCHES;
698 filter.abbrev = -1;
699
Nguyễn Thái Ngọc Duy1dacfbc2010-10-22 01:42:58 -0500700 if (argc == 2 && !strcmp(argv[1], "-h"))
701 usage_with_options(builtin_branch_usage, options);
702
Junio C Hamano98e7ab62021-10-20 12:23:53 -0700703 git_config(git_branch_config, &sorting_options);
Matthias Kestenholz6b2f2d92008-02-18 08:26:03 +0100704
Jay Soffian9ed36cf2008-02-19 11:24:37 -0500705 track = git_branch_track;
Lars Hjemlic976d412006-11-28 15:47:40 +0100706
brian m. carlson0f2dc722017-10-15 22:06:55 +0000707 head = resolve_refdup("HEAD", 0, &head_oid, NULL);
Lars Hjemlic31820c2006-10-23 23:27:45 +0200708 if (!head)
Ævar Arnfjörð Bjarmason49df4b02011-02-22 23:41:34 +0000709 die(_("Failed to resolve HEAD as a valid ref."));
René Scharfee3f1da92014-10-04 20:54:50 +0200710 if (!strcmp(head, "HEAD"))
Karthik Nayak1511b222015-09-23 23:41:11 +0530711 filter.detached = 1;
René Scharfee3f1da92014-10-04 20:54:50 +0200712 else if (!skip_prefix(head, "refs/heads/", &head))
713 die(_("HEAD not found below refs/heads!"));
Nguyễn Thái Ngọc Duyebe31ef2012-04-13 17:54:38 +0700714
Stephen Boyd37782922009-05-23 11:53:12 -0700715 argc = parse_options(argc, argv, prefix, options, builtin_branch_usage,
716 0);
Michael J Grubercddd1272011-08-28 16:54:31 +0200717
Daniels Umanovskis0ecb1fc2018-10-25 21:04:21 +0200718 if (!delete && !rename && !copy && !edit_description && !new_upstream &&
719 !show_current && !unset_upstream && argc == 0)
Michael J Grubercddd1272011-08-28 16:54:31 +0200720 list = 1;
721
Aaron Lipman21bf9332020-09-15 22:08:40 -0400722 if (filter.with_commit || filter.no_commit ||
723 filter.reachable_from || filter.unreachable_from || filter.points_at.nr)
Jeff Kingd0403502013-01-31 01:46:11 -0500724 list = 1;
725
Glen Choo6e0a2ca2022-01-28 16:04:44 -0800726 noncreate_actions = !!delete + !!rename + !!copy + !!new_upstream +
727 !!show_current + !!list + !!edit_description +
728 !!unset_upstream;
729 if (noncreate_actions > 1)
Junio C Hamano049716b2008-07-08 17:55:47 -0700730 usage_with_options(builtin_branch_usage, options);
Lars Hjemlic31820c2006-10-23 23:27:45 +0200731
Glen Choo961b1302022-01-28 16:04:45 -0800732 if (recurse_submodules_explicit) {
733 if (!submodule_propagate_branches)
734 die(_("branch with --recurse-submodules can only be used if submodule.propagateBranches is enabled"));
735 if (noncreate_actions)
736 die(_("--recurse-submodules can only be used to create branches"));
737 }
738
739 recurse_submodules =
740 (recurse_submodules || recurse_submodules_explicit) &&
741 submodule_propagate_branches;
742
Karthik Nayak1511b222015-09-23 23:41:11 +0530743 if (filter.abbrev == -1)
744 filter.abbrev = DEFAULT_ABBREV;
Nguyễn Thái Ngọc Duy3bb16a82016-12-04 09:52:25 +0700745 filter.ignore_case = icase;
746
Nguyễn Thái Ngọc Duyebe31ef2012-04-13 17:54:38 +0700747 finalize_colopts(&colopts, -1);
Karthik Nayak1511b222015-09-23 23:41:11 +0530748 if (filter.verbose) {
Nguyễn Thái Ngọc Duyebe31ef2012-04-13 17:54:38 +0700749 if (explicitly_enable_column(colopts))
Jean-Noël Avila12909b62022-01-05 20:02:16 +0000750 die(_("options '%s' and '%s' cannot be used together"), "--column", "--verbose");
Nguyễn Thái Ngọc Duyebe31ef2012-04-13 17:54:38 +0700751 colopts = 0;
752 }
Namhyung Kimb792c062011-07-01 15:06:08 +0900753
Michael J Gruber356e91f2014-12-08 17:28:45 +0100754 if (force) {
755 delete *= 2;
756 rename *= 2;
Sahil Dua52d59cc2017-06-18 23:19:16 +0200757 copy *= 2;
Michael J Gruber356e91f2014-12-08 17:28:45 +0100758 }
759
Martin Ågrend74b5412017-11-19 16:03:49 +0100760 if (list)
Martin Ågren0ae19de2017-11-19 16:03:50 +0100761 setup_auto_pager("branch", 1);
Martin Ågrend74b5412017-11-19 16:03:49 +0100762
Nguyễn Thái Ngọc Duy640d0402013-01-28 08:18:14 +0700763 if (delete) {
764 if (!argc)
765 die(_("branch name required"));
Karthik Nayak1511b222015-09-23 23:41:11 +0530766 return delete_branches(argc, argv, delete > 1, filter.kind, quiet);
Daniels Umanovskis0ecb1fc2018-10-25 21:04:21 +0200767 } else if (show_current) {
768 print_current_branch_name();
769 return 0;
Nguyễn Thái Ngọc Duy640d0402013-01-28 08:18:14 +0700770 } else if (list) {
Ævar Arnfjörð Bjarmasonffdd02a2021-01-06 11:01:35 +0100771 /* git branch --list also shows HEAD when it is detached */
Karthik Nayak1511b222015-09-23 23:41:11 +0530772 if ((filter.kind & FILTER_REFS_BRANCHES) && filter.detached)
773 filter.kind |= FILTER_REFS_DETACHED_HEAD;
774 filter.name_patterns = argv;
Nguyễn Thái Ngọc Duy3bb16a82016-12-04 09:52:25 +0700775 /*
776 * If no sorting parameter is given then we default to sorting
777 * by 'refname'. This would give us an alphabetically sorted
778 * array with the 'HEAD' ref at the beginning followed by
Robert P. J. Day30aa96c2018-06-07 07:53:36 -0400779 * local branches 'refs/heads/...' and finally remote-tracking
Nguyễn Thái Ngọc Duy3bb16a82016-12-04 09:52:25 +0700780 * branches 'refs/remotes/...'.
781 */
Junio C Hamano98e7ab62021-10-20 12:23:53 -0700782 sorting = ref_sorting_options(&sorting_options);
Ævar Arnfjörð Bjarmason7c269a72021-01-07 10:51:51 +0100783 ref_sorting_set_sort_flags_all(sorting, REF_SORTING_ICASE, icase);
Ævar Arnfjörð Bjarmason2708ce62021-01-07 10:51:52 +0100784 ref_sorting_set_sort_flags_all(
785 sorting, REF_SORTING_DETACHED_HEAD_FIRST, 1);
Ævar Arnfjörð Bjarmasond72d4f92021-10-20 20:27:21 +0200786 print_ref_list(&filter, sorting, &format, &output);
Nguyễn Thái Ngọc Duyebe31ef2012-04-13 17:54:38 +0700787 print_columns(&output, colopts, NULL);
788 string_list_clear(&output, 0);
Ævar Arnfjörð Bjarmasond72d4f92021-10-20 20:27:21 +0200789 ref_sorting_release(sorting);
Karthik Nayakca417992015-09-24 23:39:08 +0530790 return 0;
Tao Qingyun2e3c8942018-10-16 22:19:20 +0800791 } else if (edit_description) {
Junio C Hamanob7200e82011-09-20 15:10:08 -0700792 const char *branch_name;
Junio C Hamanoc2d17ba2012-02-05 17:13:36 -0800793 struct strbuf branch_ref = STRBUF_INIT;
Rubén Justo0dc4e5c2022-10-11 01:24:58 +0200794 struct strbuf buf = STRBUF_INIT;
795 int ret = 1; /* assume failure */
Junio C Hamanoc2d17ba2012-02-05 17:13:36 -0800796
Nguyễn Thái Ngọc Duy75135b22013-01-28 08:18:13 +0700797 if (!argc) {
Karthik Nayak1511b222015-09-23 23:41:11 +0530798 if (filter.detached)
Nguyễn Thái Ngọc Duy045e3882013-01-28 08:18:16 +0700799 die(_("Cannot give description to detached HEAD"));
Junio C Hamanob7200e82011-09-20 15:10:08 -0700800 branch_name = head;
Rubén Justo0dc4e5c2022-10-11 01:24:58 +0200801 } else if (argc == 1) {
802 strbuf_branchname(&buf, argv[0], INTERPRET_BRANCH_LOCAL);
803 branch_name = buf.buf;
804 } else {
Nguyễn Thái Ngọc Duy43722c42013-01-28 08:18:15 +0700805 die(_("cannot edit description of more than one branch"));
Rubén Justo0dc4e5c2022-10-11 01:24:58 +0200806 }
Junio C Hamanoc2d17ba2012-02-05 17:13:36 -0800807
808 strbuf_addf(&branch_ref, "refs/heads/%s", branch_name);
Rubén Justo0dc4e5c2022-10-11 01:24:58 +0200809 if (!ref_exists(branch_ref.buf))
810 ret = error(!argc
811 ? _("No commit on branch '%s' yet.")
812 : _("No branch named '%s'."),
813 branch_name);
814 else if (!edit_branch_description(branch_name))
815 ret = 0; /* happy */
Junio C Hamanoc2d17ba2012-02-05 17:13:36 -0800816
Junio C Hamanoc2d17ba2012-02-05 17:13:36 -0800817 strbuf_release(&branch_ref);
Rubén Justo0dc4e5c2022-10-11 01:24:58 +0200818 strbuf_release(&buf);
Junio C Hamanoc2d17ba2012-02-05 17:13:36 -0800819
Rubén Justo0dc4e5c2022-10-11 01:24:58 +0200820 return ret;
Sahil Dua52d59cc2017-06-18 23:19:16 +0200821 } else if (copy) {
822 if (!argc)
823 die(_("branch name required"));
824 else if (argc == 1)
825 copy_or_rename_branch(head, argv[0], 1, copy > 1);
826 else if (argc == 2)
827 copy_or_rename_branch(argv[0], argv[1], 1, copy > 1);
828 else
829 die(_("too many branches for a copy operation"));
Junio C Hamanoa4043ae2011-12-09 13:37:05 -0800830 } else if (rename) {
Jonathon Mahd1520c42013-03-30 18:27:44 -0700831 if (!argc)
832 die(_("branch name required"));
833 else if (argc == 1)
Sahil Dua52d59cc2017-06-18 23:19:16 +0200834 copy_or_rename_branch(head, argv[0], 0, rename > 1);
Tay Ray Chuan3706ed22011-11-03 00:17:12 +0800835 else if (argc == 2)
Sahil Dua52d59cc2017-06-18 23:19:16 +0200836 copy_or_rename_branch(argv[0], argv[1], 0, rename > 1);
Tay Ray Chuan3706ed22011-11-03 00:17:12 +0800837 else
Kaartic Sivaraamf7776232017-08-21 19:06:08 +0530838 die(_("too many arguments for a rename operation"));
Carlos Martín Nieto6183d822012-08-20 15:47:38 +0200839 } else if (new_upstream) {
Rubén Justo0dc4e5c2022-10-11 01:24:58 +0200840 struct branch *branch;
841 struct strbuf buf = STRBUF_INIT;
Carlos Martín Nieto6183d822012-08-20 15:47:38 +0200842
Rubén Justo0dc4e5c2022-10-11 01:24:58 +0200843 if (!argc)
844 branch = branch_get(NULL);
845 else if (argc == 1) {
846 strbuf_branchname(&buf, argv[0], INTERPRET_BRANCH_LOCAL);
847 branch = branch_get(buf.buf);
848 } else
Kaartic Sivaraamf7776232017-08-21 19:06:08 +0530849 die(_("too many arguments to set new upstream"));
Nguyễn Thái Ngọc Duy8efb8892013-02-23 19:22:27 +0700850
851 if (!branch) {
852 if (!argc || !strcmp(argv[0], "HEAD"))
853 die(_("could not set upstream of HEAD to %s when "
854 "it does not point to any branch."),
855 new_upstream);
856 die(_("no such branch '%s'"), argv[0]);
857 }
858
Carlos Martín Nieto6183d822012-08-20 15:47:38 +0200859 if (!ref_exists(branch->refname))
860 die(_("branch '%s' does not exist"), branch->name);
861
Glen Chooe89f1512022-01-28 16:04:41 -0800862 dwim_and_setup_tracking(the_repository, branch->name,
863 new_upstream, BRANCH_TRACK_OVERRIDE,
864 quiet);
Rubén Justo0dc4e5c2022-10-11 01:24:58 +0200865 strbuf_release(&buf);
Carlos Martín Nietob84869e2012-08-30 19:23:12 +0200866 } else if (unset_upstream) {
Rubén Justo0dc4e5c2022-10-11 01:24:58 +0200867 struct branch *branch;
Carlos Martín Nietob84869e2012-08-30 19:23:12 +0200868 struct strbuf buf = STRBUF_INIT;
869
Rubén Justo0dc4e5c2022-10-11 01:24:58 +0200870 if (!argc)
871 branch = branch_get(NULL);
872 else if (argc == 1) {
873 strbuf_branchname(&buf, argv[0], INTERPRET_BRANCH_LOCAL);
874 branch = branch_get(buf.buf);
875 } else
Kaartic Sivaraamf7776232017-08-21 19:06:08 +0530876 die(_("too many arguments to unset upstream"));
Nguyễn Thái Ngọc Duy8efb8892013-02-23 19:22:27 +0700877
878 if (!branch) {
879 if (!argc || !strcmp(argv[0], "HEAD"))
880 die(_("could not unset upstream of HEAD when "
881 "it does not point to any branch."));
882 die(_("no such branch '%s'"), argv[0]);
883 }
884
Felipe Contreras54d07f22013-10-31 03:25:38 -0600885 if (!branch_has_merge_config(branch))
Carlos Martín Nietob84869e2012-08-30 19:23:12 +0200886 die(_("Branch '%s' has no upstream information"), branch->name);
Carlos Martín Nietob84869e2012-08-30 19:23:12 +0200887
Rubén Justo0dc4e5c2022-10-11 01:24:58 +0200888 strbuf_reset(&buf);
Carlos Martín Nietob84869e2012-08-30 19:23:12 +0200889 strbuf_addf(&buf, "branch.%s.remote", branch->name);
Derrick Stolee504ee122020-11-25 22:12:49 +0000890 git_config_set_multivar(buf.buf, NULL, NULL, CONFIG_FLAGS_MULTI_REPLACE);
Carlos Martín Nietob84869e2012-08-30 19:23:12 +0200891 strbuf_reset(&buf);
892 strbuf_addf(&buf, "branch.%s.merge", branch->name);
Derrick Stolee504ee122020-11-25 22:12:49 +0000893 git_config_set_multivar(buf.buf, NULL, NULL, CONFIG_FLAGS_MULTI_REPLACE);
Carlos Martín Nietob84869e2012-08-30 19:23:12 +0200894 strbuf_release(&buf);
Glen Choo6e0a2ca2022-01-28 16:04:44 -0800895 } else if (!noncreate_actions && argc > 0 && argc <= 2) {
Glen Choo961b1302022-01-28 16:04:45 -0800896 const char *branch_name = argv[0];
897 const char *start_name = argc == 2 ? argv[1] : head;
898
Karthik Nayak1511b222015-09-23 23:41:11 +0530899 if (filter.kind != FILTER_REFS_BRANCHES)
Philip Oakley1fde99c2019-05-29 00:16:05 +0100900 die(_("The -a, and -r, options to 'git branch' do not take a branch name.\n"
901 "Did you mean to use: -a|-r --list <pattern>?"));
Carlos Martín Nietob347d062012-08-30 19:23:13 +0200902
903 if (track == BRANCH_TRACK_OVERRIDE)
Kaartic Sivaraam52668842017-08-17 08:24:24 +0530904 die(_("the '--set-upstream' option is no longer supported. Please use '--track' or '--set-upstream-to' instead."));
Carlos Martín Nietob347d062012-08-30 19:23:13 +0200905
Glen Choo961b1302022-01-28 16:04:45 -0800906 if (recurse_submodules) {
907 create_branches_recursively(the_repository, branch_name,
908 start_name, NULL, force,
909 reflog, quiet, track, 0);
910 return 0;
911 }
912 create_branch(the_repository, branch_name, start_name, force, 0,
913 reflog, quiet, track, 0);
Matthieu Moy6e8f9932009-12-30 15:45:31 +0100914 } else
Pierre Habouzita8dfd5e2007-10-07 18:26:21 +0200915 usage_with_options(builtin_branch_usage, options);
Lars Hjemlic31820c2006-10-23 23:27:45 +0200916
917 return 0;
918}