From a3f40ec4b0dc56a54e6a6866d0a44a04d4a6edf0 Mon Sep 17 00:00:00 2001 From: Josh Steadmon Date: Mon, 20 Dec 2021 19:30:22 -0800 Subject: [PATCH 1/5] branch: accept multiple upstream branches for tracking Add a new static variant of install_branch_config() that accepts multiple remote branch names for tracking. This will be used in an upcoming commit that enables inheriting the tracking configuration from a parent branch. Currently, all callers of install_branch_config() pass only a single remote. Make install_branch_config() a small wrapper around install_branch_config_multiple_remotes() so that existing callers do not need to be changed. Signed-off-by: Josh Steadmon Signed-off-by: Junio C Hamano --- branch.c | 145 +++++++++++++++++++++++++++++++++------------- t/t3200-branch.sh | 6 +- 2 files changed, 107 insertions(+), 44 deletions(-) diff --git a/branch.c b/branch.c index 07a46430b3..299c8f07f7 100644 --- a/branch.c +++ b/branch.c @@ -49,25 +49,46 @@ static int should_setup_rebase(const char *origin) return 0; } -static const char tracking_advice[] = -N_("\n" -"After fixing the error cause you may try to fix up\n" -"the remote tracking information by invoking\n" -"\"git branch --set-upstream-to=%s%s%s\"."); - -int install_branch_config(int flag, const char *local, const char *origin, const char *remote) +/** + * Install upstream tracking configuration for a branch; specifically, add + * `branch..remote` and `branch..merge` entries. + * + * `flag` contains integer flags for options; currently only + * BRANCH_CONFIG_VERBOSE is checked. + * + * `local` is the name of the branch whose configuration we're installing. + * + * `origin` is the name of the remote owning the upstream branches. NULL means + * the upstream branches are local to this repo. + * + * `remotes` is a list of refs that are upstream of local + */ +static int install_branch_config_multiple_remotes(int flag, const char *local, + const char *origin, struct string_list *remotes) { const char *shortname = NULL; struct strbuf key = STRBUF_INIT; + struct string_list_item *item; int rebasing = should_setup_rebase(origin); - if (skip_prefix(remote, "refs/heads/", &shortname) - && !strcmp(local, shortname) - && !origin) { - warning(_("Not setting branch %s as its own upstream."), - local); - return 0; - } + if (!remotes->nr) + BUG("must provide at least one remote for branch config"); + if (rebasing && remotes->nr > 1) + die(_("cannot inherit upstream tracking configuration of " + "multiple refs when rebasing is requested")); + + /* + * If the new branch is trying to track itself, something has gone + * wrong. Warn the user and don't proceed any further. + */ + if (!origin) + for_each_string_list_item(item, remotes) + if (skip_prefix(item->string, "refs/heads/", &shortname) + && !strcmp(local, shortname)) { + warning(_("not setting branch '%s' as its own upstream."), + local); + return 0; + } strbuf_addf(&key, "branch.%s.remote", local); if (git_config_set_gently(key.buf, origin ? origin : ".") < 0) @@ -75,8 +96,17 @@ int install_branch_config(int flag, const char *local, const char *origin, const strbuf_reset(&key); strbuf_addf(&key, "branch.%s.merge", local); - if (git_config_set_gently(key.buf, remote) < 0) + /* + * We want to overwrite any existing config with all the branches in + * "remotes". Override any existing config, then write our branches. If + * more than one is provided, use CONFIG_REGEX_NONE to preserve what + * we've written so far. + */ + if (git_config_set_gently(key.buf, NULL) < 0) goto out_err; + for_each_string_list_item(item, remotes) + if (git_config_set_multivar_gently(key.buf, item->string, CONFIG_REGEX_NONE, 0) < 0) + goto out_err; if (rebasing) { strbuf_reset(&key); @@ -87,29 +117,40 @@ int install_branch_config(int flag, const char *local, const char *origin, const strbuf_release(&key); if (flag & BRANCH_CONFIG_VERBOSE) { - if (shortname) { - if (origin) - printf_ln(rebasing ? - _("Branch '%s' set up to track remote branch '%s' from '%s' by rebasing.") : - _("Branch '%s' set up to track remote branch '%s' from '%s'."), - local, shortname, origin); - else - printf_ln(rebasing ? - _("Branch '%s' set up to track local branch '%s' by rebasing.") : - _("Branch '%s' set up to track local branch '%s'."), - local, shortname); - } else { - if (origin) - printf_ln(rebasing ? - _("Branch '%s' set up to track remote ref '%s' by rebasing.") : - _("Branch '%s' set up to track remote ref '%s'."), - local, remote); - else - printf_ln(rebasing ? - _("Branch '%s' set up to track local ref '%s' by rebasing.") : - _("Branch '%s' set up to track local ref '%s'."), - local, remote); + struct strbuf tmp_ref_name = STRBUF_INIT; + struct string_list friendly_ref_names = STRING_LIST_INIT_DUP; + + for_each_string_list_item(item, remotes) { + shortname = item->string; + skip_prefix(shortname, "refs/heads/", &shortname); + if (origin) { + strbuf_addf(&tmp_ref_name, "%s/%s", + origin, shortname); + string_list_append_nodup( + &friendly_ref_names, + strbuf_detach(&tmp_ref_name, NULL)); + } else { + string_list_append( + &friendly_ref_names, shortname); + } } + + if (remotes->nr == 1) { + /* + * Rebasing is only allowed in the case of a single + * upstream branch. + */ + printf_ln(rebasing ? + _("branch '%s' set up to track '%s' by rebasing.") : + _("branch '%s' set up to track '%s'."), + local, friendly_ref_names.items[0].string); + } else { + printf_ln(_("branch '%s' set up to track:"), local); + for_each_string_list_item(item, &friendly_ref_names) + printf_ln(" %s", item->string); + } + + string_list_clear(&friendly_ref_names, 0); } return 0; @@ -118,14 +159,36 @@ out_err: strbuf_release(&key); error(_("Unable to write upstream branch configuration")); - advise(_(tracking_advice), - origin ? origin : "", - origin ? "/" : "", - shortname ? shortname : remote); + advise(_("\nAfter fixing the error cause you may try to fix up\n" + "the remote tracking information by invoking:")); + if (remotes->nr == 1) + advise(" git branch --set-upstream-to=%s%s%s", + origin ? origin : "", + origin ? "/" : "", + remotes->items[0].string); + else { + advise(" git config --add branch.\"%s\".remote %s", + local, origin ? origin : "."); + for_each_string_list_item(item, remotes) + advise(" git config --add branch.\"%s\".merge %s", + local, item->string); + } return -1; } +int install_branch_config(int flag, const char *local, const char *origin, + const char *remote) +{ + int ret; + struct string_list remotes = STRING_LIST_INIT_DUP; + + string_list_append(&remotes, remote); + ret = install_branch_config_multiple_remotes(flag, local, origin, &remotes); + string_list_clear(&remotes, 0); + return ret; +} + /* * This is called when new_ref is branched off of orig_ref, and tries * to infer the settings for branch..{remote,merge} from the diff --git a/t/t3200-branch.sh b/t/t3200-branch.sh index e575ffb4ff..bcc1acaa78 100755 --- a/t/t3200-branch.sh +++ b/t/t3200-branch.sh @@ -950,15 +950,15 @@ test_expect_success 'disabled option --set-upstream fails' ' test_must_fail git branch --set-upstream origin/main ' -test_expect_success '--set-upstream-to notices an error to set branch as own upstream' ' +test_expect_success '--set-upstream-to notices an error to set branch as own upstream' " git branch --set-upstream-to refs/heads/my13 my13 2>actual && cat >expect <<-\EOF && - warning: Not setting branch my13 as its own upstream. + warning: not setting branch 'my13' as its own upstream. EOF test_expect_code 1 git config branch.my13.remote && test_expect_code 1 git config branch.my13.merge && test_cmp expect actual -' +" # Keep this test last, as it changes the current branch cat >expect < Date: Mon, 20 Dec 2021 19:30:23 -0800 Subject: [PATCH 2/5] branch: add flags and config to inherit tracking It can be helpful when creating a new branch to use the existing tracking configuration from the branch point. However, there is currently not a method to automatically do so. Teach git-{branch,checkout,switch} an "inherit" argument to the "--track" option. When this is set, creating a new branch will cause the tracking configuration to default to the configuration of the branch point, if set. For example, if branch "main" tracks "origin/main", and we run `git checkout --track=inherit -b feature main`, then branch "feature" will track "origin/main". Thus, `git status` will show us how far ahead/behind we are from origin, and `git pull` will pull from origin. This is particularly useful when creating branches across many submodules, such as with `git submodule foreach ...` (or if running with a patch such as [1], which we use at $job), as it avoids having to manually set tracking info for each submodule. Since we've added an argument to "--track", also add "--track=direct" as another way to explicitly get the original "--track" behavior ("--track" without an argument still works as well). Finally, teach branch.autoSetupMerge a new "inherit" option. When this is set, "--track=inherit" becomes the default behavior. [1]: https://lore.kernel.org/git/20180927221603.148025-1-sbeller@google.com/ Signed-off-by: Josh Steadmon Signed-off-by: Junio C Hamano --- Documentation/config/branch.txt | 3 +- Documentation/git-branch.txt | 24 +++++++++++----- Documentation/git-checkout.txt | 2 +- Documentation/git-switch.txt | 2 +- branch.c | 49 ++++++++++++++++++++++++++++----- branch.h | 3 +- builtin/branch.c | 6 ++-- builtin/checkout.c | 6 ++-- config.c | 3 ++ parse-options-cb.c | 16 +++++++++++ parse-options.h | 2 ++ t/t2017-checkout-orphan.sh | 11 +++++++- t/t2027-checkout-track.sh | 23 ++++++++++++++++ t/t2060-switch.sh | 28 +++++++++++++++++++ t/t3200-branch.sh | 33 ++++++++++++++++++++++ t/t7201-co.sh | 17 ++++++++++++ 16 files changed, 205 insertions(+), 23 deletions(-) diff --git a/Documentation/config/branch.txt b/Documentation/config/branch.txt index cc5f3249fc..55f7522e12 100644 --- a/Documentation/config/branch.txt +++ b/Documentation/config/branch.txt @@ -7,7 +7,8 @@ branch.autoSetupMerge:: automatic setup is done; `true` -- automatic setup is done when the starting point is a remote-tracking branch; `always` -- automatic setup is done when the starting point is either a - local branch or remote-tracking + local branch or remote-tracking branch; `inherit` -- if the starting point + has a tracking configuration, it is copied to the new branch. This option defaults to true. branch.autoSetupRebase:: diff --git a/Documentation/git-branch.txt b/Documentation/git-branch.txt index 5449767121..75beea7bac 100644 --- a/Documentation/git-branch.txt +++ b/Documentation/git-branch.txt @@ -16,7 +16,7 @@ SYNOPSIS [--points-at ] [--format=] [(-r | --remotes) | (-a | --all)] [--list] [...] -'git branch' [--track | --no-track] [-f] [] +'git branch' [--track [direct|inherit] | --no-track] [-f] [] 'git branch' (--set-upstream-to= | -u ) [] 'git branch' --unset-upstream [] 'git branch' (-m | -M) [] @@ -206,24 +206,34 @@ This option is only applicable in non-verbose mode. Display the full sha1s in the output listing rather than abbreviating them. -t:: ---track:: +--track [inherit|direct]:: When creating a new branch, set up `branch..remote` and - `branch..merge` configuration entries to mark the - start-point branch as "upstream" from the new branch. This + `branch..merge` configuration entries to set "upstream" tracking + configuration for the new branch. This configuration will tell git to show the relationship between the two branches in `git status` and `git branch -v`. Furthermore, it directs `git pull` without arguments to pull from the upstream when the new branch is checked out. + -This behavior is the default when the start point is a remote-tracking branch. +The exact upstream branch is chosen depending on the optional argument: +`--track` or `--track direct` means to use the start-point branch itself as the +upstream; `--track inherit` means to copy the upstream configuration of the +start-point branch. ++ +`--track direct` is the default when the start point is a remote-tracking branch. Set the branch.autoSetupMerge configuration variable to `false` if you want `git switch`, `git checkout` and `git branch` to always behave as if `--no-track` were given. Set it to `always` if you want this behavior when the -start-point is either a local or remote-tracking branch. +start-point is either a local or remote-tracking branch. Set it to +`inherit` if you want to copy the tracking configuration from the +branch point. ++ +See linkgit:git-pull[1] and linkgit:git-config[1] for additional discussion on +how the `branch..remote` and `branch..merge` options are used. --no-track:: Do not set up "upstream" configuration, even if the - branch.autoSetupMerge configuration variable is true. + branch.autoSetupMerge configuration variable is set. --set-upstream:: As this option had confusing syntax, it is no longer supported. diff --git a/Documentation/git-checkout.txt b/Documentation/git-checkout.txt index d473c9bf38..61825b060d 100644 --- a/Documentation/git-checkout.txt +++ b/Documentation/git-checkout.txt @@ -156,7 +156,7 @@ of it"). linkgit:git-branch[1] for details. -t:: ---track:: +--track [direct|inherit]:: When creating a new branch, set up "upstream" configuration. See "--track" in linkgit:git-branch[1] for details. + diff --git a/Documentation/git-switch.txt b/Documentation/git-switch.txt index 5c438cd505..96dc036ea5 100644 --- a/Documentation/git-switch.txt +++ b/Documentation/git-switch.txt @@ -152,7 +152,7 @@ should result in deletion of the path). attached to a terminal, regardless of `--quiet`. -t:: ---track:: +--track [direct|inherit]:: When creating a new branch, set up "upstream" configuration. `-c` is implied. See `--track` in linkgit:git-branch[1] for details. diff --git a/branch.c b/branch.c index 299c8f07f7..a4e4631ef1 100644 --- a/branch.c +++ b/branch.c @@ -11,7 +11,7 @@ struct tracking { struct refspec_item spec; - char *src; + struct string_list *srcs; const char *remote; int matches; }; @@ -22,11 +22,11 @@ static int find_tracked_branch(struct remote *remote, void *priv) if (!remote_find_tracking(remote, &tracking->spec)) { if (++tracking->matches == 1) { - tracking->src = tracking->spec.src; + string_list_append(tracking->srcs, tracking->spec.src); tracking->remote = remote->name; } else { free(tracking->spec.src); - FREE_AND_NULL(tracking->src); + string_list_clear(tracking->srcs, 0); } tracking->spec.src = NULL; } @@ -189,6 +189,34 @@ int install_branch_config(int flag, const char *local, const char *origin, return ret; } +static int inherit_tracking(struct tracking *tracking, const char *orig_ref) +{ + const char *bare_ref; + struct branch *branch; + int i; + + bare_ref = orig_ref; + skip_prefix(orig_ref, "refs/heads/", &bare_ref); + + branch = branch_get(bare_ref); + if (!branch->remote_name) { + warning(_("asked to inherit tracking from '%s', but no remote is set"), + bare_ref); + return -1; + } + + if (branch->merge_nr < 1 || !branch->merge_name || !branch->merge_name[0]) { + warning(_("asked to inherit tracking from '%s', but no merge configuration is set"), + bare_ref); + return -1; + } + + tracking->remote = xstrdup(branch->remote_name); + for (i = 0; i < branch->merge_nr; i++) + string_list_append(tracking->srcs, branch->merge_name[i]); + return 0; +} + /* * This is called when new_ref is branched off of orig_ref, and tries * to infer the settings for branch..{remote,merge} from the @@ -198,11 +226,15 @@ static void setup_tracking(const char *new_ref, const char *orig_ref, enum branch_track track, int quiet) { struct tracking tracking; + struct string_list tracking_srcs = STRING_LIST_INIT_DUP; int config_flags = quiet ? 0 : BRANCH_CONFIG_VERBOSE; memset(&tracking, 0, sizeof(tracking)); tracking.spec.dst = (char *)orig_ref; - if (for_each_remote(find_tracked_branch, &tracking)) + tracking.srcs = &tracking_srcs; + if (track != BRANCH_TRACK_INHERIT) + for_each_remote(find_tracked_branch, &tracking); + else if (inherit_tracking(&tracking, orig_ref)) return; if (!tracking.matches) @@ -210,6 +242,7 @@ static void setup_tracking(const char *new_ref, const char *orig_ref, case BRANCH_TRACK_ALWAYS: case BRANCH_TRACK_EXPLICIT: case BRANCH_TRACK_OVERRIDE: + case BRANCH_TRACK_INHERIT: break; default: return; @@ -219,11 +252,13 @@ static void setup_tracking(const char *new_ref, const char *orig_ref, die(_("Not tracking: ambiguous information for ref %s"), orig_ref); - if (install_branch_config(config_flags, new_ref, tracking.remote, - tracking.src ? tracking.src : orig_ref) < 0) + if (tracking.srcs->nr < 1) + string_list_append(tracking.srcs, orig_ref); + if (install_branch_config_multiple_remotes(config_flags, new_ref, + tracking.remote, tracking.srcs) < 0) exit(-1); - free(tracking.src); + string_list_clear(tracking.srcs, 0); } int read_branch_desc(struct strbuf *buf, const char *branch_name) diff --git a/branch.h b/branch.h index df0be61506..815dcd40c0 100644 --- a/branch.h +++ b/branch.h @@ -10,7 +10,8 @@ enum branch_track { BRANCH_TRACK_REMOTE, BRANCH_TRACK_ALWAYS, BRANCH_TRACK_EXPLICIT, - BRANCH_TRACK_OVERRIDE + BRANCH_TRACK_OVERRIDE, + BRANCH_TRACK_INHERIT, }; extern enum branch_track git_branch_track; diff --git a/builtin/branch.c b/builtin/branch.c index 0b7ed82654..1890afd4e5 100644 --- a/builtin/branch.c +++ b/builtin/branch.c @@ -632,8 +632,10 @@ int cmd_branch(int argc, const char **argv, const char *prefix) OPT__VERBOSE(&filter.verbose, N_("show hash and subject, give twice for upstream branch")), OPT__QUIET(&quiet, N_("suppress informational messages")), - OPT_SET_INT('t', "track", &track, N_("set up tracking mode (see git-pull(1))"), - BRANCH_TRACK_EXPLICIT), + OPT_CALLBACK_F('t', "track", &track, "direct|inherit", + N_("set branch tracking configuration"), + PARSE_OPT_OPTARG | PARSE_OPT_LITERAL_ARGHELP, + parse_opt_tracking_mode), OPT_SET_INT_F(0, "set-upstream", &track, N_("do not use"), BRANCH_TRACK_OVERRIDE, PARSE_OPT_HIDDEN), OPT_STRING('u', "set-upstream-to", &new_upstream, N_("upstream"), N_("change the upstream info")), diff --git a/builtin/checkout.c b/builtin/checkout.c index cbf73b8c9f..8d511aa6b7 100644 --- a/builtin/checkout.c +++ b/builtin/checkout.c @@ -1530,8 +1530,10 @@ static struct option *add_common_switch_branch_options( { struct option options[] = { OPT_BOOL('d', "detach", &opts->force_detach, N_("detach HEAD at named commit")), - OPT_SET_INT('t', "track", &opts->track, N_("set upstream info for new branch"), - BRANCH_TRACK_EXPLICIT), + OPT_CALLBACK_F('t', "track", &opts->track, "direct|inherit", + N_("set up tracking mode (see git-pull(1))"), + PARSE_OPT_OPTARG | PARSE_OPT_LITERAL_ARGHELP, + parse_opt_tracking_mode), OPT__FORCE(&opts->force, N_("force checkout (throw away local modifications)"), PARSE_OPT_NOCOMPLETE), OPT_STRING(0, "orphan", &opts->new_orphan_branch, N_("new-branch"), N_("new unparented branch")), diff --git a/config.c b/config.c index 2dcbe901b6..532732fc33 100644 --- a/config.c +++ b/config.c @@ -1559,6 +1559,9 @@ static int git_default_branch_config(const char *var, const char *value) if (value && !strcasecmp(value, "always")) { git_branch_track = BRANCH_TRACK_ALWAYS; return 0; + } else if (value && !strcmp(value, "inherit")) { + git_branch_track = BRANCH_TRACK_INHERIT; + return 0; } git_branch_track = git_config_bool(var, value); return 0; diff --git a/parse-options-cb.c b/parse-options-cb.c index 3c811e1e4a..d346dbe210 100644 --- a/parse-options-cb.c +++ b/parse-options-cb.c @@ -1,5 +1,6 @@ #include "git-compat-util.h" #include "parse-options.h" +#include "branch.h" #include "cache.h" #include "commit.h" #include "color.h" @@ -293,3 +294,18 @@ int parse_opt_passthru_argv(const struct option *opt, const char *arg, int unset return 0; } + +int parse_opt_tracking_mode(const struct option *opt, const char *arg, int unset) +{ + if (unset) + *(enum branch_track *)opt->value = BRANCH_TRACK_NEVER; + else if (!arg || !strcmp(arg, "direct")) + *(enum branch_track *)opt->value = BRANCH_TRACK_EXPLICIT; + else if (!strcmp(arg, "inherit")) + *(enum branch_track *)opt->value = BRANCH_TRACK_INHERIT; + else + return error(_("option `%s' expects \"%s\" or \"%s\""), + "--track", "direct", "inherit"); + + return 0; +} diff --git a/parse-options.h b/parse-options.h index 13405472ee..47ba8dcbac 100644 --- a/parse-options.h +++ b/parse-options.h @@ -302,6 +302,8 @@ enum parse_opt_result parse_opt_unknown_cb(struct parse_opt_ctx_t *ctx, const char *, int); int parse_opt_passthru(const struct option *, const char *, int); int parse_opt_passthru_argv(const struct option *, const char *, int); +/* value is enum branch_track* */ +int parse_opt_tracking_mode(const struct option *, const char *, int); #define OPT__VERBOSE(var, h) OPT_COUNTUP('v', "verbose", (var), (h)) #define OPT__QUIET(var, h) OPT_COUNTUP('q', "quiet", (var), (h)) diff --git a/t/t2017-checkout-orphan.sh b/t/t2017-checkout-orphan.sh index 88d6992a5e..4d689bd377 100755 --- a/t/t2017-checkout-orphan.sh +++ b/t/t2017-checkout-orphan.sh @@ -62,8 +62,17 @@ test_expect_success '--orphan ignores branch.autosetupmerge' ' git checkout main && git config branch.autosetupmerge always && git checkout --orphan gamma && - test -z "$(git config branch.gamma.merge)" && + test_cmp_config "" --default "" branch.gamma.merge && test refs/heads/gamma = "$(git symbolic-ref HEAD)" && + test_must_fail git rev-parse --verify HEAD^ && + git checkout main && + git config branch.autosetupmerge inherit && + git checkout --orphan eta && + test_cmp_config "" --default "" branch.eta.merge && + test_cmp_config "" --default "" branch.eta.remote && + echo refs/heads/eta >expected && + git symbolic-ref HEAD >actual && + test_cmp expected actual && test_must_fail git rev-parse --verify HEAD^ ' diff --git a/t/t2027-checkout-track.sh b/t/t2027-checkout-track.sh index 4453741b96..dca35aa3e3 100755 --- a/t/t2027-checkout-track.sh +++ b/t/t2027-checkout-track.sh @@ -24,4 +24,27 @@ test_expect_success 'checkout --track -b rejects an extra path argument' ' test_i18ngrep "cannot be used with updating paths" err ' +test_expect_success 'checkout --track -b overrides autoSetupMerge=inherit' ' + # Set up tracking config on main + test_config branch.main.remote origin && + test_config branch.main.merge refs/heads/some-branch && + test_config branch.autoSetupMerge inherit && + # With --track=inherit, we copy the tracking config from main + git checkout --track=inherit -b b1 main && + test_cmp_config origin branch.b1.remote && + test_cmp_config refs/heads/some-branch branch.b1.merge && + # With branch.autoSetupMerge=inherit, we do the same + git checkout -b b2 main && + test_cmp_config origin branch.b2.remote && + test_cmp_config refs/heads/some-branch branch.b2.merge && + # But --track overrides this + git checkout --track -b b3 main && + test_cmp_config . branch.b3.remote && + test_cmp_config refs/heads/main branch.b3.merge && + # And --track=direct does as well + git checkout --track=direct -b b4 main && + test_cmp_config . branch.b4.remote && + test_cmp_config refs/heads/main branch.b4.merge +' + test_done diff --git a/t/t2060-switch.sh b/t/t2060-switch.sh index 9bc6a3aa5c..ebb961be29 100755 --- a/t/t2060-switch.sh +++ b/t/t2060-switch.sh @@ -107,4 +107,32 @@ test_expect_success 'not switching when something is in progress' ' test_must_fail git switch -d @^ ' +test_expect_success 'tracking info copied with autoSetupMerge=inherit' ' + # default config does not copy tracking info + git switch -c foo-no-inherit foo && + test_cmp_config "" --default "" branch.foo-no-inherit.remote && + test_cmp_config "" --default "" branch.foo-no-inherit.merge && + # with --track=inherit, we copy tracking info from foo + git switch --track=inherit -c foo2 foo && + test_cmp_config origin branch.foo2.remote && + test_cmp_config refs/heads/foo branch.foo2.merge && + # with autoSetupMerge=inherit, we do the same + test_config branch.autoSetupMerge inherit && + git switch -c foo3 foo && + test_cmp_config origin branch.foo3.remote && + test_cmp_config refs/heads/foo branch.foo3.merge && + # with --track, we override autoSetupMerge + git switch --track -c foo4 foo && + test_cmp_config . branch.foo4.remote && + test_cmp_config refs/heads/foo branch.foo4.merge && + # and --track=direct does as well + git switch --track=direct -c foo5 foo && + test_cmp_config . branch.foo5.remote && + test_cmp_config refs/heads/foo branch.foo5.merge && + # no tracking info to inherit from main + git switch -c main2 main && + test_cmp_config "" --default "" branch.main2.remote && + test_cmp_config "" --default "" branch.main2.merge +' + test_done diff --git a/t/t3200-branch.sh b/t/t3200-branch.sh index bcc1acaa78..a74b2e06a1 100755 --- a/t/t3200-branch.sh +++ b/t/t3200-branch.sh @@ -1422,4 +1422,37 @@ test_expect_success 'invalid sort parameter in configuration' ' ) ' +test_expect_success 'tracking info copied with --track=inherit' ' + git branch --track=inherit foo2 my1 && + test_cmp_config local branch.foo2.remote && + test_cmp_config refs/heads/main branch.foo2.merge +' + +test_expect_success 'tracking info copied with autoSetupMerge=inherit' ' + test_unconfig branch.autoSetupMerge && + # default config does not copy tracking info + git branch foo-no-inherit my1 && + test_cmp_config "" --default "" branch.foo-no-inherit.remote && + test_cmp_config "" --default "" branch.foo-no-inherit.merge && + # with autoSetupMerge=inherit, we copy tracking info from my1 + test_config branch.autoSetupMerge inherit && + git branch foo3 my1 && + test_cmp_config local branch.foo3.remote && + test_cmp_config refs/heads/main branch.foo3.merge && + # no tracking info to inherit from main + git branch main2 main && + test_cmp_config "" --default "" branch.main2.remote && + test_cmp_config "" --default "" branch.main2.merge +' + +test_expect_success '--track overrides branch.autoSetupMerge' ' + test_config branch.autoSetupMerge inherit && + git branch --track=direct foo4 my1 && + test_cmp_config . branch.foo4.remote && + test_cmp_config refs/heads/my1 branch.foo4.merge && + git branch --no-track foo5 my1 && + test_cmp_config "" --default "" branch.foo5.remote && + test_cmp_config "" --default "" branch.foo5.merge +' + test_done diff --git a/t/t7201-co.sh b/t/t7201-co.sh index b7ba1c3268..61ad47b0c1 100755 --- a/t/t7201-co.sh +++ b/t/t7201-co.sh @@ -658,4 +658,21 @@ test_expect_success 'custom merge driver with checkout -m' ' test_cmp expect arm ' +test_expect_success 'tracking info copied with autoSetupMerge=inherit' ' + git reset --hard main && + # default config does not copy tracking info + git checkout -b foo-no-inherit koala/bear && + test_cmp_config "" --default "" branch.foo-no-inherit.remote && + test_cmp_config "" --default "" branch.foo-no-inherit.merge && + # with autoSetupMerge=inherit, we copy tracking info from koala/bear + test_config branch.autoSetupMerge inherit && + git checkout -b foo koala/bear && + test_cmp_config origin branch.foo.remote && + test_cmp_config refs/heads/koala/bear branch.foo.merge && + # no tracking info to inherit from main + git checkout -b main2 main && + test_cmp_config "" --default "" branch.main2.remote && + test_cmp_config "" --default "" branch.main2.merge +' + test_done From 44f14a9d24cd9f04a0a789e58968d52d44d7f332 Mon Sep 17 00:00:00 2001 From: Josh Steadmon Date: Mon, 20 Dec 2021 19:30:24 -0800 Subject: [PATCH 3/5] config: require lowercase for branch.*.autosetupmerge Although we only documented that branch.*.autosetupmerge would accept "always" as a value, the actual implementation would accept any combination of upper- or lower-case. Fix this to be consistent with documentation and with other values of this config variable. Signed-off-by: Josh Steadmon Signed-off-by: Junio C Hamano --- config.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/config.c b/config.c index 532732fc33..42940154d0 100644 --- a/config.c +++ b/config.c @@ -1556,7 +1556,7 @@ static int git_default_i18n_config(const char *var, const char *value) static int git_default_branch_config(const char *var, const char *value) { if (!strcmp(var, "branch.autosetupmerge")) { - if (value && !strcasecmp(value, "always")) { + if (value && !strcmp(value, "always")) { git_branch_track = BRANCH_TRACK_ALWAYS; return 0; } else if (value && !strcmp(value, "inherit")) { From 15f002812f858b49ce7641eb191561843cf31f00 Mon Sep 17 00:00:00 2001 From: Josh Steadmon Date: Tue, 18 Jan 2022 12:49:46 -0800 Subject: [PATCH 4/5] branch,checkout: fix --track usage strings MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit As Ævar pointed out in [1], the use of PARSE_OPT_LITERAL_ARGHELP with a list of allowed parameters is not recommended. Both git-branch and git-checkout were changed in d311566 (branch: add flags and config to inherit tracking, 2021-12-20) to use this discouraged combination for their --track flags. Fix this by removing PARSE_OPT_LITERAL_ARGHELP, and changing the arghelp to simply be "mode". Users may discover allowed values in the manual pages. [1]: https://lore.kernel.org/git/220111.86a6g3yqf9.gmgdl@evledraar.gmail.com/ Signed-off-by: Josh Steadmon Signed-off-by: Junio C Hamano --- builtin/branch.c | 4 ++-- builtin/checkout.c | 6 +++--- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/builtin/branch.c b/builtin/branch.c index 1890afd4e5..2e897fef14 100644 --- a/builtin/branch.c +++ b/builtin/branch.c @@ -632,9 +632,9 @@ int cmd_branch(int argc, const char **argv, const char *prefix) OPT__VERBOSE(&filter.verbose, N_("show hash and subject, give twice for upstream branch")), OPT__QUIET(&quiet, N_("suppress informational messages")), - OPT_CALLBACK_F('t', "track", &track, "direct|inherit", + OPT_CALLBACK_F('t', "track", &track, N_("mode"), N_("set branch tracking configuration"), - PARSE_OPT_OPTARG | PARSE_OPT_LITERAL_ARGHELP, + PARSE_OPT_OPTARG, parse_opt_tracking_mode), OPT_SET_INT_F(0, "set-upstream", &track, N_("do not use"), BRANCH_TRACK_OVERRIDE, PARSE_OPT_HIDDEN), diff --git a/builtin/checkout.c b/builtin/checkout.c index 8d511aa6b7..389720acbe 100644 --- a/builtin/checkout.c +++ b/builtin/checkout.c @@ -1530,9 +1530,9 @@ static struct option *add_common_switch_branch_options( { struct option options[] = { OPT_BOOL('d', "detach", &opts->force_detach, N_("detach HEAD at named commit")), - OPT_CALLBACK_F('t', "track", &opts->track, "direct|inherit", - N_("set up tracking mode (see git-pull(1))"), - PARSE_OPT_OPTARG | PARSE_OPT_LITERAL_ARGHELP, + OPT_CALLBACK_F('t', "track", &opts->track, N_("mode"), + N_("set branch tracking configuration"), + PARSE_OPT_OPTARG, parse_opt_tracking_mode), OPT__FORCE(&opts->force, N_("force checkout (throw away local modifications)"), PARSE_OPT_NOCOMPLETE), From 6327f0efed36c64d98a140110171362b7cb75a52 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ren=C3=A9=20Scharfe?= Date: Thu, 20 Jan 2022 13:35:54 +0100 Subject: [PATCH 5/5] branch,checkout: fix --track documentation MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Document that the accepted variants of the --track option are --track, --track=direct, and --track=inherit. The equal sign in the latter two cannot be replaced with whitespace; in general optional arguments need to be attached firmly to their option. Put "direct" consistently before "inherit", if only for the reasons that the former is the default, explained first in the documentation, and comes before the latter alphabetically. Mention both modes in the short help so that readers don't have to look them up in the full documentation. They are literal strings and thus untranslatable. PARSE_OPT_LITERAL_ARGHELP is inferred due to the pipe and parenthesis characters, so we don't have to provide that flag explicitly. Mention that -t has the same effect as --track and --track=direct. There is no way to specify inherit mode using the short option, because short options generally don't accept optional arguments. Signed-off-by: René Scharfe Signed-off-by: Junio C Hamano --- Documentation/git-branch.txt | 12 ++++++------ Documentation/git-checkout.txt | 2 +- builtin/branch.c | 2 +- builtin/checkout.c | 2 +- 4 files changed, 9 insertions(+), 9 deletions(-) diff --git a/Documentation/git-branch.txt b/Documentation/git-branch.txt index 75beea7bac..c59687a4d9 100644 --- a/Documentation/git-branch.txt +++ b/Documentation/git-branch.txt @@ -16,7 +16,7 @@ SYNOPSIS [--points-at ] [--format=] [(-r | --remotes) | (-a | --all)] [--list] [...] -'git branch' [--track [direct|inherit] | --no-track] [-f] [] +'git branch' [--track[=(direct|inherit)] | --no-track] [-f] [] 'git branch' (--set-upstream-to= | -u ) [] 'git branch' --unset-upstream [] 'git branch' (-m | -M) [] @@ -206,7 +206,7 @@ This option is only applicable in non-verbose mode. Display the full sha1s in the output listing rather than abbreviating them. -t:: ---track [inherit|direct]:: +--track[=(direct|inherit)]:: When creating a new branch, set up `branch..remote` and `branch..merge` configuration entries to set "upstream" tracking configuration for the new branch. This @@ -216,11 +216,11 @@ This option is only applicable in non-verbose mode. upstream when the new branch is checked out. + The exact upstream branch is chosen depending on the optional argument: -`--track` or `--track direct` means to use the start-point branch itself as the -upstream; `--track inherit` means to copy the upstream configuration of the -start-point branch. +`-t`, `--track`, or `--track=direct` means to use the start-point branch +itself as the upstream; `--track=inherit` means to copy the upstream +configuration of the start-point branch. + -`--track direct` is the default when the start point is a remote-tracking branch. +`--track=direct` is the default when the start point is a remote-tracking branch. Set the branch.autoSetupMerge configuration variable to `false` if you want `git switch`, `git checkout` and `git branch` to always behave as if `--no-track` were given. Set it to `always` if you want this behavior when the diff --git a/Documentation/git-checkout.txt b/Documentation/git-checkout.txt index 61825b060d..4353f1031b 100644 --- a/Documentation/git-checkout.txt +++ b/Documentation/git-checkout.txt @@ -156,7 +156,7 @@ of it"). linkgit:git-branch[1] for details. -t:: ---track [direct|inherit]:: +--track[=(direct|inherit)]:: When creating a new branch, set up "upstream" configuration. See "--track" in linkgit:git-branch[1] for details. + diff --git a/builtin/branch.c b/builtin/branch.c index 2e897fef14..c5de1207e4 100644 --- a/builtin/branch.c +++ b/builtin/branch.c @@ -632,7 +632,7 @@ int cmd_branch(int argc, const char **argv, const char *prefix) OPT__VERBOSE(&filter.verbose, N_("show hash and subject, give twice for upstream branch")), OPT__QUIET(&quiet, N_("suppress informational messages")), - OPT_CALLBACK_F('t', "track", &track, N_("mode"), + OPT_CALLBACK_F('t', "track", &track, "(direct|inherit)", N_("set branch tracking configuration"), PARSE_OPT_OPTARG, parse_opt_tracking_mode), diff --git a/builtin/checkout.c b/builtin/checkout.c index 389720acbe..1809ac12df 100644 --- a/builtin/checkout.c +++ b/builtin/checkout.c @@ -1530,7 +1530,7 @@ static struct option *add_common_switch_branch_options( { struct option options[] = { OPT_BOOL('d', "detach", &opts->force_detach, N_("detach HEAD at named commit")), - OPT_CALLBACK_F('t', "track", &opts->track, N_("mode"), + OPT_CALLBACK_F('t', "track", &opts->track, "(direct|inherit)", N_("set branch tracking configuration"), PARSE_OPT_OPTARG, parse_opt_tracking_mode),