Lars Hjemli | c31820c | 2006-10-23 23:27:45 +0200 | [diff] [blame] | 1 | /* |
| 2 | * Builtin "git branch" |
| 3 | * |
Junio C Hamano | d972cce | 2007-07-11 22:52:45 -0700 | [diff] [blame] | 4 | * Copyright (c) 2006 Kristian Høgsberg <krh@redhat.com> |
Lars Hjemli | c31820c | 2006-10-23 23:27:45 +0200 | [diff] [blame] | 5 | * Based on git-branch.sh by Junio C Hamano. |
| 6 | */ |
| 7 | |
| 8 | #include "cache.h" |
Brandon Williams | b2141fc | 2017-06-14 11:07:36 -0700 | [diff] [blame] | 9 | #include "config.h" |
Junio C Hamano | 8502357 | 2006-12-19 14:34:12 -0800 | [diff] [blame] | 10 | #include "color.h" |
Lars Hjemli | c31820c | 2006-10-23 23:27:45 +0200 | [diff] [blame] | 11 | #include "refs.h" |
| 12 | #include "commit.h" |
| 13 | #include "builtin.h" |
Johannes Schindelin | 6f084a5 | 2007-07-10 18:50:44 +0100 | [diff] [blame] | 14 | #include "remote.h" |
Pierre Habouzit | a8dfd5e | 2007-10-07 18:26:21 +0200 | [diff] [blame] | 15 | #include "parse-options.h" |
Daniel Barkalow | e496c00 | 2008-02-07 11:40:08 -0500 | [diff] [blame] | 16 | #include "branch.h" |
Junio C Hamano | 68067ca | 2008-07-23 15:13:41 -0700 | [diff] [blame] | 17 | #include "diff.h" |
| 18 | #include "revision.h" |
Nguyễn Thái Ngọc Duy | ebe31ef | 2012-04-13 17:54:38 +0700 | [diff] [blame] | 19 | #include "string-list.h" |
| 20 | #include "column.h" |
Nguyễn Thái Ngọc Duy | 1452bd6 | 2012-08-26 01:17:12 +0700 | [diff] [blame] | 21 | #include "utf8.h" |
Nguyễn Thái Ngọc Duy | c8183cd | 2013-03-13 18:42:53 +0700 | [diff] [blame] | 22 | #include "wt-status.h" |
Karthik Nayak | 1511b22 | 2015-09-23 23:41:11 +0530 | [diff] [blame] | 23 | #include "ref-filter.h" |
Kazuki Yamaguchi | f292244 | 2016-03-29 18:38:39 +0900 | [diff] [blame] | 24 | #include "worktree.h" |
Nguyễn Thái Ngọc Duy | 3ac68a9 | 2018-05-26 15:55:24 +0200 | [diff] [blame] | 25 | #include "help.h" |
Derrick Stolee | 6404355 | 2018-07-20 16:33:04 +0000 | [diff] [blame] | 26 | #include "commit-reach.h" |
Lars Hjemli | c31820c | 2006-10-23 23:27:45 +0200 | [diff] [blame] | 27 | |
Pierre Habouzit | a8dfd5e | 2007-10-07 18:26:21 +0200 | [diff] [blame] | 28 | static const char * const builtin_branch_usage[] = { |
Aaron Lipman | 21bf933 | 2020-09-15 22:08:40 -0400 | [diff] [blame] | 29 | N_("git branch [<options>] [-r | -a] [--merged] [--no-merged]"), |
Glen Choo | 961b130 | 2022-01-28 16:04:45 -0800 | [diff] [blame] | 30 | N_("git branch [<options>] [-f] [--recurse-submodules] <branch-name> [<start-point>]"), |
| 31 | N_("git branch [<options>] [-l] [<pattern>...]"), |
Alex Henrie | 9c9b4f2 | 2015-01-13 00:44:47 -0700 | [diff] [blame] | 32 | N_("git branch [<options>] [-r] (-d | -D) <branch-name>..."), |
| 33 | N_("git branch [<options>] (-m | -M) [<old-branch>] <new-branch>"), |
Sahil Dua | 52d59cc | 2017-06-18 23:19:16 +0200 | [diff] [blame] | 34 | N_("git branch [<options>] (-c | -C) [<old-branch>] <new-branch>"), |
Karthik Nayak | aa3bc55 | 2015-09-23 23:41:13 +0530 | [diff] [blame] | 35 | N_("git branch [<options>] [-r | -a] [--points-at]"), |
Karthik Nayak | 3d9e4ce | 2017-01-10 14:19:53 +0530 | [diff] [blame] | 36 | N_("git branch [<options>] [-r | -a] [--format]"), |
Pierre Habouzit | a8dfd5e | 2007-10-07 18:26:21 +0200 | [diff] [blame] | 37 | NULL |
| 38 | }; |
Lars Hjemli | c31820c | 2006-10-23 23:27:45 +0200 | [diff] [blame] | 39 | |
Lars Hjemli | c31820c | 2006-10-23 23:27:45 +0200 | [diff] [blame] | 40 | static const char *head; |
brian m. carlson | 0c77cd2 | 2017-02-21 23:47:26 +0000 | [diff] [blame] | 41 | static struct object_id head_oid; |
Glen Choo | 961b130 | 2022-01-28 16:04:45 -0800 | [diff] [blame] | 42 | static int recurse_submodules = 0; |
| 43 | static int submodule_propagate_branches = 0; |
Lars Hjemli | c31820c | 2006-10-23 23:27:45 +0200 | [diff] [blame] | 44 | |
Matthias Kestenholz | 6b2f2d9 | 2008-02-18 08:26:03 +0100 | [diff] [blame] | 45 | static int branch_use_color = -1; |
Andy Parkins | a1158ca | 2006-12-12 06:41:52 +0000 | [diff] [blame] | 46 | static char branch_colors[][COLOR_MAXLEN] = { |
Arjen Laarhoven | dc6ebd4 | 2009-02-13 22:53:40 +0100 | [diff] [blame] | 47 | GIT_COLOR_RESET, |
Karthik Nayak | 949af06 | 2017-01-10 14:19:52 +0530 | [diff] [blame] | 48 | 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 Belakovski | ab31381 | 2019-04-28 22:19:43 -0700 | [diff] [blame] | 53 | GIT_COLOR_CYAN, /* WORKTREE */ |
Andy Parkins | a1158ca | 2006-12-12 06:41:52 +0000 | [diff] [blame] | 54 | }; |
| 55 | enum color_branch { |
Arjen Laarhoven | 74bb2df | 2009-02-13 22:53:41 +0100 | [diff] [blame] | 56 | BRANCH_COLOR_RESET = 0, |
| 57 | BRANCH_COLOR_PLAIN = 1, |
| 58 | BRANCH_COLOR_REMOTE = 2, |
| 59 | BRANCH_COLOR_LOCAL = 3, |
Felipe Contreras | dbda21f | 2013-04-14 21:37:49 -0500 | [diff] [blame] | 60 | BRANCH_COLOR_CURRENT = 4, |
Nickolai Belakovski | ab31381 | 2019-04-28 22:19:43 -0700 | [diff] [blame] | 61 | BRANCH_COLOR_UPSTREAM = 5, |
| 62 | BRANCH_COLOR_WORKTREE = 6 |
Andy Parkins | a1158ca | 2006-12-12 06:41:52 +0000 | [diff] [blame] | 63 | }; |
| 64 | |
Nguyễn Thái Ngọc Duy | a73b368 | 2018-05-26 15:55:21 +0200 | [diff] [blame] | 65 | static 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 Belakovski | ab31381 | 2019-04-28 22:19:43 -0700 | [diff] [blame] | 72 | [BRANCH_COLOR_WORKTREE] = "worktree", |
Nguyễn Thái Ngọc Duy | a73b368 | 2018-05-26 15:55:21 +0200 | [diff] [blame] | 73 | }; |
| 74 | |
Nguyễn Thái Ngọc Duy | ebe31ef | 2012-04-13 17:54:38 +0700 | [diff] [blame] | 75 | static struct string_list output = STRING_LIST_INIT_DUP; |
| 76 | static unsigned int colopts; |
| 77 | |
Nguyễn Thái Ngọc Duy | 3ac68a9 | 2018-05-26 15:55:24 +0200 | [diff] [blame] | 78 | define_list_config_array(color_branch_slots); |
Andy Parkins | a1158ca | 2006-12-12 06:41:52 +0000 | [diff] [blame] | 79 | |
Johannes Schindelin | ef90d6d | 2008-05-14 18:46:53 +0100 | [diff] [blame] | 80 | static int git_branch_config(const char *var, const char *value, void *cb) |
Andy Parkins | a1158ca | 2006-12-12 06:41:52 +0000 | [diff] [blame] | 81 | { |
René Scharfe | e3f1da9 | 2014-10-04 20:54:50 +0200 | [diff] [blame] | 82 | const char *slot_name; |
Samuel Maftoul | 560ae1c | 2018-08-16 11:35:08 +0200 | [diff] [blame] | 83 | |
| 84 | if (!strcmp(var, "branch.sort")) { |
| 85 | if (!value) |
| 86 | return config_error_nonbool(var); |
Junio C Hamano | 98e7ab6 | 2021-10-20 12:23:53 -0700 | [diff] [blame] | 87 | string_list_append(cb, value); |
Samuel Maftoul | 560ae1c | 2018-08-16 11:35:08 +0200 | [diff] [blame] | 88 | return 0; |
| 89 | } |
René Scharfe | e3f1da9 | 2014-10-04 20:54:50 +0200 | [diff] [blame] | 90 | |
Christian Couder | 5955654 | 2013-11-30 21:55:40 +0100 | [diff] [blame] | 91 | if (starts_with(var, "column.")) |
Nguyễn Thái Ngọc Duy | ebe31ef | 2012-04-13 17:54:38 +0700 | [diff] [blame] | 92 | return git_column_config(var, value, "branch", &colopts); |
Andy Parkins | a1158ca | 2006-12-12 06:41:52 +0000 | [diff] [blame] | 93 | if (!strcmp(var, "color.branch")) { |
Jeff King | e269eb7 | 2011-08-17 22:03:48 -0700 | [diff] [blame] | 94 | branch_use_color = git_config_colorbool(var, value); |
Andy Parkins | a1158ca | 2006-12-12 06:41:52 +0000 | [diff] [blame] | 95 | return 0; |
| 96 | } |
René Scharfe | e3f1da9 | 2014-10-04 20:54:50 +0200 | [diff] [blame] | 97 | if (skip_prefix(var, "color.branch.", &slot_name)) { |
Nguyễn Thái Ngọc Duy | a73b368 | 2018-05-26 15:55:21 +0200 | [diff] [blame] | 98 | int slot = LOOKUP_CONFIG(color_branch_slots, slot_name); |
Jeff King | 8b8e862 | 2009-12-12 07:25:24 -0500 | [diff] [blame] | 99 | if (slot < 0) |
| 100 | return 0; |
Junio C Hamano | 5768c98 | 2008-02-11 10:45:50 -0800 | [diff] [blame] | 101 | if (!value) |
| 102 | return config_error_nonbool(var); |
Jeff King | f6c5a29 | 2014-10-07 15:33:09 -0400 | [diff] [blame] | 103 | return color_parse(value, branch_colors[slot]); |
Andy Parkins | a1158ca | 2006-12-12 06:41:52 +0000 | [diff] [blame] | 104 | } |
Glen Choo | 961b130 | 2022-01-28 16:04:45 -0800 | [diff] [blame] | 105 | 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 King | 33c643b | 2017-10-13 13:24:31 -0400 | [diff] [blame] | 114 | return git_color_default_config(var, value, cb); |
Andy Parkins | a1158ca | 2006-12-12 06:41:52 +0000 | [diff] [blame] | 115 | } |
| 116 | |
Pierre Habouzit | 52fae7d | 2007-06-07 22:45:00 +0200 | [diff] [blame] | 117 | static const char *branch_get_color(enum color_branch ix) |
Andy Parkins | a1158ca | 2006-12-12 06:41:52 +0000 | [diff] [blame] | 118 | { |
Jeff King | daa0c3d | 2011-08-17 22:04:23 -0700 | [diff] [blame] | 119 | if (want_color(branch_use_color)) |
Andy Parkins | a1158ca | 2006-12-12 06:41:52 +0000 | [diff] [blame] | 120 | return branch_colors[ix]; |
| 121 | return ""; |
| 122 | } |
| 123 | |
Junio C Hamano | 99c419c | 2009-12-29 22:43:04 -0800 | [diff] [blame] | 124 | static 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 Duy | 96ec7b1 | 2011-12-13 21:17:48 +0700 | [diff] [blame] | 135 | void *reference_name_to_free = NULL; |
Junio C Hamano | 99c419c | 2009-12-29 22:43:04 -0800 | [diff] [blame] | 136 | int merged; |
| 137 | |
Karthik Nayak | 1511b22 | 2015-09-23 23:41:11 +0530 | [diff] [blame] | 138 | if (kind == FILTER_REFS_BRANCHES) { |
Junio C Hamano | 99c419c | 2009-12-29 22:43:04 -0800 | [diff] [blame] | 139 | struct branch *branch = branch_get(name); |
Jeff King | 3a429d0 | 2015-05-21 00:45:32 -0400 | [diff] [blame] | 140 | const char *upstream = branch_get_upstream(branch, NULL); |
brian m. carlson | 0c77cd2 | 2017-02-21 23:47:26 +0000 | [diff] [blame] | 141 | struct object_id oid; |
Junio C Hamano | 99c419c | 2009-12-29 22:43:04 -0800 | [diff] [blame] | 142 | |
Jeff King | a9f9f8c | 2015-05-21 00:45:28 -0400 | [diff] [blame] | 143 | if (upstream && |
Nguyễn Thái Ngọc Duy | 96ec7b1 | 2011-12-13 21:17:48 +0700 | [diff] [blame] | 144 | (reference_name = reference_name_to_free = |
Jeff King | a9f9f8c | 2015-05-21 00:45:28 -0400 | [diff] [blame] | 145 | resolve_refdup(upstream, RESOLVE_REF_READING, |
brian m. carlson | 0f2dc72 | 2017-10-15 22:06:55 +0000 | [diff] [blame] | 146 | &oid, NULL)) != NULL) |
Stefan Beller | 2122f67 | 2018-06-28 18:21:58 -0700 | [diff] [blame] | 147 | reference_rev = lookup_commit_reference(the_repository, |
| 148 | &oid); |
Junio C Hamano | 99c419c | 2009-12-29 22:43:04 -0800 | [diff] [blame] | 149 | } |
| 150 | if (!reference_rev) |
| 151 | reference_rev = head_rev; |
| 152 | |
Junio C Hamano | a20efee | 2012-08-27 14:46:01 -0700 | [diff] [blame] | 153 | merged = in_merge_bases(rev, reference_rev); |
Junio C Hamano | 99c419c | 2009-12-29 22:43:04 -0800 | [diff] [blame] | 154 | |
| 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 Hamano | a20efee | 2012-08-27 14:46:01 -0700 | [diff] [blame] | 163 | in_merge_bases(rev, head_rev) != merged) { |
Junio C Hamano | 99c419c | 2009-12-29 22:43:04 -0800 | [diff] [blame] | 164 | if (merged) |
Ævar Arnfjörð Bjarmason | 49df4b0 | 2011-02-22 23:41:34 +0000 | [diff] [blame] | 165 | warning(_("deleting branch '%s' that has been merged to\n" |
Junio C Hamano | 6c80cd2 | 2011-04-01 17:55:55 -0700 | [diff] [blame] | 166 | " '%s', but not yet merged to HEAD."), |
Junio C Hamano | 99c419c | 2009-12-29 22:43:04 -0800 | [diff] [blame] | 167 | name, reference_name); |
| 168 | else |
Ævar Arnfjörð Bjarmason | 49df4b0 | 2011-02-22 23:41:34 +0000 | [diff] [blame] | 169 | warning(_("not deleting branch '%s' that is not yet merged to\n" |
| 170 | " '%s', even though it is merged to HEAD."), |
Junio C Hamano | 99c419c | 2009-12-29 22:43:04 -0800 | [diff] [blame] | 171 | name, reference_name); |
| 172 | } |
Nguyễn Thái Ngọc Duy | 96ec7b1 | 2011-12-13 21:17:48 +0700 | [diff] [blame] | 173 | free(reference_name_to_free); |
Junio C Hamano | 99c419c | 2009-12-29 22:43:04 -0800 | [diff] [blame] | 174 | return merged; |
| 175 | } |
| 176 | |
René Scharfe | f5d0e16 | 2012-10-18 14:02:51 +0200 | [diff] [blame] | 177 | static int check_branch_commit(const char *branchname, const char *refname, |
brian m. carlson | 0c77cd2 | 2017-02-21 23:47:26 +0000 | [diff] [blame] | 178 | const struct object_id *oid, struct commit *head_rev, |
René Scharfe | f5d0e16 | 2012-10-18 14:02:51 +0200 | [diff] [blame] | 179 | int kinds, int force) |
| 180 | { |
Stefan Beller | 2122f67 | 2018-06-28 18:21:58 -0700 | [diff] [blame] | 181 | struct commit *rev = lookup_commit_reference(the_repository, oid); |
René Scharfe | 597a977 | 2021-08-27 20:35:35 +0200 | [diff] [blame] | 182 | if (!force && !rev) { |
René Scharfe | f5d0e16 | 2012-10-18 14:02:51 +0200 | [diff] [blame] | 183 | 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é Scharfe | 22ed792 | 2012-10-18 14:04:08 +0200 | [diff] [blame] | 195 | static 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 King | d65ddf1 | 2012-03-26 19:51:06 -0400 | [diff] [blame] | 204 | static int delete_branches(int argc, const char **argv, int force, int kinds, |
| 205 | int quiet) |
Lars Hjemli | c31820c | 2006-10-23 23:27:45 +0200 | [diff] [blame] | 206 | { |
René Scharfe | f5d0e16 | 2012-10-18 14:02:51 +0200 | [diff] [blame] | 207 | struct commit *head_rev = NULL; |
brian m. carlson | 0c77cd2 | 2017-02-21 23:47:26 +0000 | [diff] [blame] | 208 | struct object_id oid; |
Quy Tonthat | b8e9a00 | 2006-12-19 09:42:16 +1100 | [diff] [blame] | 209 | char *name = NULL; |
Ævar Arnfjörð Bjarmason | c179837 | 2012-04-30 15:33:12 +0000 | [diff] [blame] | 210 | const char *fmt; |
Lars Hjemli | c31820c | 2006-10-23 23:27:45 +0200 | [diff] [blame] | 211 | int i; |
Quy Tonthat | b8e9a00 | 2006-12-19 09:42:16 +1100 | [diff] [blame] | 212 | int ret = 0; |
Ævar Arnfjörð Bjarmason | c179837 | 2012-04-30 15:33:12 +0000 | [diff] [blame] | 213 | int remote_branch = 0; |
Junio C Hamano | 8415d5c | 2009-02-13 23:08:05 -0800 | [diff] [blame] | 214 | struct strbuf bname = STRBUF_INIT; |
Jeff King | 6b145e0 | 2017-03-02 03:23:10 -0500 | [diff] [blame] | 215 | unsigned allowed_interpret; |
Phil Hord | 8198907 | 2021-01-20 19:23:32 -0800 | [diff] [blame] | 216 | struct string_list refs_to_delete = STRING_LIST_INIT_DUP; |
| 217 | struct string_list_item *item; |
| 218 | int branch_name_pos; |
Lars Hjemli | c31820c | 2006-10-23 23:27:45 +0200 | [diff] [blame] | 219 | |
Junio C Hamano | f3d985c | 2006-12-17 23:58:16 -0800 | [diff] [blame] | 220 | switch (kinds) { |
Karthik Nayak | 1511b22 | 2015-09-23 23:41:11 +0530 | [diff] [blame] | 221 | case FILTER_REFS_REMOTES: |
Junio C Hamano | f3d985c | 2006-12-17 23:58:16 -0800 | [diff] [blame] | 222 | fmt = "refs/remotes/%s"; |
Ævar Arnfjörð Bjarmason | c179837 | 2012-04-30 15:33:12 +0000 | [diff] [blame] | 223 | /* For subsequent UI messages */ |
| 224 | remote_branch = 1; |
Jeff King | 6b145e0 | 2017-03-02 03:23:10 -0500 | [diff] [blame] | 225 | allowed_interpret = INTERPRET_BRANCH_REMOTE; |
Ævar Arnfjörð Bjarmason | c179837 | 2012-04-30 15:33:12 +0000 | [diff] [blame] | 226 | |
Junio C Hamano | f3d985c | 2006-12-17 23:58:16 -0800 | [diff] [blame] | 227 | force = 1; |
| 228 | break; |
Karthik Nayak | 1511b22 | 2015-09-23 23:41:11 +0530 | [diff] [blame] | 229 | case FILTER_REFS_BRANCHES: |
Junio C Hamano | f3d985c | 2006-12-17 23:58:16 -0800 | [diff] [blame] | 230 | fmt = "refs/heads/%s"; |
Jeff King | 6b145e0 | 2017-03-02 03:23:10 -0500 | [diff] [blame] | 231 | allowed_interpret = INTERPRET_BRANCH_LOCAL; |
Junio C Hamano | f3d985c | 2006-12-17 23:58:16 -0800 | [diff] [blame] | 232 | break; |
| 233 | default: |
Ævar Arnfjörð Bjarmason | 49df4b0 | 2011-02-22 23:41:34 +0000 | [diff] [blame] | 234 | die(_("cannot use -a with -d")); |
Junio C Hamano | f3d985c | 2006-12-17 23:58:16 -0800 | [diff] [blame] | 235 | } |
Phil Hord | 8198907 | 2021-01-20 19:23:32 -0800 | [diff] [blame] | 236 | branch_name_pos = strcspn(fmt, "%"); |
Lars Hjemli | c31820c | 2006-10-23 23:27:45 +0200 | [diff] [blame] | 237 | |
Junio C Hamano | 67affd5 | 2006-11-24 23:10:23 -0800 | [diff] [blame] | 238 | if (!force) { |
Stefan Beller | 2122f67 | 2018-06-28 18:21:58 -0700 | [diff] [blame] | 239 | head_rev = lookup_commit_reference(the_repository, &head_oid); |
Junio C Hamano | 67affd5 | 2006-11-24 23:10:23 -0800 | [diff] [blame] | 240 | if (!head_rev) |
Ævar Arnfjörð Bjarmason | 49df4b0 | 2011-02-22 23:41:34 +0000 | [diff] [blame] | 241 | die(_("Couldn't look up commit object for HEAD")); |
Junio C Hamano | 67affd5 | 2006-11-24 23:10:23 -0800 | [diff] [blame] | 242 | } |
Anders Kaseorg | c8dd491 | 2021-12-01 14:15:43 -0800 | [diff] [blame] | 243 | |
Stefan Beller | a9155c5 | 2017-10-03 15:17:40 -0700 | [diff] [blame] | 244 | for (i = 0; i < argc; i++, strbuf_reset(&bname)) { |
Michael Haggerty | 8bb0455 | 2016-04-25 10:42:19 +0200 | [diff] [blame] | 245 | char *target = NULL; |
René Scharfe | 0fe700e | 2012-10-18 14:07:11 +0200 | [diff] [blame] | 246 | int flags = 0; |
| 247 | |
Jeff King | 6b145e0 | 2017-03-02 03:23:10 -0500 | [diff] [blame] | 248 | strbuf_branchname(&bname, argv[i], allowed_interpret); |
Kazuki Yamaguchi | f292244 | 2016-03-29 18:38:39 +0900 | [diff] [blame] | 249 | free(name); |
| 250 | name = mkpathdup(fmt, bname.buf); |
| 251 | |
| 252 | if (kinds == FILTER_REFS_BRANCHES) { |
Derrick Stolee | b489b9d | 2022-06-14 19:27:32 +0000 | [diff] [blame] | 253 | const char *path; |
| 254 | if ((path = branch_checked_out(name))) { |
Kazuki Yamaguchi | f292244 | 2016-03-29 18:38:39 +0900 | [diff] [blame] | 255 | error(_("Cannot delete branch '%s' " |
| 256 | "checked out at '%s'"), |
Derrick Stolee | b489b9d | 2022-06-14 19:27:32 +0000 | [diff] [blame] | 257 | bname.buf, path); |
Kazuki Yamaguchi | f292244 | 2016-03-29 18:38:39 +0900 | [diff] [blame] | 258 | ret = 1; |
| 259 | continue; |
| 260 | } |
Quy Tonthat | b8e9a00 | 2006-12-19 09:42:16 +1100 | [diff] [blame] | 261 | } |
Lars Hjemli | c31820c | 2006-10-23 23:27:45 +0200 | [diff] [blame] | 262 | |
Michael Haggerty | 8bb0455 | 2016-04-25 10:42:19 +0200 | [diff] [blame] | 263 | target = resolve_refdup(name, |
| 264 | RESOLVE_REF_READING |
| 265 | | RESOLVE_REF_NO_RECURSE |
| 266 | | RESOLVE_REF_ALLOW_BAD_NAME, |
brian m. carlson | 0f2dc72 | 2017-10-15 22:06:55 +0000 | [diff] [blame] | 267 | &oid, &flags); |
Ronnie Sahlberg | 18f29fc | 2014-09-11 10:34:36 -0700 | [diff] [blame] | 268 | if (!target) { |
Ævar Arnfjörð Bjarmason | c179837 | 2012-04-30 15:33:12 +0000 | [diff] [blame] | 269 | error(remote_branch |
Danny Lin | ccd593c | 2015-05-07 03:01:55 +0800 | [diff] [blame] | 270 | ? _("remote-tracking branch '%s' not found.") |
Ævar Arnfjörð Bjarmason | c179837 | 2012-04-30 15:33:12 +0000 | [diff] [blame] | 271 | : _("branch '%s' not found."), bname.buf); |
Quy Tonthat | b8e9a00 | 2006-12-19 09:42:16 +1100 | [diff] [blame] | 272 | ret = 1; |
| 273 | continue; |
| 274 | } |
Lars Hjemli | c31820c | 2006-10-23 23:27:45 +0200 | [diff] [blame] | 275 | |
Ronnie Sahlberg | d0f810f | 2014-09-03 11:45:43 -0700 | [diff] [blame] | 276 | if (!(flags & (REF_ISSYMREF|REF_ISBROKEN)) && |
brian m. carlson | 0c77cd2 | 2017-02-21 23:47:26 +0000 | [diff] [blame] | 277 | check_branch_commit(bname.buf, name, &oid, head_rev, kinds, |
René Scharfe | f5d0e16 | 2012-10-18 14:02:51 +0200 | [diff] [blame] | 278 | force)) { |
Quy Tonthat | b8e9a00 | 2006-12-19 09:42:16 +1100 | [diff] [blame] | 279 | ret = 1; |
Michael Haggerty | 8bb0455 | 2016-04-25 10:42:19 +0200 | [diff] [blame] | 280 | goto next; |
Lars Hjemli | c31820c | 2006-10-23 23:27:45 +0200 | [diff] [blame] | 281 | } |
| 282 | |
Phil Hord | 8198907 | 2021-01-20 19:23:32 -0800 | [diff] [blame] | 283 | 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 Haggerty | 8bb0455 | 2016-04-25 10:42:19 +0200 | [diff] [blame] | 287 | |
| 288 | next: |
| 289 | free(target); |
Lars Hjemli | c31820c | 2006-10-23 23:27:45 +0200 | [diff] [blame] | 290 | } |
Lars Hjemli | c31820c | 2006-10-23 23:27:45 +0200 | [diff] [blame] | 291 | |
Phil Hord | 8198907 | 2021-01-20 19:23:32 -0800 | [diff] [blame] | 292 | 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 Meyering | 8e0f700 | 2008-01-31 18:26:32 +0100 | [diff] [blame] | 312 | free(name); |
Stefan Beller | a9155c5 | 2017-10-03 15:17:40 -0700 | [diff] [blame] | 313 | strbuf_release(&bname); |
Quy Tonthat | b8e9a00 | 2006-12-19 09:42:16 +1100 | [diff] [blame] | 314 | |
Stefan Beller | a9155c5 | 2017-10-03 15:17:40 -0700 | [diff] [blame] | 315 | return ret; |
Lars Hjemli | c31820c | 2006-10-23 23:27:45 +0200 | [diff] [blame] | 316 | } |
Lars Hjemli | c31820c | 2006-10-23 23:27:45 +0200 | [diff] [blame] | 317 | |
Karthik Nayak | 1511b22 | 2015-09-23 23:41:11 +0530 | [diff] [blame] | 318 | static int calc_maxwidth(struct ref_array *refs, int remote_bonus) |
Lars Hjemli | b6f637d | 2008-07-26 12:27:25 +0200 | [diff] [blame] | 319 | { |
Karthik Nayak | 1051e40 | 2015-09-23 23:41:06 +0530 | [diff] [blame] | 320 | int i, max = 0; |
Karthik Nayak | 1511b22 | 2015-09-23 23:41:11 +0530 | [diff] [blame] | 321 | for (i = 0; i < refs->nr; i++) { |
| 322 | struct ref_array_item *it = refs->items[i]; |
Karthik Nayak | aedcb7d | 2015-09-23 23:41:12 +0530 | [diff] [blame] | 323 | const char *desc = it->refname; |
Karthik Nayak | 1051e40 | 2015-09-23 23:41:06 +0530 | [diff] [blame] | 324 | int w; |
| 325 | |
Karthik Nayak | aedcb7d | 2015-09-23 23:41:12 +0530 | [diff] [blame] | 326 | skip_prefix(it->refname, "refs/heads/", &desc); |
| 327 | skip_prefix(it->refname, "refs/remotes/", &desc); |
Karthik Nayak | 949af06 | 2017-01-10 14:19:52 +0530 | [diff] [blame] | 328 | 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 Nayak | aedcb7d | 2015-09-23 23:41:12 +0530 | [diff] [blame] | 334 | |
Karthik Nayak | 1511b22 | 2015-09-23 23:41:11 +0530 | [diff] [blame] | 335 | if (it->kind == FILTER_REFS_REMOTES) |
Karthik Nayak | 1051e40 | 2015-09-23 23:41:06 +0530 | [diff] [blame] | 336 | w += remote_bonus; |
| 337 | if (w > max) |
| 338 | max = w; |
Lars Hjemli | b6f637d | 2008-07-26 12:27:25 +0200 | [diff] [blame] | 339 | } |
Karthik Nayak | 1051e40 | 2015-09-23 23:41:06 +0530 | [diff] [blame] | 340 | return max; |
Lars Hjemli | b6f637d | 2008-07-26 12:27:25 +0200 | [diff] [blame] | 341 | } |
| 342 | |
Karthik Nayak | 949af06 | 2017-01-10 14:19:52 +0530 | [diff] [blame] | 343 | static 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 | |
| 362 | static 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 Belakovski | ab31381 | 2019-04-28 22:19:43 -0700 | [diff] [blame] | 368 | 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 King | 7ca260a | 2017-07-09 06:00:45 -0400 | [diff] [blame] | 372 | strbuf_addf(&remote, " %s", |
| 373 | branch_get_color(BRANCH_COLOR_REMOTE)); |
Karthik Nayak | 949af06 | 2017-01-10 14:19:52 +0530 | [diff] [blame] | 374 | |
| 375 | if (filter->verbose) { |
Junio C Hamano | ac5bbc0 | 2017-03-08 14:13:09 -0800 | [diff] [blame] | 376 | 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 Nayak | 949af06 | 2017-01-10 14:19:52 +0530 | [diff] [blame] | 385 | strbuf_addf(&local, "%%(align:%d,left)%%(refname:lstrip=2)%%(end)", maxwidth); |
René Scharfe | 72d4a9a | 2017-10-01 16:44:20 +0200 | [diff] [blame] | 386 | strbuf_addstr(&local, branch_get_color(BRANCH_COLOR_RESET)); |
Junio C Hamano | ac5bbc0 | 2017-03-08 14:13:09 -0800 | [diff] [blame] | 387 | strbuf_addf(&local, " %s ", obname.buf); |
Karthik Nayak | 949af06 | 2017-01-10 14:19:52 +0530 | [diff] [blame] | 388 | |
| 389 | if (filter->verbose > 1) |
Nickolai Belakovski | 6e93814 | 2019-04-28 22:19:44 -0700 | [diff] [blame] | 390 | { |
| 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 Nayak | 949af06 | 2017-01-10 14:19:52 +0530 | [diff] [blame] | 393 | 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 Belakovski | 6e93814 | 2019-04-28 22:19:44 -0700 | [diff] [blame] | 396 | } |
Karthik Nayak | 949af06 | 2017-01-10 14:19:52 +0530 | [diff] [blame] | 397 | else |
| 398 | strbuf_addf(&local, "%%(if)%%(upstream:track)%%(then)%%(upstream:track) %%(end)%%(contents:subject)"); |
| 399 | |
Jeff King | 7ca260a | 2017-07-09 06:00:45 -0400 | [diff] [blame] | 400 | strbuf_addf(&remote, "%%(align:%d,left)%s%%(refname:lstrip=2)%%(end)%s" |
Junio C Hamano | ac5bbc0 | 2017-03-08 14:13:09 -0800 | [diff] [blame] | 401 | "%%(if)%%(symref)%%(then) -> %%(symref:short)" |
| 402 | "%%(else) %s %%(contents:subject)%%(end)", |
Jeff King | 7ca260a | 2017-07-09 06:00:45 -0400 | [diff] [blame] | 403 | maxwidth, quote_literal_for_format(remote_prefix), |
Junio C Hamano | ac5bbc0 | 2017-03-08 14:13:09 -0800 | [diff] [blame] | 404 | branch_get_color(BRANCH_COLOR_RESET), obname.buf); |
| 405 | strbuf_release(&obname); |
Karthik Nayak | 949af06 | 2017-01-10 14:19:52 +0530 | [diff] [blame] | 406 | } else { |
| 407 | strbuf_addf(&local, "%%(refname:lstrip=2)%s%%(if)%%(symref)%%(then) -> %%(symref:short)%%(end)", |
| 408 | branch_get_color(BRANCH_COLOR_RESET)); |
Jeff King | 7ca260a | 2017-07-09 06:00:45 -0400 | [diff] [blame] | 409 | strbuf_addf(&remote, "%s%%(refname:lstrip=2)%s%%(if)%%(symref)%%(then) -> %%(symref:short)%%(end)", |
| 410 | quote_literal_for_format(remote_prefix), |
Karthik Nayak | 949af06 | 2017-01-10 14:19:52 +0530 | [diff] [blame] | 411 | 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ð Bjarmason | d72d4f9 | 2021-10-20 20:27:21 +0200 | [diff] [blame] | 421 | static void print_ref_list(struct ref_filter *filter, struct ref_sorting *sorting, |
| 422 | struct ref_format *format, struct string_list *output) |
Lars Hjemli | c31820c | 2006-10-23 23:27:45 +0200 | [diff] [blame] | 423 | { |
| 424 | int i; |
Karthik Nayak | 1511b22 | 2015-09-23 23:41:11 +0530 | [diff] [blame] | 425 | struct ref_array array; |
ZheNing Hu | 844c3f0 | 2021-04-20 16:52:11 +0000 | [diff] [blame] | 426 | struct strbuf out = STRBUF_INIT; |
| 427 | struct strbuf err = STRBUF_INIT; |
Karthik Nayak | 1051e40 | 2015-09-23 23:41:06 +0530 | [diff] [blame] | 428 | int maxwidth = 0; |
| 429 | const char *remote_prefix = ""; |
Karthik Nayak | 3d9e4ce | 2017-01-10 14:19:53 +0530 | [diff] [blame] | 430 | char *to_free = NULL; |
Lars Hjemli | c31820c | 2006-10-23 23:27:45 +0200 | [diff] [blame] | 431 | |
Karthik Nayak | 35257aa | 2015-07-07 21:36:12 +0530 | [diff] [blame] | 432 | /* |
Karthik Nayak | 1051e40 | 2015-09-23 23:41:06 +0530 | [diff] [blame] | 433 | * 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 Nayak | 35257aa | 2015-07-07 21:36:12 +0530 | [diff] [blame] | 436 | */ |
Karthik Nayak | 1511b22 | 2015-09-23 23:41:11 +0530 | [diff] [blame] | 437 | if (filter->kind != FILTER_REFS_REMOTES) |
Karthik Nayak | 1051e40 | 2015-09-23 23:41:06 +0530 | [diff] [blame] | 438 | remote_prefix = "remotes/"; |
Carlos Martín Nieto | 6c41e97 | 2012-02-27 16:11:53 +0100 | [diff] [blame] | 439 | |
Karthik Nayak | 1511b22 | 2015-09-23 23:41:11 +0530 | [diff] [blame] | 440 | memset(&array, 0, sizeof(array)); |
Stefan Beller | 81c3ce3 | 2014-08-10 23:33:26 +0200 | [diff] [blame] | 441 | |
Jeff King | 1763334 | 2021-09-24 14:48:05 -0400 | [diff] [blame] | 442 | filter_refs(&array, filter, filter->kind); |
Jeff King | 8376a70 | 2014-09-18 06:49:43 -0400 | [diff] [blame] | 443 | |
Karthik Nayak | 1511b22 | 2015-09-23 23:41:11 +0530 | [diff] [blame] | 444 | if (filter->verbose) |
| 445 | maxwidth = calc_maxwidth(&array, strlen(remote_prefix)); |
Jeff King | 8376a70 | 2014-09-18 06:49:43 -0400 | [diff] [blame] | 446 | |
Jeff King | 4a68e36 | 2017-07-13 11:01:18 -0400 | [diff] [blame] | 447 | if (!format->format) |
| 448 | format->format = to_free = build_format(filter, maxwidth, remote_prefix); |
Jeff King | 11b087a | 2017-07-13 11:09:32 -0400 | [diff] [blame] | 449 | format->use_color = branch_use_color; |
Jeff King | 2eda010 | 2017-07-13 10:56:10 -0400 | [diff] [blame] | 450 | |
| 451 | if (verify_ref_format(format)) |
| 452 | die(_("unable to parse format string")); |
Karthik Nayak | 949af06 | 2017-01-10 14:19:52 +0530 | [diff] [blame] | 453 | |
Karthik Nayak | aedcb7d | 2015-09-23 23:41:12 +0530 | [diff] [blame] | 454 | ref_array_sort(sorting, &array); |
Jeff King | 8376a70 | 2014-09-18 06:49:43 -0400 | [diff] [blame] | 455 | |
Karthik Nayak | 949af06 | 2017-01-10 14:19:52 +0530 | [diff] [blame] | 456 | for (i = 0; i < array.nr; i++) { |
ZheNing Hu | 844c3f0 | 2021-04-20 16:52:11 +0000 | [diff] [blame] | 457 | strbuf_reset(&err); |
| 458 | strbuf_reset(&out); |
Olga Telezhnaya | 3019eca | 2018-03-29 12:49:45 +0000 | [diff] [blame] | 459 | if (format_ref_array_item(array.items[i], format, &out, &err)) |
| 460 | die("%s", err.buf); |
Karthik Nayak | 949af06 | 2017-01-10 14:19:52 +0530 | [diff] [blame] | 461 | 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ð Bjarmason | d72d4f9 | 2021-10-20 20:27:21 +0200 | [diff] [blame] | 464 | string_list_append(output, out.buf); |
Karthik Nayak | 949af06 | 2017-01-10 14:19:52 +0530 | [diff] [blame] | 465 | } else { |
| 466 | fwrite(out.buf, 1, out.len, stdout); |
| 467 | putchar('\n'); |
| 468 | } |
Karthik Nayak | 949af06 | 2017-01-10 14:19:52 +0530 | [diff] [blame] | 469 | } |
Lars Hjemli | c31820c | 2006-10-23 23:27:45 +0200 | [diff] [blame] | 470 | |
ZheNing Hu | 844c3f0 | 2021-04-20 16:52:11 +0000 | [diff] [blame] | 471 | strbuf_release(&err); |
| 472 | strbuf_release(&out); |
Karthik Nayak | 1511b22 | 2015-09-23 23:41:11 +0530 | [diff] [blame] | 473 | ref_array_clear(&array); |
Karthik Nayak | 3d9e4ce | 2017-01-10 14:19:53 +0530 | [diff] [blame] | 474 | free(to_free); |
Lars Hjemli | c31820c | 2006-10-23 23:27:45 +0200 | [diff] [blame] | 475 | } |
| 476 | |
Daniels Umanovskis | 0ecb1fc | 2018-10-25 21:04:21 +0200 | [diff] [blame] | 477 | static 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 Duy | 14ace5b | 2016-04-22 20:01:36 +0700 | [diff] [blame] | 492 | static void reject_rebase_or_bisect_branch(const char *target) |
| 493 | { |
Eric Sunshine | 03f2465 | 2020-06-19 19:35:44 -0400 | [diff] [blame] | 494 | struct worktree **worktrees = get_worktrees(); |
Nguyễn Thái Ngọc Duy | 14ace5b | 2016-04-22 20:01:36 +0700 | [diff] [blame] | 495 | 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 Dua | 52d59cc | 2017-06-18 23:19:16 +0200 | [diff] [blame] | 515 | static void copy_or_rename_branch(const char *oldname, const char *newname, int copy, int force) |
Lars Hjemli | c976d41 | 2006-11-28 15:47:40 +0100 | [diff] [blame] | 516 | { |
Miklos Vajna | da3f78a | 2008-11-17 21:48:37 +0100 | [diff] [blame] | 517 | struct strbuf oldref = STRBUF_INIT, newref = STRBUF_INIT, logmsg = STRBUF_INIT; |
Miklos Vajna | da3f78a | 2008-11-17 21:48:37 +0100 | [diff] [blame] | 518 | struct strbuf oldsection = STRBUF_INIT, newsection = STRBUF_INIT; |
Kaartic Sivaraam | 255073c | 2017-12-01 11:29:33 +0530 | [diff] [blame] | 519 | const char *interpreted_oldname = NULL; |
| 520 | const char *interpreted_newname = NULL; |
Junio C Hamano | cbdffe4 | 2009-03-21 13:27:31 -0700 | [diff] [blame] | 521 | int recovery = 0; |
Lars Hjemli | c976d41 | 2006-11-28 15:47:40 +0100 | [diff] [blame] | 522 | |
Sahil Dua | 52d59cc | 2017-06-18 23:19:16 +0200 | [diff] [blame] | 523 | 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 Hamano | c847f53 | 2007-01-01 23:31:08 -0800 | [diff] [blame] | 529 | |
Junio C Hamano | cbdffe4 | 2009-03-21 13:27:31 -0700 | [diff] [blame] | 530 | 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 Duy | c689332 | 2011-11-13 17:22:14 +0700 | [diff] [blame] | 535 | if (ref_exists(oldref.buf)) |
Junio C Hamano | cbdffe4 | 2009-03-21 13:27:31 -0700 | [diff] [blame] | 536 | recovery = 1; |
| 537 | else |
Ævar Arnfjörð Bjarmason | 49df4b0 | 2011-02-22 23:41:34 +0000 | [diff] [blame] | 538 | die(_("Invalid branch name: '%s'"), oldname); |
Junio C Hamano | cbdffe4 | 2009-03-21 13:27:31 -0700 | [diff] [blame] | 539 | } |
Lars Hjemli | c976d41 | 2006-11-28 15:47:40 +0100 | [diff] [blame] | 540 | |
Jonathan Nieder | 3f59481 | 2011-11-25 20:30:02 -0600 | [diff] [blame] | 541 | /* |
| 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 Hamano | bc1c9c0 | 2017-10-13 13:45:40 +0900 | [diff] [blame] | 545 | if (!strcmp(oldname, newname)) |
| 546 | validate_branchname(newname, &newref); |
| 547 | else |
| 548 | validate_new_branchname(newname, &newref, force); |
Lars Hjemli | c976d41 | 2006-11-28 15:47:40 +0100 | [diff] [blame] | 549 | |
Nguyễn Thái Ngọc Duy | 14ace5b | 2016-04-22 20:01:36 +0700 | [diff] [blame] | 550 | reject_rebase_or_bisect_branch(oldref.buf); |
| 551 | |
Kaartic Sivaraam | 255073c | 2017-12-01 11:29:33 +0530 | [diff] [blame] | 552 | if (!skip_prefix(oldref.buf, "refs/heads/", &interpreted_oldname) || |
| 553 | !skip_prefix(newref.buf, "refs/heads/", &interpreted_newname)) { |
Johannes Schindelin | 033abf9 | 2018-05-02 11:38:39 +0200 | [diff] [blame] | 554 | BUG("expected prefix missing for refs"); |
Kaartic Sivaraam | 255073c | 2017-12-01 11:29:33 +0530 | [diff] [blame] | 555 | } |
| 556 | |
Sahil Dua | 52d59cc | 2017-06-18 23:19:16 +0200 | [diff] [blame] | 557 | 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 Hjemli | 678d0f4 | 2006-11-30 03:16:56 +0100 | [diff] [blame] | 563 | |
Johannes Schindelin | cfaff3a | 2020-12-11 11:36:55 +0000 | [diff] [blame] | 564 | if (!copy && |
| 565 | (!head || strcmp(oldname, head) || !is_null_oid(&head_oid)) && |
| 566 | rename_ref(oldref.buf, newref.buf, logmsg.buf)) |
Ævar Arnfjörð Bjarmason | 49df4b0 | 2011-02-22 23:41:34 +0000 | [diff] [blame] | 567 | die(_("Branch rename failed")); |
Sahil Dua | 52d59cc | 2017-06-18 23:19:16 +0200 | [diff] [blame] | 568 | if (copy && copy_existing_ref(oldref.buf, newref.buf, logmsg.buf)) |
| 569 | die(_("Branch copy failed")); |
Lars Hjemli | c976d41 | 2006-11-28 15:47:40 +0100 | [diff] [blame] | 570 | |
Sahil Dua | 52d59cc | 2017-06-18 23:19:16 +0200 | [diff] [blame] | 571 | if (recovery) { |
| 572 | if (copy) |
Kaartic Sivaraam | a48ebe9 | 2017-11-18 22:56:47 +0530 | [diff] [blame] | 573 | warning(_("Created a copy of a misnamed branch '%s'"), |
Kaartic Sivaraam | 255073c | 2017-12-01 11:29:33 +0530 | [diff] [blame] | 574 | interpreted_oldname); |
Sahil Dua | 52d59cc | 2017-06-18 23:19:16 +0200 | [diff] [blame] | 575 | else |
| 576 | warning(_("Renamed a misnamed branch '%s' away"), |
Kaartic Sivaraam | 255073c | 2017-12-01 11:29:33 +0530 | [diff] [blame] | 577 | interpreted_oldname); |
Sahil Dua | 52d59cc | 2017-06-18 23:19:16 +0200 | [diff] [blame] | 578 | } |
Junio C Hamano | cbdffe4 | 2009-03-21 13:27:31 -0700 | [diff] [blame] | 579 | |
Junio C Hamano | e5435ff | 2017-09-22 12:24:50 +0900 | [diff] [blame] | 580 | if (!copy && |
| 581 | replace_each_worktree_head_symref(oldref.buf, newref.buf, logmsg.buf)) |
Ævar Arnfjörð Bjarmason | 49df4b0 | 2011-02-22 23:41:34 +0000 | [diff] [blame] | 582 | die(_("Branch renamed to %s, but HEAD is not updated!"), newname); |
Lars Hjemli | 19eba15 | 2007-04-06 14:13:00 +0200 | [diff] [blame] | 583 | |
Kyle Meyer | 39ee4c6 | 2017-02-20 20:10:35 -0500 | [diff] [blame] | 584 | strbuf_release(&logmsg); |
| 585 | |
Kaartic Sivaraam | 255073c | 2017-12-01 11:29:33 +0530 | [diff] [blame] | 586 | strbuf_addf(&oldsection, "branch.%s", interpreted_oldname); |
Miklos Vajna | da3f78a | 2008-11-17 21:48:37 +0100 | [diff] [blame] | 587 | strbuf_release(&oldref); |
Kaartic Sivaraam | 255073c | 2017-12-01 11:29:33 +0530 | [diff] [blame] | 588 | strbuf_addf(&newsection, "branch.%s", interpreted_newname); |
Miklos Vajna | da3f78a | 2008-11-17 21:48:37 +0100 | [diff] [blame] | 589 | strbuf_release(&newref); |
Sahil Dua | 52d59cc | 2017-06-18 23:19:16 +0200 | [diff] [blame] | 590 | if (!copy && git_config_rename_section(oldsection.buf, newsection.buf) < 0) |
Ævar Arnfjörð Bjarmason | 49df4b0 | 2011-02-22 23:41:34 +0000 | [diff] [blame] | 591 | die(_("Branch is renamed, but update of config-file failed")); |
Sahil Dua | 52d59cc | 2017-06-18 23:19:16 +0200 | [diff] [blame] | 592 | 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 Vajna | da3f78a | 2008-11-17 21:48:37 +0100 | [diff] [blame] | 594 | strbuf_release(&oldsection); |
| 595 | strbuf_release(&newsection); |
Lars Hjemli | c976d41 | 2006-11-28 15:47:40 +0100 | [diff] [blame] | 596 | } |
| 597 | |
Jeff King | c10388c | 2017-04-20 17:08:41 -0400 | [diff] [blame] | 598 | static GIT_PATH_FUNC(edit_description, "EDIT_DESCRIPTION") |
Junio C Hamano | b7200e8 | 2011-09-20 15:10:08 -0700 | [diff] [blame] | 599 | |
| 600 | static int edit_branch_description(const char *branch_name) |
| 601 | { |
Junio C Hamano | b7200e8 | 2011-09-20 15:10:08 -0700 | [diff] [blame] | 602 | 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 Hamano | eff80a9 | 2013-01-16 20:18:48 +0100 | [diff] [blame] | 608 | strbuf_commented_addf(&buf, |
Vasco Almeida | b18237f | 2016-06-17 21:54:15 +0000 | [diff] [blame] | 609 | _("Please edit the description for the branch\n" |
| 610 | " %s\n" |
| 611 | "Lines starting with '%c' will be stripped.\n"), |
Junio C Hamano | eff80a9 | 2013-01-16 20:18:48 +0100 | [diff] [blame] | 612 | branch_name, comment_line_char); |
Jeff King | c10388c | 2017-04-20 17:08:41 -0400 | [diff] [blame] | 613 | write_file_buf(edit_description(), buf.buf, buf.len); |
Junio C Hamano | b7200e8 | 2011-09-20 15:10:08 -0700 | [diff] [blame] | 614 | strbuf_reset(&buf); |
Jeff King | c10388c | 2017-04-20 17:08:41 -0400 | [diff] [blame] | 615 | if (launch_editor(edit_description(), &buf, NULL)) { |
Junio C Hamano | b7200e8 | 2011-09-20 15:10:08 -0700 | [diff] [blame] | 616 | strbuf_release(&buf); |
| 617 | return -1; |
| 618 | } |
Tobias Klauser | 63af4a8 | 2015-10-16 17:16:42 +0200 | [diff] [blame] | 619 | strbuf_stripspace(&buf, 1); |
Junio C Hamano | b7200e8 | 2011-09-20 15:10:08 -0700 | [diff] [blame] | 620 | |
| 621 | strbuf_addf(&name, "branch.%s.description", branch_name); |
Patrick Steinhardt | 3d18064 | 2016-02-22 12:23:36 +0100 | [diff] [blame] | 622 | git_config_set(name.buf, buf.len ? buf.buf : NULL); |
Junio C Hamano | b7200e8 | 2011-09-20 15:10:08 -0700 | [diff] [blame] | 623 | strbuf_release(&name); |
| 624 | strbuf_release(&buf); |
| 625 | |
Patrick Steinhardt | bd25f89 | 2016-02-22 12:23:25 +0100 | [diff] [blame] | 626 | return 0; |
Junio C Hamano | b7200e8 | 2011-09-20 15:10:08 -0700 | [diff] [blame] | 627 | } |
| 628 | |
Lars Hjemli | c31820c | 2006-10-23 23:27:45 +0200 | [diff] [blame] | 629 | int cmd_branch(int argc, const char **argv, const char *prefix) |
| 630 | { |
Glen Choo | 6e0a2ca | 2022-01-28 16:04:44 -0800 | [diff] [blame] | 631 | /* 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 Nieto | 6183d82 | 2012-08-20 15:47:38 +0200 | [diff] [blame] | 634 | const char *new_upstream = NULL; |
Glen Choo | 6e0a2ca | 2022-01-28 16:04:44 -0800 | [diff] [blame] | 635 | int noncreate_actions = 0; |
| 636 | /* possible options */ |
Glen Choo | 961b130 | 2022-01-28 16:04:45 -0800 | [diff] [blame] | 637 | int reflog = 0, quiet = 0, icase = 0, force = 0, |
| 638 | recurse_submodules_explicit = 0; |
Jay Soffian | 9ed36cf | 2008-02-19 11:24:37 -0500 | [diff] [blame] | 639 | enum branch_track track; |
Karthik Nayak | 1511b22 | 2015-09-23 23:41:11 +0530 | [diff] [blame] | 640 | struct ref_filter filter; |
Junio C Hamano | 98e7ab6 | 2021-10-20 12:23:53 -0700 | [diff] [blame] | 641 | static struct ref_sorting *sorting; |
| 642 | struct string_list sorting_options = STRING_LIST_INIT_DUP; |
Jeff King | 4a68e36 | 2017-07-13 11:01:18 -0400 | [diff] [blame] | 643 | struct ref_format format = REF_FORMAT_INIT; |
Pierre Habouzit | a8dfd5e | 2007-10-07 18:26:21 +0200 | [diff] [blame] | 644 | |
| 645 | struct option options[] = { |
Nguyễn Thái Ngọc Duy | 24a8521 | 2012-08-20 19:31:55 +0700 | [diff] [blame] | 646 | OPT_GROUP(N_("Generic options")), |
Karthik Nayak | 1511b22 | 2015-09-23 23:41:11 +0530 | [diff] [blame] | 647 | OPT__VERBOSE(&filter.verbose, |
Nguyễn Thái Ngọc Duy | 24a8521 | 2012-08-20 19:31:55 +0700 | [diff] [blame] | 648 | N_("show hash and subject, give twice for upstream branch")), |
| 649 | OPT__QUIET(&quiet, N_("suppress informational messages")), |
René Scharfe | 6327f0e | 2022-01-20 13:35:54 +0100 | [diff] [blame] | 650 | OPT_CALLBACK_F('t', "track", &track, "(direct|inherit)", |
Josh Steadmon | d311566 | 2021-12-20 19:30:23 -0800 | [diff] [blame] | 651 | N_("set branch tracking configuration"), |
Josh Steadmon | 15f0028 | 2022-01-18 12:49:46 -0800 | [diff] [blame] | 652 | PARSE_OPT_OPTARG, |
Josh Steadmon | d311566 | 2021-12-20 19:30:23 -0800 | [diff] [blame] | 653 | parse_opt_tracking_mode), |
Nguyễn Thái Ngọc Duy | 3e4a67b | 2018-05-20 17:42:58 +0200 | [diff] [blame] | 654 | OPT_SET_INT_F(0, "set-upstream", &track, N_("do not use"), |
| 655 | BRANCH_TRACK_OVERRIDE, PARSE_OPT_HIDDEN), |
Vasco Almeida | ab86885 | 2016-04-08 20:02:45 +0000 | [diff] [blame] | 656 | OPT_STRING('u', "set-upstream-to", &new_upstream, N_("upstream"), N_("change the upstream info")), |
Dimitriy Ryazantcev | 11de8dd | 2019-12-08 11:26:47 +0200 | [diff] [blame] | 657 | OPT_BOOL(0, "unset-upstream", &unset_upstream, N_("unset the upstream info")), |
Nguyễn Thái Ngọc Duy | 24a8521 | 2012-08-20 19:31:55 +0700 | [diff] [blame] | 658 | OPT__COLOR(&branch_use_color, N_("use colored output")), |
Karthik Nayak | 1511b22 | 2015-09-23 23:41:11 +0530 | [diff] [blame] | 659 | 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ð Bjarmason | ac3f5a3 | 2017-03-24 18:40:57 +0000 | [diff] [blame] | 662 | OPT_NO_CONTAINS(&filter.no_commit, N_("print only branches that don't contain the commit")), |
Karthik Nayak | 1511b22 | 2015-09-23 23:41:11 +0530 | [diff] [blame] | 663 | OPT_WITH(&filter.with_commit, N_("print only branches that contain the commit")), |
Ævar Arnfjörð Bjarmason | ac3f5a3 | 2017-03-24 18:40:57 +0000 | [diff] [blame] | 664 | OPT_WITHOUT(&filter.no_commit, N_("print only branches that don't contain the commit")), |
Karthik Nayak | 1511b22 | 2015-09-23 23:41:11 +0530 | [diff] [blame] | 665 | OPT__ABBREV(&filter.abbrev), |
Pierre Habouzit | a8dfd5e | 2007-10-07 18:26:21 +0200 | [diff] [blame] | 666 | |
Nguyễn Thái Ngọc Duy | 24a8521 | 2012-08-20 19:31:55 +0700 | [diff] [blame] | 667 | OPT_GROUP(N_("Specific git-branch actions:")), |
Karthik Nayak | 1511b22 | 2015-09-23 23:41:11 +0530 | [diff] [blame] | 668 | 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 Duy | 24a8521 | 2012-08-20 19:31:55 +0700 | [diff] [blame] | 670 | 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 Dua | 52d59cc | 2017-06-18 23:19:16 +0200 | [diff] [blame] | 674 | OPT_BIT('c', "copy", ©, N_("copy a branch and its reflog"), 1), |
| 675 | OPT_BIT('C', NULL, ©, N_("copy a branch, even if target exists"), 2), |
Jeff King | a15d598 | 2018-06-22 05:24:59 -0400 | [diff] [blame] | 676 | OPT_BOOL('l', "list", &list, N_("list branch names")), |
Daniels Umanovskis | 0ecb1fc | 2018-10-25 21:04:21 +0200 | [diff] [blame] | 677 | OPT_BOOL(0, "show-current", &show_current, N_("show current branch name")), |
Jeff King | 055930b | 2018-06-22 05:24:14 -0400 | [diff] [blame] | 678 | OPT_BOOL(0, "create-reflog", &reflog, N_("create the branch's reflog")), |
Stefan Beller | d5d09d4 | 2013-08-03 13:51:19 +0200 | [diff] [blame] | 679 | OPT_BOOL(0, "edit-description", &edit_description, |
| 680 | N_("edit the description for the branch")), |
Nguyễn Thái Ngọc Duy | c01b56a | 2018-02-09 18:01:47 +0700 | [diff] [blame] | 681 | OPT__FORCE(&force, N_("force creation, move/rename, deletion"), PARSE_OPT_NOCOMPLETE), |
Karthik Nayak | 1511b22 | 2015-09-23 23:41:11 +0530 | [diff] [blame] | 682 | 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 Duy | 24a8521 | 2012-08-20 19:31:55 +0700 | [diff] [blame] | 684 | OPT_COLUMN(0, "column", &colopts, N_("list branches in columns")), |
Junio C Hamano | 98e7ab6 | 2021-10-20 12:23:53 -0700 | [diff] [blame] | 685 | OPT_REF_SORT(&sorting_options), |
Denton Liu | 203c853 | 2020-04-28 04:36:28 -0400 | [diff] [blame] | 686 | 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 Duy | 3bb16a8 | 2016-12-04 09:52:25 +0700 | [diff] [blame] | 688 | OPT_BOOL('i', "ignore-case", &icase, N_("sorting and filtering are case insensitive")), |
Glen Choo | 961b130 | 2022-01-28 16:04:45 -0800 | [diff] [blame] | 689 | OPT_BOOL(0, "recurse-submodules", &recurse_submodules_explicit, N_("recurse through submodules")), |
Jeff King | 4a68e36 | 2017-07-13 11:01:18 -0400 | [diff] [blame] | 690 | OPT_STRING( 0 , "format", &format.format, N_("format"), N_("format to use for the output")), |
Pierre Habouzit | a8dfd5e | 2007-10-07 18:26:21 +0200 | [diff] [blame] | 691 | OPT_END(), |
| 692 | }; |
Lars Hjemli | c31820c | 2006-10-23 23:27:45 +0200 | [diff] [blame] | 693 | |
Karthik Nayak | 56b4360 | 2017-01-10 14:19:51 +0530 | [diff] [blame] | 694 | setup_ref_filter_porcelain_msg(); |
| 695 | |
Karthik Nayak | 1511b22 | 2015-09-23 23:41:11 +0530 | [diff] [blame] | 696 | memset(&filter, 0, sizeof(filter)); |
| 697 | filter.kind = FILTER_REFS_BRANCHES; |
| 698 | filter.abbrev = -1; |
| 699 | |
Nguyễn Thái Ngọc Duy | 1dacfbc | 2010-10-22 01:42:58 -0500 | [diff] [blame] | 700 | if (argc == 2 && !strcmp(argv[1], "-h")) |
| 701 | usage_with_options(builtin_branch_usage, options); |
| 702 | |
Junio C Hamano | 98e7ab6 | 2021-10-20 12:23:53 -0700 | [diff] [blame] | 703 | git_config(git_branch_config, &sorting_options); |
Matthias Kestenholz | 6b2f2d9 | 2008-02-18 08:26:03 +0100 | [diff] [blame] | 704 | |
Jay Soffian | 9ed36cf | 2008-02-19 11:24:37 -0500 | [diff] [blame] | 705 | track = git_branch_track; |
Lars Hjemli | c976d41 | 2006-11-28 15:47:40 +0100 | [diff] [blame] | 706 | |
brian m. carlson | 0f2dc72 | 2017-10-15 22:06:55 +0000 | [diff] [blame] | 707 | head = resolve_refdup("HEAD", 0, &head_oid, NULL); |
Lars Hjemli | c31820c | 2006-10-23 23:27:45 +0200 | [diff] [blame] | 708 | if (!head) |
Ævar Arnfjörð Bjarmason | 49df4b0 | 2011-02-22 23:41:34 +0000 | [diff] [blame] | 709 | die(_("Failed to resolve HEAD as a valid ref.")); |
René Scharfe | e3f1da9 | 2014-10-04 20:54:50 +0200 | [diff] [blame] | 710 | if (!strcmp(head, "HEAD")) |
Karthik Nayak | 1511b22 | 2015-09-23 23:41:11 +0530 | [diff] [blame] | 711 | filter.detached = 1; |
René Scharfe | e3f1da9 | 2014-10-04 20:54:50 +0200 | [diff] [blame] | 712 | else if (!skip_prefix(head, "refs/heads/", &head)) |
| 713 | die(_("HEAD not found below refs/heads!")); |
Nguyễn Thái Ngọc Duy | ebe31ef | 2012-04-13 17:54:38 +0700 | [diff] [blame] | 714 | |
Stephen Boyd | 3778292 | 2009-05-23 11:53:12 -0700 | [diff] [blame] | 715 | argc = parse_options(argc, argv, prefix, options, builtin_branch_usage, |
| 716 | 0); |
Michael J Gruber | cddd127 | 2011-08-28 16:54:31 +0200 | [diff] [blame] | 717 | |
Daniels Umanovskis | 0ecb1fc | 2018-10-25 21:04:21 +0200 | [diff] [blame] | 718 | if (!delete && !rename && !copy && !edit_description && !new_upstream && |
| 719 | !show_current && !unset_upstream && argc == 0) |
Michael J Gruber | cddd127 | 2011-08-28 16:54:31 +0200 | [diff] [blame] | 720 | list = 1; |
| 721 | |
Aaron Lipman | 21bf933 | 2020-09-15 22:08:40 -0400 | [diff] [blame] | 722 | if (filter.with_commit || filter.no_commit || |
| 723 | filter.reachable_from || filter.unreachable_from || filter.points_at.nr) |
Jeff King | d040350 | 2013-01-31 01:46:11 -0500 | [diff] [blame] | 724 | list = 1; |
| 725 | |
Glen Choo | 6e0a2ca | 2022-01-28 16:04:44 -0800 | [diff] [blame] | 726 | noncreate_actions = !!delete + !!rename + !!copy + !!new_upstream + |
| 727 | !!show_current + !!list + !!edit_description + |
| 728 | !!unset_upstream; |
| 729 | if (noncreate_actions > 1) |
Junio C Hamano | 049716b | 2008-07-08 17:55:47 -0700 | [diff] [blame] | 730 | usage_with_options(builtin_branch_usage, options); |
Lars Hjemli | c31820c | 2006-10-23 23:27:45 +0200 | [diff] [blame] | 731 | |
Glen Choo | 961b130 | 2022-01-28 16:04:45 -0800 | [diff] [blame] | 732 | 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 Nayak | 1511b22 | 2015-09-23 23:41:11 +0530 | [diff] [blame] | 743 | if (filter.abbrev == -1) |
| 744 | filter.abbrev = DEFAULT_ABBREV; |
Nguyễn Thái Ngọc Duy | 3bb16a8 | 2016-12-04 09:52:25 +0700 | [diff] [blame] | 745 | filter.ignore_case = icase; |
| 746 | |
Nguyễn Thái Ngọc Duy | ebe31ef | 2012-04-13 17:54:38 +0700 | [diff] [blame] | 747 | finalize_colopts(&colopts, -1); |
Karthik Nayak | 1511b22 | 2015-09-23 23:41:11 +0530 | [diff] [blame] | 748 | if (filter.verbose) { |
Nguyễn Thái Ngọc Duy | ebe31ef | 2012-04-13 17:54:38 +0700 | [diff] [blame] | 749 | if (explicitly_enable_column(colopts)) |
Jean-Noël Avila | 12909b6 | 2022-01-05 20:02:16 +0000 | [diff] [blame] | 750 | die(_("options '%s' and '%s' cannot be used together"), "--column", "--verbose"); |
Nguyễn Thái Ngọc Duy | ebe31ef | 2012-04-13 17:54:38 +0700 | [diff] [blame] | 751 | colopts = 0; |
| 752 | } |
Namhyung Kim | b792c06 | 2011-07-01 15:06:08 +0900 | [diff] [blame] | 753 | |
Michael J Gruber | 356e91f | 2014-12-08 17:28:45 +0100 | [diff] [blame] | 754 | if (force) { |
| 755 | delete *= 2; |
| 756 | rename *= 2; |
Sahil Dua | 52d59cc | 2017-06-18 23:19:16 +0200 | [diff] [blame] | 757 | copy *= 2; |
Michael J Gruber | 356e91f | 2014-12-08 17:28:45 +0100 | [diff] [blame] | 758 | } |
| 759 | |
Martin Ågren | d74b541 | 2017-11-19 16:03:49 +0100 | [diff] [blame] | 760 | if (list) |
Martin Ågren | 0ae19de | 2017-11-19 16:03:50 +0100 | [diff] [blame] | 761 | setup_auto_pager("branch", 1); |
Martin Ågren | d74b541 | 2017-11-19 16:03:49 +0100 | [diff] [blame] | 762 | |
Nguyễn Thái Ngọc Duy | 640d040 | 2013-01-28 08:18:14 +0700 | [diff] [blame] | 763 | if (delete) { |
| 764 | if (!argc) |
| 765 | die(_("branch name required")); |
Karthik Nayak | 1511b22 | 2015-09-23 23:41:11 +0530 | [diff] [blame] | 766 | return delete_branches(argc, argv, delete > 1, filter.kind, quiet); |
Daniels Umanovskis | 0ecb1fc | 2018-10-25 21:04:21 +0200 | [diff] [blame] | 767 | } else if (show_current) { |
| 768 | print_current_branch_name(); |
| 769 | return 0; |
Nguyễn Thái Ngọc Duy | 640d040 | 2013-01-28 08:18:14 +0700 | [diff] [blame] | 770 | } else if (list) { |
Ævar Arnfjörð Bjarmason | ffdd02a | 2021-01-06 11:01:35 +0100 | [diff] [blame] | 771 | /* git branch --list also shows HEAD when it is detached */ |
Karthik Nayak | 1511b22 | 2015-09-23 23:41:11 +0530 | [diff] [blame] | 772 | 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 Duy | 3bb16a8 | 2016-12-04 09:52:25 +0700 | [diff] [blame] | 775 | /* |
| 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. Day | 30aa96c | 2018-06-07 07:53:36 -0400 | [diff] [blame] | 779 | * local branches 'refs/heads/...' and finally remote-tracking |
Nguyễn Thái Ngọc Duy | 3bb16a8 | 2016-12-04 09:52:25 +0700 | [diff] [blame] | 780 | * branches 'refs/remotes/...'. |
| 781 | */ |
Junio C Hamano | 98e7ab6 | 2021-10-20 12:23:53 -0700 | [diff] [blame] | 782 | sorting = ref_sorting_options(&sorting_options); |
Ævar Arnfjörð Bjarmason | 7c269a7 | 2021-01-07 10:51:51 +0100 | [diff] [blame] | 783 | ref_sorting_set_sort_flags_all(sorting, REF_SORTING_ICASE, icase); |
Ævar Arnfjörð Bjarmason | 2708ce6 | 2021-01-07 10:51:52 +0100 | [diff] [blame] | 784 | ref_sorting_set_sort_flags_all( |
| 785 | sorting, REF_SORTING_DETACHED_HEAD_FIRST, 1); |
Ævar Arnfjörð Bjarmason | d72d4f9 | 2021-10-20 20:27:21 +0200 | [diff] [blame] | 786 | print_ref_list(&filter, sorting, &format, &output); |
Nguyễn Thái Ngọc Duy | ebe31ef | 2012-04-13 17:54:38 +0700 | [diff] [blame] | 787 | print_columns(&output, colopts, NULL); |
| 788 | string_list_clear(&output, 0); |
Ævar Arnfjörð Bjarmason | d72d4f9 | 2021-10-20 20:27:21 +0200 | [diff] [blame] | 789 | ref_sorting_release(sorting); |
Karthik Nayak | ca41799 | 2015-09-24 23:39:08 +0530 | [diff] [blame] | 790 | return 0; |
Tao Qingyun | 2e3c894 | 2018-10-16 22:19:20 +0800 | [diff] [blame] | 791 | } else if (edit_description) { |
Junio C Hamano | b7200e8 | 2011-09-20 15:10:08 -0700 | [diff] [blame] | 792 | const char *branch_name; |
Junio C Hamano | c2d17ba | 2012-02-05 17:13:36 -0800 | [diff] [blame] | 793 | struct strbuf branch_ref = STRBUF_INIT; |
Rubén Justo | 0dc4e5c | 2022-10-11 01:24:58 +0200 | [diff] [blame^] | 794 | struct strbuf buf = STRBUF_INIT; |
| 795 | int ret = 1; /* assume failure */ |
Junio C Hamano | c2d17ba | 2012-02-05 17:13:36 -0800 | [diff] [blame] | 796 | |
Nguyễn Thái Ngọc Duy | 75135b2 | 2013-01-28 08:18:13 +0700 | [diff] [blame] | 797 | if (!argc) { |
Karthik Nayak | 1511b22 | 2015-09-23 23:41:11 +0530 | [diff] [blame] | 798 | if (filter.detached) |
Nguyễn Thái Ngọc Duy | 045e388 | 2013-01-28 08:18:16 +0700 | [diff] [blame] | 799 | die(_("Cannot give description to detached HEAD")); |
Junio C Hamano | b7200e8 | 2011-09-20 15:10:08 -0700 | [diff] [blame] | 800 | branch_name = head; |
Rubén Justo | 0dc4e5c | 2022-10-11 01:24:58 +0200 | [diff] [blame^] | 801 | } 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 Duy | 43722c4 | 2013-01-28 08:18:15 +0700 | [diff] [blame] | 805 | die(_("cannot edit description of more than one branch")); |
Rubén Justo | 0dc4e5c | 2022-10-11 01:24:58 +0200 | [diff] [blame^] | 806 | } |
Junio C Hamano | c2d17ba | 2012-02-05 17:13:36 -0800 | [diff] [blame] | 807 | |
| 808 | strbuf_addf(&branch_ref, "refs/heads/%s", branch_name); |
Rubén Justo | 0dc4e5c | 2022-10-11 01:24:58 +0200 | [diff] [blame^] | 809 | 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 Hamano | c2d17ba | 2012-02-05 17:13:36 -0800 | [diff] [blame] | 816 | |
Junio C Hamano | c2d17ba | 2012-02-05 17:13:36 -0800 | [diff] [blame] | 817 | strbuf_release(&branch_ref); |
Rubén Justo | 0dc4e5c | 2022-10-11 01:24:58 +0200 | [diff] [blame^] | 818 | strbuf_release(&buf); |
Junio C Hamano | c2d17ba | 2012-02-05 17:13:36 -0800 | [diff] [blame] | 819 | |
Rubén Justo | 0dc4e5c | 2022-10-11 01:24:58 +0200 | [diff] [blame^] | 820 | return ret; |
Sahil Dua | 52d59cc | 2017-06-18 23:19:16 +0200 | [diff] [blame] | 821 | } 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 Hamano | a4043ae | 2011-12-09 13:37:05 -0800 | [diff] [blame] | 830 | } else if (rename) { |
Jonathon Mah | d1520c4 | 2013-03-30 18:27:44 -0700 | [diff] [blame] | 831 | if (!argc) |
| 832 | die(_("branch name required")); |
| 833 | else if (argc == 1) |
Sahil Dua | 52d59cc | 2017-06-18 23:19:16 +0200 | [diff] [blame] | 834 | copy_or_rename_branch(head, argv[0], 0, rename > 1); |
Tay Ray Chuan | 3706ed2 | 2011-11-03 00:17:12 +0800 | [diff] [blame] | 835 | else if (argc == 2) |
Sahil Dua | 52d59cc | 2017-06-18 23:19:16 +0200 | [diff] [blame] | 836 | copy_or_rename_branch(argv[0], argv[1], 0, rename > 1); |
Tay Ray Chuan | 3706ed2 | 2011-11-03 00:17:12 +0800 | [diff] [blame] | 837 | else |
Kaartic Sivaraam | f777623 | 2017-08-21 19:06:08 +0530 | [diff] [blame] | 838 | die(_("too many arguments for a rename operation")); |
Carlos Martín Nieto | 6183d82 | 2012-08-20 15:47:38 +0200 | [diff] [blame] | 839 | } else if (new_upstream) { |
Rubén Justo | 0dc4e5c | 2022-10-11 01:24:58 +0200 | [diff] [blame^] | 840 | struct branch *branch; |
| 841 | struct strbuf buf = STRBUF_INIT; |
Carlos Martín Nieto | 6183d82 | 2012-08-20 15:47:38 +0200 | [diff] [blame] | 842 | |
Rubén Justo | 0dc4e5c | 2022-10-11 01:24:58 +0200 | [diff] [blame^] | 843 | 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 Sivaraam | f777623 | 2017-08-21 19:06:08 +0530 | [diff] [blame] | 849 | die(_("too many arguments to set new upstream")); |
Nguyễn Thái Ngọc Duy | 8efb889 | 2013-02-23 19:22:27 +0700 | [diff] [blame] | 850 | |
| 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 Nieto | 6183d82 | 2012-08-20 15:47:38 +0200 | [diff] [blame] | 859 | if (!ref_exists(branch->refname)) |
| 860 | die(_("branch '%s' does not exist"), branch->name); |
| 861 | |
Glen Choo | e89f151 | 2022-01-28 16:04:41 -0800 | [diff] [blame] | 862 | dwim_and_setup_tracking(the_repository, branch->name, |
| 863 | new_upstream, BRANCH_TRACK_OVERRIDE, |
| 864 | quiet); |
Rubén Justo | 0dc4e5c | 2022-10-11 01:24:58 +0200 | [diff] [blame^] | 865 | strbuf_release(&buf); |
Carlos Martín Nieto | b84869e | 2012-08-30 19:23:12 +0200 | [diff] [blame] | 866 | } else if (unset_upstream) { |
Rubén Justo | 0dc4e5c | 2022-10-11 01:24:58 +0200 | [diff] [blame^] | 867 | struct branch *branch; |
Carlos Martín Nieto | b84869e | 2012-08-30 19:23:12 +0200 | [diff] [blame] | 868 | struct strbuf buf = STRBUF_INIT; |
| 869 | |
Rubén Justo | 0dc4e5c | 2022-10-11 01:24:58 +0200 | [diff] [blame^] | 870 | 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 Sivaraam | f777623 | 2017-08-21 19:06:08 +0530 | [diff] [blame] | 876 | die(_("too many arguments to unset upstream")); |
Nguyễn Thái Ngọc Duy | 8efb889 | 2013-02-23 19:22:27 +0700 | [diff] [blame] | 877 | |
| 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 Contreras | 54d07f2 | 2013-10-31 03:25:38 -0600 | [diff] [blame] | 885 | if (!branch_has_merge_config(branch)) |
Carlos Martín Nieto | b84869e | 2012-08-30 19:23:12 +0200 | [diff] [blame] | 886 | die(_("Branch '%s' has no upstream information"), branch->name); |
Carlos Martín Nieto | b84869e | 2012-08-30 19:23:12 +0200 | [diff] [blame] | 887 | |
Rubén Justo | 0dc4e5c | 2022-10-11 01:24:58 +0200 | [diff] [blame^] | 888 | strbuf_reset(&buf); |
Carlos Martín Nieto | b84869e | 2012-08-30 19:23:12 +0200 | [diff] [blame] | 889 | strbuf_addf(&buf, "branch.%s.remote", branch->name); |
Derrick Stolee | 504ee12 | 2020-11-25 22:12:49 +0000 | [diff] [blame] | 890 | git_config_set_multivar(buf.buf, NULL, NULL, CONFIG_FLAGS_MULTI_REPLACE); |
Carlos Martín Nieto | b84869e | 2012-08-30 19:23:12 +0200 | [diff] [blame] | 891 | strbuf_reset(&buf); |
| 892 | strbuf_addf(&buf, "branch.%s.merge", branch->name); |
Derrick Stolee | 504ee12 | 2020-11-25 22:12:49 +0000 | [diff] [blame] | 893 | git_config_set_multivar(buf.buf, NULL, NULL, CONFIG_FLAGS_MULTI_REPLACE); |
Carlos Martín Nieto | b84869e | 2012-08-30 19:23:12 +0200 | [diff] [blame] | 894 | strbuf_release(&buf); |
Glen Choo | 6e0a2ca | 2022-01-28 16:04:44 -0800 | [diff] [blame] | 895 | } else if (!noncreate_actions && argc > 0 && argc <= 2) { |
Glen Choo | 961b130 | 2022-01-28 16:04:45 -0800 | [diff] [blame] | 896 | const char *branch_name = argv[0]; |
| 897 | const char *start_name = argc == 2 ? argv[1] : head; |
| 898 | |
Karthik Nayak | 1511b22 | 2015-09-23 23:41:11 +0530 | [diff] [blame] | 899 | if (filter.kind != FILTER_REFS_BRANCHES) |
Philip Oakley | 1fde99c | 2019-05-29 00:16:05 +0100 | [diff] [blame] | 900 | 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 Nieto | b347d06 | 2012-08-30 19:23:13 +0200 | [diff] [blame] | 902 | |
| 903 | if (track == BRANCH_TRACK_OVERRIDE) |
Kaartic Sivaraam | 5266884 | 2017-08-17 08:24:24 +0530 | [diff] [blame] | 904 | die(_("the '--set-upstream' option is no longer supported. Please use '--track' or '--set-upstream-to' instead.")); |
Carlos Martín Nieto | b347d06 | 2012-08-30 19:23:13 +0200 | [diff] [blame] | 905 | |
Glen Choo | 961b130 | 2022-01-28 16:04:45 -0800 | [diff] [blame] | 906 | 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 Moy | 6e8f993 | 2009-12-30 15:45:31 +0100 | [diff] [blame] | 914 | } else |
Pierre Habouzit | a8dfd5e | 2007-10-07 18:26:21 +0200 | [diff] [blame] | 915 | usage_with_options(builtin_branch_usage, options); |
Lars Hjemli | c31820c | 2006-10-23 23:27:45 +0200 | [diff] [blame] | 916 | |
| 917 | return 0; |
| 918 | } |