2014-02-28 07:43:33 +01:00
|
|
|
#include "git-compat-util.h"
|
2008-02-07 17:40:08 +01:00
|
|
|
#include "cache.h"
|
2017-06-14 20:07:36 +02:00
|
|
|
#include "config.h"
|
2008-02-07 17:40:08 +01:00
|
|
|
#include "branch.h"
|
|
|
|
|
#include "refs.h"
|
2018-05-17 00:57:48 +02:00
|
|
|
#include "refspec.h"
|
2008-02-07 17:40:08 +01:00
|
|
|
#include "remote.h"
|
2019-04-16 12:18:41 +02:00
|
|
|
#include "sequencer.h"
|
2008-02-07 17:40:08 +01:00
|
|
|
#include "commit.h"
|
2015-10-02 13:55:31 +02:00
|
|
|
#include "worktree.h"
|
branch: add --recurse-submodules option for branch creation
To improve the submodules UX, we would like to teach Git to handle
branches in submodules. Start this process by teaching "git branch" the
--recurse-submodules option so that "git branch --recurse-submodules
topic" will create the `topic` branch in the superproject and its
submodules.
Although this commit does not introduce breaking changes, it does not
work well with existing --recurse-submodules commands because "git
branch --recurse-submodules" writes to the submodule ref store, but most
commands only consider the superproject gitlink and ignore the submodule
ref store. For example, "git checkout --recurse-submodules" will check
out the commits in the superproject gitlinks (and put the submodules in
detached HEAD) instead of checking out the submodule branches.
Because of this, this commit introduces a new configuration value,
`submodule.propagateBranches`. The plan is for Git commands to
prioritize submodule ref store information over superproject gitlinks if
this value is true. Because "git branch --recurse-submodules" writes to
submodule ref stores, for the sake of clarity, it will not function
unless this configuration value is set.
This commit also includes changes that support working with submodules
from a superproject commit because "branch --recurse-submodules" (and
future commands) need to read .gitmodules and gitlinks from the
superproject commit, but submodules are typically read from the
filesystem's .gitmodules and the index's gitlinks. These changes are:
* add a submodules_of_tree() helper that gives the relevant
information of an in-tree submodule (e.g. path and oid) and
initializes the repository
* add is_tree_submodule_active() by adding a treeish_name parameter to
is_submodule_active()
* add the "submoduleNotUpdated" advice to advise users to update the
submodules in their trees
Incidentally, fix an incorrect usage string that combined the 'list'
usage of git branch (-l) with the 'create' usage; this string has been
incorrect since its inception, a8dfd5eac4 (Make builtin-branch.c use
parse_options., 2007-10-07).
Helped-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Glen Choo <chooglen@google.com>
Reviewed-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-01-29 01:04:45 +01:00
|
|
|
#include "submodule-config.h"
|
|
|
|
|
#include "run-command.h"
|
2008-02-07 17:40:08 +01:00
|
|
|
|
|
|
|
|
struct tracking {
|
2018-05-17 00:57:49 +02:00
|
|
|
struct refspec_item spec;
|
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 <steadmon@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-12-21 04:30:23 +01:00
|
|
|
struct string_list *srcs;
|
2008-02-07 17:40:08 +01:00
|
|
|
const char *remote;
|
|
|
|
|
int matches;
|
|
|
|
|
};
|
|
|
|
|
|
2022-04-01 08:05:13 +02:00
|
|
|
struct find_tracked_branch_cb {
|
|
|
|
|
struct tracking *tracking;
|
|
|
|
|
struct string_list ambiguous_remotes;
|
|
|
|
|
};
|
|
|
|
|
|
2008-02-07 17:40:08 +01:00
|
|
|
static int find_tracked_branch(struct remote *remote, void *priv)
|
|
|
|
|
{
|
2022-04-01 08:05:13 +02:00
|
|
|
struct find_tracked_branch_cb *ftb = priv;
|
|
|
|
|
struct tracking *tracking = ftb->tracking;
|
2008-02-07 17:40:08 +01:00
|
|
|
|
|
|
|
|
if (!remote_find_tracking(remote, &tracking->spec)) {
|
2022-04-01 08:05:13 +02:00
|
|
|
switch (++tracking->matches) {
|
|
|
|
|
case 1:
|
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 <steadmon@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-12-21 04:30:23 +01:00
|
|
|
string_list_append(tracking->srcs, tracking->spec.src);
|
2008-02-07 17:40:08 +01:00
|
|
|
tracking->remote = remote->name;
|
2022-04-01 08:05:13 +02:00
|
|
|
break;
|
|
|
|
|
case 2:
|
|
|
|
|
/* there are at least two remotes; backfill the first one */
|
|
|
|
|
string_list_append(&ftb->ambiguous_remotes, tracking->remote);
|
|
|
|
|
/* fall through */
|
|
|
|
|
default:
|
|
|
|
|
string_list_append(&ftb->ambiguous_remotes, remote->name);
|
2008-02-07 17:40:08 +01:00
|
|
|
free(tracking->spec.src);
|
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 <steadmon@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-12-21 04:30:23 +01:00
|
|
|
string_list_clear(tracking->srcs, 0);
|
2022-04-01 08:05:13 +02:00
|
|
|
break;
|
2008-02-07 17:40:08 +01:00
|
|
|
}
|
|
|
|
|
tracking->spec.src = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2009-03-04 07:29:55 +01:00
|
|
|
static int should_setup_rebase(const char *origin)
|
2008-05-11 00:36:29 +02:00
|
|
|
{
|
|
|
|
|
switch (autorebase) {
|
|
|
|
|
case AUTOREBASE_NEVER:
|
|
|
|
|
return 0;
|
|
|
|
|
case AUTOREBASE_LOCAL:
|
2009-03-04 07:29:55 +01:00
|
|
|
return origin == NULL;
|
2008-05-11 00:36:29 +02:00
|
|
|
case AUTOREBASE_REMOTE:
|
2009-03-04 07:29:55 +01:00
|
|
|
return origin != NULL;
|
2008-05-11 00:36:29 +02:00
|
|
|
case AUTOREBASE_ALWAYS:
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2021-12-21 04:30:22 +01:00
|
|
|
/**
|
|
|
|
|
* 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)
|
2009-03-04 07:29:55 +01:00
|
|
|
{
|
refactor skip_prefix to return a boolean
The skip_prefix() function returns a pointer to the content
past the prefix, or NULL if the prefix was not found. While
this is nice and simple, in practice it makes it hard to use
for two reasons:
1. When you want to conditionally skip or keep the string
as-is, you have to introduce a temporary variable.
For example:
tmp = skip_prefix(buf, "foo");
if (tmp)
buf = tmp;
2. It is verbose to check the outcome in a conditional, as
you need extra parentheses to silence compiler
warnings. For example:
if ((cp = skip_prefix(buf, "foo"))
/* do something with cp */
Both of these make it harder to use for long if-chains, and
we tend to use starts_with() instead. However, the first line
of "do something" is often to then skip forward in buf past
the prefix, either using a magic constant or with an extra
strlen(3) (which is generally computed at compile time, but
means we are repeating ourselves).
This patch refactors skip_prefix() to return a simple boolean,
and to provide the pointer value as an out-parameter. If the
prefix is not found, the out-parameter is untouched. This
lets you write:
if (skip_prefix(arg, "foo ", &arg))
do_foo(arg);
else if (skip_prefix(arg, "bar ", &arg))
do_bar(arg);
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2014-06-18 21:44:19 +02:00
|
|
|
const char *shortname = NULL;
|
2009-03-04 07:29:55 +01:00
|
|
|
struct strbuf key = STRBUF_INIT;
|
2021-12-21 04:30:22 +01:00
|
|
|
struct string_list_item *item;
|
2009-03-04 07:29:55 +01:00
|
|
|
int rebasing = should_setup_rebase(origin);
|
|
|
|
|
|
2021-12-21 04:30:22 +01:00
|
|
|
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)) {
|
2022-01-10 20:52:54 +01:00
|
|
|
warning(_("not setting branch '%s' as its own upstream"),
|
2021-12-21 04:30:22 +01:00
|
|
|
local);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2010-01-18 21:44:12 +01:00
|
|
|
|
2009-03-04 07:29:55 +01:00
|
|
|
strbuf_addf(&key, "branch.%s.remote", local);
|
2016-02-22 12:23:35 +01:00
|
|
|
if (git_config_set_gently(key.buf, origin ? origin : ".") < 0)
|
2016-02-22 12:23:23 +01:00
|
|
|
goto out_err;
|
2009-03-04 07:29:55 +01:00
|
|
|
|
|
|
|
|
strbuf_reset(&key);
|
|
|
|
|
strbuf_addf(&key, "branch.%s.merge", local);
|
2021-12-21 04:30:22 +01:00
|
|
|
/*
|
|
|
|
|
* 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)
|
2016-02-22 12:23:23 +01:00
|
|
|
goto out_err;
|
2021-12-21 04:30:22 +01:00
|
|
|
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;
|
2009-03-04 07:29:55 +01:00
|
|
|
|
|
|
|
|
if (rebasing) {
|
|
|
|
|
strbuf_reset(&key);
|
|
|
|
|
strbuf_addf(&key, "branch.%s.rebase", local);
|
2016-02-22 12:23:35 +01:00
|
|
|
if (git_config_set_gently(key.buf, "true") < 0)
|
2016-02-22 12:23:23 +01:00
|
|
|
goto out_err;
|
2009-03-04 07:29:55 +01:00
|
|
|
}
|
2012-06-07 14:05:10 +02:00
|
|
|
strbuf_release(&key);
|
2009-03-04 07:29:55 +01:00
|
|
|
|
2009-03-10 09:20:42 +01:00
|
|
|
if (flag & BRANCH_CONFIG_VERBOSE) {
|
2021-12-21 04:30:22 +01:00
|
|
|
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);
|
2014-03-10 06:32:01 +01:00
|
|
|
} else {
|
2021-12-21 04:30:22 +01:00
|
|
|
printf_ln(_("branch '%s' set up to track:"), local);
|
|
|
|
|
for_each_string_list_item(item, &friendly_ref_names)
|
|
|
|
|
printf_ln(" %s", item->string);
|
2014-03-10 06:32:01 +01:00
|
|
|
}
|
2021-12-21 04:30:22 +01:00
|
|
|
|
|
|
|
|
string_list_clear(&friendly_ref_names, 0);
|
2009-03-10 09:20:42 +01:00
|
|
|
}
|
2016-02-22 12:23:23 +01:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
out_err:
|
|
|
|
|
strbuf_release(&key);
|
2021-12-01 23:15:42 +01:00
|
|
|
error(_("unable to write upstream branch configuration"));
|
2016-02-22 12:23:23 +01:00
|
|
|
|
2021-12-21 04:30:22 +01:00
|
|
|
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);
|
|
|
|
|
}
|
2016-02-22 12:23:23 +01:00
|
|
|
|
|
|
|
|
return -1;
|
2009-03-04 07:29:55 +01:00
|
|
|
}
|
|
|
|
|
|
2021-12-21 04:30:22 +01:00
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
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 <steadmon@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-12-21 04:30:23 +01:00
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2008-02-07 17:40:08 +01:00
|
|
|
/*
|
2022-01-29 01:04:41 +01:00
|
|
|
* Used internally to set the branch.<new_ref>.{remote,merge} config
|
|
|
|
|
* settings so that branch 'new_ref' tracks 'orig_ref'. Unlike
|
|
|
|
|
* dwim_and_setup_tracking(), this does not do DWIM, i.e. "origin/main"
|
|
|
|
|
* will not be expanded to "refs/remotes/origin/main", so it is not safe
|
|
|
|
|
* for 'orig_ref' to be raw user input.
|
2008-02-07 17:40:08 +01:00
|
|
|
*/
|
2016-02-22 12:23:23 +01:00
|
|
|
static void setup_tracking(const char *new_ref, const char *orig_ref,
|
|
|
|
|
enum branch_track track, int quiet)
|
2008-02-07 17:40:08 +01:00
|
|
|
{
|
|
|
|
|
struct tracking tracking;
|
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 <steadmon@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-12-21 04:30:23 +01:00
|
|
|
struct string_list tracking_srcs = STRING_LIST_INIT_DUP;
|
2012-03-27 01:51:01 +02:00
|
|
|
int config_flags = quiet ? 0 : BRANCH_CONFIG_VERBOSE;
|
2022-04-01 08:05:13 +02:00
|
|
|
struct find_tracked_branch_cb ftb_cb = {
|
|
|
|
|
.tracking = &tracking,
|
|
|
|
|
.ambiguous_remotes = STRING_LIST_INIT_DUP,
|
|
|
|
|
};
|
2008-02-07 17:40:08 +01:00
|
|
|
|
2022-03-29 22:01:16 +02:00
|
|
|
if (!track)
|
|
|
|
|
BUG("asked to set up tracking, but tracking is disallowed");
|
|
|
|
|
|
2008-02-07 17:40:08 +01:00
|
|
|
memset(&tracking, 0, sizeof(tracking));
|
|
|
|
|
tracking.spec.dst = (char *)orig_ref;
|
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 <steadmon@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-12-21 04:30:23 +01:00
|
|
|
tracking.srcs = &tracking_srcs;
|
|
|
|
|
if (track != BRANCH_TRACK_INHERIT)
|
2022-04-01 08:05:13 +02:00
|
|
|
for_each_remote(find_tracked_branch, &ftb_cb);
|
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 <steadmon@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-12-21 04:30:23 +01:00
|
|
|
else if (inherit_tracking(&tracking, orig_ref))
|
2022-01-29 01:04:46 +01:00
|
|
|
goto cleanup;
|
2008-02-07 17:40:08 +01:00
|
|
|
|
2008-02-19 17:24:37 +01:00
|
|
|
if (!tracking.matches)
|
|
|
|
|
switch (track) {
|
|
|
|
|
case BRANCH_TRACK_ALWAYS:
|
|
|
|
|
case BRANCH_TRACK_EXPLICIT:
|
2010-01-18 21:44:11 +01:00
|
|
|
case BRANCH_TRACK_OVERRIDE:
|
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 <steadmon@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-12-21 04:30:23 +01:00
|
|
|
case BRANCH_TRACK_INHERIT:
|
2008-02-19 17:24:37 +01:00
|
|
|
break;
|
|
|
|
|
default:
|
2022-01-29 01:04:46 +01:00
|
|
|
goto cleanup;
|
2008-02-19 17:24:37 +01:00
|
|
|
}
|
|
|
|
|
|
2022-04-01 08:05:13 +02:00
|
|
|
if (tracking.matches > 1) {
|
|
|
|
|
int status = die_message(_("not tracking: ambiguous information for ref '%s'"),
|
|
|
|
|
orig_ref);
|
|
|
|
|
if (advice_enabled(ADVICE_AMBIGUOUS_FETCH_REFSPEC)) {
|
|
|
|
|
struct strbuf remotes_advice = STRBUF_INIT;
|
|
|
|
|
struct string_list_item *item;
|
|
|
|
|
|
|
|
|
|
for_each_string_list_item(item, &ftb_cb.ambiguous_remotes)
|
|
|
|
|
/*
|
|
|
|
|
* TRANSLATORS: This is a line listing a remote with duplicate
|
|
|
|
|
* refspecs in the advice message below. For RTL languages you'll
|
|
|
|
|
* probably want to swap the "%s" and leading " " space around.
|
|
|
|
|
*/
|
|
|
|
|
strbuf_addf(&remotes_advice, _(" %s\n"), item->string);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* TRANSLATORS: The second argument is a \n-delimited list of
|
|
|
|
|
* duplicate refspecs, composed above.
|
|
|
|
|
*/
|
|
|
|
|
advise(_("There are multiple remotes whose fetch refspecs map to the remote\n"
|
|
|
|
|
"tracking ref '%s':\n"
|
|
|
|
|
"%s"
|
|
|
|
|
"\n"
|
|
|
|
|
"This is typically a configuration error.\n"
|
|
|
|
|
"\n"
|
|
|
|
|
"To support setting up tracking branches, ensure that\n"
|
|
|
|
|
"different remotes' fetch refspecs map into different\n"
|
|
|
|
|
"tracking namespaces."), orig_ref,
|
|
|
|
|
remotes_advice.buf);
|
|
|
|
|
strbuf_release(&remotes_advice);
|
|
|
|
|
}
|
|
|
|
|
exit(status);
|
|
|
|
|
}
|
2008-02-07 17:40:08 +01:00
|
|
|
|
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 <steadmon@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-12-21 04:30:23 +01:00
|
|
|
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)
|
2022-03-29 22:01:19 +02:00
|
|
|
exit(1);
|
2008-02-07 17:40:08 +01:00
|
|
|
|
2022-01-29 01:04:46 +01:00
|
|
|
cleanup:
|
|
|
|
|
string_list_clear(&tracking_srcs, 0);
|
2022-04-01 08:05:13 +02:00
|
|
|
string_list_clear(&ftb_cb.ambiguous_remotes, 0);
|
2008-02-07 17:40:08 +01:00
|
|
|
}
|
|
|
|
|
|
2011-09-22 05:19:38 +02:00
|
|
|
int read_branch_desc(struct strbuf *buf, const char *branch_name)
|
|
|
|
|
{
|
2014-08-07 19:56:42 +02:00
|
|
|
char *v = NULL;
|
2011-09-22 05:19:38 +02:00
|
|
|
struct strbuf name = STRBUF_INIT;
|
|
|
|
|
strbuf_addf(&name, "branch.%s.description", branch_name);
|
2014-08-07 19:56:42 +02:00
|
|
|
if (git_config_get_string(name.buf, &v)) {
|
|
|
|
|
strbuf_release(&name);
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
strbuf_addstr(buf, v);
|
|
|
|
|
free(v);
|
2011-09-22 05:19:38 +02:00
|
|
|
strbuf_release(&name);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2017-10-13 06:45:40 +02:00
|
|
|
/*
|
|
|
|
|
* Check if 'name' can be a valid name for a branch; die otherwise.
|
|
|
|
|
* Return 1 if the named branch already exists; return 0 otherwise.
|
|
|
|
|
* Fill ref with the full refname for the branch.
|
|
|
|
|
*/
|
|
|
|
|
int validate_branchname(const char *name, struct strbuf *ref)
|
2011-08-20 23:49:48 +02:00
|
|
|
{
|
|
|
|
|
if (strbuf_check_branch_ref(ref, name))
|
2021-12-01 23:15:42 +01:00
|
|
|
die(_("'%s' is not a valid branch name"), name);
|
2011-08-20 23:49:48 +02:00
|
|
|
|
2017-10-13 06:45:40 +02:00
|
|
|
return ref_exists(ref->buf);
|
|
|
|
|
}
|
2011-08-20 23:49:48 +02:00
|
|
|
|
2017-10-13 06:45:40 +02:00
|
|
|
/*
|
|
|
|
|
* Check if a branch 'name' can be created as a new branch; die otherwise.
|
|
|
|
|
* 'force' can be used when it is OK for the named branch already exists.
|
|
|
|
|
* Return 1 if the named branch already exists; return 0 otherwise.
|
|
|
|
|
* Fill ref with the full refname for the branch.
|
|
|
|
|
*/
|
|
|
|
|
int validate_new_branchname(const char *name, struct strbuf *ref, int force)
|
|
|
|
|
{
|
2021-12-01 23:15:47 +01:00
|
|
|
struct worktree **worktrees;
|
|
|
|
|
const struct worktree *wt;
|
2017-10-13 06:45:40 +02:00
|
|
|
|
|
|
|
|
if (!validate_branchname(name, ref))
|
2011-08-20 23:49:48 +02:00
|
|
|
return 0;
|
|
|
|
|
|
2017-10-13 05:57:02 +02:00
|
|
|
if (!force)
|
2021-12-01 23:15:42 +01:00
|
|
|
die(_("a branch named '%s' already exists"),
|
2017-10-13 05:57:02 +02:00
|
|
|
ref->buf + strlen("refs/heads/"));
|
|
|
|
|
|
2021-12-01 23:15:47 +01:00
|
|
|
worktrees = get_worktrees();
|
|
|
|
|
wt = find_shared_symref(worktrees, "HEAD", ref->buf);
|
|
|
|
|
if (wt && !wt->is_bare)
|
2022-01-11 13:36:27 +01:00
|
|
|
die(_("cannot force update the branch '%s' "
|
2021-12-01 23:15:47 +01:00
|
|
|
"checked out at '%s'"),
|
|
|
|
|
ref->buf + strlen("refs/heads/"), wt->path);
|
|
|
|
|
free_worktrees(worktrees);
|
2011-08-20 23:49:48 +02:00
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
branch.c: Validate tracking branches with refspecs instead of refs/remotes/*
The current code for validating tracking branches (e.g. the argument to
the -t/--track option) hardcodes refs/heads/* and refs/remotes/* as the
potential locations for tracking branches. This works with the refspecs
created by "git clone" or "git remote add", but is suboptimal in other
cases:
- If "refs/remotes/foo/bar" exists without any association to a remote
(i.e. there is no remote named "foo", or no remote with a refspec
that matches "refs/remotes/foo/bar"), then it is impossible to set up
a valid upstream config that tracks it. Currently, the code defaults
to using "refs/remotes/foo/bar" from repo "." as the upstream, which
works, but is probably not what the user had in mind when running
"git branch baz --track foo/bar".
- If the user has tweaked the fetch refspec for a remote to put its
remote-tracking branches outside of refs/remotes/*, e.g. by running
git config remote.foo.fetch "+refs/heads/*:refs/foo_stuff/*"
then the current code will refuse to use its remote-tracking branches
as --track arguments, since they do not match refs/remotes/*.
This patch removes the "refs/remotes/*" requirement for upstream branches,
and replaces it with explicit checking of the refspecs for each remote to
determine whether a given --track argument is a valid remote-tracking
branch. This solves both of the above problems, since the matching refspec
guarantees that there is a both a remote name and a remote branch name
that can be used for the upstream config.
However, this means that refs located within refs/remotes/* without a
corresponding remote/refspec will no longer be usable as upstreams.
The few existing tests which depended on this behavioral quirk has
already been fixed in the preceding patches.
This patch fixes the last remaining test failure in t2024-checkout-dwim.
Signed-off-by: Johan Herland <johan@herland.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-21 23:52:05 +02:00
|
|
|
static int check_tracking_branch(struct remote *remote, void *cb_data)
|
|
|
|
|
{
|
|
|
|
|
char *tracking_branch = cb_data;
|
2018-05-17 00:57:49 +02:00
|
|
|
struct refspec_item query;
|
|
|
|
|
memset(&query, 0, sizeof(struct refspec_item));
|
branch.c: Validate tracking branches with refspecs instead of refs/remotes/*
The current code for validating tracking branches (e.g. the argument to
the -t/--track option) hardcodes refs/heads/* and refs/remotes/* as the
potential locations for tracking branches. This works with the refspecs
created by "git clone" or "git remote add", but is suboptimal in other
cases:
- If "refs/remotes/foo/bar" exists without any association to a remote
(i.e. there is no remote named "foo", or no remote with a refspec
that matches "refs/remotes/foo/bar"), then it is impossible to set up
a valid upstream config that tracks it. Currently, the code defaults
to using "refs/remotes/foo/bar" from repo "." as the upstream, which
works, but is probably not what the user had in mind when running
"git branch baz --track foo/bar".
- If the user has tweaked the fetch refspec for a remote to put its
remote-tracking branches outside of refs/remotes/*, e.g. by running
git config remote.foo.fetch "+refs/heads/*:refs/foo_stuff/*"
then the current code will refuse to use its remote-tracking branches
as --track arguments, since they do not match refs/remotes/*.
This patch removes the "refs/remotes/*" requirement for upstream branches,
and replaces it with explicit checking of the refspecs for each remote to
determine whether a given --track argument is a valid remote-tracking
branch. This solves both of the above problems, since the matching refspec
guarantees that there is a both a remote name and a remote branch name
that can be used for the upstream config.
However, this means that refs located within refs/remotes/* without a
corresponding remote/refspec will no longer be usable as upstreams.
The few existing tests which depended on this behavioral quirk has
already been fixed in the preceding patches.
This patch fixes the last remaining test failure in t2024-checkout-dwim.
Signed-off-by: Johan Herland <johan@herland.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-21 23:52:05 +02:00
|
|
|
query.dst = tracking_branch;
|
2013-09-08 22:58:15 +02:00
|
|
|
return !remote_find_tracking(remote, &query);
|
branch.c: Validate tracking branches with refspecs instead of refs/remotes/*
The current code for validating tracking branches (e.g. the argument to
the -t/--track option) hardcodes refs/heads/* and refs/remotes/* as the
potential locations for tracking branches. This works with the refspecs
created by "git clone" or "git remote add", but is suboptimal in other
cases:
- If "refs/remotes/foo/bar" exists without any association to a remote
(i.e. there is no remote named "foo", or no remote with a refspec
that matches "refs/remotes/foo/bar"), then it is impossible to set up
a valid upstream config that tracks it. Currently, the code defaults
to using "refs/remotes/foo/bar" from repo "." as the upstream, which
works, but is probably not what the user had in mind when running
"git branch baz --track foo/bar".
- If the user has tweaked the fetch refspec for a remote to put its
remote-tracking branches outside of refs/remotes/*, e.g. by running
git config remote.foo.fetch "+refs/heads/*:refs/foo_stuff/*"
then the current code will refuse to use its remote-tracking branches
as --track arguments, since they do not match refs/remotes/*.
This patch removes the "refs/remotes/*" requirement for upstream branches,
and replaces it with explicit checking of the refspecs for each remote to
determine whether a given --track argument is a valid remote-tracking
branch. This solves both of the above problems, since the matching refspec
guarantees that there is a both a remote name and a remote branch name
that can be used for the upstream config.
However, this means that refs located within refs/remotes/* without a
corresponding remote/refspec will no longer be usable as upstreams.
The few existing tests which depended on this behavioral quirk has
already been fixed in the preceding patches.
This patch fixes the last remaining test failure in t2024-checkout-dwim.
Signed-off-by: Johan Herland <johan@herland.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-21 23:52:05 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int validate_remote_tracking_branch(char *ref)
|
|
|
|
|
{
|
|
|
|
|
return !for_each_remote(check_tracking_branch, ref);
|
|
|
|
|
}
|
|
|
|
|
|
2013-04-02 21:03:55 +02:00
|
|
|
static const char upstream_not_branch[] =
|
2021-12-01 23:15:42 +01:00
|
|
|
N_("cannot set up tracking information; starting point '%s' is not a branch");
|
2013-04-02 21:04:27 +02:00
|
|
|
static const char upstream_missing[] =
|
2013-04-02 21:05:12 +02:00
|
|
|
N_("the requested upstream branch '%s' does not exist");
|
|
|
|
|
static const char upstream_advice[] =
|
|
|
|
|
N_("\n"
|
|
|
|
|
"If you are planning on basing your work on an upstream\n"
|
|
|
|
|
"branch that already exists at the remote, you may need to\n"
|
|
|
|
|
"run \"git fetch\" to retrieve it.\n"
|
|
|
|
|
"\n"
|
|
|
|
|
"If you are planning to push out a new local branch that\n"
|
|
|
|
|
"will track its remote counterpart, you may want to use\n"
|
|
|
|
|
"\"git push -u\" to set the upstream config as you push.");
|
2013-04-02 21:03:55 +02:00
|
|
|
|
2022-01-29 01:04:41 +01:00
|
|
|
/**
|
|
|
|
|
* DWIMs a user-provided ref to determine the starting point for a
|
|
|
|
|
* branch and validates it, where:
|
|
|
|
|
*
|
|
|
|
|
* - r is the repository to validate the branch for
|
|
|
|
|
*
|
|
|
|
|
* - start_name is the ref that we would like to test. This is
|
|
|
|
|
* expanded with DWIM and assigned to out_real_ref.
|
|
|
|
|
*
|
|
|
|
|
* - track is the tracking mode of the new branch. If tracking is
|
|
|
|
|
* explicitly requested, start_name must be a branch (because
|
|
|
|
|
* otherwise start_name cannot be tracked)
|
|
|
|
|
*
|
|
|
|
|
* - out_oid is an out parameter containing the object_id of start_name
|
|
|
|
|
*
|
|
|
|
|
* - out_real_ref is an out parameter containing the full, 'real' form
|
|
|
|
|
* of start_name e.g. refs/heads/main instead of main
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
static void dwim_branch_start(struct repository *r, const char *start_name,
|
|
|
|
|
enum branch_track track, char **out_real_ref,
|
|
|
|
|
struct object_id *out_oid)
|
2008-02-07 17:40:08 +01:00
|
|
|
{
|
|
|
|
|
struct commit *commit;
|
2017-05-01 04:29:00 +02:00
|
|
|
struct object_id oid;
|
2017-03-28 21:46:36 +02:00
|
|
|
char *real_ref;
|
2010-01-18 21:44:11 +01:00
|
|
|
int explicit_tracking = 0;
|
|
|
|
|
|
|
|
|
|
if (track == BRANCH_TRACK_EXPLICIT || track == BRANCH_TRACK_OVERRIDE)
|
|
|
|
|
explicit_tracking = 1;
|
2008-02-07 17:40:08 +01:00
|
|
|
|
|
|
|
|
real_ref = NULL;
|
2019-04-27 14:02:22 +02:00
|
|
|
if (get_oid_mb(start_name, &oid)) {
|
2013-04-02 21:05:12 +02:00
|
|
|
if (explicit_tracking) {
|
2022-04-01 00:41:18 +02:00
|
|
|
int code = die_message(_(upstream_missing), start_name);
|
|
|
|
|
advise_if_enabled(ADVICE_SET_UPSTREAM_FAILURE,
|
|
|
|
|
_(upstream_advice));
|
|
|
|
|
exit(code);
|
2013-04-02 21:05:12 +02:00
|
|
|
}
|
2021-12-01 23:15:42 +01:00
|
|
|
die(_("not a valid object name: '%s'"), start_name);
|
2013-04-02 21:04:27 +02:00
|
|
|
}
|
2008-02-07 17:40:08 +01:00
|
|
|
|
2020-09-02 00:28:09 +02:00
|
|
|
switch (dwim_ref(start_name, strlen(start_name), &oid, &real_ref, 0)) {
|
2008-02-07 17:40:08 +01:00
|
|
|
case 0:
|
|
|
|
|
/* Not branching from any existing branch */
|
2010-01-18 21:44:11 +01:00
|
|
|
if (explicit_tracking)
|
2013-04-02 21:04:51 +02:00
|
|
|
die(_(upstream_not_branch), start_name);
|
2008-02-07 17:40:08 +01:00
|
|
|
break;
|
|
|
|
|
case 1:
|
2011-02-17 00:12:20 +01:00
|
|
|
/* Unique completion -- good, only if it is a real branch */
|
2013-11-30 21:55:40 +01:00
|
|
|
if (!starts_with(real_ref, "refs/heads/") &&
|
branch.c: Validate tracking branches with refspecs instead of refs/remotes/*
The current code for validating tracking branches (e.g. the argument to
the -t/--track option) hardcodes refs/heads/* and refs/remotes/* as the
potential locations for tracking branches. This works with the refspecs
created by "git clone" or "git remote add", but is suboptimal in other
cases:
- If "refs/remotes/foo/bar" exists without any association to a remote
(i.e. there is no remote named "foo", or no remote with a refspec
that matches "refs/remotes/foo/bar"), then it is impossible to set up
a valid upstream config that tracks it. Currently, the code defaults
to using "refs/remotes/foo/bar" from repo "." as the upstream, which
works, but is probably not what the user had in mind when running
"git branch baz --track foo/bar".
- If the user has tweaked the fetch refspec for a remote to put its
remote-tracking branches outside of refs/remotes/*, e.g. by running
git config remote.foo.fetch "+refs/heads/*:refs/foo_stuff/*"
then the current code will refuse to use its remote-tracking branches
as --track arguments, since they do not match refs/remotes/*.
This patch removes the "refs/remotes/*" requirement for upstream branches,
and replaces it with explicit checking of the refspecs for each remote to
determine whether a given --track argument is a valid remote-tracking
branch. This solves both of the above problems, since the matching refspec
guarantees that there is a both a remote name and a remote branch name
that can be used for the upstream config.
However, this means that refs located within refs/remotes/* without a
corresponding remote/refspec will no longer be usable as upstreams.
The few existing tests which depended on this behavioral quirk has
already been fixed in the preceding patches.
This patch fixes the last remaining test failure in t2024-checkout-dwim.
Signed-off-by: Johan Herland <johan@herland.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-04-21 23:52:05 +02:00
|
|
|
validate_remote_tracking_branch(real_ref)) {
|
2011-02-17 00:12:20 +01:00
|
|
|
if (explicit_tracking)
|
2013-04-02 21:04:51 +02:00
|
|
|
die(_(upstream_not_branch), start_name);
|
2011-02-17 00:12:20 +01:00
|
|
|
else
|
2021-04-25 16:16:12 +02:00
|
|
|
FREE_AND_NULL(real_ref);
|
2011-02-17 00:12:20 +01:00
|
|
|
}
|
2008-02-07 17:40:08 +01:00
|
|
|
break;
|
|
|
|
|
default:
|
2021-12-01 23:15:42 +01:00
|
|
|
die(_("ambiguous object name: '%s'"), start_name);
|
2008-02-07 17:40:08 +01:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2022-05-02 18:50:37 +02:00
|
|
|
if (!(commit = lookup_commit_reference(r, &oid)))
|
2021-12-01 23:15:42 +01:00
|
|
|
die(_("not a valid branch point: '%s'"), start_name);
|
2022-01-29 01:04:41 +01:00
|
|
|
if (out_real_ref) {
|
|
|
|
|
*out_real_ref = real_ref;
|
|
|
|
|
real_ref = NULL;
|
|
|
|
|
}
|
|
|
|
|
if (out_oid)
|
|
|
|
|
oidcpy(out_oid, &commit->object.oid);
|
|
|
|
|
|
|
|
|
|
FREE_AND_NULL(real_ref);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void create_branch(struct repository *r,
|
|
|
|
|
const char *name, const char *start_name,
|
|
|
|
|
int force, int clobber_head_ok, int reflog,
|
2022-01-29 01:04:43 +01:00
|
|
|
int quiet, enum branch_track track, int dry_run)
|
2022-01-29 01:04:41 +01:00
|
|
|
{
|
|
|
|
|
struct object_id oid;
|
|
|
|
|
char *real_ref;
|
|
|
|
|
struct strbuf ref = STRBUF_INIT;
|
|
|
|
|
int forcing = 0;
|
2022-01-29 01:04:42 +01:00
|
|
|
struct ref_transaction *transaction;
|
|
|
|
|
struct strbuf err = STRBUF_INIT;
|
|
|
|
|
char *msg;
|
|
|
|
|
|
|
|
|
|
if (track == BRANCH_TRACK_OVERRIDE)
|
|
|
|
|
BUG("'track' cannot be BRANCH_TRACK_OVERRIDE. Did you mean to call dwim_and_setup_tracking()?");
|
|
|
|
|
if (clobber_head_ok && !force)
|
|
|
|
|
BUG("'clobber_head_ok' can only be used with 'force'");
|
|
|
|
|
|
|
|
|
|
if (clobber_head_ok ?
|
|
|
|
|
validate_branchname(name, &ref) :
|
|
|
|
|
validate_new_branchname(name, &ref, force)) {
|
|
|
|
|
forcing = 1;
|
2022-01-29 01:04:41 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
dwim_branch_start(r, start_name, track, &real_ref, &oid);
|
2022-01-29 01:04:43 +01:00
|
|
|
if (dry_run)
|
|
|
|
|
goto cleanup;
|
2008-02-07 17:40:08 +01:00
|
|
|
|
2014-04-17 01:21:53 +02:00
|
|
|
if (reflog)
|
2017-01-27 11:09:47 +01:00
|
|
|
log_all_ref_updates = LOG_REFS_NORMAL;
|
2014-04-17 01:21:53 +02:00
|
|
|
|
2022-01-29 01:04:42 +01:00
|
|
|
if (forcing)
|
|
|
|
|
msg = xstrfmt("branch: Reset to %s", start_name);
|
|
|
|
|
else
|
|
|
|
|
msg = xstrfmt("branch: Created from %s", start_name);
|
|
|
|
|
transaction = ref_transaction_begin(&err);
|
|
|
|
|
if (!transaction ||
|
|
|
|
|
ref_transaction_update(transaction, ref.buf,
|
|
|
|
|
&oid, forcing ? NULL : null_oid(),
|
|
|
|
|
0, msg, &err) ||
|
|
|
|
|
ref_transaction_commit(transaction, &err))
|
|
|
|
|
die("%s", err.buf);
|
|
|
|
|
ref_transaction_free(transaction);
|
|
|
|
|
strbuf_release(&err);
|
|
|
|
|
free(msg);
|
2014-04-17 01:21:53 +02:00
|
|
|
|
2008-02-07 17:40:08 +01:00
|
|
|
if (real_ref && track)
|
2013-08-30 23:56:46 +02:00
|
|
|
setup_tracking(ref.buf + 11, real_ref, track, quiet);
|
2008-02-07 17:40:08 +01:00
|
|
|
|
2022-01-29 01:04:43 +01:00
|
|
|
cleanup:
|
2009-02-14 08:08:05 +01:00
|
|
|
strbuf_release(&ref);
|
2008-02-19 17:24:37 +01:00
|
|
|
free(real_ref);
|
2008-02-07 17:40:08 +01:00
|
|
|
}
|
2008-02-07 17:40:16 +01:00
|
|
|
|
2022-01-29 01:04:41 +01:00
|
|
|
void dwim_and_setup_tracking(struct repository *r, const char *new_ref,
|
|
|
|
|
const char *orig_ref, enum branch_track track,
|
|
|
|
|
int quiet)
|
|
|
|
|
{
|
|
|
|
|
char *real_orig_ref;
|
|
|
|
|
dwim_branch_start(r, orig_ref, track, &real_orig_ref, NULL);
|
|
|
|
|
setup_tracking(new_ref, real_orig_ref, track, quiet);
|
|
|
|
|
}
|
|
|
|
|
|
branch: add --recurse-submodules option for branch creation
To improve the submodules UX, we would like to teach Git to handle
branches in submodules. Start this process by teaching "git branch" the
--recurse-submodules option so that "git branch --recurse-submodules
topic" will create the `topic` branch in the superproject and its
submodules.
Although this commit does not introduce breaking changes, it does not
work well with existing --recurse-submodules commands because "git
branch --recurse-submodules" writes to the submodule ref store, but most
commands only consider the superproject gitlink and ignore the submodule
ref store. For example, "git checkout --recurse-submodules" will check
out the commits in the superproject gitlinks (and put the submodules in
detached HEAD) instead of checking out the submodule branches.
Because of this, this commit introduces a new configuration value,
`submodule.propagateBranches`. The plan is for Git commands to
prioritize submodule ref store information over superproject gitlinks if
this value is true. Because "git branch --recurse-submodules" writes to
submodule ref stores, for the sake of clarity, it will not function
unless this configuration value is set.
This commit also includes changes that support working with submodules
from a superproject commit because "branch --recurse-submodules" (and
future commands) need to read .gitmodules and gitlinks from the
superproject commit, but submodules are typically read from the
filesystem's .gitmodules and the index's gitlinks. These changes are:
* add a submodules_of_tree() helper that gives the relevant
information of an in-tree submodule (e.g. path and oid) and
initializes the repository
* add is_tree_submodule_active() by adding a treeish_name parameter to
is_submodule_active()
* add the "submoduleNotUpdated" advice to advise users to update the
submodules in their trees
Incidentally, fix an incorrect usage string that combined the 'list'
usage of git branch (-l) with the 'create' usage; this string has been
incorrect since its inception, a8dfd5eac4 (Make builtin-branch.c use
parse_options., 2007-10-07).
Helped-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Glen Choo <chooglen@google.com>
Reviewed-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-01-29 01:04:45 +01:00
|
|
|
/**
|
|
|
|
|
* Creates a branch in a submodule by calling
|
|
|
|
|
* create_branches_recursively() in a child process. The child process
|
|
|
|
|
* is necessary because install_branch_config_multiple_remotes() (which
|
|
|
|
|
* is called by setup_tracking()) does not support writing configs to
|
|
|
|
|
* submodules.
|
|
|
|
|
*/
|
|
|
|
|
static int submodule_create_branch(struct repository *r,
|
|
|
|
|
const struct submodule *submodule,
|
|
|
|
|
const char *name, const char *start_oid,
|
|
|
|
|
const char *tracking_name, int force,
|
|
|
|
|
int reflog, int quiet,
|
|
|
|
|
enum branch_track track, int dry_run)
|
|
|
|
|
{
|
|
|
|
|
int ret = 0;
|
|
|
|
|
struct child_process child = CHILD_PROCESS_INIT;
|
|
|
|
|
struct strbuf child_err = STRBUF_INIT;
|
|
|
|
|
struct strbuf out_buf = STRBUF_INIT;
|
|
|
|
|
char *out_prefix = xstrfmt("submodule '%s': ", submodule->name);
|
|
|
|
|
child.git_cmd = 1;
|
|
|
|
|
child.err = -1;
|
|
|
|
|
child.stdout_to_stderr = 1;
|
|
|
|
|
|
|
|
|
|
prepare_other_repo_env(&child.env_array, r->gitdir);
|
|
|
|
|
/*
|
|
|
|
|
* submodule_create_branch() is indirectly invoked by "git
|
|
|
|
|
* branch", but we cannot invoke "git branch" in the child
|
|
|
|
|
* process. "git branch" accepts a branch name and start point,
|
|
|
|
|
* where the start point is assumed to provide both the OID
|
|
|
|
|
* (start_oid) and the branch to use for tracking
|
|
|
|
|
* (tracking_name). But when recursing through submodules,
|
|
|
|
|
* start_oid and tracking name need to be specified separately
|
|
|
|
|
* (see create_branches_recursively()).
|
|
|
|
|
*/
|
|
|
|
|
strvec_pushl(&child.args, "submodule--helper", "create-branch", NULL);
|
|
|
|
|
if (dry_run)
|
|
|
|
|
strvec_push(&child.args, "--dry-run");
|
|
|
|
|
if (force)
|
|
|
|
|
strvec_push(&child.args, "--force");
|
|
|
|
|
if (quiet)
|
|
|
|
|
strvec_push(&child.args, "--quiet");
|
|
|
|
|
if (reflog)
|
|
|
|
|
strvec_push(&child.args, "--create-reflog");
|
2022-03-29 22:01:16 +02:00
|
|
|
|
|
|
|
|
switch (track) {
|
|
|
|
|
case BRANCH_TRACK_NEVER:
|
|
|
|
|
strvec_push(&child.args, "--no-track");
|
|
|
|
|
break;
|
|
|
|
|
case BRANCH_TRACK_ALWAYS:
|
|
|
|
|
case BRANCH_TRACK_EXPLICIT:
|
|
|
|
|
strvec_push(&child.args, "--track=direct");
|
|
|
|
|
break;
|
|
|
|
|
case BRANCH_TRACK_OVERRIDE:
|
|
|
|
|
BUG("BRANCH_TRACK_OVERRIDE cannot be used when creating a branch.");
|
|
|
|
|
break;
|
|
|
|
|
case BRANCH_TRACK_INHERIT:
|
|
|
|
|
strvec_push(&child.args, "--track=inherit");
|
|
|
|
|
break;
|
|
|
|
|
case BRANCH_TRACK_UNSPECIFIED:
|
2022-04-01 00:41:17 +02:00
|
|
|
/* Default for "git checkout". Do not pass --track. */
|
2022-03-29 22:01:16 +02:00
|
|
|
case BRANCH_TRACK_REMOTE:
|
2022-04-01 00:41:17 +02:00
|
|
|
/* Default for "git branch". Do not pass --track. */
|
2022-03-29 22:01:16 +02:00
|
|
|
break;
|
|
|
|
|
}
|
branch: add --recurse-submodules option for branch creation
To improve the submodules UX, we would like to teach Git to handle
branches in submodules. Start this process by teaching "git branch" the
--recurse-submodules option so that "git branch --recurse-submodules
topic" will create the `topic` branch in the superproject and its
submodules.
Although this commit does not introduce breaking changes, it does not
work well with existing --recurse-submodules commands because "git
branch --recurse-submodules" writes to the submodule ref store, but most
commands only consider the superproject gitlink and ignore the submodule
ref store. For example, "git checkout --recurse-submodules" will check
out the commits in the superproject gitlinks (and put the submodules in
detached HEAD) instead of checking out the submodule branches.
Because of this, this commit introduces a new configuration value,
`submodule.propagateBranches`. The plan is for Git commands to
prioritize submodule ref store information over superproject gitlinks if
this value is true. Because "git branch --recurse-submodules" writes to
submodule ref stores, for the sake of clarity, it will not function
unless this configuration value is set.
This commit also includes changes that support working with submodules
from a superproject commit because "branch --recurse-submodules" (and
future commands) need to read .gitmodules and gitlinks from the
superproject commit, but submodules are typically read from the
filesystem's .gitmodules and the index's gitlinks. These changes are:
* add a submodules_of_tree() helper that gives the relevant
information of an in-tree submodule (e.g. path and oid) and
initializes the repository
* add is_tree_submodule_active() by adding a treeish_name parameter to
is_submodule_active()
* add the "submoduleNotUpdated" advice to advise users to update the
submodules in their trees
Incidentally, fix an incorrect usage string that combined the 'list'
usage of git branch (-l) with the 'create' usage; this string has been
incorrect since its inception, a8dfd5eac4 (Make builtin-branch.c use
parse_options., 2007-10-07).
Helped-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Glen Choo <chooglen@google.com>
Reviewed-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-01-29 01:04:45 +01:00
|
|
|
|
|
|
|
|
strvec_pushl(&child.args, name, start_oid, tracking_name, NULL);
|
|
|
|
|
|
|
|
|
|
if ((ret = start_command(&child)))
|
|
|
|
|
return ret;
|
|
|
|
|
ret = finish_command(&child);
|
|
|
|
|
strbuf_read(&child_err, child.err, 0);
|
|
|
|
|
strbuf_add_lines(&out_buf, out_prefix, child_err.buf, child_err.len);
|
|
|
|
|
|
|
|
|
|
if (ret)
|
|
|
|
|
fprintf(stderr, "%s", out_buf.buf);
|
|
|
|
|
else
|
|
|
|
|
printf("%s", out_buf.buf);
|
|
|
|
|
|
|
|
|
|
strbuf_release(&child_err);
|
|
|
|
|
strbuf_release(&out_buf);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void create_branches_recursively(struct repository *r, const char *name,
|
|
|
|
|
const char *start_commitish,
|
|
|
|
|
const char *tracking_name, int force,
|
|
|
|
|
int reflog, int quiet, enum branch_track track,
|
|
|
|
|
int dry_run)
|
|
|
|
|
{
|
|
|
|
|
int i = 0;
|
|
|
|
|
char *branch_point = NULL;
|
|
|
|
|
struct object_id super_oid;
|
|
|
|
|
struct submodule_entry_list submodule_entry_list;
|
|
|
|
|
|
|
|
|
|
/* Perform dwim on start_commitish to get super_oid and branch_point. */
|
|
|
|
|
dwim_branch_start(r, start_commitish, BRANCH_TRACK_NEVER,
|
|
|
|
|
&branch_point, &super_oid);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* If we were not given an explicit name to track, then assume we are at
|
|
|
|
|
* the top level and, just like the non-recursive case, the tracking
|
|
|
|
|
* name is the branch point.
|
|
|
|
|
*/
|
|
|
|
|
if (!tracking_name)
|
|
|
|
|
tracking_name = branch_point;
|
|
|
|
|
|
|
|
|
|
submodules_of_tree(r, &super_oid, &submodule_entry_list);
|
|
|
|
|
/*
|
|
|
|
|
* Before creating any branches, first check that the branch can
|
|
|
|
|
* be created in every submodule.
|
|
|
|
|
*/
|
|
|
|
|
for (i = 0; i < submodule_entry_list.entry_nr; i++) {
|
|
|
|
|
if (submodule_entry_list.entries[i].repo == NULL) {
|
2022-03-29 22:01:17 +02:00
|
|
|
int code = die_message(
|
|
|
|
|
_("submodule '%s': unable to find submodule"),
|
|
|
|
|
submodule_entry_list.entries[i].submodule->name);
|
branch: add --recurse-submodules option for branch creation
To improve the submodules UX, we would like to teach Git to handle
branches in submodules. Start this process by teaching "git branch" the
--recurse-submodules option so that "git branch --recurse-submodules
topic" will create the `topic` branch in the superproject and its
submodules.
Although this commit does not introduce breaking changes, it does not
work well with existing --recurse-submodules commands because "git
branch --recurse-submodules" writes to the submodule ref store, but most
commands only consider the superproject gitlink and ignore the submodule
ref store. For example, "git checkout --recurse-submodules" will check
out the commits in the superproject gitlinks (and put the submodules in
detached HEAD) instead of checking out the submodule branches.
Because of this, this commit introduces a new configuration value,
`submodule.propagateBranches`. The plan is for Git commands to
prioritize submodule ref store information over superproject gitlinks if
this value is true. Because "git branch --recurse-submodules" writes to
submodule ref stores, for the sake of clarity, it will not function
unless this configuration value is set.
This commit also includes changes that support working with submodules
from a superproject commit because "branch --recurse-submodules" (and
future commands) need to read .gitmodules and gitlinks from the
superproject commit, but submodules are typically read from the
filesystem's .gitmodules and the index's gitlinks. These changes are:
* add a submodules_of_tree() helper that gives the relevant
information of an in-tree submodule (e.g. path and oid) and
initializes the repository
* add is_tree_submodule_active() by adding a treeish_name parameter to
is_submodule_active()
* add the "submoduleNotUpdated" advice to advise users to update the
submodules in their trees
Incidentally, fix an incorrect usage string that combined the 'list'
usage of git branch (-l) with the 'create' usage; this string has been
incorrect since its inception, a8dfd5eac4 (Make builtin-branch.c use
parse_options., 2007-10-07).
Helped-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Glen Choo <chooglen@google.com>
Reviewed-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-01-29 01:04:45 +01:00
|
|
|
if (advice_enabled(ADVICE_SUBMODULES_NOT_UPDATED))
|
|
|
|
|
advise(_("You may try updating the submodules using 'git checkout %s && git submodule update --init'"),
|
|
|
|
|
start_commitish);
|
2022-03-29 22:01:17 +02:00
|
|
|
exit(code);
|
branch: add --recurse-submodules option for branch creation
To improve the submodules UX, we would like to teach Git to handle
branches in submodules. Start this process by teaching "git branch" the
--recurse-submodules option so that "git branch --recurse-submodules
topic" will create the `topic` branch in the superproject and its
submodules.
Although this commit does not introduce breaking changes, it does not
work well with existing --recurse-submodules commands because "git
branch --recurse-submodules" writes to the submodule ref store, but most
commands only consider the superproject gitlink and ignore the submodule
ref store. For example, "git checkout --recurse-submodules" will check
out the commits in the superproject gitlinks (and put the submodules in
detached HEAD) instead of checking out the submodule branches.
Because of this, this commit introduces a new configuration value,
`submodule.propagateBranches`. The plan is for Git commands to
prioritize submodule ref store information over superproject gitlinks if
this value is true. Because "git branch --recurse-submodules" writes to
submodule ref stores, for the sake of clarity, it will not function
unless this configuration value is set.
This commit also includes changes that support working with submodules
from a superproject commit because "branch --recurse-submodules" (and
future commands) need to read .gitmodules and gitlinks from the
superproject commit, but submodules are typically read from the
filesystem's .gitmodules and the index's gitlinks. These changes are:
* add a submodules_of_tree() helper that gives the relevant
information of an in-tree submodule (e.g. path and oid) and
initializes the repository
* add is_tree_submodule_active() by adding a treeish_name parameter to
is_submodule_active()
* add the "submoduleNotUpdated" advice to advise users to update the
submodules in their trees
Incidentally, fix an incorrect usage string that combined the 'list'
usage of git branch (-l) with the 'create' usage; this string has been
incorrect since its inception, a8dfd5eac4 (Make builtin-branch.c use
parse_options., 2007-10-07).
Helped-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Glen Choo <chooglen@google.com>
Reviewed-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-01-29 01:04:45 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (submodule_create_branch(
|
|
|
|
|
submodule_entry_list.entries[i].repo,
|
|
|
|
|
submodule_entry_list.entries[i].submodule, name,
|
|
|
|
|
oid_to_hex(&submodule_entry_list.entries[i]
|
|
|
|
|
.name_entry->oid),
|
|
|
|
|
tracking_name, force, reflog, quiet, track, 1))
|
|
|
|
|
die(_("submodule '%s': cannot create branch '%s'"),
|
|
|
|
|
submodule_entry_list.entries[i].submodule->name,
|
|
|
|
|
name);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
create_branch(the_repository, name, start_commitish, force, 0, reflog, quiet,
|
|
|
|
|
BRANCH_TRACK_NEVER, dry_run);
|
|
|
|
|
if (dry_run)
|
|
|
|
|
return;
|
|
|
|
|
/*
|
|
|
|
|
* NEEDSWORK If tracking was set up in the superproject but not the
|
|
|
|
|
* submodule, users might expect "git branch --recurse-submodules" to
|
|
|
|
|
* fail or give a warning, but this is not yet implemented because it is
|
|
|
|
|
* tedious to determine whether or not tracking was set up in the
|
|
|
|
|
* superproject.
|
|
|
|
|
*/
|
2022-03-29 22:01:16 +02:00
|
|
|
if (track)
|
|
|
|
|
setup_tracking(name, tracking_name, track, quiet);
|
branch: add --recurse-submodules option for branch creation
To improve the submodules UX, we would like to teach Git to handle
branches in submodules. Start this process by teaching "git branch" the
--recurse-submodules option so that "git branch --recurse-submodules
topic" will create the `topic` branch in the superproject and its
submodules.
Although this commit does not introduce breaking changes, it does not
work well with existing --recurse-submodules commands because "git
branch --recurse-submodules" writes to the submodule ref store, but most
commands only consider the superproject gitlink and ignore the submodule
ref store. For example, "git checkout --recurse-submodules" will check
out the commits in the superproject gitlinks (and put the submodules in
detached HEAD) instead of checking out the submodule branches.
Because of this, this commit introduces a new configuration value,
`submodule.propagateBranches`. The plan is for Git commands to
prioritize submodule ref store information over superproject gitlinks if
this value is true. Because "git branch --recurse-submodules" writes to
submodule ref stores, for the sake of clarity, it will not function
unless this configuration value is set.
This commit also includes changes that support working with submodules
from a superproject commit because "branch --recurse-submodules" (and
future commands) need to read .gitmodules and gitlinks from the
superproject commit, but submodules are typically read from the
filesystem's .gitmodules and the index's gitlinks. These changes are:
* add a submodules_of_tree() helper that gives the relevant
information of an in-tree submodule (e.g. path and oid) and
initializes the repository
* add is_tree_submodule_active() by adding a treeish_name parameter to
is_submodule_active()
* add the "submoduleNotUpdated" advice to advise users to update the
submodules in their trees
Incidentally, fix an incorrect usage string that combined the 'list'
usage of git branch (-l) with the 'create' usage; this string has been
incorrect since its inception, a8dfd5eac4 (Make builtin-branch.c use
parse_options., 2007-10-07).
Helped-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Glen Choo <chooglen@google.com>
Reviewed-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2022-01-29 01:04:45 +01:00
|
|
|
|
|
|
|
|
for (i = 0; i < submodule_entry_list.entry_nr; i++) {
|
|
|
|
|
if (submodule_create_branch(
|
|
|
|
|
submodule_entry_list.entries[i].repo,
|
|
|
|
|
submodule_entry_list.entries[i].submodule, name,
|
|
|
|
|
oid_to_hex(&submodule_entry_list.entries[i]
|
|
|
|
|
.name_entry->oid),
|
|
|
|
|
tracking_name, force, reflog, quiet, track, 0))
|
|
|
|
|
die(_("submodule '%s': cannot create branch '%s'"),
|
|
|
|
|
submodule_entry_list.entries[i].submodule->name,
|
|
|
|
|
name);
|
|
|
|
|
repo_clear(submodule_entry_list.entries[i].repo);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2019-05-09 12:10:27 +02:00
|
|
|
void remove_merge_branch_state(struct repository *r)
|
2008-02-07 17:40:16 +01:00
|
|
|
{
|
2018-11-10 06:49:00 +01:00
|
|
|
unlink(git_path_merge_head(r));
|
|
|
|
|
unlink(git_path_merge_rr(r));
|
|
|
|
|
unlink(git_path_merge_msg(r));
|
|
|
|
|
unlink(git_path_merge_mode(r));
|
2021-03-20 01:03:52 +01:00
|
|
|
unlink(git_path_auto_merge(r));
|
2020-04-07 16:28:07 +02:00
|
|
|
save_autostash(git_path_merge_autostash(r));
|
2019-05-09 12:10:27 +02:00
|
|
|
}
|
|
|
|
|
|
2019-07-10 00:25:44 +02:00
|
|
|
void remove_branch_state(struct repository *r, int verbose)
|
2019-05-09 12:10:27 +02:00
|
|
|
{
|
2019-07-10 00:25:44 +02:00
|
|
|
sequencer_post_commit_cleanup(r, verbose);
|
2018-11-10 06:49:00 +01:00
|
|
|
unlink(git_path_squash_msg(r));
|
2019-05-09 12:10:27 +02:00
|
|
|
remove_merge_branch_state(r);
|
2008-02-07 17:40:16 +01:00
|
|
|
}
|
2015-07-18 01:00:04 +02:00
|
|
|
|
2016-04-22 15:01:33 +02:00
|
|
|
void die_if_checked_out(const char *branch, int ignore_current_worktree)
|
2015-08-10 19:52:44 +02:00
|
|
|
{
|
2021-12-01 23:15:43 +01:00
|
|
|
struct worktree **worktrees = get_worktrees();
|
2016-04-22 15:01:27 +02:00
|
|
|
const struct worktree *wt;
|
2015-08-10 19:52:44 +02:00
|
|
|
|
2021-12-01 23:15:43 +01:00
|
|
|
wt = find_shared_symref(worktrees, "HEAD", branch);
|
|
|
|
|
if (wt && (!ignore_current_worktree || !wt->is_current)) {
|
|
|
|
|
skip_prefix(branch, "refs/heads/", &branch);
|
|
|
|
|
die(_("'%s' is already checked out at '%s'"), branch, wt->path);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
free_worktrees(worktrees);
|
2015-07-18 01:00:04 +02:00
|
|
|
}
|
2016-03-27 16:37:14 +02:00
|
|
|
|
2017-02-21 02:10:35 +01:00
|
|
|
int replace_each_worktree_head_symref(const char *oldref, const char *newref,
|
|
|
|
|
const char *logmsg)
|
2016-03-27 16:37:14 +02:00
|
|
|
{
|
|
|
|
|
int ret = 0;
|
2020-06-20 01:35:44 +02:00
|
|
|
struct worktree **worktrees = get_worktrees();
|
2016-03-27 16:37:14 +02:00
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
for (i = 0; worktrees[i]; i++) {
|
2017-04-24 12:01:24 +02:00
|
|
|
struct ref_store *refs;
|
|
|
|
|
|
2016-03-27 16:37:14 +02:00
|
|
|
if (worktrees[i]->is_detached)
|
|
|
|
|
continue;
|
branch: fix branch renaming not updating HEADs correctly
There are two bugs that sort of work together and cause
problems. Let's start with one in replace_each_worktree_head_symref.
Before fa099d2322 (worktree.c: kill parse_ref() in favor of
refs_resolve_ref_unsafe() - 2017-04-24), this code looks like this:
if (strcmp(oldref, worktrees[i]->head_ref))
continue;
set_worktree_head_symref(...);
After fa099d2322, it is possible that head_ref can be NULL. However,
the updated code takes the wrong exit. In the error case (NULL
head_ref), we should "continue;" to the next worktree. The updated
code makes us _skip_ "continue;" and update HEAD anyway.
The NULL head_ref is triggered by the second bug in add_head_info (in
the same commit). With the flag RESOLVE_REF_READING, resolve_ref_unsafe()
will abort if it cannot resolve the target ref. For orphan checkouts,
HEAD always points to an unborned branch, resolving target ref will
always fail. Now we have NULL head_ref. Now we always update HEAD.
Correct the logic in replace_ function so that we don't accidentally
update HEAD on error. As it turns out, correcting the logic bug above
breaks branch renaming completely, thanks to the second bug.
"git branch -[Mm]" does two steps (on a normal checkout, no orphan!):
- rename the branch on disk (e.g. refs/heads/abc to refs/heads/def)
- update HEAD if it points to the branch being renamed.
At the second step, since the branch pointed to by HEAD (e.g. "abc") no
longer exists on disk, we run into a temporary orphan checkout situation
that has been just corrected to _not_ update HEAD. But we need to update
HEAD since it's not actually an orphan checkout. We need to update HEAD
to move out of that orphan state.
Correct add_head_info(), remove RESOLVE_REF_READING flag. With the flag
gone, we should always return good "head_ref" in orphan checkouts (either
temporary or permanent). With good head_ref, things start to work again.
Noticed-by: Nish Aravamudan <nish.aravamudan@canonical.com>
Signed-off-by: Nguyễn Thái Ngọc Duy <pclouds@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-08-24 12:41:24 +02:00
|
|
|
if (!worktrees[i]->head_ref)
|
|
|
|
|
continue;
|
|
|
|
|
if (strcmp(oldref, worktrees[i]->head_ref))
|
2016-03-27 16:37:14 +02:00
|
|
|
continue;
|
|
|
|
|
|
2017-04-24 12:01:24 +02:00
|
|
|
refs = get_worktree_ref_store(worktrees[i]);
|
|
|
|
|
if (refs_create_symref(refs, "HEAD", newref, logmsg))
|
|
|
|
|
ret = error(_("HEAD of working tree %s is not updated"),
|
|
|
|
|
worktrees[i]->path);
|
2016-03-27 16:37:14 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
free_worktrees(worktrees);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
