Merge branch 'js/branch-track-inherit'

"git -c branch.autosetupmerge=inherit branch new old" makes "new"
to have the same upstream as the "old" branch, instead of marking
"old" itself as its upstream.

* js/branch-track-inherit:
  config: require lowercase for branch.*.autosetupmerge
  branch: add flags and config to inherit tracking
  branch: accept multiple upstream branches for tracking
pull/1183/head
Junio C Hamano 9 months ago
commit 0669bdf4eb
  1. 3
      Documentation/config/branch.txt
  2. 24
      Documentation/git-branch.txt
  3. 2
      Documentation/git-checkout.txt
  4. 2
      Documentation/git-switch.txt
  5. 192
      branch.c
  6. 3
      branch.h
  7. 6
      builtin/branch.c
  8. 6
      builtin/checkout.c
  9. 5
      config.c
  10. 16
      parse-options-cb.c
  11. 2
      parse-options.h
  12. 11
      t/t2017-checkout-orphan.sh
  13. 23
      t/t2027-checkout-track.sh
  14. 28
      t/t2060-switch.sh
  15. 39
      t/t3200-branch.sh
  16. 17
      t/t7201-co.sh

@ -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::

@ -16,7 +16,7 @@ SYNOPSIS
[--points-at <object>] [--format=<format>]
[(-r | --remotes) | (-a | --all)]
[--list] [<pattern>...]
'git branch' [--track | --no-track] [-f] <branchname> [<start-point>]
'git branch' [--track [direct|inherit] | --no-track] [-f] <branchname> [<start-point>]
'git branch' (--set-upstream-to=<upstream> | -u <upstream>) [<branchname>]
'git branch' --unset-upstream [<branchname>]
'git branch' (-m | -M) [<oldbranch>] <newbranch>
@ -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.<name>.remote` and
`branch.<name>.merge` configuration entries to mark the
start-point branch as "upstream" from the new branch. This
`branch.<name>.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.<name>.remote` and `branch.<name>.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.

@ -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.
+

@ -151,7 +151,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.

@ -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;
}
@ -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.<name>.remote` and `branch.<name>.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);
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 {
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);
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,64 @@ 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;
}
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.<new_ref>.{remote,merge} from the
@ -135,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)
@ -147,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;
@ -156,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)

@ -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;

@ -638,8 +638,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")),

@ -1549,8 +1549,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")),

@ -1559,9 +1559,12 @@ 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")) {
git_branch_track = BRANCH_TRACK_INHERIT;
return 0;
}
git_branch_track = git_config_bool(var, value);
return 0;

@ -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;
}

@ -301,6 +301,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))

@ -63,8 +63,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^
'

@ -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

@ -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

@ -979,15 +979,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 <<EOF
@ -1461,4 +1461,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

@ -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

Loading…
Cancel
Save