2017-12-12 19:53:52 +00:00
|
|
|
|
2009-10-19 12:38:32 +00:00
|
|
|
#include "cache.h"
|
2017-06-22 18:43:45 +00:00
|
|
|
#include "repository.h"
|
2017-06-14 18:07:36 +00:00
|
|
|
#include "config.h"
|
2015-08-18 00:21:59 +00:00
|
|
|
#include "submodule-config.h"
|
2009-10-19 12:38:32 +00:00
|
|
|
#include "submodule.h"
|
|
|
|
#include "dir.h"
|
|
|
|
#include "diff.h"
|
|
|
|
#include "commit.h"
|
|
|
|
#include "revision.h"
|
2010-01-16 17:42:24 +00:00
|
|
|
#include "run-command.h"
|
2010-03-04 21:20:33 +00:00
|
|
|
#include "diffcore.h"
|
2010-07-07 13:39:13 +00:00
|
|
|
#include "refs.h"
|
2010-08-05 22:39:25 +00:00
|
|
|
#include "string-list.h"
|
2020-03-30 14:03:46 +00:00
|
|
|
#include "oid-array.h"
|
2020-07-28 20:23:39 +00:00
|
|
|
#include "strvec.h"
|
2013-07-30 19:50:34 +00:00
|
|
|
#include "blob.h"
|
2015-12-16 00:04:11 +00:00
|
|
|
#include "thread-utils.h"
|
2016-04-28 13:38:20 +00:00
|
|
|
#include "quote.h"
|
2017-04-05 17:47:19 +00:00
|
|
|
#include "remote.h"
|
2016-12-12 19:04:35 +00:00
|
|
|
#include "worktree.h"
|
2017-06-01 00:30:47 +00:00
|
|
|
#include "parse-options.h"
|
2018-03-23 17:20:56 +00:00
|
|
|
#include "object-store.h"
|
2018-07-20 16:33:04 +00:00
|
|
|
#include "commit-reach.h"
|
2022-03-17 18:24:47 +00:00
|
|
|
#include "shallow.h"
|
2010-08-05 22:39:25 +00:00
|
|
|
|
2017-05-26 19:10:12 +00:00
|
|
|
static int config_update_recurse_submodules = RECURSE_SUBMODULES_OFF;
|
2011-09-12 19:56:52 +00:00
|
|
|
static int initialized_fetch_ref_tips;
|
2017-03-31 01:40:00 +00:00
|
|
|
static struct oid_array ref_tips_before_fetch;
|
|
|
|
static struct oid_array ref_tips_after_fetch;
|
2011-09-12 19:56:52 +00:00
|
|
|
|
2011-05-14 16:26:58 +00:00
|
|
|
/*
|
2017-08-02 19:49:21 +00:00
|
|
|
* Check if the .gitmodules file is unmerged. Parsing of the .gitmodules file
|
|
|
|
* will be disabled because we can't guess what might be configured in
|
|
|
|
* .gitmodules unless the user resolves the conflict.
|
2011-05-14 16:26:58 +00:00
|
|
|
*/
|
2021-04-01 01:49:39 +00:00
|
|
|
int is_gitmodules_unmerged(struct index_state *istate)
|
2017-08-02 19:49:21 +00:00
|
|
|
{
|
|
|
|
int pos = index_name_pos(istate, GITMODULES_FILE, strlen(GITMODULES_FILE));
|
|
|
|
if (pos < 0) { /* .gitmodules not found or isn't merged */
|
|
|
|
pos = -1 - pos;
|
|
|
|
if (istate->cache_nr > pos) { /* there is a .gitmodules */
|
|
|
|
const struct cache_entry *ce = istate->cache[pos];
|
|
|
|
if (ce_namelen(ce) == strlen(GITMODULES_FILE) &&
|
|
|
|
!strcmp(ce->name, GITMODULES_FILE))
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2009-10-19 12:38:32 +00:00
|
|
|
|
2018-10-05 13:05:59 +00:00
|
|
|
/*
|
|
|
|
* Check if the .gitmodules file is safe to write.
|
|
|
|
*
|
|
|
|
* Writing to the .gitmodules file requires that the file exists in the
|
|
|
|
* working tree or, if it doesn't, that a brand new .gitmodules file is going
|
|
|
|
* to be created (i.e. it's neither in the index nor in the current branch).
|
|
|
|
*
|
|
|
|
* It is not safe to write to .gitmodules if it's not in the working tree but
|
|
|
|
* it is in the index or in the current branch, because writing new values
|
|
|
|
* (and staging them) would blindly overwrite ALL the old content.
|
|
|
|
*/
|
|
|
|
int is_writing_gitmodules_ok(void)
|
|
|
|
{
|
|
|
|
struct object_id oid;
|
|
|
|
return file_exists(GITMODULES_FILE) ||
|
|
|
|
(get_oid(GITMODULES_INDEX, &oid) < 0 && get_oid(GITMODULES_HEAD, &oid) < 0);
|
|
|
|
}
|
|
|
|
|
2013-07-30 19:50:34 +00:00
|
|
|
/*
|
2017-08-02 19:49:20 +00:00
|
|
|
* Check if the .gitmodules file has unstaged modifications. This must be
|
|
|
|
* checked before allowing modifications to the .gitmodules file with the
|
|
|
|
* intention to stage them later, because when continuing we would stage the
|
|
|
|
* modifications the user didn't stage herself too. That might change in a
|
|
|
|
* future version when we learn to stage the changes we do ourselves without
|
|
|
|
* staging any previous modifications.
|
2013-07-30 19:50:34 +00:00
|
|
|
*/
|
2017-12-12 19:53:51 +00:00
|
|
|
int is_staging_gitmodules_ok(struct index_state *istate)
|
2013-07-30 19:50:34 +00:00
|
|
|
{
|
2017-08-02 19:49:20 +00:00
|
|
|
int pos = index_name_pos(istate, GITMODULES_FILE, strlen(GITMODULES_FILE));
|
|
|
|
|
|
|
|
if ((pos >= 0) && (pos < istate->cache_nr)) {
|
|
|
|
struct stat st;
|
|
|
|
if (lstat(GITMODULES_FILE, &st) == 0 &&
|
2020-01-27 18:58:56 +00:00
|
|
|
ie_modified(istate, istate->cache[pos], &st, 0) & DATA_CHANGED)
|
2017-08-02 19:49:20 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
2013-07-30 19:50:34 +00:00
|
|
|
}
|
|
|
|
|
2017-08-23 12:36:57 +00:00
|
|
|
static int for_each_remote_ref_submodule(const char *submodule,
|
|
|
|
each_ref_fn fn, void *cb_data)
|
|
|
|
{
|
|
|
|
return refs_for_each_remote_ref(get_submodule_ref_store(submodule),
|
|
|
|
fn, cb_data);
|
|
|
|
}
|
|
|
|
|
2013-08-06 19:15:11 +00:00
|
|
|
/*
|
|
|
|
* Try to update the "path" entry in the "submodule.<name>" section of the
|
|
|
|
* .gitmodules file. Return 0 only if a .gitmodules file was found, a section
|
|
|
|
* with the correct path=<oldpath> setting was found and we could update it.
|
|
|
|
*/
|
|
|
|
int update_path_in_gitmodules(const char *oldpath, const char *newpath)
|
|
|
|
{
|
|
|
|
struct strbuf entry = STRBUF_INIT;
|
2015-08-18 00:21:59 +00:00
|
|
|
const struct submodule *submodule;
|
2018-10-05 13:05:53 +00:00
|
|
|
int ret;
|
2013-08-06 19:15:11 +00:00
|
|
|
|
2017-08-02 19:49:16 +00:00
|
|
|
if (!file_exists(GITMODULES_FILE)) /* Do nothing without .gitmodules */
|
2013-08-06 19:15:11 +00:00
|
|
|
return -1;
|
|
|
|
|
2018-08-13 16:14:31 +00:00
|
|
|
if (is_gitmodules_unmerged(the_repository->index))
|
2013-08-06 19:15:11 +00:00
|
|
|
die(_("Cannot change unmerged .gitmodules, resolve merge conflicts first"));
|
|
|
|
|
2021-04-26 01:02:56 +00:00
|
|
|
submodule = submodule_from_path(the_repository, null_oid(), oldpath);
|
2015-08-18 00:21:59 +00:00
|
|
|
if (!submodule || !submodule->name) {
|
2013-08-06 19:15:11 +00:00
|
|
|
warning(_("Could not find section in .gitmodules where path=%s"), oldpath);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
strbuf_addstr(&entry, "submodule.");
|
2015-08-18 00:21:59 +00:00
|
|
|
strbuf_addstr(&entry, submodule->name);
|
2013-08-06 19:15:11 +00:00
|
|
|
strbuf_addstr(&entry, ".path");
|
2018-10-05 13:05:53 +00:00
|
|
|
ret = config_set_in_gitmodules_file_gently(entry.buf, newpath);
|
2013-08-06 19:15:11 +00:00
|
|
|
strbuf_release(&entry);
|
2018-10-05 13:05:53 +00:00
|
|
|
return ret;
|
2013-08-06 19:15:11 +00:00
|
|
|
}
|
|
|
|
|
2013-08-06 19:15:25 +00:00
|
|
|
/*
|
|
|
|
* Try to remove the "submodule.<name>" section from .gitmodules where the given
|
|
|
|
* path is configured. Return 0 only if a .gitmodules file was found, a section
|
|
|
|
* with the correct path=<path> setting was found and we could remove it.
|
|
|
|
*/
|
|
|
|
int remove_path_from_gitmodules(const char *path)
|
|
|
|
{
|
|
|
|
struct strbuf sect = STRBUF_INIT;
|
2015-08-18 00:21:59 +00:00
|
|
|
const struct submodule *submodule;
|
2013-08-06 19:15:25 +00:00
|
|
|
|
2017-08-02 19:49:16 +00:00
|
|
|
if (!file_exists(GITMODULES_FILE)) /* Do nothing without .gitmodules */
|
2013-08-06 19:15:25 +00:00
|
|
|
return -1;
|
|
|
|
|
2018-08-13 16:14:31 +00:00
|
|
|
if (is_gitmodules_unmerged(the_repository->index))
|
2013-08-06 19:15:25 +00:00
|
|
|
die(_("Cannot change unmerged .gitmodules, resolve merge conflicts first"));
|
|
|
|
|
2021-04-26 01:02:56 +00:00
|
|
|
submodule = submodule_from_path(the_repository, null_oid(), path);
|
2015-08-18 00:21:59 +00:00
|
|
|
if (!submodule || !submodule->name) {
|
2013-08-06 19:15:25 +00:00
|
|
|
warning(_("Could not find section in .gitmodules where path=%s"), path);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
strbuf_addstr(§, "submodule.");
|
2015-08-18 00:21:59 +00:00
|
|
|
strbuf_addstr(§, submodule->name);
|
2017-08-02 19:49:16 +00:00
|
|
|
if (git_config_rename_section_in_file(GITMODULES_FILE, sect.buf, NULL) < 0) {
|
2013-08-06 19:15:25 +00:00
|
|
|
/* Maybe the user already did that, don't error out here */
|
|
|
|
warning(_("Could not remove .gitmodules entry for %s"), path);
|
|
|
|
strbuf_release(§);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
strbuf_release(§);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-12-12 19:53:50 +00:00
|
|
|
void stage_updated_gitmodules(struct index_state *istate)
|
2013-07-30 19:50:34 +00:00
|
|
|
{
|
2017-12-12 19:53:50 +00:00
|
|
|
if (add_file_to_index(istate, GITMODULES_FILE, 0))
|
2013-07-30 19:50:34 +00:00
|
|
|
die(_("staging updated .gitmodules failed"));
|
|
|
|
}
|
|
|
|
|
2021-08-16 21:09:51 +00:00
|
|
|
static struct string_list added_submodule_odb_paths = STRING_LIST_INIT_NODUP;
|
|
|
|
|
2021-08-16 21:09:52 +00:00
|
|
|
void add_submodule_odb_by_path(const char *path)
|
|
|
|
{
|
|
|
|
string_list_insert(&added_submodule_odb_paths, xstrdup(path));
|
|
|
|
}
|
|
|
|
|
2021-08-16 21:09:51 +00:00
|
|
|
int register_all_submodule_odb_as_alternates(void)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int ret = added_submodule_odb_paths.nr;
|
|
|
|
|
|
|
|
for (i = 0; i < added_submodule_odb_paths.nr; i++)
|
|
|
|
add_to_alternates_memory(added_submodule_odb_paths.items[i].string);
|
|
|
|
if (ret) {
|
|
|
|
string_list_clear(&added_submodule_odb_paths, 0);
|
2021-10-08 21:08:20 +00:00
|
|
|
trace2_data_intmax("submodule", the_repository,
|
|
|
|
"register_all_submodule_odb_as_alternates/registered", ret);
|
2021-08-16 21:09:51 +00:00
|
|
|
if (git_env_bool("GIT_TEST_FATAL_REGISTER_SUBMODULE_ODB", 0))
|
|
|
|
BUG("register_all_submodule_odb_as_alternates() called");
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-08-05 22:39:25 +00:00
|
|
|
void set_diffopt_flags_from_submodule_config(struct diff_options *diffopt,
|
|
|
|
const char *path)
|
|
|
|
{
|
2018-03-28 22:35:29 +00:00
|
|
|
const struct submodule *submodule = submodule_from_path(the_repository,
|
2021-04-26 01:02:56 +00:00
|
|
|
null_oid(),
|
|
|
|
path);
|
2015-08-18 00:21:59 +00:00
|
|
|
if (submodule) {
|
2017-08-03 18:19:52 +00:00
|
|
|
const char *ignore;
|
|
|
|
char *key;
|
2010-08-05 22:39:25 +00:00
|
|
|
|
2017-08-03 18:19:52 +00:00
|
|
|
key = xstrfmt("submodule.%s.ignore", submodule->name);
|
2020-08-14 16:17:36 +00:00
|
|
|
if (repo_config_get_string_tmp(the_repository, key, &ignore))
|
2017-08-03 18:19:52 +00:00
|
|
|
ignore = submodule->ignore;
|
|
|
|
free(key);
|
2010-08-05 22:40:48 +00:00
|
|
|
|
2017-08-03 18:19:52 +00:00
|
|
|
if (ignore)
|
|
|
|
handle_ignore_submodules_arg(diffopt, ignore);
|
2018-08-13 16:14:31 +00:00
|
|
|
else if (is_gitmodules_unmerged(the_repository->index))
|
2017-10-31 18:19:11 +00:00
|
|
|
diffopt->flags.ignore_submodules = 1;
|
2017-06-01 00:30:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Cheap function that only determines if we're interested in submodules at all */
|
2022-08-19 10:08:44 +00:00
|
|
|
int git_default_submodule_config(const char *var, const char *value,
|
2022-08-25 17:09:48 +00:00
|
|
|
void *cb UNUSED)
|
2017-06-01 00:30:47 +00:00
|
|
|
{
|
|
|
|
if (!strcmp(var, "submodule.recurse")) {
|
|
|
|
int v = git_config_bool(var, value) ?
|
|
|
|
RECURSE_SUBMODULES_ON : RECURSE_SUBMODULES_OFF;
|
|
|
|
config_update_recurse_submodules = v;
|
|
|
|
}
|
|
|
|
return 0;
|
2017-05-26 19:10:13 +00:00
|
|
|
}
|
|
|
|
|
2017-05-26 19:10:12 +00:00
|
|
|
int option_parse_recurse_submodules_worktree_updater(const struct option *opt,
|
|
|
|
const char *arg, int unset)
|
|
|
|
{
|
|
|
|
if (unset) {
|
|
|
|
config_update_recurse_submodules = RECURSE_SUBMODULES_OFF;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (arg)
|
|
|
|
config_update_recurse_submodules =
|
|
|
|
parse_update_recurse_submodules_arg(opt->long_name,
|
|
|
|
arg);
|
|
|
|
else
|
|
|
|
config_update_recurse_submodules = RECURSE_SUBMODULES_ON;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-12-16 19:03:17 +00:00
|
|
|
/*
|
|
|
|
* Determine if a submodule has been initialized at a given 'path'
|
|
|
|
*/
|
2021-08-06 14:04:31 +00:00
|
|
|
/*
|
|
|
|
* NEEDSWORK: Emit a warning if submodule.active exists, but is valueless,
|
|
|
|
* ie, the config looks like: "[submodule] active\n".
|
|
|
|
* Since that is an invalid pathspec, we should inform the user.
|
|
|
|
*/
|
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 00:04:45 +00:00
|
|
|
int is_tree_submodule_active(struct repository *repo,
|
|
|
|
const struct object_id *treeish_name,
|
|
|
|
const char *path)
|
2016-12-16 19:03:17 +00:00
|
|
|
{
|
|
|
|
int ret = 0;
|
submodule: decouple url and submodule interest
Currently the submodule.<name>.url config option is used to determine if
a given submodule is of interest to the user. This ends up being
cumbersome in a world where we want to have different submodules checked
out in different worktrees or a more generalized mechanism to select
which submodules are of interest.
In a future with worktree support for submodules, there will be multiple
working trees, each of which may only need a subset of the submodules
checked out. The URL (which is where the submodule repository can be
obtained) should not differ between different working trees.
It may also be convenient for users to more easily specify groups of
submodules they are interested in as opposed to running "git submodule
init <path>" on each submodule they want checked out in their working
tree.
To this end two config options are introduced, submodule.active and
submodule.<name>.active. The submodule.active config holds a pathspec
that specifies which submodules should exist in the working tree. The
submodule.<name>.active config is a boolean flag used to indicate if
that particular submodule should exist in the working tree.
Its important to note that submodule.active functions differently than
the other configuration options since it takes a pathspec. This allows
users to adopt at least two new workflows:
1. Submodules can be grouped with a leading directory, such that a
pathspec e.g. 'lib/' would cover all library-ish modules to allow
those who are interested in library-ish modules to set
"submodule.active = lib/" just once to say any and all modules in
'lib/' are interesting.
2. Once the pathspec-attribute feature is invented, users can label
submodules with attributes to group them, so that a broad pathspec
with attribute requirements, e.g. ':(attr:lib)', can be used to say
any and all modules with the 'lib' attribute are interesting.
Since the .gitattributes file, just like the .gitmodules file, is
tracked by the superproject, when a submodule moves in the
superproject tree, the project can adjust which path gets the
attribute in .gitattributes, just like it can adjust which path has
the submodule in .gitmodules.
Neither of these two additional configuration options solve the problem
of wanting different submodules checked out in different worktrees
because multiple worktrees share .git/config. Only once per-worktree
configurations become a reality can this be solved, but this is a
necessary preparatory step for that future.
Given these multiple ways to check if a submodule is of interest, the
more fine-grained submodule.<name>.active option has the highest order
of precedence followed by the pathspec check against submodule.active.
To ensure backwards compatibility, if neither of these options are set,
git falls back to checking the submodule.<name>.url option to determine
if a submodule is interesting.
Signed-off-by: Brandon Williams <bmwill@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-17 22:38:01 +00:00
|
|
|
char *key = NULL;
|
|
|
|
char *value = NULL;
|
|
|
|
const struct string_list *sl;
|
2017-06-22 18:43:46 +00:00
|
|
|
const struct submodule *module;
|
|
|
|
|
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 00:04:45 +00:00
|
|
|
module = submodule_from_path(repo, treeish_name, path);
|
2016-12-16 19:03:17 +00:00
|
|
|
|
submodule: decouple url and submodule interest
Currently the submodule.<name>.url config option is used to determine if
a given submodule is of interest to the user. This ends up being
cumbersome in a world where we want to have different submodules checked
out in different worktrees or a more generalized mechanism to select
which submodules are of interest.
In a future with worktree support for submodules, there will be multiple
working trees, each of which may only need a subset of the submodules
checked out. The URL (which is where the submodule repository can be
obtained) should not differ between different working trees.
It may also be convenient for users to more easily specify groups of
submodules they are interested in as opposed to running "git submodule
init <path>" on each submodule they want checked out in their working
tree.
To this end two config options are introduced, submodule.active and
submodule.<name>.active. The submodule.active config holds a pathspec
that specifies which submodules should exist in the working tree. The
submodule.<name>.active config is a boolean flag used to indicate if
that particular submodule should exist in the working tree.
Its important to note that submodule.active functions differently than
the other configuration options since it takes a pathspec. This allows
users to adopt at least two new workflows:
1. Submodules can be grouped with a leading directory, such that a
pathspec e.g. 'lib/' would cover all library-ish modules to allow
those who are interested in library-ish modules to set
"submodule.active = lib/" just once to say any and all modules in
'lib/' are interesting.
2. Once the pathspec-attribute feature is invented, users can label
submodules with attributes to group them, so that a broad pathspec
with attribute requirements, e.g. ':(attr:lib)', can be used to say
any and all modules with the 'lib' attribute are interesting.
Since the .gitattributes file, just like the .gitmodules file, is
tracked by the superproject, when a submodule moves in the
superproject tree, the project can adjust which path gets the
attribute in .gitattributes, just like it can adjust which path has
the submodule in .gitmodules.
Neither of these two additional configuration options solve the problem
of wanting different submodules checked out in different worktrees
because multiple worktrees share .git/config. Only once per-worktree
configurations become a reality can this be solved, but this is a
necessary preparatory step for that future.
Given these multiple ways to check if a submodule is of interest, the
more fine-grained submodule.<name>.active option has the highest order
of precedence followed by the pathspec check against submodule.active.
To ensure backwards compatibility, if neither of these options are set,
git falls back to checking the submodule.<name>.url option to determine
if a submodule is interesting.
Signed-off-by: Brandon Williams <bmwill@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-17 22:38:01 +00:00
|
|
|
/* early return if there isn't a path->module mapping */
|
|
|
|
if (!module)
|
|
|
|
return 0;
|
2016-12-16 19:03:17 +00:00
|
|
|
|
submodule: decouple url and submodule interest
Currently the submodule.<name>.url config option is used to determine if
a given submodule is of interest to the user. This ends up being
cumbersome in a world where we want to have different submodules checked
out in different worktrees or a more generalized mechanism to select
which submodules are of interest.
In a future with worktree support for submodules, there will be multiple
working trees, each of which may only need a subset of the submodules
checked out. The URL (which is where the submodule repository can be
obtained) should not differ between different working trees.
It may also be convenient for users to more easily specify groups of
submodules they are interested in as opposed to running "git submodule
init <path>" on each submodule they want checked out in their working
tree.
To this end two config options are introduced, submodule.active and
submodule.<name>.active. The submodule.active config holds a pathspec
that specifies which submodules should exist in the working tree. The
submodule.<name>.active config is a boolean flag used to indicate if
that particular submodule should exist in the working tree.
Its important to note that submodule.active functions differently than
the other configuration options since it takes a pathspec. This allows
users to adopt at least two new workflows:
1. Submodules can be grouped with a leading directory, such that a
pathspec e.g. 'lib/' would cover all library-ish modules to allow
those who are interested in library-ish modules to set
"submodule.active = lib/" just once to say any and all modules in
'lib/' are interesting.
2. Once the pathspec-attribute feature is invented, users can label
submodules with attributes to group them, so that a broad pathspec
with attribute requirements, e.g. ':(attr:lib)', can be used to say
any and all modules with the 'lib' attribute are interesting.
Since the .gitattributes file, just like the .gitmodules file, is
tracked by the superproject, when a submodule moves in the
superproject tree, the project can adjust which path gets the
attribute in .gitattributes, just like it can adjust which path has
the submodule in .gitmodules.
Neither of these two additional configuration options solve the problem
of wanting different submodules checked out in different worktrees
because multiple worktrees share .git/config. Only once per-worktree
configurations become a reality can this be solved, but this is a
necessary preparatory step for that future.
Given these multiple ways to check if a submodule is of interest, the
more fine-grained submodule.<name>.active option has the highest order
of precedence followed by the pathspec check against submodule.active.
To ensure backwards compatibility, if neither of these options are set,
git falls back to checking the submodule.<name>.url option to determine
if a submodule is interesting.
Signed-off-by: Brandon Williams <bmwill@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-17 22:38:01 +00:00
|
|
|
/* submodule.<name>.active is set */
|
|
|
|
key = xstrfmt("submodule.%s.active", module->name);
|
2017-06-22 18:43:46 +00:00
|
|
|
if (!repo_config_get_bool(repo, key, &ret)) {
|
submodule: decouple url and submodule interest
Currently the submodule.<name>.url config option is used to determine if
a given submodule is of interest to the user. This ends up being
cumbersome in a world where we want to have different submodules checked
out in different worktrees or a more generalized mechanism to select
which submodules are of interest.
In a future with worktree support for submodules, there will be multiple
working trees, each of which may only need a subset of the submodules
checked out. The URL (which is where the submodule repository can be
obtained) should not differ between different working trees.
It may also be convenient for users to more easily specify groups of
submodules they are interested in as opposed to running "git submodule
init <path>" on each submodule they want checked out in their working
tree.
To this end two config options are introduced, submodule.active and
submodule.<name>.active. The submodule.active config holds a pathspec
that specifies which submodules should exist in the working tree. The
submodule.<name>.active config is a boolean flag used to indicate if
that particular submodule should exist in the working tree.
Its important to note that submodule.active functions differently than
the other configuration options since it takes a pathspec. This allows
users to adopt at least two new workflows:
1. Submodules can be grouped with a leading directory, such that a
pathspec e.g. 'lib/' would cover all library-ish modules to allow
those who are interested in library-ish modules to set
"submodule.active = lib/" just once to say any and all modules in
'lib/' are interesting.
2. Once the pathspec-attribute feature is invented, users can label
submodules with attributes to group them, so that a broad pathspec
with attribute requirements, e.g. ':(attr:lib)', can be used to say
any and all modules with the 'lib' attribute are interesting.
Since the .gitattributes file, just like the .gitmodules file, is
tracked by the superproject, when a submodule moves in the
superproject tree, the project can adjust which path gets the
attribute in .gitattributes, just like it can adjust which path has
the submodule in .gitmodules.
Neither of these two additional configuration options solve the problem
of wanting different submodules checked out in different worktrees
because multiple worktrees share .git/config. Only once per-worktree
configurations become a reality can this be solved, but this is a
necessary preparatory step for that future.
Given these multiple ways to check if a submodule is of interest, the
more fine-grained submodule.<name>.active option has the highest order
of precedence followed by the pathspec check against submodule.active.
To ensure backwards compatibility, if neither of these options are set,
git falls back to checking the submodule.<name>.url option to determine
if a submodule is interesting.
Signed-off-by: Brandon Williams <bmwill@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-17 22:38:01 +00:00
|
|
|
free(key);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
free(key);
|
2016-12-16 19:03:17 +00:00
|
|
|
|
submodule: decouple url and submodule interest
Currently the submodule.<name>.url config option is used to determine if
a given submodule is of interest to the user. This ends up being
cumbersome in a world where we want to have different submodules checked
out in different worktrees or a more generalized mechanism to select
which submodules are of interest.
In a future with worktree support for submodules, there will be multiple
working trees, each of which may only need a subset of the submodules
checked out. The URL (which is where the submodule repository can be
obtained) should not differ between different working trees.
It may also be convenient for users to more easily specify groups of
submodules they are interested in as opposed to running "git submodule
init <path>" on each submodule they want checked out in their working
tree.
To this end two config options are introduced, submodule.active and
submodule.<name>.active. The submodule.active config holds a pathspec
that specifies which submodules should exist in the working tree. The
submodule.<name>.active config is a boolean flag used to indicate if
that particular submodule should exist in the working tree.
Its important to note that submodule.active functions differently than
the other configuration options since it takes a pathspec. This allows
users to adopt at least two new workflows:
1. Submodules can be grouped with a leading directory, such that a
pathspec e.g. 'lib/' would cover all library-ish modules to allow
those who are interested in library-ish modules to set
"submodule.active = lib/" just once to say any and all modules in
'lib/' are interesting.
2. Once the pathspec-attribute feature is invented, users can label
submodules with attributes to group them, so that a broad pathspec
with attribute requirements, e.g. ':(attr:lib)', can be used to say
any and all modules with the 'lib' attribute are interesting.
Since the .gitattributes file, just like the .gitmodules file, is
tracked by the superproject, when a submodule moves in the
superproject tree, the project can adjust which path gets the
attribute in .gitattributes, just like it can adjust which path has
the submodule in .gitmodules.
Neither of these two additional configuration options solve the problem
of wanting different submodules checked out in different worktrees
because multiple worktrees share .git/config. Only once per-worktree
configurations become a reality can this be solved, but this is a
necessary preparatory step for that future.
Given these multiple ways to check if a submodule is of interest, the
more fine-grained submodule.<name>.active option has the highest order
of precedence followed by the pathspec check against submodule.active.
To ensure backwards compatibility, if neither of these options are set,
git falls back to checking the submodule.<name>.url option to determine
if a submodule is interesting.
Signed-off-by: Brandon Williams <bmwill@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-17 22:38:01 +00:00
|
|
|
/* submodule.active is set */
|
2017-06-22 18:43:46 +00:00
|
|
|
sl = repo_config_get_value_multi(repo, "submodule.active");
|
submodule: decouple url and submodule interest
Currently the submodule.<name>.url config option is used to determine if
a given submodule is of interest to the user. This ends up being
cumbersome in a world where we want to have different submodules checked
out in different worktrees or a more generalized mechanism to select
which submodules are of interest.
In a future with worktree support for submodules, there will be multiple
working trees, each of which may only need a subset of the submodules
checked out. The URL (which is where the submodule repository can be
obtained) should not differ between different working trees.
It may also be convenient for users to more easily specify groups of
submodules they are interested in as opposed to running "git submodule
init <path>" on each submodule they want checked out in their working
tree.
To this end two config options are introduced, submodule.active and
submodule.<name>.active. The submodule.active config holds a pathspec
that specifies which submodules should exist in the working tree. The
submodule.<name>.active config is a boolean flag used to indicate if
that particular submodule should exist in the working tree.
Its important to note that submodule.active functions differently than
the other configuration options since it takes a pathspec. This allows
users to adopt at least two new workflows:
1. Submodules can be grouped with a leading directory, such that a
pathspec e.g. 'lib/' would cover all library-ish modules to allow
those who are interested in library-ish modules to set
"submodule.active = lib/" just once to say any and all modules in
'lib/' are interesting.
2. Once the pathspec-attribute feature is invented, users can label
submodules with attributes to group them, so that a broad pathspec
with attribute requirements, e.g. ':(attr:lib)', can be used to say
any and all modules with the 'lib' attribute are interesting.
Since the .gitattributes file, just like the .gitmodules file, is
tracked by the superproject, when a submodule moves in the
superproject tree, the project can adjust which path gets the
attribute in .gitattributes, just like it can adjust which path has
the submodule in .gitmodules.
Neither of these two additional configuration options solve the problem
of wanting different submodules checked out in different worktrees
because multiple worktrees share .git/config. Only once per-worktree
configurations become a reality can this be solved, but this is a
necessary preparatory step for that future.
Given these multiple ways to check if a submodule is of interest, the
more fine-grained submodule.<name>.active option has the highest order
of precedence followed by the pathspec check against submodule.active.
To ensure backwards compatibility, if neither of these options are set,
git falls back to checking the submodule.<name>.url option to determine
if a submodule is interesting.
Signed-off-by: Brandon Williams <bmwill@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-17 22:38:01 +00:00
|
|
|
if (sl) {
|
|
|
|
struct pathspec ps;
|
2020-07-28 20:25:12 +00:00
|
|
|
struct strvec args = STRVEC_INIT;
|
submodule: decouple url and submodule interest
Currently the submodule.<name>.url config option is used to determine if
a given submodule is of interest to the user. This ends up being
cumbersome in a world where we want to have different submodules checked
out in different worktrees or a more generalized mechanism to select
which submodules are of interest.
In a future with worktree support for submodules, there will be multiple
working trees, each of which may only need a subset of the submodules
checked out. The URL (which is where the submodule repository can be
obtained) should not differ between different working trees.
It may also be convenient for users to more easily specify groups of
submodules they are interested in as opposed to running "git submodule
init <path>" on each submodule they want checked out in their working
tree.
To this end two config options are introduced, submodule.active and
submodule.<name>.active. The submodule.active config holds a pathspec
that specifies which submodules should exist in the working tree. The
submodule.<name>.active config is a boolean flag used to indicate if
that particular submodule should exist in the working tree.
Its important to note that submodule.active functions differently than
the other configuration options since it takes a pathspec. This allows
users to adopt at least two new workflows:
1. Submodules can be grouped with a leading directory, such that a
pathspec e.g. 'lib/' would cover all library-ish modules to allow
those who are interested in library-ish modules to set
"submodule.active = lib/" just once to say any and all modules in
'lib/' are interesting.
2. Once the pathspec-attribute feature is invented, users can label
submodules with attributes to group them, so that a broad pathspec
with attribute requirements, e.g. ':(attr:lib)', can be used to say
any and all modules with the 'lib' attribute are interesting.
Since the .gitattributes file, just like the .gitmodules file, is
tracked by the superproject, when a submodule moves in the
superproject tree, the project can adjust which path gets the
attribute in .gitattributes, just like it can adjust which path has
the submodule in .gitmodules.
Neither of these two additional configuration options solve the problem
of wanting different submodules checked out in different worktrees
because multiple worktrees share .git/config. Only once per-worktree
configurations become a reality can this be solved, but this is a
necessary preparatory step for that future.
Given these multiple ways to check if a submodule is of interest, the
more fine-grained submodule.<name>.active option has the highest order
of precedence followed by the pathspec check against submodule.active.
To ensure backwards compatibility, if neither of these options are set,
git falls back to checking the submodule.<name>.url option to determine
if a submodule is interesting.
Signed-off-by: Brandon Williams <bmwill@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-17 22:38:01 +00:00
|
|
|
const struct string_list_item *item;
|
2016-12-16 19:03:17 +00:00
|
|
|
|
submodule: decouple url and submodule interest
Currently the submodule.<name>.url config option is used to determine if
a given submodule is of interest to the user. This ends up being
cumbersome in a world where we want to have different submodules checked
out in different worktrees or a more generalized mechanism to select
which submodules are of interest.
In a future with worktree support for submodules, there will be multiple
working trees, each of which may only need a subset of the submodules
checked out. The URL (which is where the submodule repository can be
obtained) should not differ between different working trees.
It may also be convenient for users to more easily specify groups of
submodules they are interested in as opposed to running "git submodule
init <path>" on each submodule they want checked out in their working
tree.
To this end two config options are introduced, submodule.active and
submodule.<name>.active. The submodule.active config holds a pathspec
that specifies which submodules should exist in the working tree. The
submodule.<name>.active config is a boolean flag used to indicate if
that particular submodule should exist in the working tree.
Its important to note that submodule.active functions differently than
the other configuration options since it takes a pathspec. This allows
users to adopt at least two new workflows:
1. Submodules can be grouped with a leading directory, such that a
pathspec e.g. 'lib/' would cover all library-ish modules to allow
those who are interested in library-ish modules to set
"submodule.active = lib/" just once to say any and all modules in
'lib/' are interesting.
2. Once the pathspec-attribute feature is invented, users can label
submodules with attributes to group them, so that a broad pathspec
with attribute requirements, e.g. ':(attr:lib)', can be used to say
any and all modules with the 'lib' attribute are interesting.
Since the .gitattributes file, just like the .gitmodules file, is
tracked by the superproject, when a submodule moves in the
superproject tree, the project can adjust which path gets the
attribute in .gitattributes, just like it can adjust which path has
the submodule in .gitmodules.
Neither of these two additional configuration options solve the problem
of wanting different submodules checked out in different worktrees
because multiple worktrees share .git/config. Only once per-worktree
configurations become a reality can this be solved, but this is a
necessary preparatory step for that future.
Given these multiple ways to check if a submodule is of interest, the
more fine-grained submodule.<name>.active option has the highest order
of precedence followed by the pathspec check against submodule.active.
To ensure backwards compatibility, if neither of these options are set,
git falls back to checking the submodule.<name>.url option to determine
if a submodule is interesting.
Signed-off-by: Brandon Williams <bmwill@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-17 22:38:01 +00:00
|
|
|
for_each_string_list_item(item, sl) {
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_push(&args, item->string);
|
submodule: decouple url and submodule interest
Currently the submodule.<name>.url config option is used to determine if
a given submodule is of interest to the user. This ends up being
cumbersome in a world where we want to have different submodules checked
out in different worktrees or a more generalized mechanism to select
which submodules are of interest.
In a future with worktree support for submodules, there will be multiple
working trees, each of which may only need a subset of the submodules
checked out. The URL (which is where the submodule repository can be
obtained) should not differ between different working trees.
It may also be convenient for users to more easily specify groups of
submodules they are interested in as opposed to running "git submodule
init <path>" on each submodule they want checked out in their working
tree.
To this end two config options are introduced, submodule.active and
submodule.<name>.active. The submodule.active config holds a pathspec
that specifies which submodules should exist in the working tree. The
submodule.<name>.active config is a boolean flag used to indicate if
that particular submodule should exist in the working tree.
Its important to note that submodule.active functions differently than
the other configuration options since it takes a pathspec. This allows
users to adopt at least two new workflows:
1. Submodules can be grouped with a leading directory, such that a
pathspec e.g. 'lib/' would cover all library-ish modules to allow
those who are interested in library-ish modules to set
"submodule.active = lib/" just once to say any and all modules in
'lib/' are interesting.
2. Once the pathspec-attribute feature is invented, users can label
submodules with attributes to group them, so that a broad pathspec
with attribute requirements, e.g. ':(attr:lib)', can be used to say
any and all modules with the 'lib' attribute are interesting.
Since the .gitattributes file, just like the .gitmodules file, is
tracked by the superproject, when a submodule moves in the
superproject tree, the project can adjust which path gets the
attribute in .gitattributes, just like it can adjust which path has
the submodule in .gitmodules.
Neither of these two additional configuration options solve the problem
of wanting different submodules checked out in different worktrees
because multiple worktrees share .git/config. Only once per-worktree
configurations become a reality can this be solved, but this is a
necessary preparatory step for that future.
Given these multiple ways to check if a submodule is of interest, the
more fine-grained submodule.<name>.active option has the highest order
of precedence followed by the pathspec check against submodule.active.
To ensure backwards compatibility, if neither of these options are set,
git falls back to checking the submodule.<name>.url option to determine
if a submodule is interesting.
Signed-off-by: Brandon Williams <bmwill@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-17 22:38:01 +00:00
|
|
|
}
|
|
|
|
|
2020-07-29 00:37:20 +00:00
|
|
|
parse_pathspec(&ps, 0, 0, NULL, args.v);
|
2018-08-13 16:14:31 +00:00
|
|
|
ret = match_pathspec(repo->index, &ps, path, strlen(path), 0, NULL, 1);
|
submodule: decouple url and submodule interest
Currently the submodule.<name>.url config option is used to determine if
a given submodule is of interest to the user. This ends up being
cumbersome in a world where we want to have different submodules checked
out in different worktrees or a more generalized mechanism to select
which submodules are of interest.
In a future with worktree support for submodules, there will be multiple
working trees, each of which may only need a subset of the submodules
checked out. The URL (which is where the submodule repository can be
obtained) should not differ between different working trees.
It may also be convenient for users to more easily specify groups of
submodules they are interested in as opposed to running "git submodule
init <path>" on each submodule they want checked out in their working
tree.
To this end two config options are introduced, submodule.active and
submodule.<name>.active. The submodule.active config holds a pathspec
that specifies which submodules should exist in the working tree. The
submodule.<name>.active config is a boolean flag used to indicate if
that particular submodule should exist in the working tree.
Its important to note that submodule.active functions differently than
the other configuration options since it takes a pathspec. This allows
users to adopt at least two new workflows:
1. Submodules can be grouped with a leading directory, such that a
pathspec e.g. 'lib/' would cover all library-ish modules to allow
those who are interested in library-ish modules to set
"submodule.active = lib/" just once to say any and all modules in
'lib/' are interesting.
2. Once the pathspec-attribute feature is invented, users can label
submodules with attributes to group them, so that a broad pathspec
with attribute requirements, e.g. ':(attr:lib)', can be used to say
any and all modules with the 'lib' attribute are interesting.
Since the .gitattributes file, just like the .gitmodules file, is
tracked by the superproject, when a submodule moves in the
superproject tree, the project can adjust which path gets the
attribute in .gitattributes, just like it can adjust which path has
the submodule in .gitmodules.
Neither of these two additional configuration options solve the problem
of wanting different submodules checked out in different worktrees
because multiple worktrees share .git/config. Only once per-worktree
configurations become a reality can this be solved, but this is a
necessary preparatory step for that future.
Given these multiple ways to check if a submodule is of interest, the
more fine-grained submodule.<name>.active option has the highest order
of precedence followed by the pathspec check against submodule.active.
To ensure backwards compatibility, if neither of these options are set,
git falls back to checking the submodule.<name>.url option to determine
if a submodule is interesting.
Signed-off-by: Brandon Williams <bmwill@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-17 22:38:01 +00:00
|
|
|
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_clear(&args);
|
submodule: decouple url and submodule interest
Currently the submodule.<name>.url config option is used to determine if
a given submodule is of interest to the user. This ends up being
cumbersome in a world where we want to have different submodules checked
out in different worktrees or a more generalized mechanism to select
which submodules are of interest.
In a future with worktree support for submodules, there will be multiple
working trees, each of which may only need a subset of the submodules
checked out. The URL (which is where the submodule repository can be
obtained) should not differ between different working trees.
It may also be convenient for users to more easily specify groups of
submodules they are interested in as opposed to running "git submodule
init <path>" on each submodule they want checked out in their working
tree.
To this end two config options are introduced, submodule.active and
submodule.<name>.active. The submodule.active config holds a pathspec
that specifies which submodules should exist in the working tree. The
submodule.<name>.active config is a boolean flag used to indicate if
that particular submodule should exist in the working tree.
Its important to note that submodule.active functions differently than
the other configuration options since it takes a pathspec. This allows
users to adopt at least two new workflows:
1. Submodules can be grouped with a leading directory, such that a
pathspec e.g. 'lib/' would cover all library-ish modules to allow
those who are interested in library-ish modules to set
"submodule.active = lib/" just once to say any and all modules in
'lib/' are interesting.
2. Once the pathspec-attribute feature is invented, users can label
submodules with attributes to group them, so that a broad pathspec
with attribute requirements, e.g. ':(attr:lib)', can be used to say
any and all modules with the 'lib' attribute are interesting.
Since the .gitattributes file, just like the .gitmodules file, is
tracked by the superproject, when a submodule moves in the
superproject tree, the project can adjust which path gets the
attribute in .gitattributes, just like it can adjust which path has
the submodule in .gitmodules.
Neither of these two additional configuration options solve the problem
of wanting different submodules checked out in different worktrees
because multiple worktrees share .git/config. Only once per-worktree
configurations become a reality can this be solved, but this is a
necessary preparatory step for that future.
Given these multiple ways to check if a submodule is of interest, the
more fine-grained submodule.<name>.active option has the highest order
of precedence followed by the pathspec check against submodule.active.
To ensure backwards compatibility, if neither of these options are set,
git falls back to checking the submodule.<name>.url option to determine
if a submodule is interesting.
Signed-off-by: Brandon Williams <bmwill@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-17 22:38:01 +00:00
|
|
|
clear_pathspec(&ps);
|
|
|
|
return ret;
|
2016-12-16 19:03:17 +00:00
|
|
|
}
|
|
|
|
|
submodule: decouple url and submodule interest
Currently the submodule.<name>.url config option is used to determine if
a given submodule is of interest to the user. This ends up being
cumbersome in a world where we want to have different submodules checked
out in different worktrees or a more generalized mechanism to select
which submodules are of interest.
In a future with worktree support for submodules, there will be multiple
working trees, each of which may only need a subset of the submodules
checked out. The URL (which is where the submodule repository can be
obtained) should not differ between different working trees.
It may also be convenient for users to more easily specify groups of
submodules they are interested in as opposed to running "git submodule
init <path>" on each submodule they want checked out in their working
tree.
To this end two config options are introduced, submodule.active and
submodule.<name>.active. The submodule.active config holds a pathspec
that specifies which submodules should exist in the working tree. The
submodule.<name>.active config is a boolean flag used to indicate if
that particular submodule should exist in the working tree.
Its important to note that submodule.active functions differently than
the other configuration options since it takes a pathspec. This allows
users to adopt at least two new workflows:
1. Submodules can be grouped with a leading directory, such that a
pathspec e.g. 'lib/' would cover all library-ish modules to allow
those who are interested in library-ish modules to set
"submodule.active = lib/" just once to say any and all modules in
'lib/' are interesting.
2. Once the pathspec-attribute feature is invented, users can label
submodules with attributes to group them, so that a broad pathspec
with attribute requirements, e.g. ':(attr:lib)', can be used to say
any and all modules with the 'lib' attribute are interesting.
Since the .gitattributes file, just like the .gitmodules file, is
tracked by the superproject, when a submodule moves in the
superproject tree, the project can adjust which path gets the
attribute in .gitattributes, just like it can adjust which path has
the submodule in .gitmodules.
Neither of these two additional configuration options solve the problem
of wanting different submodules checked out in different worktrees
because multiple worktrees share .git/config. Only once per-worktree
configurations become a reality can this be solved, but this is a
necessary preparatory step for that future.
Given these multiple ways to check if a submodule is of interest, the
more fine-grained submodule.<name>.active option has the highest order
of precedence followed by the pathspec check against submodule.active.
To ensure backwards compatibility, if neither of these options are set,
git falls back to checking the submodule.<name>.url option to determine
if a submodule is interesting.
Signed-off-by: Brandon Williams <bmwill@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-17 22:38:01 +00:00
|
|
|
/* fallback to checking if the URL is set */
|
|
|
|
key = xstrfmt("submodule.%s.url", module->name);
|
2017-06-22 18:43:46 +00:00
|
|
|
ret = !repo_config_get_string(repo, key, &value);
|
submodule: decouple url and submodule interest
Currently the submodule.<name>.url config option is used to determine if
a given submodule is of interest to the user. This ends up being
cumbersome in a world where we want to have different submodules checked
out in different worktrees or a more generalized mechanism to select
which submodules are of interest.
In a future with worktree support for submodules, there will be multiple
working trees, each of which may only need a subset of the submodules
checked out. The URL (which is where the submodule repository can be
obtained) should not differ between different working trees.
It may also be convenient for users to more easily specify groups of
submodules they are interested in as opposed to running "git submodule
init <path>" on each submodule they want checked out in their working
tree.
To this end two config options are introduced, submodule.active and
submodule.<name>.active. The submodule.active config holds a pathspec
that specifies which submodules should exist in the working tree. The
submodule.<name>.active config is a boolean flag used to indicate if
that particular submodule should exist in the working tree.
Its important to note that submodule.active functions differently than
the other configuration options since it takes a pathspec. This allows
users to adopt at least two new workflows:
1. Submodules can be grouped with a leading directory, such that a
pathspec e.g. 'lib/' would cover all library-ish modules to allow
those who are interested in library-ish modules to set
"submodule.active = lib/" just once to say any and all modules in
'lib/' are interesting.
2. Once the pathspec-attribute feature is invented, users can label
submodules with attributes to group them, so that a broad pathspec
with attribute requirements, e.g. ':(attr:lib)', can be used to say
any and all modules with the 'lib' attribute are interesting.
Since the .gitattributes file, just like the .gitmodules file, is
tracked by the superproject, when a submodule moves in the
superproject tree, the project can adjust which path gets the
attribute in .gitattributes, just like it can adjust which path has
the submodule in .gitmodules.
Neither of these two additional configuration options solve the problem
of wanting different submodules checked out in different worktrees
because multiple worktrees share .git/config. Only once per-worktree
configurations become a reality can this be solved, but this is a
necessary preparatory step for that future.
Given these multiple ways to check if a submodule is of interest, the
more fine-grained submodule.<name>.active option has the highest order
of precedence followed by the pathspec check against submodule.active.
To ensure backwards compatibility, if neither of these options are set,
git falls back to checking the submodule.<name>.url option to determine
if a submodule is interesting.
Signed-off-by: Brandon Williams <bmwill@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-03-17 22:38:01 +00:00
|
|
|
|
|
|
|
free(value);
|
|
|
|
free(key);
|
2016-12-16 19:03:17 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
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 00:04:45 +00:00
|
|
|
int is_submodule_active(struct repository *repo, const char *path)
|
|
|
|
{
|
|
|
|
return is_tree_submodule_active(repo, null_oid(), path);
|
|
|
|
}
|
|
|
|
|
2017-03-14 21:46:31 +00:00
|
|
|
int is_submodule_populated_gently(const char *path, int *return_error_code)
|
2016-12-16 19:03:16 +00:00
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
char *gitdir = xstrfmt("%s/.git", path);
|
|
|
|
|
2017-03-14 21:46:31 +00:00
|
|
|
if (resolve_gitdir_gently(gitdir, return_error_code))
|
2016-12-16 19:03:16 +00:00
|
|
|
ret = 1;
|
|
|
|
|
|
|
|
free(gitdir);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-05-09 19:17:59 +00:00
|
|
|
/*
|
|
|
|
* Dies if the provided 'prefix' corresponds to an unpopulated submodule
|
|
|
|
*/
|
2021-04-01 01:49:39 +00:00
|
|
|
void die_in_unpopulated_submodule(struct index_state *istate,
|
2017-05-09 19:17:59 +00:00
|
|
|
const char *prefix)
|
|
|
|
{
|
|
|
|
int i, prefixlen;
|
|
|
|
|
|
|
|
if (!prefix)
|
|
|
|
return;
|
|
|
|
|
|
|
|
prefixlen = strlen(prefix);
|
|
|
|
|
|
|
|
for (i = 0; i < istate->cache_nr; i++) {
|
|
|
|
struct cache_entry *ce = istate->cache[i];
|
|
|
|
int ce_len = ce_namelen(ce);
|
|
|
|
|
|
|
|
if (!S_ISGITLINK(ce->ce_mode))
|
|
|
|
continue;
|
|
|
|
if (prefixlen <= ce_len)
|
|
|
|
continue;
|
|
|
|
if (strncmp(ce->name, prefix, ce_len))
|
|
|
|
continue;
|
|
|
|
if (prefix[ce_len] != '/')
|
|
|
|
continue;
|
|
|
|
|
|
|
|
die(_("in unpopulated submodule '%s'"), ce->name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-05-11 22:04:24 +00:00
|
|
|
/*
|
|
|
|
* Dies if any paths in the provided pathspec descends into a submodule
|
|
|
|
*/
|
2021-04-01 01:49:39 +00:00
|
|
|
void die_path_inside_submodule(struct index_state *istate,
|
2017-05-11 22:04:24 +00:00
|
|
|
const struct pathspec *ps)
|
|
|
|
{
|
|
|
|
int i, j;
|
|
|
|
|
|
|
|
for (i = 0; i < istate->cache_nr; i++) {
|
|
|
|
struct cache_entry *ce = istate->cache[i];
|
|
|
|
int ce_len = ce_namelen(ce);
|
|
|
|
|
|
|
|
if (!S_ISGITLINK(ce->ce_mode))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
for (j = 0; j < ps->nr ; j++) {
|
|
|
|
const struct pathspec_item *item = &ps->items[j];
|
|
|
|
|
|
|
|
if (item->len <= ce_len)
|
|
|
|
continue;
|
|
|
|
if (item->match[ce_len] != '/')
|
|
|
|
continue;
|
|
|
|
if (strncmp(ce->name, item->match, ce_len))
|
|
|
|
continue;
|
|
|
|
if (item->len == ce_len + 1)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
die(_("Pathspec '%s' is in submodule '%.*s'"),
|
|
|
|
item->original, ce_len, ce->name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-08-03 18:19:50 +00:00
|
|
|
enum submodule_update_type parse_submodule_update_type(const char *value)
|
2016-03-01 02:07:11 +00:00
|
|
|
{
|
|
|
|
if (!strcmp(value, "none"))
|
2017-08-03 18:19:50 +00:00
|
|
|
return SM_UPDATE_NONE;
|
2016-03-01 02:07:11 +00:00
|
|
|
else if (!strcmp(value, "checkout"))
|
2017-08-03 18:19:50 +00:00
|
|
|
return SM_UPDATE_CHECKOUT;
|
2016-03-01 02:07:11 +00:00
|
|
|
else if (!strcmp(value, "rebase"))
|
2017-08-03 18:19:50 +00:00
|
|
|
return SM_UPDATE_REBASE;
|
2016-03-01 02:07:11 +00:00
|
|
|
else if (!strcmp(value, "merge"))
|
2017-08-03 18:19:50 +00:00
|
|
|
return SM_UPDATE_MERGE;
|
|
|
|
else if (*value == '!')
|
|
|
|
return SM_UPDATE_COMMAND;
|
|
|
|
else
|
|
|
|
return SM_UPDATE_UNSPECIFIED;
|
|
|
|
}
|
|
|
|
|
|
|
|
int parse_submodule_update_strategy(const char *value,
|
|
|
|
struct submodule_update_strategy *dst)
|
|
|
|
{
|
|
|
|
enum submodule_update_type type;
|
|
|
|
|
|
|
|
free((void*)dst->command);
|
|
|
|
dst->command = NULL;
|
|
|
|
|
|
|
|
type = parse_submodule_update_type(value);
|
|
|
|
if (type == SM_UPDATE_UNSPECIFIED)
|
2016-03-01 02:07:11 +00:00
|
|
|
return -1;
|
2017-08-03 18:19:50 +00:00
|
|
|
|
|
|
|
dst->type = type;
|
|
|
|
if (type == SM_UPDATE_COMMAND)
|
|
|
|
dst->command = xstrdup(value + 1);
|
|
|
|
|
2016-03-01 02:07:11 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2022-08-31 23:18:05 +00:00
|
|
|
const char *submodule_update_type_to_string(enum submodule_update_type type)
|
submodule: port init from shell to C
By having the `submodule init` functionality in C, we can reference it
easier from other parts in the code in later patches. The code is split
up to have one function to initialize one submodule and a calling function
that takes care of the rest, such as argument handling and translating the
arguments to the paths of the submodules.
This is the first submodule subcommand that is fully converted to C
except for the usage string, so this is actually removing a call to
the `submodule--helper list` function, which is supposed to be used in
this transition. Instead we'll make a direct call to `module_list_compute`.
An explanation why we need to edit the prefixes in cmd_update in
git-submodule.sh in this patch:
By having no processing in the shell part, we need to convey the notion
of wt_prefix and prefix to the C parts, which former patches punted on
and did the processing of displaying path in the shell.
`wt_prefix` used to hold the path from the repository root to the current
directory, e.g. wt_prefix would be t/ if the user invoked the
`git submodule` command in ~/repo/t and ~repo is the GIT_DIR.
`prefix` used to hold the relative path from the repository root to the
operation, e.g. if you have recursive submodules, the shell script would
modify the `prefix` in each recursive step by adding the submodule path.
We will pass `wt_prefix` into the C helper via `git -C <dir>` as that
will setup git in the directory the user actually called git-submodule.sh
from. The `prefix` will be passed in via the `--prefix` option.
Having `prefix` and `wt_prefix` relative to the GIT_DIR of the
calling superproject is unfortunate with this patch as the C code doesn't
know about a possible recursion from a superproject via `submodule update
--init --recursive`.
To fix this, we change the meaning of `wt_prefix` to point to the current
project instead of the superproject and `prefix` to include any relative
paths issues in the superproject. That way `prefix` will become the leading
part for displaying paths and `wt_prefix` will be empty in recursive
calls for now.
The new notion of `wt_prefix` and `prefix` still allows us to reconstruct
the calling directory in the superproject by just traveling reverse of
`prefix`.
Signed-off-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-04-16 00:50:13 +00:00
|
|
|
{
|
2022-08-31 23:18:05 +00:00
|
|
|
switch (type) {
|
submodule: port init from shell to C
By having the `submodule init` functionality in C, we can reference it
easier from other parts in the code in later patches. The code is split
up to have one function to initialize one submodule and a calling function
that takes care of the rest, such as argument handling and translating the
arguments to the paths of the submodules.
This is the first submodule subcommand that is fully converted to C
except for the usage string, so this is actually removing a call to
the `submodule--helper list` function, which is supposed to be used in
this transition. Instead we'll make a direct call to `module_list_compute`.
An explanation why we need to edit the prefixes in cmd_update in
git-submodule.sh in this patch:
By having no processing in the shell part, we need to convey the notion
of wt_prefix and prefix to the C parts, which former patches punted on
and did the processing of displaying path in the shell.
`wt_prefix` used to hold the path from the repository root to the current
directory, e.g. wt_prefix would be t/ if the user invoked the
`git submodule` command in ~/repo/t and ~repo is the GIT_DIR.
`prefix` used to hold the relative path from the repository root to the
operation, e.g. if you have recursive submodules, the shell script would
modify the `prefix` in each recursive step by adding the submodule path.
We will pass `wt_prefix` into the C helper via `git -C <dir>` as that
will setup git in the directory the user actually called git-submodule.sh
from. The `prefix` will be passed in via the `--prefix` option.
Having `prefix` and `wt_prefix` relative to the GIT_DIR of the
calling superproject is unfortunate with this patch as the C code doesn't
know about a possible recursion from a superproject via `submodule update
--init --recursive`.
To fix this, we change the meaning of `wt_prefix` to point to the current
project instead of the superproject and `prefix` to include any relative
paths issues in the superproject. That way `prefix` will become the leading
part for displaying paths and `wt_prefix` will be empty in recursive
calls for now.
The new notion of `wt_prefix` and `prefix` still allows us to reconstruct
the calling directory in the superproject by just traveling reverse of
`prefix`.
Signed-off-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-04-16 00:50:13 +00:00
|
|
|
case SM_UPDATE_CHECKOUT:
|
|
|
|
return "checkout";
|
|
|
|
case SM_UPDATE_MERGE:
|
|
|
|
return "merge";
|
|
|
|
case SM_UPDATE_REBASE:
|
|
|
|
return "rebase";
|
|
|
|
case SM_UPDATE_NONE:
|
|
|
|
return "none";
|
|
|
|
case SM_UPDATE_UNSPECIFIED:
|
|
|
|
case SM_UPDATE_COMMAND:
|
2022-08-31 23:18:05 +00:00
|
|
|
BUG("init_submodule() should handle type %d", type);
|
|
|
|
default:
|
|
|
|
BUG("unexpected update strategy type: %d", type);
|
submodule: port init from shell to C
By having the `submodule init` functionality in C, we can reference it
easier from other parts in the code in later patches. The code is split
up to have one function to initialize one submodule and a calling function
that takes care of the rest, such as argument handling and translating the
arguments to the paths of the submodules.
This is the first submodule subcommand that is fully converted to C
except for the usage string, so this is actually removing a call to
the `submodule--helper list` function, which is supposed to be used in
this transition. Instead we'll make a direct call to `module_list_compute`.
An explanation why we need to edit the prefixes in cmd_update in
git-submodule.sh in this patch:
By having no processing in the shell part, we need to convey the notion
of wt_prefix and prefix to the C parts, which former patches punted on
and did the processing of displaying path in the shell.
`wt_prefix` used to hold the path from the repository root to the current
directory, e.g. wt_prefix would be t/ if the user invoked the
`git submodule` command in ~/repo/t and ~repo is the GIT_DIR.
`prefix` used to hold the relative path from the repository root to the
operation, e.g. if you have recursive submodules, the shell script would
modify the `prefix` in each recursive step by adding the submodule path.
We will pass `wt_prefix` into the C helper via `git -C <dir>` as that
will setup git in the directory the user actually called git-submodule.sh
from. The `prefix` will be passed in via the `--prefix` option.
Having `prefix` and `wt_prefix` relative to the GIT_DIR of the
calling superproject is unfortunate with this patch as the C code doesn't
know about a possible recursion from a superproject via `submodule update
--init --recursive`.
To fix this, we change the meaning of `wt_prefix` to point to the current
project instead of the superproject and `prefix` to include any relative
paths issues in the superproject. That way `prefix` will become the leading
part for displaying paths and `wt_prefix` will be empty in recursive
calls for now.
The new notion of `wt_prefix` and `prefix` still allows us to reconstruct
the calling directory in the superproject by just traveling reverse of
`prefix`.
Signed-off-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-04-16 00:50:13 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-06-25 14:56:47 +00:00
|
|
|
void handle_ignore_submodules_arg(struct diff_options *diffopt,
|
|
|
|
const char *arg)
|
|
|
|
{
|
2020-11-10 08:39:00 +00:00
|
|
|
diffopt->flags.ignore_submodule_set = 1;
|
2017-10-31 18:19:11 +00:00
|
|
|
diffopt->flags.ignore_submodules = 0;
|
|
|
|
diffopt->flags.ignore_untracked_in_submodules = 0;
|
|
|
|
diffopt->flags.ignore_dirty_submodules = 0;
|
2010-08-05 08:49:55 +00:00
|
|
|
|
2010-06-25 14:56:47 +00:00
|
|
|
if (!strcmp(arg, "all"))
|
2017-10-31 18:19:11 +00:00
|
|
|
diffopt->flags.ignore_submodules = 1;
|
2010-06-25 14:56:47 +00:00
|
|
|
else if (!strcmp(arg, "untracked"))
|
2017-10-31 18:19:11 +00:00
|
|
|
diffopt->flags.ignore_untracked_in_submodules = 1;
|
2010-06-25 14:56:47 +00:00
|
|
|
else if (!strcmp(arg, "dirty"))
|
2017-10-31 18:19:11 +00:00
|
|
|
diffopt->flags.ignore_dirty_submodules = 1;
|
2010-08-05 22:39:25 +00:00
|
|
|
else if (strcmp(arg, "none"))
|
2020-01-15 18:07:01 +00:00
|
|
|
die(_("bad --ignore-submodules argument: %s"), arg);
|
2019-02-16 11:24:41 +00:00
|
|
|
/*
|
|
|
|
* Please update _git_status() in git-completion.bash when you
|
|
|
|
* add new options
|
|
|
|
*/
|
2010-06-25 14:56:47 +00:00
|
|
|
}
|
|
|
|
|
2020-09-19 00:58:05 +00:00
|
|
|
static int prepare_submodule_diff_summary(struct repository *r, struct rev_info *rev,
|
|
|
|
const char *path,
|
|
|
|
struct commit *left, struct commit *right,
|
|
|
|
struct commit_list *merge_bases)
|
2011-03-16 07:14:11 +00:00
|
|
|
{
|
2016-08-31 23:27:24 +00:00
|
|
|
struct commit_list *list;
|
2011-03-16 07:14:11 +00:00
|
|
|
|
2020-06-23 20:56:59 +00:00
|
|
|
repo_init_revisions(r, rev, NULL);
|
2011-03-16 07:14:11 +00:00
|
|
|
setup_revisions(0, NULL, rev, NULL);
|
|
|
|
rev->left_right = 1;
|
|
|
|
rev->first_parent_only = 1;
|
|
|
|
left->object.flags |= SYMMETRIC_LEFT;
|
|
|
|
add_pending_object(rev, &left->object, path);
|
|
|
|
add_pending_object(rev, &right->object, path);
|
|
|
|
for (list = merge_bases; list; list = list->next) {
|
|
|
|
list->item->object.flags |= UNINTERESTING;
|
|
|
|
add_pending_object(rev, &list->item->object,
|
2015-11-10 02:22:28 +00:00
|
|
|
oid_to_hex(&list->item->object.oid));
|
2011-03-16 07:14:11 +00:00
|
|
|
}
|
|
|
|
return prepare_revision_walk(rev);
|
|
|
|
}
|
|
|
|
|
2020-08-12 19:44:02 +00:00
|
|
|
static void print_submodule_diff_summary(struct repository *r, struct rev_info *rev, struct diff_options *o)
|
2011-03-16 07:14:11 +00:00
|
|
|
{
|
|
|
|
static const char format[] = " %m %s";
|
|
|
|
struct strbuf sb = STRBUF_INIT;
|
|
|
|
struct commit *commit;
|
|
|
|
|
|
|
|
while ((commit = get_revision(rev))) {
|
|
|
|
struct pretty_print_context ctx = {0};
|
|
|
|
ctx.date_mode = rev->date_mode;
|
2013-06-26 10:19:50 +00:00
|
|
|
ctx.output_encoding = get_log_output_encoding();
|
2011-03-16 07:14:11 +00:00
|
|
|
strbuf_setlen(&sb, 0);
|
2018-12-15 00:09:37 +00:00
|
|
|
repo_format_commit_message(r, commit, format, &sb,
|
|
|
|
&ctx);
|
2011-03-16 07:14:11 +00:00
|
|
|
strbuf_addch(&sb, '\n');
|
2017-06-30 00:07:00 +00:00
|
|
|
if (commit->object.flags & SYMMETRIC_LEFT)
|
|
|
|
diff_emit_submodule_del(o, sb.buf);
|
|
|
|
else
|
|
|
|
diff_emit_submodule_add(o, sb.buf);
|
2011-03-16 07:14:11 +00:00
|
|
|
}
|
|
|
|
strbuf_release(&sb);
|
|
|
|
}
|
|
|
|
|
2020-07-28 20:25:12 +00:00
|
|
|
void prepare_submodule_repo_env(struct strvec *out)
|
2017-03-14 21:46:35 +00:00
|
|
|
{
|
2021-06-17 17:13:25 +00:00
|
|
|
prepare_other_repo_env(out, DEFAULT_GIT_DIR_ENVIRONMENT);
|
2017-03-14 21:46:35 +00:00
|
|
|
}
|
|
|
|
|
2020-07-28 20:25:12 +00:00
|
|
|
static void prepare_submodule_repo_env_in_gitdir(struct strvec *out)
|
2018-11-29 00:27:55 +00:00
|
|
|
{
|
2021-06-17 17:13:25 +00:00
|
|
|
prepare_other_repo_env(out, ".");
|
2018-11-29 00:27:55 +00:00
|
|
|
}
|
|
|
|
|
2018-12-15 00:09:37 +00:00
|
|
|
/*
|
|
|
|
* Initialize a repository struct for a submodule based on the provided 'path'.
|
|
|
|
*
|
|
|
|
* Returns the repository struct on success,
|
|
|
|
* NULL when the submodule is not present.
|
2016-08-31 23:27:24 +00:00
|
|
|
*/
|
2018-12-15 00:09:37 +00:00
|
|
|
static struct repository *open_submodule(const char *path)
|
|
|
|
{
|
|
|
|
struct strbuf sb = STRBUF_INIT;
|
|
|
|
struct repository *out = xmalloc(sizeof(*out));
|
|
|
|
|
|
|
|
if (submodule_to_gitdir(&sb, path) || repo_init(out, sb.buf, NULL)) {
|
|
|
|
strbuf_release(&sb);
|
|
|
|
free(out);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Mark it as a submodule */
|
|
|
|
out->submodule_prefix = xstrdup(path);
|
|
|
|
|
|
|
|
strbuf_release(&sb);
|
|
|
|
return out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Helper function to display the submodule header line prior to the full
|
|
|
|
* summary output.
|
|
|
|
*
|
|
|
|
* If it can locate the submodule git directory it will create a repository
|
|
|
|
* handle for the submodule and lookup both the left and right commits and
|
|
|
|
* put them into the left and right pointers.
|
2016-08-31 23:27:24 +00:00
|
|
|
*/
|
2018-12-15 00:09:37 +00:00
|
|
|
static void show_submodule_header(struct diff_options *o,
|
|
|
|
const char *path,
|
2016-08-31 23:27:23 +00:00
|
|
|
struct object_id *one, struct object_id *two,
|
2017-06-30 00:07:00 +00:00
|
|
|
unsigned dirty_submodule,
|
2018-12-15 00:09:37 +00:00
|
|
|
struct repository *sub,
|
2016-08-31 23:27:24 +00:00
|
|
|
struct commit **left, struct commit **right,
|
|
|
|
struct commit_list **merge_bases)
|
2009-10-19 12:38:32 +00:00
|
|
|
{
|
|
|
|
const char *message = NULL;
|
|
|
|
struct strbuf sb = STRBUF_INIT;
|
|
|
|
int fast_forward = 0, fast_backward = 0;
|
|
|
|
|
2010-03-04 21:20:33 +00:00
|
|
|
if (dirty_submodule & DIRTY_SUBMODULE_UNTRACKED)
|
2017-06-30 00:07:00 +00:00
|
|
|
diff_emit_submodule_untracked(o, path);
|
|
|
|
|
2010-03-04 21:20:33 +00:00
|
|
|
if (dirty_submodule & DIRTY_SUBMODULE_MODIFIED)
|
2017-06-30 00:07:00 +00:00
|
|
|
diff_emit_submodule_modified(o, path);
|
2010-03-04 21:20:33 +00:00
|
|
|
|
2016-08-31 23:27:24 +00:00
|
|
|
if (is_null_oid(one))
|
|
|
|
message = "(new submodule)";
|
|
|
|
else if (is_null_oid(two))
|
|
|
|
message = "(submodule deleted)";
|
|
|
|
|
2018-12-15 00:09:37 +00:00
|
|
|
if (!sub) {
|
2016-08-31 23:27:24 +00:00
|
|
|
if (!message)
|
2017-09-26 18:27:56 +00:00
|
|
|
message = "(commits not present)";
|
2016-08-31 23:27:24 +00:00
|
|
|
goto output_header;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Attempt to lookup the commit references, and determine if this is
|
|
|
|
* a fast forward or fast backwards update.
|
|
|
|
*/
|
2018-12-15 00:09:37 +00:00
|
|
|
*left = lookup_commit_reference(sub, one);
|
|
|
|
*right = lookup_commit_reference(sub, two);
|
2016-08-31 23:27:24 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Warn about missing commits in the submodule project, but only if
|
|
|
|
* they aren't null.
|
|
|
|
*/
|
|
|
|
if ((!is_null_oid(one) && !*left) ||
|
|
|
|
(!is_null_oid(two) && !*right))
|
|
|
|
message = "(commits not present)";
|
|
|
|
|
2018-12-15 00:09:37 +00:00
|
|
|
*merge_bases = repo_get_merge_bases(sub, *left, *right);
|
2016-08-31 23:27:24 +00:00
|
|
|
if (*merge_bases) {
|
|
|
|
if ((*merge_bases)->item == *left)
|
|
|
|
fast_forward = 1;
|
|
|
|
else if ((*merge_bases)->item == *right)
|
|
|
|
fast_backward = 1;
|
|
|
|
}
|
|
|
|
|
convert "oidcmp() == 0" to oideq()
Using the more restrictive oideq() should, in the long run,
give the compiler more opportunities to optimize these
callsites. For now, this conversion should be a complete
noop with respect to the generated code.
The result is also perhaps a little more readable, as it
avoids the "zero is equal" idiom. Since it's so prevalent in
C, I think seasoned programmers tend not to even notice it
anymore, but it can sometimes make for awkward double
negations (e.g., we can drop a few !!oidcmp() instances
here).
This patch was generated almost entirely by the included
coccinelle patch. This mechanical conversion should be
completely safe, because we check explicitly for cases where
oidcmp() is compared to 0, which is what oideq() is doing
under the hood. Note that we don't have to catch "!oidcmp()"
separately; coccinelle's standard isomorphisms make sure the
two are treated equivalently.
I say "almost" because I did hand-edit the coccinelle output
to fix up a few style violations (it mostly keeps the
original formatting, but sometimes unwraps long lines).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-08-28 21:22:40 +00:00
|
|
|
if (oideq(one, two)) {
|
2010-03-04 21:20:33 +00:00
|
|
|
strbuf_release(&sb);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-08-31 23:27:24 +00:00
|
|
|
output_header:
|
2017-06-30 00:07:00 +00:00
|
|
|
strbuf_addf(&sb, "Submodule %s ", path);
|
strbuf: convert strbuf_add_unique_abbrev to use struct object_id
Convert the declaration and definition of strbuf_add_unique_abbrev to
make it take a pointer to struct object_id. Predeclare the struct in
strbuf.h, as cache.h includes strbuf.h before it declares the struct,
and otherwise the struct declaration would have the wrong scope.
Apply the following semantic patch, along with the standard object_id
transforms, to adjust the callers:
@@
expression E1, E2, E3;
@@
- strbuf_add_unique_abbrev(E1, E2.hash, E3);
+ strbuf_add_unique_abbrev(E1, &E2, E3);
@@
expression E1, E2, E3;
@@
- strbuf_add_unique_abbrev(E1, E2->hash, E3);
+ strbuf_add_unique_abbrev(E1, E2, E3);
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-03-12 02:27:28 +00:00
|
|
|
strbuf_add_unique_abbrev(&sb, one, DEFAULT_ABBREV);
|
2016-10-08 15:38:47 +00:00
|
|
|
strbuf_addstr(&sb, (fast_backward || fast_forward) ? ".." : "...");
|
strbuf: convert strbuf_add_unique_abbrev to use struct object_id
Convert the declaration and definition of strbuf_add_unique_abbrev to
make it take a pointer to struct object_id. Predeclare the struct in
strbuf.h, as cache.h includes strbuf.h before it declares the struct,
and otherwise the struct declaration would have the wrong scope.
Apply the following semantic patch, along with the standard object_id
transforms, to adjust the callers:
@@
expression E1, E2, E3;
@@
- strbuf_add_unique_abbrev(E1, E2.hash, E3);
+ strbuf_add_unique_abbrev(E1, &E2, E3);
@@
expression E1, E2, E3;
@@
- strbuf_add_unique_abbrev(E1, E2->hash, E3);
+ strbuf_add_unique_abbrev(E1, E2, E3);
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-03-12 02:27:28 +00:00
|
|
|
strbuf_add_unique_abbrev(&sb, two, DEFAULT_ABBREV);
|
2009-10-19 12:38:32 +00:00
|
|
|
if (message)
|
2017-06-30 00:07:00 +00:00
|
|
|
strbuf_addf(&sb, " %s\n", message);
|
2009-10-19 12:38:32 +00:00
|
|
|
else
|
2017-06-30 00:07:00 +00:00
|
|
|
strbuf_addf(&sb, "%s:\n", fast_backward ? " (rewind)" : "");
|
|
|
|
diff_emit_submodule_header(o, sb.buf);
|
2009-10-19 12:38:32 +00:00
|
|
|
|
|
|
|
strbuf_release(&sb);
|
|
|
|
}
|
2010-01-16 17:42:24 +00:00
|
|
|
|
2020-08-12 19:44:02 +00:00
|
|
|
void show_submodule_diff_summary(struct diff_options *o, const char *path,
|
2016-08-31 23:27:24 +00:00
|
|
|
struct object_id *one, struct object_id *two,
|
2017-06-30 00:07:00 +00:00
|
|
|
unsigned dirty_submodule)
|
2016-08-31 23:27:24 +00:00
|
|
|
{
|
2022-04-13 20:01:38 +00:00
|
|
|
struct rev_info rev = REV_INFO_INIT;
|
2016-08-31 23:27:24 +00:00
|
|
|
struct commit *left = NULL, *right = NULL;
|
|
|
|
struct commit_list *merge_bases = NULL;
|
2018-12-15 00:09:37 +00:00
|
|
|
struct repository *sub;
|
2016-08-31 23:27:24 +00:00
|
|
|
|
2018-12-15 00:09:37 +00:00
|
|
|
sub = open_submodule(path);
|
2017-06-30 00:07:00 +00:00
|
|
|
show_submodule_header(o, path, one, two, dirty_submodule,
|
2018-12-15 00:09:37 +00:00
|
|
|
sub, &left, &right, &merge_bases);
|
2016-08-31 23:27:24 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If we don't have both a left and a right pointer, there is no
|
|
|
|
* reason to try and display a summary. The header line should contain
|
|
|
|
* all the information the user needs.
|
|
|
|
*/
|
2018-12-15 00:09:37 +00:00
|
|
|
if (!left || !right || !sub)
|
2016-08-31 23:27:24 +00:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* Treat revision walker failure the same as missing commits */
|
2020-09-19 00:58:05 +00:00
|
|
|
if (prepare_submodule_diff_summary(sub, &rev, path, left, right, merge_bases)) {
|
2017-06-30 00:07:00 +00:00
|
|
|
diff_emit_submodule_error(o, "(revision walker failed)\n");
|
2016-08-31 23:27:24 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2020-08-12 19:44:02 +00:00
|
|
|
print_submodule_diff_summary(sub, &rev, o);
|
2016-08-31 23:27:24 +00:00
|
|
|
|
|
|
|
out:
|
2022-04-13 20:01:34 +00:00
|
|
|
free_commit_list(merge_bases);
|
2022-04-13 20:01:38 +00:00
|
|
|
release_revisions(&rev);
|
2016-08-31 23:27:24 +00:00
|
|
|
clear_commit_marks(left, ~0);
|
|
|
|
clear_commit_marks(right, ~0);
|
2018-12-15 00:09:37 +00:00
|
|
|
if (sub) {
|
|
|
|
repo_clear(sub);
|
|
|
|
free(sub);
|
|
|
|
}
|
2016-08-31 23:27:24 +00:00
|
|
|
}
|
|
|
|
|
2017-06-30 00:07:00 +00:00
|
|
|
void show_submodule_inline_diff(struct diff_options *o, const char *path,
|
2016-08-31 23:27:25 +00:00
|
|
|
struct object_id *one, struct object_id *two,
|
2017-06-30 00:07:00 +00:00
|
|
|
unsigned dirty_submodule)
|
2016-08-31 23:27:25 +00:00
|
|
|
{
|
2018-02-14 18:59:49 +00:00
|
|
|
const struct object_id *old_oid = the_hash_algo->empty_tree, *new_oid = the_hash_algo->empty_tree;
|
2016-08-31 23:27:25 +00:00
|
|
|
struct commit *left = NULL, *right = NULL;
|
|
|
|
struct commit_list *merge_bases = NULL;
|
|
|
|
struct child_process cp = CHILD_PROCESS_INIT;
|
2017-06-30 00:07:00 +00:00
|
|
|
struct strbuf sb = STRBUF_INIT;
|
2018-12-15 00:09:37 +00:00
|
|
|
struct repository *sub;
|
2016-08-31 23:27:25 +00:00
|
|
|
|
2018-12-15 00:09:37 +00:00
|
|
|
sub = open_submodule(path);
|
2017-06-30 00:07:00 +00:00
|
|
|
show_submodule_header(o, path, one, two, dirty_submodule,
|
2018-12-15 00:09:37 +00:00
|
|
|
sub, &left, &right, &merge_bases);
|
2016-08-31 23:27:25 +00:00
|
|
|
|
|
|
|
/* We need a valid left and right commit to display a difference */
|
|
|
|
if (!(left || is_null_oid(one)) ||
|
|
|
|
!(right || is_null_oid(two)))
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
if (left)
|
2018-02-14 18:59:49 +00:00
|
|
|
old_oid = one;
|
2016-08-31 23:27:25 +00:00
|
|
|
if (right)
|
2018-02-14 18:59:49 +00:00
|
|
|
new_oid = two;
|
2016-08-31 23:27:25 +00:00
|
|
|
|
|
|
|
cp.git_cmd = 1;
|
|
|
|
cp.dir = path;
|
2017-06-30 00:07:00 +00:00
|
|
|
cp.out = -1;
|
2016-08-31 23:27:25 +00:00
|
|
|
cp.no_stdin = 1;
|
|
|
|
|
|
|
|
/* TODO: other options may need to be passed here. */
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_pushl(&cp.args, "diff", "--submodule=diff", NULL);
|
|
|
|
strvec_pushf(&cp.args, "--color=%s", want_color(o->use_color) ?
|
2017-06-30 00:07:00 +00:00
|
|
|
"always" : "never");
|
2017-05-04 21:43:55 +00:00
|
|
|
|
2017-10-31 18:19:11 +00:00
|
|
|
if (o->flags.reverse_diff) {
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_pushf(&cp.args, "--src-prefix=%s%s/",
|
strvec: fix indentation in renamed calls
Code which split an argv_array call across multiple lines, like:
argv_array_pushl(&args, "one argument",
"another argument", "and more",
NULL);
was recently mechanically renamed to use strvec, which results in
mis-matched indentation like:
strvec_pushl(&args, "one argument",
"another argument", "and more",
NULL);
Let's fix these up to align the arguments with the opening paren. I did
this manually by sifting through the results of:
git jump grep 'strvec_.*,$'
and liberally applying my editor's auto-format. Most of the changes are
of the form shown above, though I also normalized a few that had
originally used a single-tab indentation (rather than our usual style of
aligning with the open paren). I also rewrapped a couple of obvious
cases (e.g., where previously too-long lines became short enough to fit
on one), but I wasn't aggressive about it. In cases broken to three or
more lines, the grouping of arguments is sometimes meaningful, and it
wasn't worth my time or reviewer time to ponder each case individually.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-07-28 20:26:31 +00:00
|
|
|
o->b_prefix, path);
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_pushf(&cp.args, "--dst-prefix=%s%s/",
|
strvec: fix indentation in renamed calls
Code which split an argv_array call across multiple lines, like:
argv_array_pushl(&args, "one argument",
"another argument", "and more",
NULL);
was recently mechanically renamed to use strvec, which results in
mis-matched indentation like:
strvec_pushl(&args, "one argument",
"another argument", "and more",
NULL);
Let's fix these up to align the arguments with the opening paren. I did
this manually by sifting through the results of:
git jump grep 'strvec_.*,$'
and liberally applying my editor's auto-format. Most of the changes are
of the form shown above, though I also normalized a few that had
originally used a single-tab indentation (rather than our usual style of
aligning with the open paren). I also rewrapped a couple of obvious
cases (e.g., where previously too-long lines became short enough to fit
on one), but I wasn't aggressive about it. In cases broken to three or
more lines, the grouping of arguments is sometimes meaningful, and it
wasn't worth my time or reviewer time to ponder each case individually.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-07-28 20:26:31 +00:00
|
|
|
o->a_prefix, path);
|
2016-08-31 23:27:25 +00:00
|
|
|
} else {
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_pushf(&cp.args, "--src-prefix=%s%s/",
|
strvec: fix indentation in renamed calls
Code which split an argv_array call across multiple lines, like:
argv_array_pushl(&args, "one argument",
"another argument", "and more",
NULL);
was recently mechanically renamed to use strvec, which results in
mis-matched indentation like:
strvec_pushl(&args, "one argument",
"another argument", "and more",
NULL);
Let's fix these up to align the arguments with the opening paren. I did
this manually by sifting through the results of:
git jump grep 'strvec_.*,$'
and liberally applying my editor's auto-format. Most of the changes are
of the form shown above, though I also normalized a few that had
originally used a single-tab indentation (rather than our usual style of
aligning with the open paren). I also rewrapped a couple of obvious
cases (e.g., where previously too-long lines became short enough to fit
on one), but I wasn't aggressive about it. In cases broken to three or
more lines, the grouping of arguments is sometimes meaningful, and it
wasn't worth my time or reviewer time to ponder each case individually.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-07-28 20:26:31 +00:00
|
|
|
o->a_prefix, path);
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_pushf(&cp.args, "--dst-prefix=%s%s/",
|
strvec: fix indentation in renamed calls
Code which split an argv_array call across multiple lines, like:
argv_array_pushl(&args, "one argument",
"another argument", "and more",
NULL);
was recently mechanically renamed to use strvec, which results in
mis-matched indentation like:
strvec_pushl(&args, "one argument",
"another argument", "and more",
NULL);
Let's fix these up to align the arguments with the opening paren. I did
this manually by sifting through the results of:
git jump grep 'strvec_.*,$'
and liberally applying my editor's auto-format. Most of the changes are
of the form shown above, though I also normalized a few that had
originally used a single-tab indentation (rather than our usual style of
aligning with the open paren). I also rewrapped a couple of obvious
cases (e.g., where previously too-long lines became short enough to fit
on one), but I wasn't aggressive about it. In cases broken to three or
more lines, the grouping of arguments is sometimes meaningful, and it
wasn't worth my time or reviewer time to ponder each case individually.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-07-28 20:26:31 +00:00
|
|
|
o->b_prefix, path);
|
2016-08-31 23:27:25 +00:00
|
|
|
}
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_push(&cp.args, oid_to_hex(old_oid));
|
2016-08-31 23:27:25 +00:00
|
|
|
/*
|
|
|
|
* If the submodule has modified content, we will diff against the
|
|
|
|
* work tree, under the assumption that the user has asked for the
|
|
|
|
* diff format and wishes to actually see all differences even if they
|
|
|
|
* haven't yet been committed to the submodule yet.
|
|
|
|
*/
|
|
|
|
if (!(dirty_submodule & DIRTY_SUBMODULE_MODIFIED))
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_push(&cp.args, oid_to_hex(new_oid));
|
2016-08-31 23:27:25 +00:00
|
|
|
|
2022-06-02 09:09:50 +00:00
|
|
|
prepare_submodule_repo_env(&cp.env);
|
diff --submodule=diff: do not fail on ever-initialied deleted submodules
If you have ever initialized a submodule, open_submodule will open it.
If you then delete the submodule's worktree directory (but don't
remove it from .gitmodules), git diff --submodule=diff would error out
as it attempted to chdir into the now-deleted working tree directory.
This only matters if the submodules git dir is absorbed. If not, then
we no longer have anywhere to run the diff. But that case does not
trigger this error, because in that case, open_submodule fails, so we
don't resolve a left commit, so we exit early, which is the only thing
we could do.
If absorbed, then we can run the diff from the submodule's absorbed
git dir (.git/modules/sm2). In practice, that's a bit more
complicated, because `git diff` expects to be run from inside a
working directory, not a git dir. So it looks in the config for
core.worktree, and does chdir("../../../sm2"), which is the very dir
that we're trying to avoid visiting because it's been deleted. We
work around this by setting GIT_WORK_TREE (and GIT_DIR) to ".". It is
little weird to set GIT_WORK_TREE to something that is not a working
tree just to avoid an unnecessary chdir, but it works.
Signed-off-by: David Turner <dturner@twosigma.com
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-08-31 13:12:56 +00:00
|
|
|
|
|
|
|
if (!is_directory(path)) {
|
|
|
|
/* fall back to absorbed git dir, if any */
|
|
|
|
if (!sub)
|
|
|
|
goto done;
|
|
|
|
cp.dir = sub->gitdir;
|
2022-06-02 09:09:50 +00:00
|
|
|
strvec_push(&cp.env, GIT_DIR_ENVIRONMENT "=.");
|
|
|
|
strvec_push(&cp.env, GIT_WORK_TREE_ENVIRONMENT "=.");
|
diff --submodule=diff: do not fail on ever-initialied deleted submodules
If you have ever initialized a submodule, open_submodule will open it.
If you then delete the submodule's worktree directory (but don't
remove it from .gitmodules), git diff --submodule=diff would error out
as it attempted to chdir into the now-deleted working tree directory.
This only matters if the submodules git dir is absorbed. If not, then
we no longer have anywhere to run the diff. But that case does not
trigger this error, because in that case, open_submodule fails, so we
don't resolve a left commit, so we exit early, which is the only thing
we could do.
If absorbed, then we can run the diff from the submodule's absorbed
git dir (.git/modules/sm2). In practice, that's a bit more
complicated, because `git diff` expects to be run from inside a
working directory, not a git dir. So it looks in the config for
core.worktree, and does chdir("../../../sm2"), which is the very dir
that we're trying to avoid visiting because it's been deleted. We
work around this by setting GIT_WORK_TREE (and GIT_DIR) to ".". It is
little weird to set GIT_WORK_TREE to something that is not a working
tree just to avoid an unnecessary chdir, but it works.
Signed-off-by: David Turner <dturner@twosigma.com
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-08-31 13:12:56 +00:00
|
|
|
}
|
|
|
|
|
2021-08-31 13:12:57 +00:00
|
|
|
if (start_command(&cp)) {
|
2017-06-30 00:07:00 +00:00
|
|
|
diff_emit_submodule_error(o, "(diff failed)\n");
|
2021-08-31 13:12:57 +00:00
|
|
|
goto done;
|
|
|
|
}
|
2017-06-30 00:07:00 +00:00
|
|
|
|
|
|
|
while (strbuf_getwholeline_fd(&sb, cp.out, '\n') != EOF)
|
|
|
|
diff_emit_submodule_pipethrough(o, sb.buf, sb.len);
|
|
|
|
|
|
|
|
if (finish_command(&cp))
|
|
|
|
diff_emit_submodule_error(o, "(diff failed)\n");
|
2016-08-31 23:27:25 +00:00
|
|
|
|
|
|
|
done:
|
2017-06-30 00:07:00 +00:00
|
|
|
strbuf_release(&sb);
|
2022-04-13 20:01:34 +00:00
|
|
|
free_commit_list(merge_bases);
|
2016-08-31 23:27:25 +00:00
|
|
|
if (left)
|
|
|
|
clear_commit_marks(left, ~0);
|
|
|
|
if (right)
|
|
|
|
clear_commit_marks(right, ~0);
|
2018-12-15 00:09:37 +00:00
|
|
|
if (sub) {
|
|
|
|
repo_clear(sub);
|
|
|
|
free(sub);
|
|
|
|
}
|
2016-08-31 23:27:25 +00:00
|
|
|
}
|
|
|
|
|
2017-03-14 21:46:34 +00:00
|
|
|
int should_update_submodules(void)
|
|
|
|
{
|
|
|
|
return config_update_recurse_submodules == RECURSE_SUBMODULES_ON;
|
|
|
|
}
|
|
|
|
|
|
|
|
const struct submodule *submodule_from_ce(const struct cache_entry *ce)
|
|
|
|
{
|
|
|
|
if (!S_ISGITLINK(ce->ce_mode))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (!should_update_submodules())
|
|
|
|
return NULL;
|
|
|
|
|
2021-04-26 01:02:56 +00:00
|
|
|
return submodule_from_path(the_repository, null_oid(), ce->name);
|
2017-03-14 21:46:34 +00:00
|
|
|
}
|
|
|
|
|
2017-05-02 01:02:39 +00:00
|
|
|
|
2017-10-16 13:58:27 +00:00
|
|
|
struct collect_changed_submodules_cb_data {
|
2018-10-19 17:34:43 +00:00
|
|
|
struct repository *repo;
|
2017-10-16 13:58:27 +00:00
|
|
|
struct string_list *changed;
|
|
|
|
const struct object_id *commit_oid;
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* this would normally be two functions: default_name_from_path() and
|
|
|
|
* path_from_default_name(). Since the default name is the same as
|
|
|
|
* the submodule path we can get away with just one function which only
|
|
|
|
* checks whether there is a submodule in the working directory at that
|
|
|
|
* location.
|
|
|
|
*/
|
|
|
|
static const char *default_name_or_path(const char *path_or_name)
|
|
|
|
{
|
|
|
|
int error_code;
|
|
|
|
|
|
|
|
if (!is_submodule_populated_gently(path_or_name, &error_code))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return path_or_name;
|
|
|
|
}
|
|
|
|
|
2022-03-08 00:14:29 +00:00
|
|
|
/*
|
|
|
|
* Holds relevant information for a changed submodule. Used as the .util
|
2022-03-08 00:14:32 +00:00
|
|
|
* member of the changed submodule name string_list_item.
|
|
|
|
*
|
|
|
|
* (super_oid, path) allows the submodule config to be read from _some_
|
|
|
|
* .gitmodules file. We store this information the first time we find a
|
|
|
|
* superproject commit that points to the submodule, but this is
|
|
|
|
* arbitrary - we can choose any (super_oid, path) that matches the
|
|
|
|
* submodule's name.
|
|
|
|
*
|
|
|
|
* NEEDSWORK: Storing an arbitrary commit is undesirable because we can't
|
|
|
|
* guarantee that we're reading the commit that the user would expect. A better
|
|
|
|
* scheme would be to just fetch a submodule by its name. This requires two
|
|
|
|
* steps:
|
|
|
|
* - Create a function that behaves like repo_submodule_init(), but accepts a
|
|
|
|
* submodule name instead of treeish_name and path. This should be easy
|
|
|
|
* because repo_submodule_init() internally uses the submodule's name.
|
|
|
|
*
|
|
|
|
* - Replace most instances of 'struct submodule' (which is the .gitmodules
|
|
|
|
* config) with just the submodule name. This is OK because we expect
|
|
|
|
* submodule settings to be stored in .git/config (via "git submodule init"),
|
|
|
|
* not .gitmodules. This also lets us delete get_non_gitmodules_submodule(),
|
|
|
|
* which constructs a bogus 'struct submodule' for the sake of giving a
|
|
|
|
* placeholder name to a gitlink.
|
2022-03-08 00:14:29 +00:00
|
|
|
*/
|
|
|
|
struct changed_submodule_data {
|
2022-03-08 00:14:32 +00:00
|
|
|
/*
|
|
|
|
* The first superproject commit in the rev walk that points to
|
|
|
|
* the submodule.
|
|
|
|
*/
|
|
|
|
const struct object_id *super_oid;
|
|
|
|
/*
|
|
|
|
* Path to the submodule in the superproject commit referenced
|
|
|
|
* by 'super_oid'.
|
|
|
|
*/
|
|
|
|
char *path;
|
2022-03-08 00:14:29 +00:00
|
|
|
/* The submodule commits that have changed in the rev walk. */
|
|
|
|
struct oid_array new_commits;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void changed_submodule_data_clear(struct changed_submodule_data *cs_data)
|
|
|
|
{
|
|
|
|
oid_array_clear(&cs_data->new_commits);
|
2022-03-08 00:14:32 +00:00
|
|
|
free(cs_data->path);
|
2022-03-08 00:14:29 +00:00
|
|
|
}
|
|
|
|
|
2017-05-02 01:02:39 +00:00
|
|
|
static void collect_changed_submodules_cb(struct diff_queue_struct *q,
|
|
|
|
struct diff_options *options,
|
|
|
|
void *data)
|
|
|
|
{
|
2017-10-16 13:58:27 +00:00
|
|
|
struct collect_changed_submodules_cb_data *me = data;
|
|
|
|
struct string_list *changed = me->changed;
|
|
|
|
const struct object_id *commit_oid = me->commit_oid;
|
2017-05-02 01:02:39 +00:00
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < q->nr; i++) {
|
|
|
|
struct diff_filepair *p = q->queue[i];
|
2017-10-16 13:58:27 +00:00
|
|
|
const struct submodule *submodule;
|
|
|
|
const char *name;
|
2022-03-08 00:14:28 +00:00
|
|
|
struct string_list_item *item;
|
2022-03-08 00:14:29 +00:00
|
|
|
struct changed_submodule_data *cs_data;
|
2017-10-16 13:58:27 +00:00
|
|
|
|
2017-05-02 01:02:39 +00:00
|
|
|
if (!S_ISGITLINK(p->two->mode))
|
|
|
|
continue;
|
|
|
|
|
2018-10-19 17:34:43 +00:00
|
|
|
submodule = submodule_from_path(me->repo,
|
2018-03-28 22:35:29 +00:00
|
|
|
commit_oid, p->two->path);
|
2017-10-16 13:58:27 +00:00
|
|
|
if (submodule)
|
|
|
|
name = submodule->name;
|
|
|
|
else {
|
|
|
|
name = default_name_or_path(p->two->path);
|
|
|
|
/* make sure name does not collide with existing one */
|
submodule: fix NULL correctness in renamed broken submodules
When fetching with recursing into submodules, the fetch logic inspects
the superproject which submodules actually need to be fetched. This is
tricky for submodules that were renamed in the fetched range of commits.
This was implemented in c68f8375760 (implement fetching of moved
submodules, 2017-10-16), and this patch fixes a mistake in the logic
there.
When the warning is printed, the `name` might be NULL as
default_name_or_path can return NULL, so fix the warning to use the path
as obtained from the diff machinery, as that is not NULL.
While at it, make sure we only attempt to load the submodule if a git
directory of the submodule is found as default_name_or_path will return
NULL in case the git directory cannot be found. Note that passing NULL
to submodule_from_name is just a semantic error, as submodule_from_name
accepts NULL as a value, but then the return value is not the submodule
that was asked for, but some arbitrary other submodule. (Cf. 'config_from'
in submodule-config.c: "If any parameter except the cache is a NULL
pointer just return the first submodule. Can be used to check whether
there are any submodules parsed.")
Reported-by: Duy Nguyen <pclouds@gmail.com>
Helped-by: Duy Nguyen <pclouds@gmail.com>
Helped-by: Heiko Voigt <hvoigt@hvoigt.net>
Signed-off-by: Stefan Beller <sbeller@google.com>
Acked-by: Heiko Voigt <hvoigt@hvoigt.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-06-14 17:31:07 +00:00
|
|
|
if (name)
|
2018-10-19 17:34:43 +00:00
|
|
|
submodule = submodule_from_name(me->repo,
|
submodule: fix NULL correctness in renamed broken submodules
When fetching with recursing into submodules, the fetch logic inspects
the superproject which submodules actually need to be fetched. This is
tricky for submodules that were renamed in the fetched range of commits.
This was implemented in c68f8375760 (implement fetching of moved
submodules, 2017-10-16), and this patch fixes a mistake in the logic
there.
When the warning is printed, the `name` might be NULL as
default_name_or_path can return NULL, so fix the warning to use the path
as obtained from the diff machinery, as that is not NULL.
While at it, make sure we only attempt to load the submodule if a git
directory of the submodule is found as default_name_or_path will return
NULL in case the git directory cannot be found. Note that passing NULL
to submodule_from_name is just a semantic error, as submodule_from_name
accepts NULL as a value, but then the return value is not the submodule
that was asked for, but some arbitrary other submodule. (Cf. 'config_from'
in submodule-config.c: "If any parameter except the cache is a NULL
pointer just return the first submodule. Can be used to check whether
there are any submodules parsed.")
Reported-by: Duy Nguyen <pclouds@gmail.com>
Helped-by: Duy Nguyen <pclouds@gmail.com>
Helped-by: Heiko Voigt <hvoigt@hvoigt.net>
Signed-off-by: Stefan Beller <sbeller@google.com>
Acked-by: Heiko Voigt <hvoigt@hvoigt.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-06-14 17:31:07 +00:00
|
|
|
commit_oid, name);
|
2017-10-16 13:58:27 +00:00
|
|
|
if (submodule) {
|
2020-01-15 18:07:01 +00:00
|
|
|
warning(_("Submodule in commit %s at path: "
|
2017-10-16 13:58:27 +00:00
|
|
|
"'%s' collides with a submodule named "
|
2020-01-15 18:07:01 +00:00
|
|
|
"the same. Skipping it."),
|
submodule: fix NULL correctness in renamed broken submodules
When fetching with recursing into submodules, the fetch logic inspects
the superproject which submodules actually need to be fetched. This is
tricky for submodules that were renamed in the fetched range of commits.
This was implemented in c68f8375760 (implement fetching of moved
submodules, 2017-10-16), and this patch fixes a mistake in the logic
there.
When the warning is printed, the `name` might be NULL as
default_name_or_path can return NULL, so fix the warning to use the path
as obtained from the diff machinery, as that is not NULL.
While at it, make sure we only attempt to load the submodule if a git
directory of the submodule is found as default_name_or_path will return
NULL in case the git directory cannot be found. Note that passing NULL
to submodule_from_name is just a semantic error, as submodule_from_name
accepts NULL as a value, but then the return value is not the submodule
that was asked for, but some arbitrary other submodule. (Cf. 'config_from'
in submodule-config.c: "If any parameter except the cache is a NULL
pointer just return the first submodule. Can be used to check whether
there are any submodules parsed.")
Reported-by: Duy Nguyen <pclouds@gmail.com>
Helped-by: Duy Nguyen <pclouds@gmail.com>
Helped-by: Heiko Voigt <hvoigt@hvoigt.net>
Signed-off-by: Stefan Beller <sbeller@google.com>
Acked-by: Heiko Voigt <hvoigt@hvoigt.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-06-14 17:31:07 +00:00
|
|
|
oid_to_hex(commit_oid), p->two->path);
|
2017-10-16 13:58:27 +00:00
|
|
|
name = NULL;
|
|
|
|
}
|
2017-05-02 01:02:39 +00:00
|
|
|
}
|
2017-10-16 13:58:27 +00:00
|
|
|
|
|
|
|
if (!name)
|
|
|
|
continue;
|
|
|
|
|
2022-03-08 00:14:28 +00:00
|
|
|
item = string_list_insert(changed, name);
|
2022-03-08 00:14:32 +00:00
|
|
|
if (item->util)
|
|
|
|
cs_data = item->util;
|
|
|
|
else {
|
2022-03-08 00:14:29 +00:00
|
|
|
item->util = xcalloc(1, sizeof(struct changed_submodule_data));
|
2022-03-08 00:14:32 +00:00
|
|
|
cs_data = item->util;
|
|
|
|
cs_data->super_oid = commit_oid;
|
|
|
|
cs_data->path = xstrdup(p->two->path);
|
|
|
|
}
|
2022-03-08 00:14:29 +00:00
|
|
|
oid_array_append(&cs_data->new_commits, &p->two->oid);
|
2017-05-02 01:02:39 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Collect the paths of submodules in 'changed' which have changed based on
|
|
|
|
* the revisions as specified in 'argv'. Each entry in 'changed' will also
|
|
|
|
* have a corresponding 'struct oid_array' (in the 'util' field) which lists
|
|
|
|
* what the submodule pointers were updated to during the change.
|
|
|
|
*/
|
2018-10-19 17:34:43 +00:00
|
|
|
static void collect_changed_submodules(struct repository *r,
|
2018-09-21 15:57:35 +00:00
|
|
|
struct string_list *changed,
|
2020-07-28 20:25:12 +00:00
|
|
|
struct strvec *argv)
|
2017-05-02 01:02:39 +00:00
|
|
|
{
|
|
|
|
struct rev_info rev;
|
|
|
|
const struct commit *commit;
|
2020-09-06 20:53:55 +00:00
|
|
|
int save_warning;
|
|
|
|
struct setup_revision_opt s_r_opt = {
|
|
|
|
.assume_dashdash = 1,
|
|
|
|
};
|
2017-05-02 01:02:39 +00:00
|
|
|
|
2020-09-06 20:53:55 +00:00
|
|
|
save_warning = warn_on_object_refname_ambiguity;
|
|
|
|
warn_on_object_refname_ambiguity = 0;
|
2018-10-19 17:34:43 +00:00
|
|
|
repo_init_revisions(r, &rev, NULL);
|
2020-09-06 20:53:55 +00:00
|
|
|
setup_revisions(argv->nr, argv->v, &rev, &s_r_opt);
|
|
|
|
warn_on_object_refname_ambiguity = save_warning;
|
2017-05-02 01:02:39 +00:00
|
|
|
if (prepare_revision_walk(&rev))
|
2020-01-15 18:07:01 +00:00
|
|
|
die(_("revision walk setup failed"));
|
2017-05-02 01:02:39 +00:00
|
|
|
|
|
|
|
while ((commit = get_revision(&rev))) {
|
|
|
|
struct rev_info diff_rev;
|
2017-10-16 13:58:27 +00:00
|
|
|
struct collect_changed_submodules_cb_data data;
|
2018-10-19 17:34:43 +00:00
|
|
|
data.repo = r;
|
2017-10-16 13:58:27 +00:00
|
|
|
data.changed = changed;
|
|
|
|
data.commit_oid = &commit->object.oid;
|
2017-05-02 01:02:39 +00:00
|
|
|
|
2018-10-19 17:34:43 +00:00
|
|
|
repo_init_revisions(r, &diff_rev, NULL);
|
2017-05-02 01:02:39 +00:00
|
|
|
diff_rev.diffopt.output_format |= DIFF_FORMAT_CALLBACK;
|
|
|
|
diff_rev.diffopt.format_callback = collect_changed_submodules_cb;
|
2017-10-16 13:58:27 +00:00
|
|
|
diff_rev.diffopt.format_callback_data = &data;
|
2020-09-29 11:31:22 +00:00
|
|
|
diff_rev.dense_combined_merges = 1;
|
|
|
|
diff_tree_combined_merge(commit, &diff_rev);
|
2022-04-13 20:01:36 +00:00
|
|
|
release_revisions(&diff_rev);
|
2017-05-02 01:02:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
reset_revision_walk();
|
2022-04-13 20:01:36 +00:00
|
|
|
release_revisions(&rev);
|
2017-05-02 01:02:39 +00:00
|
|
|
}
|
|
|
|
|
2022-03-08 00:14:29 +00:00
|
|
|
static void free_submodules_data(struct string_list *submodules)
|
2017-05-02 01:02:39 +00:00
|
|
|
{
|
|
|
|
struct string_list_item *item;
|
|
|
|
for_each_string_list_item(item, submodules)
|
2022-03-08 00:14:29 +00:00
|
|
|
changed_submodule_data_clear(item->util);
|
|
|
|
|
2017-05-02 01:02:39 +00:00
|
|
|
string_list_clear(submodules, 1);
|
|
|
|
}
|
|
|
|
|
2022-08-25 17:09:48 +00:00
|
|
|
static int has_remote(const char *refname UNUSED,
|
|
|
|
const struct object_id *oid UNUSED,
|
|
|
|
int flags UNUSED, void *cb_data UNUSED)
|
2011-08-19 22:08:47 +00:00
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2017-03-31 01:39:59 +00:00
|
|
|
static int append_oid_to_argv(const struct object_id *oid, void *data)
|
2011-08-19 22:08:47 +00:00
|
|
|
{
|
2020-07-28 20:25:12 +00:00
|
|
|
struct strvec *argv = data;
|
|
|
|
strvec_push(argv, oid_to_hex(oid));
|
2016-11-16 15:11:05 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-09-12 17:30:27 +00:00
|
|
|
struct has_commit_data {
|
2018-10-19 17:34:43 +00:00
|
|
|
struct repository *repo;
|
2017-09-12 17:30:27 +00:00
|
|
|
int result;
|
|
|
|
const char *path;
|
2022-03-08 00:14:27 +00:00
|
|
|
const struct object_id *super_oid;
|
2017-09-12 17:30:27 +00:00
|
|
|
};
|
|
|
|
|
2017-03-31 01:39:59 +00:00
|
|
|
static int check_has_commit(const struct object_id *oid, void *data)
|
2011-08-19 22:08:47 +00:00
|
|
|
{
|
2017-09-12 17:30:27 +00:00
|
|
|
struct has_commit_data *cb = data;
|
2021-10-08 21:08:19 +00:00
|
|
|
struct repository subrepo;
|
|
|
|
enum object_type type;
|
2016-11-16 15:11:06 +00:00
|
|
|
|
2022-03-08 00:14:27 +00:00
|
|
|
if (repo_submodule_init(&subrepo, cb->repo, cb->path, cb->super_oid)) {
|
2021-10-08 21:08:19 +00:00
|
|
|
cb->result = 0;
|
2022-03-08 00:14:33 +00:00
|
|
|
/* subrepo failed to init, so don't clean it up. */
|
|
|
|
return 0;
|
2021-10-08 21:08:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
type = oid_object_info(&subrepo, oid, NULL);
|
2016-11-16 15:11:06 +00:00
|
|
|
|
2017-09-12 17:30:27 +00:00
|
|
|
switch (type) {
|
|
|
|
case OBJ_COMMIT:
|
2021-10-08 21:08:19 +00:00
|
|
|
goto cleanup;
|
2017-09-12 17:30:27 +00:00
|
|
|
case OBJ_BAD:
|
|
|
|
/*
|
|
|
|
* Object is missing or invalid. If invalid, an error message
|
|
|
|
* has already been printed.
|
|
|
|
*/
|
|
|
|
cb->result = 0;
|
2021-10-08 21:08:19 +00:00
|
|
|
goto cleanup;
|
2017-09-12 17:30:27 +00:00
|
|
|
default:
|
|
|
|
die(_("submodule entry '%s' (%s) is a %s, not a commit"),
|
2018-02-14 18:59:24 +00:00
|
|
|
cb->path, oid_to_hex(oid), type_name(type));
|
2017-09-12 17:30:27 +00:00
|
|
|
}
|
2021-10-08 21:08:19 +00:00
|
|
|
cleanup:
|
|
|
|
repo_clear(&subrepo);
|
|
|
|
return 0;
|
2016-11-16 15:11:06 +00:00
|
|
|
}
|
|
|
|
|
2018-10-19 17:34:43 +00:00
|
|
|
static int submodule_has_commits(struct repository *r,
|
|
|
|
const char *path,
|
2022-03-08 00:14:27 +00:00
|
|
|
const struct object_id *super_oid,
|
2018-10-19 17:34:43 +00:00
|
|
|
struct oid_array *commits)
|
2016-11-16 15:11:06 +00:00
|
|
|
{
|
2022-03-08 00:14:27 +00:00
|
|
|
struct has_commit_data has_commit = {
|
|
|
|
.repo = r,
|
|
|
|
.result = 1,
|
|
|
|
.path = path,
|
|
|
|
.super_oid = super_oid
|
|
|
|
};
|
2016-11-16 15:11:06 +00:00
|
|
|
|
2017-03-31 01:40:00 +00:00
|
|
|
oid_array_for_each_unique(commits, check_has_commit, &has_commit);
|
2017-05-02 01:02:38 +00:00
|
|
|
|
2017-09-12 17:30:27 +00:00
|
|
|
if (has_commit.result) {
|
2017-05-02 01:02:38 +00:00
|
|
|
/*
|
|
|
|
* Even if the submodule is checked out and the commit is
|
|
|
|
* present, make sure it exists in the submodule's object store
|
|
|
|
* and that it is reachable from a ref.
|
|
|
|
*/
|
|
|
|
struct child_process cp = CHILD_PROCESS_INIT;
|
|
|
|
struct strbuf out = STRBUF_INIT;
|
|
|
|
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_pushl(&cp.args, "rev-list", "-n", "1", NULL);
|
2017-05-02 01:02:38 +00:00
|
|
|
oid_array_for_each_unique(commits, append_oid_to_argv, &cp.args);
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_pushl(&cp.args, "--not", "--all", NULL);
|
2017-05-02 01:02:38 +00:00
|
|
|
|
2022-06-02 09:09:50 +00:00
|
|
|
prepare_submodule_repo_env(&cp.env);
|
2017-05-02 01:02:38 +00:00
|
|
|
cp.git_cmd = 1;
|
|
|
|
cp.no_stdin = 1;
|
|
|
|
cp.dir = path;
|
|
|
|
|
|
|
|
if (capture_command(&cp, &out, GIT_MAX_HEXSZ + 1) || out.len)
|
2017-09-12 17:30:27 +00:00
|
|
|
has_commit.result = 0;
|
2017-05-02 01:02:38 +00:00
|
|
|
|
|
|
|
strbuf_release(&out);
|
|
|
|
}
|
|
|
|
|
2017-09-12 17:30:27 +00:00
|
|
|
return has_commit.result;
|
2016-11-16 15:11:06 +00:00
|
|
|
}
|
|
|
|
|
2018-10-19 17:34:43 +00:00
|
|
|
static int submodule_needs_pushing(struct repository *r,
|
|
|
|
const char *path,
|
|
|
|
struct oid_array *commits)
|
2016-11-16 15:11:06 +00:00
|
|
|
{
|
2022-03-08 00:14:27 +00:00
|
|
|
if (!submodule_has_commits(r, path, null_oid(), commits))
|
2016-11-16 15:11:07 +00:00
|
|
|
/*
|
|
|
|
* NOTE: We do consider it safe to return "no" here. The
|
|
|
|
* correct answer would be "We do not know" instead of
|
|
|
|
* "No push needed", but it is quite hard to change
|
|
|
|
* the submodule pointer without having the submodule
|
|
|
|
* around. If a user did however change the submodules
|
|
|
|
* without having the submodule around, this indicates
|
|
|
|
* an expert who knows what they are doing or a
|
|
|
|
* maintainer integrating work from other people. In
|
|
|
|
* both cases it should be safe to skip this check.
|
|
|
|
*/
|
2011-08-19 22:08:47 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (for_each_remote_ref_submodule(path, has_remote, NULL) > 0) {
|
2014-08-19 19:09:35 +00:00
|
|
|
struct child_process cp = CHILD_PROCESS_INIT;
|
2011-08-19 22:08:47 +00:00
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
int needs_pushing = 0;
|
|
|
|
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_push(&cp.args, "rev-list");
|
2017-03-31 01:40:00 +00:00
|
|
|
oid_array_for_each_unique(commits, append_oid_to_argv, &cp.args);
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_pushl(&cp.args, "--not", "--remotes", "-n", "1" , NULL);
|
2016-11-16 15:11:06 +00:00
|
|
|
|
2022-06-02 09:09:50 +00:00
|
|
|
prepare_submodule_repo_env(&cp.env);
|
2011-08-19 22:08:47 +00:00
|
|
|
cp.git_cmd = 1;
|
|
|
|
cp.no_stdin = 1;
|
|
|
|
cp.out = -1;
|
|
|
|
cp.dir = path;
|
|
|
|
if (start_command(&cp))
|
2020-01-15 18:07:01 +00:00
|
|
|
die(_("Could not run 'git rev-list <commits> --not --remotes -n 1' command in submodule %s"),
|
2016-11-16 15:11:06 +00:00
|
|
|
path);
|
2019-02-19 00:04:59 +00:00
|
|
|
if (strbuf_read(&buf, cp.out, the_hash_algo->hexsz + 1))
|
2011-08-19 22:08:47 +00:00
|
|
|
needs_pushing = 1;
|
|
|
|
finish_command(&cp);
|
|
|
|
close(cp.out);
|
|
|
|
strbuf_release(&buf);
|
|
|
|
return needs_pushing;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-10-19 17:34:43 +00:00
|
|
|
int find_unpushed_submodules(struct repository *r,
|
2018-09-21 15:57:35 +00:00
|
|
|
struct oid_array *commits,
|
|
|
|
const char *remotes_name,
|
|
|
|
struct string_list *needs_pushing)
|
2011-08-19 22:08:47 +00:00
|
|
|
{
|
2016-11-16 15:11:04 +00:00
|
|
|
struct string_list submodules = STRING_LIST_INIT_DUP;
|
2017-10-16 13:58:27 +00:00
|
|
|
struct string_list_item *name;
|
2020-07-28 20:25:12 +00:00
|
|
|
struct strvec argv = STRVEC_INIT;
|
2012-03-29 07:21:23 +00:00
|
|
|
|
2020-07-29 00:37:20 +00:00
|
|
|
/* argv.v[0] will be ignored by setup_revisions */
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_push(&argv, "find_unpushed_submodules");
|
2017-03-31 01:40:00 +00:00
|
|
|
oid_array_for_each_unique(commits, append_oid_to_argv, &argv);
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_push(&argv, "--not");
|
|
|
|
strvec_pushf(&argv, "--remotes=%s", remotes_name);
|
2016-11-16 15:11:05 +00:00
|
|
|
|
2018-10-19 17:34:43 +00:00
|
|
|
collect_changed_submodules(r, &submodules, &argv);
|
2011-08-19 22:08:47 +00:00
|
|
|
|
2017-10-16 13:58:27 +00:00
|
|
|
for_each_string_list_item(name, &submodules) {
|
2022-03-08 00:14:29 +00:00
|
|
|
struct changed_submodule_data *cs_data = name->util;
|
2017-10-16 13:58:27 +00:00
|
|
|
const struct submodule *submodule;
|
|
|
|
const char *path = NULL;
|
|
|
|
|
2021-04-26 01:02:56 +00:00
|
|
|
submodule = submodule_from_name(r, null_oid(), name->string);
|
2017-10-16 13:58:27 +00:00
|
|
|
if (submodule)
|
|
|
|
path = submodule->path;
|
|
|
|
else
|
|
|
|
path = default_name_or_path(name->string);
|
|
|
|
|
|
|
|
if (!path)
|
|
|
|
continue;
|
2016-11-16 15:11:06 +00:00
|
|
|
|
2022-03-08 00:14:29 +00:00
|
|
|
if (submodule_needs_pushing(r, path, &cs_data->new_commits))
|
2017-05-02 01:02:39 +00:00
|
|
|
string_list_insert(needs_pushing, path);
|
2016-11-16 15:11:04 +00:00
|
|
|
}
|
2017-04-28 23:53:58 +00:00
|
|
|
|
2022-03-08 00:14:29 +00:00
|
|
|
free_submodules_data(&submodules);
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_clear(&argv);
|
2011-08-19 22:08:47 +00:00
|
|
|
|
2012-03-29 07:21:23 +00:00
|
|
|
return needs_pushing->nr;
|
2011-08-19 22:08:47 +00:00
|
|
|
}
|
|
|
|
|
2017-04-05 17:47:16 +00:00
|
|
|
static int push_submodule(const char *path,
|
2017-04-05 17:47:19 +00:00
|
|
|
const struct remote *remote,
|
2018-05-16 22:58:23 +00:00
|
|
|
const struct refspec *rs,
|
2017-04-05 17:47:16 +00:00
|
|
|
const struct string_list *push_options,
|
|
|
|
int dry_run)
|
2012-03-29 07:21:24 +00:00
|
|
|
{
|
|
|
|
if (for_each_remote_ref_submodule(path, has_remote, NULL) > 0) {
|
2014-08-19 19:09:35 +00:00
|
|
|
struct child_process cp = CHILD_PROCESS_INIT;
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_push(&cp.args, "push");
|
2016-11-17 18:46:04 +00:00
|
|
|
if (dry_run)
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_push(&cp.args, "--dry-run");
|
2012-03-29 07:21:24 +00:00
|
|
|
|
2017-04-05 17:47:16 +00:00
|
|
|
if (push_options && push_options->nr) {
|
|
|
|
const struct string_list_item *item;
|
|
|
|
for_each_string_list_item(item, push_options)
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_pushf(&cp.args, "--push-option=%s",
|
strvec: fix indentation in renamed calls
Code which split an argv_array call across multiple lines, like:
argv_array_pushl(&args, "one argument",
"another argument", "and more",
NULL);
was recently mechanically renamed to use strvec, which results in
mis-matched indentation like:
strvec_pushl(&args, "one argument",
"another argument", "and more",
NULL);
Let's fix these up to align the arguments with the opening paren. I did
this manually by sifting through the results of:
git jump grep 'strvec_.*,$'
and liberally applying my editor's auto-format. Most of the changes are
of the form shown above, though I also normalized a few that had
originally used a single-tab indentation (rather than our usual style of
aligning with the open paren). I also rewrapped a couple of obvious
cases (e.g., where previously too-long lines became short enough to fit
on one), but I wasn't aggressive about it. In cases broken to three or
more lines, the grouping of arguments is sometimes meaningful, and it
wasn't worth my time or reviewer time to ponder each case individually.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-07-28 20:26:31 +00:00
|
|
|
item->string);
|
2017-04-05 17:47:16 +00:00
|
|
|
}
|
2017-04-05 17:47:19 +00:00
|
|
|
|
|
|
|
if (remote->origin != REMOTE_UNCONFIGURED) {
|
|
|
|
int i;
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_push(&cp.args, remote->name);
|
2018-05-16 22:58:23 +00:00
|
|
|
for (i = 0; i < rs->raw_nr; i++)
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_push(&cp.args, rs->raw[i]);
|
2017-04-05 17:47:19 +00:00
|
|
|
}
|
|
|
|
|
2022-06-02 09:09:50 +00:00
|
|
|
prepare_submodule_repo_env(&cp.env);
|
2012-03-29 07:21:24 +00:00
|
|
|
cp.git_cmd = 1;
|
|
|
|
cp.no_stdin = 1;
|
|
|
|
cp.dir = path;
|
|
|
|
if (run_command(&cp))
|
|
|
|
return 0;
|
|
|
|
close(cp.out);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2017-04-05 17:47:19 +00:00
|
|
|
/*
|
|
|
|
* Perform a check in the submodule to see if the remote and refspec work.
|
|
|
|
* Die if the submodule can't be pushed.
|
|
|
|
*/
|
2017-07-20 17:40:37 +00:00
|
|
|
static void submodule_push_check(const char *path, const char *head,
|
|
|
|
const struct remote *remote,
|
2018-05-16 22:58:23 +00:00
|
|
|
const struct refspec *rs)
|
2017-04-05 17:47:19 +00:00
|
|
|
{
|
|
|
|
struct child_process cp = CHILD_PROCESS_INIT;
|
|
|
|
int i;
|
|
|
|
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_push(&cp.args, "submodule--helper");
|
|
|
|
strvec_push(&cp.args, "push-check");
|
|
|
|
strvec_push(&cp.args, head);
|
|
|
|
strvec_push(&cp.args, remote->name);
|
2017-04-05 17:47:19 +00:00
|
|
|
|
2018-05-16 22:58:23 +00:00
|
|
|
for (i = 0; i < rs->raw_nr; i++)
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_push(&cp.args, rs->raw[i]);
|
2017-04-05 17:47:19 +00:00
|
|
|
|
2022-06-02 09:09:50 +00:00
|
|
|
prepare_submodule_repo_env(&cp.env);
|
2017-04-05 17:47:19 +00:00
|
|
|
cp.git_cmd = 1;
|
|
|
|
cp.no_stdin = 1;
|
|
|
|
cp.no_stdout = 1;
|
|
|
|
cp.dir = path;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Simply indicate if 'submodule--helper push-check' failed.
|
|
|
|
* More detailed error information will be provided by the
|
|
|
|
* child process.
|
|
|
|
*/
|
|
|
|
if (run_command(&cp))
|
2020-01-15 18:07:01 +00:00
|
|
|
die(_("process for submodule '%s' failed"), path);
|
2017-04-05 17:47:19 +00:00
|
|
|
}
|
|
|
|
|
2018-10-19 17:34:43 +00:00
|
|
|
int push_unpushed_submodules(struct repository *r,
|
2018-09-21 15:57:35 +00:00
|
|
|
struct oid_array *commits,
|
2017-04-05 17:47:19 +00:00
|
|
|
const struct remote *remote,
|
2018-05-16 22:58:23 +00:00
|
|
|
const struct refspec *rs,
|
2017-04-05 17:47:16 +00:00
|
|
|
const struct string_list *push_options,
|
2016-11-17 18:46:04 +00:00
|
|
|
int dry_run)
|
2012-03-29 07:21:24 +00:00
|
|
|
{
|
|
|
|
int i, ret = 1;
|
2014-07-18 09:19:00 +00:00
|
|
|
struct string_list needs_pushing = STRING_LIST_INIT_DUP;
|
2012-03-29 07:21:24 +00:00
|
|
|
|
2018-10-19 17:34:43 +00:00
|
|
|
if (!find_unpushed_submodules(r, commits,
|
2018-09-21 15:57:35 +00:00
|
|
|
remote->name, &needs_pushing))
|
2012-03-29 07:21:24 +00:00
|
|
|
return 1;
|
|
|
|
|
2017-04-05 17:47:19 +00:00
|
|
|
/*
|
|
|
|
* Verify that the remote and refspec can be propagated to all
|
|
|
|
* submodules. This check can be skipped if the remote and refspec
|
|
|
|
* won't be propagated due to the remote being unconfigured (e.g. a URL
|
|
|
|
* instead of a remote name).
|
|
|
|
*/
|
2017-07-20 17:40:37 +00:00
|
|
|
if (remote->origin != REMOTE_UNCONFIGURED) {
|
|
|
|
char *head;
|
|
|
|
struct object_id head_oid;
|
|
|
|
|
refs: convert resolve_refdup and refs_resolve_refdup to struct object_id
All of the callers already pass the hash member of struct object_id, so
update them to pass a pointer to the struct directly,
This transformation was done with an update to declaration and
definition and the following semantic patch:
@@
expression E1, E2, E3, E4;
@@
- resolve_refdup(E1, E2, E3.hash, E4)
+ resolve_refdup(E1, E2, &E3, E4)
@@
expression E1, E2, E3, E4;
@@
- resolve_refdup(E1, E2, E3->hash, E4)
+ resolve_refdup(E1, E2, E3, E4)
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-10-15 22:06:55 +00:00
|
|
|
head = resolve_refdup("HEAD", 0, &head_oid, NULL);
|
2017-07-20 17:40:37 +00:00
|
|
|
if (!head)
|
|
|
|
die(_("Failed to resolve HEAD as a valid ref."));
|
|
|
|
|
2017-04-05 17:47:19 +00:00
|
|
|
for (i = 0; i < needs_pushing.nr; i++)
|
|
|
|
submodule_push_check(needs_pushing.items[i].string,
|
2018-05-16 22:58:23 +00:00
|
|
|
head, remote, rs);
|
2017-07-20 17:40:37 +00:00
|
|
|
free(head);
|
|
|
|
}
|
2017-04-05 17:47:19 +00:00
|
|
|
|
|
|
|
/* Actually push the submodules */
|
2012-03-29 07:21:24 +00:00
|
|
|
for (i = 0; i < needs_pushing.nr; i++) {
|
|
|
|
const char *path = needs_pushing.items[i].string;
|
2020-01-15 18:07:01 +00:00
|
|
|
fprintf(stderr, _("Pushing submodule '%s'\n"), path);
|
2018-05-16 22:58:23 +00:00
|
|
|
if (!push_submodule(path, remote, rs,
|
2017-04-05 17:47:19 +00:00
|
|
|
push_options, dry_run)) {
|
2020-01-15 18:07:01 +00:00
|
|
|
fprintf(stderr, _("Unable to push submodule '%s'\n"), path);
|
2012-03-29 07:21:24 +00:00
|
|
|
ret = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
string_list_clear(&needs_pushing, 0);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2022-08-25 17:09:48 +00:00
|
|
|
static int append_oid_to_array(const char *ref UNUSED,
|
2022-08-19 10:08:32 +00:00
|
|
|
const struct object_id *oid,
|
2022-08-25 17:09:48 +00:00
|
|
|
int flags UNUSED, void *data)
|
2011-09-12 19:56:52 +00:00
|
|
|
{
|
2017-04-28 23:53:57 +00:00
|
|
|
struct oid_array *array = data;
|
|
|
|
oid_array_append(array, oid);
|
2011-09-12 19:56:52 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-03-26 16:01:35 +00:00
|
|
|
void check_for_new_submodule_commits(struct object_id *oid)
|
2011-09-12 19:56:52 +00:00
|
|
|
{
|
|
|
|
if (!initialized_fetch_ref_tips) {
|
2017-04-28 23:53:57 +00:00
|
|
|
for_each_ref(append_oid_to_array, &ref_tips_before_fetch);
|
2011-09-12 19:56:52 +00:00
|
|
|
initialized_fetch_ref_tips = 1;
|
|
|
|
}
|
|
|
|
|
2017-03-31 01:40:00 +00:00
|
|
|
oid_array_append(&ref_tips_after_fetch, oid);
|
2011-09-12 19:56:52 +00:00
|
|
|
}
|
|
|
|
|
2022-03-08 00:14:32 +00:00
|
|
|
/*
|
|
|
|
* Returns 1 if there is at least one submodule gitdir in
|
|
|
|
* $GIT_DIR/modules and 0 otherwise. This follows
|
|
|
|
* submodule_name_to_gitdir(), which looks for submodules in
|
|
|
|
* $GIT_DIR/modules, not $GIT_COMMON_DIR.
|
|
|
|
*
|
|
|
|
* A submodule can be moved to $GIT_DIR/modules manually by running "git
|
|
|
|
* submodule absorbgitdirs", or it may be initialized there by "git
|
|
|
|
* submodule update".
|
|
|
|
*/
|
|
|
|
static int repo_has_absorbed_submodules(struct repository *r)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
|
|
|
|
strbuf_repo_git_path(&buf, r, "modules/");
|
|
|
|
ret = file_exists(buf.buf) && !is_empty_dir(buf.buf);
|
|
|
|
strbuf_release(&buf);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2018-11-29 00:27:51 +00:00
|
|
|
static void calculate_changed_submodule_paths(struct repository *r,
|
|
|
|
struct string_list *changed_submodule_names)
|
2011-03-06 22:10:46 +00:00
|
|
|
{
|
2020-07-28 20:25:12 +00:00
|
|
|
struct strvec argv = STRVEC_INIT;
|
2018-11-29 00:27:52 +00:00
|
|
|
struct string_list_item *name;
|
2011-03-06 22:10:46 +00:00
|
|
|
|
2022-03-08 00:14:32 +00:00
|
|
|
/* No need to check if no submodules would be fetched */
|
|
|
|
if (!submodule_from_path(r, NULL, NULL) &&
|
|
|
|
!repo_has_absorbed_submodules(r))
|
2011-09-09 18:22:03 +00:00
|
|
|
return;
|
|
|
|
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_push(&argv, "--"); /* argv[0] program name */
|
2017-03-31 01:40:00 +00:00
|
|
|
oid_array_for_each_unique(&ref_tips_after_fetch,
|
2017-04-28 23:53:59 +00:00
|
|
|
append_oid_to_argv, &argv);
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_push(&argv, "--not");
|
2017-03-31 01:40:00 +00:00
|
|
|
oid_array_for_each_unique(&ref_tips_before_fetch,
|
2017-04-28 23:53:59 +00:00
|
|
|
append_oid_to_argv, &argv);
|
2011-03-06 22:10:46 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Collect all submodules (whether checked out or not) for which new
|
2017-10-16 13:58:27 +00:00
|
|
|
* commits have been recorded upstream in "changed_submodule_names".
|
2011-03-06 22:10:46 +00:00
|
|
|
*/
|
2018-11-29 00:27:52 +00:00
|
|
|
collect_changed_submodules(r, changed_submodule_names, &argv);
|
2017-05-02 01:02:39 +00:00
|
|
|
|
2018-11-29 00:27:52 +00:00
|
|
|
for_each_string_list_item(name, changed_submodule_names) {
|
2022-03-08 00:14:29 +00:00
|
|
|
struct changed_submodule_data *cs_data = name->util;
|
2017-10-16 13:58:27 +00:00
|
|
|
const struct submodule *submodule;
|
|
|
|
const char *path = NULL;
|
|
|
|
|
2021-04-26 01:02:56 +00:00
|
|
|
submodule = submodule_from_name(r, null_oid(), name->string);
|
2017-10-16 13:58:27 +00:00
|
|
|
if (submodule)
|
|
|
|
path = submodule->path;
|
|
|
|
else
|
|
|
|
path = default_name_or_path(name->string);
|
|
|
|
|
|
|
|
if (!path)
|
|
|
|
continue;
|
2017-05-02 01:02:39 +00:00
|
|
|
|
2022-03-08 00:14:29 +00:00
|
|
|
if (submodule_has_commits(r, path, null_oid(), &cs_data->new_commits)) {
|
|
|
|
changed_submodule_data_clear(cs_data);
|
2018-11-29 00:27:52 +00:00
|
|
|
*name->string = '\0';
|
|
|
|
}
|
2011-03-06 22:10:46 +00:00
|
|
|
}
|
2011-09-12 19:56:52 +00:00
|
|
|
|
2018-11-29 00:27:52 +00:00
|
|
|
string_list_remove_empty_items(changed_submodule_names, 1);
|
|
|
|
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_clear(&argv);
|
2017-03-31 01:40:00 +00:00
|
|
|
oid_array_clear(&ref_tips_before_fetch);
|
|
|
|
oid_array_clear(&ref_tips_after_fetch);
|
2011-09-12 19:56:52 +00:00
|
|
|
initialized_fetch_ref_tips = 0;
|
2011-03-06 22:10:46 +00:00
|
|
|
}
|
|
|
|
|
2018-10-19 17:34:43 +00:00
|
|
|
int submodule_touches_in_range(struct repository *r,
|
2018-09-21 15:57:35 +00:00
|
|
|
struct object_id *excl_oid,
|
pull: optionally rebase submodules (remote submodule changes only)
Teach pull to optionally update submodules when '--recurse-submodules'
is provided. This will teach pull to run 'submodule update --rebase'
when the '--recurse-submodules' and '--rebase' flags are given under
specific circumstances.
On a rebase workflow:
=====================
1. Both sides change the submodule
------------------------------
Let's assume the following history in a submodule:
H---I---J---K---L local branch
\
M---N---O---P remote branch
and the following in the superproject (recorded submodule in parens):
A(H)---B(I)---F(K)---G(L) local branch
\
C(N)---D(N)---E(P) remote branch
In an ideal world this would rebase the submodule and rewrite
the submodule pointers that the superproject points at such that
the superproject looks like
A(H)---B(I) F(K')---G(L') rebased branch
\ /
C(N)---D(N)---E(P) remote branch
and the submodule as:
J---K---L (old dangeling tip)
/
H---I J'---K'---L' rebased branch
\ /
M---N---O---P remote branch
And if a conflict arises in the submodule the superproject rebase
would stop at that commit at which the submodule conflict occurs.
Currently a "pull --rebase" in the superproject produces
a merge conflict as the submodule pointer changes are
conflicting and cannot be resolved.
2. Local submodule changes only
-----------------------
Assuming histories as above, except that the remote branch
would not contain submodule changes, then a result as
A(H)---B(I) F(K)---G(L) rebased branch
\ /
C(I)---D(I)---E(I) remote branch
is desire-able. This is what currently happens in rebase.
If the recursive flag is given, the ideal git would
produce a superproject as:
A(H)---B(I) F(K')---G(L') rebased branch (incl. sub rebase!)
\ /
C(I)---D(I)---E(I) remote branch
and the submodule as:
J---K---L (old dangeling tip)
/
H---I J'---K'---L' locally rebased branch
\ /
M---N---O---P advanced branch
This patch doesn't address this issue, however
a test is added that this fails up front.
3. Remote submodule changes only
----------------------
Assuming histories as in (1) except that the local superproject branch
would not have touched the submodule the rebase already works out in the
superproject with no conflicts:
A(H)---B(I) F(P)---G(P) rebased branch (no sub changes)
\ /
C(N)---D(N)---E(P) remote branch
The recurse flag as presented in this patch would additionally
update the submodule as:
H---I J'---K'---L' rebased branch
\ /
M---N---O---P remote branch
As neither J, K, L nor J', K', L' are referred to from the superproject,
no rewriting of the superproject commits is required.
Conclusion for 'pull --rebase --recursive'
-----------------------------------------
If there are no local superproject changes it is sufficient to call
"submodule update --rebase" as this produces the desired results. In case
of conflicts, the behavior is the same as in 'submodule update --recursive'
which is assumed to be sane.
This patch implements (3) only.
On a merge workflow:
====================
We'll start off with the same underlying DAG as in (1) in the rebase
workflow. So in an ideal world a 'pull --merge --recursive' would
produce this:
H---I---J---K---L----X
\ /
M---N---O---P
with X as the new merge-commit in the submodule and the superproject
as:
A(H)---B(I)---F(K)---G(L)---Y(X)
\ /
C(N)---D(N)---E(P)
However modifying the submodules on the fly is not supported in git-merge
such that Y(X) is not easy to produce in a single patch. In fact git-merge
doesn't know about submodules at all.
However when at least one side does not contain commits touching the
submodule at all, then we do not need to perform the merge for the
submodule but a fast-forward can be done via checking out either L or P
in the submodule. This strategy is implemented in 68d03e4a6e (Implement
automatic fast-forward merge for submodules, 2010-07-07) already, so
to align with the rebase behavior we need to also update the worktree
of the submodule.
Signed-off-by: Brandon Williams <bmwill@google.com>
Signed-off-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-06-23 19:13:02 +00:00
|
|
|
struct object_id *incl_oid)
|
|
|
|
{
|
|
|
|
struct string_list subs = STRING_LIST_INIT_DUP;
|
2020-07-28 20:25:12 +00:00
|
|
|
struct strvec args = STRVEC_INIT;
|
pull: optionally rebase submodules (remote submodule changes only)
Teach pull to optionally update submodules when '--recurse-submodules'
is provided. This will teach pull to run 'submodule update --rebase'
when the '--recurse-submodules' and '--rebase' flags are given under
specific circumstances.
On a rebase workflow:
=====================
1. Both sides change the submodule
------------------------------
Let's assume the following history in a submodule:
H---I---J---K---L local branch
\
M---N---O---P remote branch
and the following in the superproject (recorded submodule in parens):
A(H)---B(I)---F(K)---G(L) local branch
\
C(N)---D(N)---E(P) remote branch
In an ideal world this would rebase the submodule and rewrite
the submodule pointers that the superproject points at such that
the superproject looks like
A(H)---B(I) F(K')---G(L') rebased branch
\ /
C(N)---D(N)---E(P) remote branch
and the submodule as:
J---K---L (old dangeling tip)
/
H---I J'---K'---L' rebased branch
\ /
M---N---O---P remote branch
And if a conflict arises in the submodule the superproject rebase
would stop at that commit at which the submodule conflict occurs.
Currently a "pull --rebase" in the superproject produces
a merge conflict as the submodule pointer changes are
conflicting and cannot be resolved.
2. Local submodule changes only
-----------------------
Assuming histories as above, except that the remote branch
would not contain submodule changes, then a result as
A(H)---B(I) F(K)---G(L) rebased branch
\ /
C(I)---D(I)---E(I) remote branch
is desire-able. This is what currently happens in rebase.
If the recursive flag is given, the ideal git would
produce a superproject as:
A(H)---B(I) F(K')---G(L') rebased branch (incl. sub rebase!)
\ /
C(I)---D(I)---E(I) remote branch
and the submodule as:
J---K---L (old dangeling tip)
/
H---I J'---K'---L' locally rebased branch
\ /
M---N---O---P advanced branch
This patch doesn't address this issue, however
a test is added that this fails up front.
3. Remote submodule changes only
----------------------
Assuming histories as in (1) except that the local superproject branch
would not have touched the submodule the rebase already works out in the
superproject with no conflicts:
A(H)---B(I) F(P)---G(P) rebased branch (no sub changes)
\ /
C(N)---D(N)---E(P) remote branch
The recurse flag as presented in this patch would additionally
update the submodule as:
H---I J'---K'---L' rebased branch
\ /
M---N---O---P remote branch
As neither J, K, L nor J', K', L' are referred to from the superproject,
no rewriting of the superproject commits is required.
Conclusion for 'pull --rebase --recursive'
-----------------------------------------
If there are no local superproject changes it is sufficient to call
"submodule update --rebase" as this produces the desired results. In case
of conflicts, the behavior is the same as in 'submodule update --recursive'
which is assumed to be sane.
This patch implements (3) only.
On a merge workflow:
====================
We'll start off with the same underlying DAG as in (1) in the rebase
workflow. So in an ideal world a 'pull --merge --recursive' would
produce this:
H---I---J---K---L----X
\ /
M---N---O---P
with X as the new merge-commit in the submodule and the superproject
as:
A(H)---B(I)---F(K)---G(L)---Y(X)
\ /
C(N)---D(N)---E(P)
However modifying the submodules on the fly is not supported in git-merge
such that Y(X) is not easy to produce in a single patch. In fact git-merge
doesn't know about submodules at all.
However when at least one side does not contain commits touching the
submodule at all, then we do not need to perform the merge for the
submodule but a fast-forward can be done via checking out either L or P
in the submodule. This strategy is implemented in 68d03e4a6e (Implement
automatic fast-forward merge for submodules, 2010-07-07) already, so
to align with the rebase behavior we need to also update the worktree
of the submodule.
Signed-off-by: Brandon Williams <bmwill@google.com>
Signed-off-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-06-23 19:13:02 +00:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* No need to check if there are no submodules configured */
|
2018-10-19 17:34:43 +00:00
|
|
|
if (!submodule_from_path(r, NULL, NULL))
|
pull: optionally rebase submodules (remote submodule changes only)
Teach pull to optionally update submodules when '--recurse-submodules'
is provided. This will teach pull to run 'submodule update --rebase'
when the '--recurse-submodules' and '--rebase' flags are given under
specific circumstances.
On a rebase workflow:
=====================
1. Both sides change the submodule
------------------------------
Let's assume the following history in a submodule:
H---I---J---K---L local branch
\
M---N---O---P remote branch
and the following in the superproject (recorded submodule in parens):
A(H)---B(I)---F(K)---G(L) local branch
\
C(N)---D(N)---E(P) remote branch
In an ideal world this would rebase the submodule and rewrite
the submodule pointers that the superproject points at such that
the superproject looks like
A(H)---B(I) F(K')---G(L') rebased branch
\ /
C(N)---D(N)---E(P) remote branch
and the submodule as:
J---K---L (old dangeling tip)
/
H---I J'---K'---L' rebased branch
\ /
M---N---O---P remote branch
And if a conflict arises in the submodule the superproject rebase
would stop at that commit at which the submodule conflict occurs.
Currently a "pull --rebase" in the superproject produces
a merge conflict as the submodule pointer changes are
conflicting and cannot be resolved.
2. Local submodule changes only
-----------------------
Assuming histories as above, except that the remote branch
would not contain submodule changes, then a result as
A(H)---B(I) F(K)---G(L) rebased branch
\ /
C(I)---D(I)---E(I) remote branch
is desire-able. This is what currently happens in rebase.
If the recursive flag is given, the ideal git would
produce a superproject as:
A(H)---B(I) F(K')---G(L') rebased branch (incl. sub rebase!)
\ /
C(I)---D(I)---E(I) remote branch
and the submodule as:
J---K---L (old dangeling tip)
/
H---I J'---K'---L' locally rebased branch
\ /
M---N---O---P advanced branch
This patch doesn't address this issue, however
a test is added that this fails up front.
3. Remote submodule changes only
----------------------
Assuming histories as in (1) except that the local superproject branch
would not have touched the submodule the rebase already works out in the
superproject with no conflicts:
A(H)---B(I) F(P)---G(P) rebased branch (no sub changes)
\ /
C(N)---D(N)---E(P) remote branch
The recurse flag as presented in this patch would additionally
update the submodule as:
H---I J'---K'---L' rebased branch
\ /
M---N---O---P remote branch
As neither J, K, L nor J', K', L' are referred to from the superproject,
no rewriting of the superproject commits is required.
Conclusion for 'pull --rebase --recursive'
-----------------------------------------
If there are no local superproject changes it is sufficient to call
"submodule update --rebase" as this produces the desired results. In case
of conflicts, the behavior is the same as in 'submodule update --recursive'
which is assumed to be sane.
This patch implements (3) only.
On a merge workflow:
====================
We'll start off with the same underlying DAG as in (1) in the rebase
workflow. So in an ideal world a 'pull --merge --recursive' would
produce this:
H---I---J---K---L----X
\ /
M---N---O---P
with X as the new merge-commit in the submodule and the superproject
as:
A(H)---B(I)---F(K)---G(L)---Y(X)
\ /
C(N)---D(N)---E(P)
However modifying the submodules on the fly is not supported in git-merge
such that Y(X) is not easy to produce in a single patch. In fact git-merge
doesn't know about submodules at all.
However when at least one side does not contain commits touching the
submodule at all, then we do not need to perform the merge for the
submodule but a fast-forward can be done via checking out either L or P
in the submodule. This strategy is implemented in 68d03e4a6e (Implement
automatic fast-forward merge for submodules, 2010-07-07) already, so
to align with the rebase behavior we need to also update the worktree
of the submodule.
Signed-off-by: Brandon Williams <bmwill@google.com>
Signed-off-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-06-23 19:13:02 +00:00
|
|
|
return 0;
|
|
|
|
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_push(&args, "--"); /* args[0] program name */
|
|
|
|
strvec_push(&args, oid_to_hex(incl_oid));
|
2018-05-24 20:47:29 +00:00
|
|
|
if (!is_null_oid(excl_oid)) {
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_push(&args, "--not");
|
|
|
|
strvec_push(&args, oid_to_hex(excl_oid));
|
2018-05-24 20:47:29 +00:00
|
|
|
}
|
pull: optionally rebase submodules (remote submodule changes only)
Teach pull to optionally update submodules when '--recurse-submodules'
is provided. This will teach pull to run 'submodule update --rebase'
when the '--recurse-submodules' and '--rebase' flags are given under
specific circumstances.
On a rebase workflow:
=====================
1. Both sides change the submodule
------------------------------
Let's assume the following history in a submodule:
H---I---J---K---L local branch
\
M---N---O---P remote branch
and the following in the superproject (recorded submodule in parens):
A(H)---B(I)---F(K)---G(L) local branch
\
C(N)---D(N)---E(P) remote branch
In an ideal world this would rebase the submodule and rewrite
the submodule pointers that the superproject points at such that
the superproject looks like
A(H)---B(I) F(K')---G(L') rebased branch
\ /
C(N)---D(N)---E(P) remote branch
and the submodule as:
J---K---L (old dangeling tip)
/
H---I J'---K'---L' rebased branch
\ /
M---N---O---P remote branch
And if a conflict arises in the submodule the superproject rebase
would stop at that commit at which the submodule conflict occurs.
Currently a "pull --rebase" in the superproject produces
a merge conflict as the submodule pointer changes are
conflicting and cannot be resolved.
2. Local submodule changes only
-----------------------
Assuming histories as above, except that the remote branch
would not contain submodule changes, then a result as
A(H)---B(I) F(K)---G(L) rebased branch
\ /
C(I)---D(I)---E(I) remote branch
is desire-able. This is what currently happens in rebase.
If the recursive flag is given, the ideal git would
produce a superproject as:
A(H)---B(I) F(K')---G(L') rebased branch (incl. sub rebase!)
\ /
C(I)---D(I)---E(I) remote branch
and the submodule as:
J---K---L (old dangeling tip)
/
H---I J'---K'---L' locally rebased branch
\ /
M---N---O---P advanced branch
This patch doesn't address this issue, however
a test is added that this fails up front.
3. Remote submodule changes only
----------------------
Assuming histories as in (1) except that the local superproject branch
would not have touched the submodule the rebase already works out in the
superproject with no conflicts:
A(H)---B(I) F(P)---G(P) rebased branch (no sub changes)
\ /
C(N)---D(N)---E(P) remote branch
The recurse flag as presented in this patch would additionally
update the submodule as:
H---I J'---K'---L' rebased branch
\ /
M---N---O---P remote branch
As neither J, K, L nor J', K', L' are referred to from the superproject,
no rewriting of the superproject commits is required.
Conclusion for 'pull --rebase --recursive'
-----------------------------------------
If there are no local superproject changes it is sufficient to call
"submodule update --rebase" as this produces the desired results. In case
of conflicts, the behavior is the same as in 'submodule update --recursive'
which is assumed to be sane.
This patch implements (3) only.
On a merge workflow:
====================
We'll start off with the same underlying DAG as in (1) in the rebase
workflow. So in an ideal world a 'pull --merge --recursive' would
produce this:
H---I---J---K---L----X
\ /
M---N---O---P
with X as the new merge-commit in the submodule and the superproject
as:
A(H)---B(I)---F(K)---G(L)---Y(X)
\ /
C(N)---D(N)---E(P)
However modifying the submodules on the fly is not supported in git-merge
such that Y(X) is not easy to produce in a single patch. In fact git-merge
doesn't know about submodules at all.
However when at least one side does not contain commits touching the
submodule at all, then we do not need to perform the merge for the
submodule but a fast-forward can be done via checking out either L or P
in the submodule. This strategy is implemented in 68d03e4a6e (Implement
automatic fast-forward merge for submodules, 2010-07-07) already, so
to align with the rebase behavior we need to also update the worktree
of the submodule.
Signed-off-by: Brandon Williams <bmwill@google.com>
Signed-off-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-06-23 19:13:02 +00:00
|
|
|
|
2018-10-19 17:34:43 +00:00
|
|
|
collect_changed_submodules(r, &subs, &args);
|
pull: optionally rebase submodules (remote submodule changes only)
Teach pull to optionally update submodules when '--recurse-submodules'
is provided. This will teach pull to run 'submodule update --rebase'
when the '--recurse-submodules' and '--rebase' flags are given under
specific circumstances.
On a rebase workflow:
=====================
1. Both sides change the submodule
------------------------------
Let's assume the following history in a submodule:
H---I---J---K---L local branch
\
M---N---O---P remote branch
and the following in the superproject (recorded submodule in parens):
A(H)---B(I)---F(K)---G(L) local branch
\
C(N)---D(N)---E(P) remote branch
In an ideal world this would rebase the submodule and rewrite
the submodule pointers that the superproject points at such that
the superproject looks like
A(H)---B(I) F(K')---G(L') rebased branch
\ /
C(N)---D(N)---E(P) remote branch
and the submodule as:
J---K---L (old dangeling tip)
/
H---I J'---K'---L' rebased branch
\ /
M---N---O---P remote branch
And if a conflict arises in the submodule the superproject rebase
would stop at that commit at which the submodule conflict occurs.
Currently a "pull --rebase" in the superproject produces
a merge conflict as the submodule pointer changes are
conflicting and cannot be resolved.
2. Local submodule changes only
-----------------------
Assuming histories as above, except that the remote branch
would not contain submodule changes, then a result as
A(H)---B(I) F(K)---G(L) rebased branch
\ /
C(I)---D(I)---E(I) remote branch
is desire-able. This is what currently happens in rebase.
If the recursive flag is given, the ideal git would
produce a superproject as:
A(H)---B(I) F(K')---G(L') rebased branch (incl. sub rebase!)
\ /
C(I)---D(I)---E(I) remote branch
and the submodule as:
J---K---L (old dangeling tip)
/
H---I J'---K'---L' locally rebased branch
\ /
M---N---O---P advanced branch
This patch doesn't address this issue, however
a test is added that this fails up front.
3. Remote submodule changes only
----------------------
Assuming histories as in (1) except that the local superproject branch
would not have touched the submodule the rebase already works out in the
superproject with no conflicts:
A(H)---B(I) F(P)---G(P) rebased branch (no sub changes)
\ /
C(N)---D(N)---E(P) remote branch
The recurse flag as presented in this patch would additionally
update the submodule as:
H---I J'---K'---L' rebased branch
\ /
M---N---O---P remote branch
As neither J, K, L nor J', K', L' are referred to from the superproject,
no rewriting of the superproject commits is required.
Conclusion for 'pull --rebase --recursive'
-----------------------------------------
If there are no local superproject changes it is sufficient to call
"submodule update --rebase" as this produces the desired results. In case
of conflicts, the behavior is the same as in 'submodule update --recursive'
which is assumed to be sane.
This patch implements (3) only.
On a merge workflow:
====================
We'll start off with the same underlying DAG as in (1) in the rebase
workflow. So in an ideal world a 'pull --merge --recursive' would
produce this:
H---I---J---K---L----X
\ /
M---N---O---P
with X as the new merge-commit in the submodule and the superproject
as:
A(H)---B(I)---F(K)---G(L)---Y(X)
\ /
C(N)---D(N)---E(P)
However modifying the submodules on the fly is not supported in git-merge
such that Y(X) is not easy to produce in a single patch. In fact git-merge
doesn't know about submodules at all.
However when at least one side does not contain commits touching the
submodule at all, then we do not need to perform the merge for the
submodule but a fast-forward can be done via checking out either L or P
in the submodule. This strategy is implemented in 68d03e4a6e (Implement
automatic fast-forward merge for submodules, 2010-07-07) already, so
to align with the rebase behavior we need to also update the worktree
of the submodule.
Signed-off-by: Brandon Williams <bmwill@google.com>
Signed-off-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-06-23 19:13:02 +00:00
|
|
|
ret = subs.nr;
|
|
|
|
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_clear(&args);
|
pull: optionally rebase submodules (remote submodule changes only)
Teach pull to optionally update submodules when '--recurse-submodules'
is provided. This will teach pull to run 'submodule update --rebase'
when the '--recurse-submodules' and '--rebase' flags are given under
specific circumstances.
On a rebase workflow:
=====================
1. Both sides change the submodule
------------------------------
Let's assume the following history in a submodule:
H---I---J---K---L local branch
\
M---N---O---P remote branch
and the following in the superproject (recorded submodule in parens):
A(H)---B(I)---F(K)---G(L) local branch
\
C(N)---D(N)---E(P) remote branch
In an ideal world this would rebase the submodule and rewrite
the submodule pointers that the superproject points at such that
the superproject looks like
A(H)---B(I) F(K')---G(L') rebased branch
\ /
C(N)---D(N)---E(P) remote branch
and the submodule as:
J---K---L (old dangeling tip)
/
H---I J'---K'---L' rebased branch
\ /
M---N---O---P remote branch
And if a conflict arises in the submodule the superproject rebase
would stop at that commit at which the submodule conflict occurs.
Currently a "pull --rebase" in the superproject produces
a merge conflict as the submodule pointer changes are
conflicting and cannot be resolved.
2. Local submodule changes only
-----------------------
Assuming histories as above, except that the remote branch
would not contain submodule changes, then a result as
A(H)---B(I) F(K)---G(L) rebased branch
\ /
C(I)---D(I)---E(I) remote branch
is desire-able. This is what currently happens in rebase.
If the recursive flag is given, the ideal git would
produce a superproject as:
A(H)---B(I) F(K')---G(L') rebased branch (incl. sub rebase!)
\ /
C(I)---D(I)---E(I) remote branch
and the submodule as:
J---K---L (old dangeling tip)
/
H---I J'---K'---L' locally rebased branch
\ /
M---N---O---P advanced branch
This patch doesn't address this issue, however
a test is added that this fails up front.
3. Remote submodule changes only
----------------------
Assuming histories as in (1) except that the local superproject branch
would not have touched the submodule the rebase already works out in the
superproject with no conflicts:
A(H)---B(I) F(P)---G(P) rebased branch (no sub changes)
\ /
C(N)---D(N)---E(P) remote branch
The recurse flag as presented in this patch would additionally
update the submodule as:
H---I J'---K'---L' rebased branch
\ /
M---N---O---P remote branch
As neither J, K, L nor J', K', L' are referred to from the superproject,
no rewriting of the superproject commits is required.
Conclusion for 'pull --rebase --recursive'
-----------------------------------------
If there are no local superproject changes it is sufficient to call
"submodule update --rebase" as this produces the desired results. In case
of conflicts, the behavior is the same as in 'submodule update --recursive'
which is assumed to be sane.
This patch implements (3) only.
On a merge workflow:
====================
We'll start off with the same underlying DAG as in (1) in the rebase
workflow. So in an ideal world a 'pull --merge --recursive' would
produce this:
H---I---J---K---L----X
\ /
M---N---O---P
with X as the new merge-commit in the submodule and the superproject
as:
A(H)---B(I)---F(K)---G(L)---Y(X)
\ /
C(N)---D(N)---E(P)
However modifying the submodules on the fly is not supported in git-merge
such that Y(X) is not easy to produce in a single patch. In fact git-merge
doesn't know about submodules at all.
However when at least one side does not contain commits touching the
submodule at all, then we do not need to perform the merge for the
submodule but a fast-forward can be done via checking out either L or P
in the submodule. This strategy is implemented in 68d03e4a6e (Implement
automatic fast-forward merge for submodules, 2010-07-07) already, so
to align with the rebase behavior we need to also update the worktree
of the submodule.
Signed-off-by: Brandon Williams <bmwill@google.com>
Signed-off-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-06-23 19:13:02 +00:00
|
|
|
|
2022-03-08 00:14:29 +00:00
|
|
|
free_submodules_data(&subs);
|
pull: optionally rebase submodules (remote submodule changes only)
Teach pull to optionally update submodules when '--recurse-submodules'
is provided. This will teach pull to run 'submodule update --rebase'
when the '--recurse-submodules' and '--rebase' flags are given under
specific circumstances.
On a rebase workflow:
=====================
1. Both sides change the submodule
------------------------------
Let's assume the following history in a submodule:
H---I---J---K---L local branch
\
M---N---O---P remote branch
and the following in the superproject (recorded submodule in parens):
A(H)---B(I)---F(K)---G(L) local branch
\
C(N)---D(N)---E(P) remote branch
In an ideal world this would rebase the submodule and rewrite
the submodule pointers that the superproject points at such that
the superproject looks like
A(H)---B(I) F(K')---G(L') rebased branch
\ /
C(N)---D(N)---E(P) remote branch
and the submodule as:
J---K---L (old dangeling tip)
/
H---I J'---K'---L' rebased branch
\ /
M---N---O---P remote branch
And if a conflict arises in the submodule the superproject rebase
would stop at that commit at which the submodule conflict occurs.
Currently a "pull --rebase" in the superproject produces
a merge conflict as the submodule pointer changes are
conflicting and cannot be resolved.
2. Local submodule changes only
-----------------------
Assuming histories as above, except that the remote branch
would not contain submodule changes, then a result as
A(H)---B(I) F(K)---G(L) rebased branch
\ /
C(I)---D(I)---E(I) remote branch
is desire-able. This is what currently happens in rebase.
If the recursive flag is given, the ideal git would
produce a superproject as:
A(H)---B(I) F(K')---G(L') rebased branch (incl. sub rebase!)
\ /
C(I)---D(I)---E(I) remote branch
and the submodule as:
J---K---L (old dangeling tip)
/
H---I J'---K'---L' locally rebased branch
\ /
M---N---O---P advanced branch
This patch doesn't address this issue, however
a test is added that this fails up front.
3. Remote submodule changes only
----------------------
Assuming histories as in (1) except that the local superproject branch
would not have touched the submodule the rebase already works out in the
superproject with no conflicts:
A(H)---B(I) F(P)---G(P) rebased branch (no sub changes)
\ /
C(N)---D(N)---E(P) remote branch
The recurse flag as presented in this patch would additionally
update the submodule as:
H---I J'---K'---L' rebased branch
\ /
M---N---O---P remote branch
As neither J, K, L nor J', K', L' are referred to from the superproject,
no rewriting of the superproject commits is required.
Conclusion for 'pull --rebase --recursive'
-----------------------------------------
If there are no local superproject changes it is sufficient to call
"submodule update --rebase" as this produces the desired results. In case
of conflicts, the behavior is the same as in 'submodule update --recursive'
which is assumed to be sane.
This patch implements (3) only.
On a merge workflow:
====================
We'll start off with the same underlying DAG as in (1) in the rebase
workflow. So in an ideal world a 'pull --merge --recursive' would
produce this:
H---I---J---K---L----X
\ /
M---N---O---P
with X as the new merge-commit in the submodule and the superproject
as:
A(H)---B(I)---F(K)---G(L)---Y(X)
\ /
C(N)---D(N)---E(P)
However modifying the submodules on the fly is not supported in git-merge
such that Y(X) is not easy to produce in a single patch. In fact git-merge
doesn't know about submodules at all.
However when at least one side does not contain commits touching the
submodule at all, then we do not need to perform the merge for the
submodule but a fast-forward can be done via checking out either L or P
in the submodule. This strategy is implemented in 68d03e4a6e (Implement
automatic fast-forward merge for submodules, 2010-07-07) already, so
to align with the rebase behavior we need to also update the worktree
of the submodule.
Signed-off-by: Brandon Williams <bmwill@google.com>
Signed-off-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-06-23 19:13:02 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-12-16 00:04:11 +00:00
|
|
|
struct submodule_parallel_fetch {
|
2022-03-08 00:14:32 +00:00
|
|
|
/*
|
|
|
|
* The index of the last index entry processed by
|
|
|
|
* get_fetch_task_from_index().
|
|
|
|
*/
|
|
|
|
int index_count;
|
|
|
|
/*
|
|
|
|
* The index of the last string_list entry processed by
|
|
|
|
* get_fetch_task_from_changed().
|
|
|
|
*/
|
|
|
|
int changed_count;
|
2020-07-28 20:25:12 +00:00
|
|
|
struct strvec args;
|
2017-12-12 19:53:52 +00:00
|
|
|
struct repository *r;
|
2015-12-16 00:04:11 +00:00
|
|
|
const char *prefix;
|
|
|
|
int command_line_option;
|
2017-08-02 19:49:19 +00:00
|
|
|
int default_option;
|
2015-12-16 00:04:11 +00:00
|
|
|
int quiet;
|
|
|
|
int result;
|
2018-11-29 00:27:51 +00:00
|
|
|
|
2022-03-08 00:14:32 +00:00
|
|
|
/*
|
|
|
|
* Names of submodules that have new commits. Generated by
|
|
|
|
* walking the newly fetched superproject commits.
|
|
|
|
*/
|
2018-11-29 00:27:51 +00:00
|
|
|
struct string_list changed_submodule_names;
|
2022-03-08 00:14:32 +00:00
|
|
|
/*
|
|
|
|
* Names of submodules that have already been processed. Lets us
|
|
|
|
* avoid fetching the same submodule more than once.
|
|
|
|
*/
|
|
|
|
struct string_list seen_submodule_names;
|
2018-12-06 21:26:55 +00:00
|
|
|
|
|
|
|
/* Pending fetches by OIDs */
|
|
|
|
struct fetch_task **oid_fetch_tasks;
|
|
|
|
int oid_fetch_tasks_nr, oid_fetch_tasks_alloc;
|
2020-01-16 22:20:12 +00:00
|
|
|
|
|
|
|
struct strbuf submodules_with_errors;
|
2015-12-16 00:04:11 +00:00
|
|
|
};
|
2021-09-27 12:54:27 +00:00
|
|
|
#define SPF_INIT { \
|
|
|
|
.args = STRVEC_INIT, \
|
|
|
|
.changed_submodule_names = STRING_LIST_INIT_DUP, \
|
2022-03-08 00:14:32 +00:00
|
|
|
.seen_submodule_names = STRING_LIST_INIT_DUP, \
|
2021-09-27 12:54:27 +00:00
|
|
|
.submodules_with_errors = STRBUF_INIT, \
|
|
|
|
}
|
2015-12-16 00:04:11 +00:00
|
|
|
|
2017-10-16 13:59:05 +00:00
|
|
|
static int get_fetch_recurse_config(const struct submodule *submodule,
|
|
|
|
struct submodule_parallel_fetch *spf)
|
|
|
|
{
|
|
|
|
if (spf->command_line_option != RECURSE_SUBMODULES_DEFAULT)
|
|
|
|
return spf->command_line_option;
|
|
|
|
|
|
|
|
if (submodule) {
|
|
|
|
char *key;
|
|
|
|
const char *value;
|
|
|
|
|
|
|
|
int fetch_recurse = submodule->fetch_recurse;
|
|
|
|
key = xstrfmt("submodule.%s.fetchRecurseSubmodules", submodule->name);
|
2020-08-14 16:17:36 +00:00
|
|
|
if (!repo_config_get_string_tmp(spf->r, key, &value)) {
|
2017-10-16 13:59:05 +00:00
|
|
|
fetch_recurse = parse_fetch_recurse_submodules_arg(key, value);
|
|
|
|
}
|
|
|
|
free(key);
|
|
|
|
|
|
|
|
if (fetch_recurse != RECURSE_SUBMODULES_NONE)
|
|
|
|
/* local config overrules everything except commandline */
|
|
|
|
return fetch_recurse;
|
|
|
|
}
|
|
|
|
|
|
|
|
return spf->default_option;
|
|
|
|
}
|
|
|
|
|
2018-12-06 21:26:55 +00:00
|
|
|
/*
|
|
|
|
* Fetch in progress (if callback data) or
|
|
|
|
* pending (if in oid_fetch_tasks in struct submodule_parallel_fetch)
|
|
|
|
*/
|
|
|
|
struct fetch_task {
|
|
|
|
struct repository *repo;
|
|
|
|
const struct submodule *sub;
|
|
|
|
unsigned free_sub : 1; /* Do we need to free the submodule? */
|
2022-03-08 00:14:30 +00:00
|
|
|
const char *default_argv; /* The default fetch mode. */
|
2022-03-08 00:14:32 +00:00
|
|
|
struct strvec git_args; /* Args for the child git process. */
|
2018-12-06 21:26:55 +00:00
|
|
|
|
|
|
|
struct oid_array *commits; /* Ensure these commits are fetched */
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* When a submodule is not defined in .gitmodules, we cannot access it
|
|
|
|
* via the regular submodule-config. Create a fake submodule, which we can
|
|
|
|
* work on.
|
|
|
|
*/
|
|
|
|
static const struct submodule *get_non_gitmodules_submodule(const char *path)
|
|
|
|
{
|
|
|
|
struct submodule *ret = NULL;
|
|
|
|
const char *name = default_name_or_path(path);
|
|
|
|
|
|
|
|
if (!name)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
ret = xmalloc(sizeof(*ret));
|
|
|
|
memset(ret, 0, sizeof(*ret));
|
|
|
|
ret->path = name;
|
|
|
|
ret->name = name;
|
|
|
|
|
|
|
|
return (const struct submodule *) ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void fetch_task_release(struct fetch_task *p)
|
|
|
|
{
|
|
|
|
if (p->free_sub)
|
|
|
|
free((void*)p->sub);
|
|
|
|
p->free_sub = 0;
|
|
|
|
p->sub = NULL;
|
|
|
|
|
|
|
|
if (p->repo)
|
|
|
|
repo_clear(p->repo);
|
|
|
|
FREE_AND_NULL(p->repo);
|
2022-03-08 00:14:32 +00:00
|
|
|
|
|
|
|
strvec_clear(&p->git_args);
|
2018-12-06 21:26:55 +00:00
|
|
|
}
|
|
|
|
|
2018-11-29 00:27:54 +00:00
|
|
|
static struct repository *get_submodule_repo_for(struct repository *r,
|
2022-03-08 00:14:27 +00:00
|
|
|
const char *path,
|
|
|
|
const struct object_id *treeish_name)
|
2018-11-29 00:27:54 +00:00
|
|
|
{
|
|
|
|
struct repository *ret = xmalloc(sizeof(*ret));
|
|
|
|
|
2022-03-08 00:14:27 +00:00
|
|
|
if (repo_submodule_init(ret, r, path, treeish_name)) {
|
submodule: remove unnecessary unabsorbed fallback
In get_submodule_repo_for(), there is a fallback code path for the case
in which a submodule has an unabsorbed gitdir. (See the documentation
for "git submodule absorbgitdirs" for more information about absorbed
and unabsorbed gitdirs.) However, this code path is unnecessary, because
such submodules are already handled: when the fetch_task is created in
fetch_task_create(), it will create its own struct submodule with a path
and name, and repo_submodule_init() can handle such a struct.
This fallback was introduced in 26f80ccfc1 ("submodule: migrate
get_next_submodule to use repository structs", 2018-12-05). It was
unnecessary even then, but perhaps it escaped notice because its parent
commit d5498e0871 ("repository: repo_submodule_init to take a submodule
struct", 2018-12-05) was the one that taught repo_submodule_init() to
handle such created structs. Before, it took a path and always checked
.gitmodules, so it truly would have failed if there were no entry in
.gitmodules.
(Note to reviewers: in 26f80ccfc1, the "own struct submodule" I
mentioned is in get_next_submodule(), not fetch_task_create().)
Signed-off-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-09-09 18:47:27 +00:00
|
|
|
free(ret);
|
|
|
|
return NULL;
|
2018-11-29 00:27:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2022-03-08 00:14:31 +00:00
|
|
|
static struct fetch_task *fetch_task_create(struct submodule_parallel_fetch *spf,
|
|
|
|
const char *path,
|
|
|
|
const struct object_id *treeish_name)
|
|
|
|
{
|
|
|
|
struct fetch_task *task = xmalloc(sizeof(*task));
|
|
|
|
memset(task, 0, sizeof(*task));
|
|
|
|
|
|
|
|
task->sub = submodule_from_path(spf->r, treeish_name, path);
|
|
|
|
|
|
|
|
if (!task->sub) {
|
|
|
|
/*
|
|
|
|
* No entry in .gitmodules? Technically not a submodule,
|
|
|
|
* but historically we supported repositories that happen to be
|
|
|
|
* in-place where a gitlink is. Keep supporting them.
|
|
|
|
*/
|
|
|
|
task->sub = get_non_gitmodules_submodule(path);
|
|
|
|
if (!task->sub)
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
task->free_sub = 1;
|
|
|
|
}
|
|
|
|
|
2022-03-08 00:14:32 +00:00
|
|
|
if (string_list_lookup(&spf->seen_submodule_names, task->sub->name))
|
|
|
|
goto cleanup;
|
|
|
|
|
2022-03-08 00:14:31 +00:00
|
|
|
switch (get_fetch_recurse_config(task->sub, spf))
|
|
|
|
{
|
|
|
|
default:
|
|
|
|
case RECURSE_SUBMODULES_DEFAULT:
|
|
|
|
case RECURSE_SUBMODULES_ON_DEMAND:
|
|
|
|
if (!task->sub ||
|
|
|
|
!string_list_lookup(
|
|
|
|
&spf->changed_submodule_names,
|
|
|
|
task->sub->name))
|
|
|
|
goto cleanup;
|
|
|
|
task->default_argv = "on-demand";
|
|
|
|
break;
|
|
|
|
case RECURSE_SUBMODULES_ON:
|
|
|
|
task->default_argv = "yes";
|
|
|
|
break;
|
|
|
|
case RECURSE_SUBMODULES_OFF:
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
task->repo = get_submodule_repo_for(spf->r, path, treeish_name);
|
|
|
|
|
|
|
|
return task;
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
fetch_task_release(task);
|
|
|
|
free(task);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2022-03-08 00:14:30 +00:00
|
|
|
static struct fetch_task *
|
2022-03-08 00:14:32 +00:00
|
|
|
get_fetch_task_from_index(struct submodule_parallel_fetch *spf,
|
|
|
|
struct strbuf *err)
|
2010-11-12 12:54:52 +00:00
|
|
|
{
|
2022-03-08 00:14:32 +00:00
|
|
|
for (; spf->index_count < spf->r->index->cache_nr; spf->index_count++) {
|
|
|
|
const struct cache_entry *ce =
|
|
|
|
spf->r->index->cache[spf->index_count];
|
2018-12-06 21:26:55 +00:00
|
|
|
struct fetch_task *task;
|
2010-11-12 12:54:52 +00:00
|
|
|
|
|
|
|
if (!S_ISGITLINK(ce->ce_mode))
|
|
|
|
continue;
|
|
|
|
|
2022-03-08 00:14:31 +00:00
|
|
|
task = fetch_task_create(spf, ce->name, null_oid());
|
2018-12-06 21:26:55 +00:00
|
|
|
if (!task)
|
|
|
|
continue;
|
2017-08-03 18:19:51 +00:00
|
|
|
|
2018-12-06 21:26:55 +00:00
|
|
|
if (task->repo) {
|
2015-12-16 00:04:11 +00:00
|
|
|
if (!spf->quiet)
|
2020-01-15 18:07:01 +00:00
|
|
|
strbuf_addf(err, _("Fetching submodule %s%s\n"),
|
2015-12-16 00:04:11 +00:00
|
|
|
spf->prefix, ce->name);
|
2018-11-29 00:27:54 +00:00
|
|
|
|
2022-03-08 00:14:32 +00:00
|
|
|
spf->index_count++;
|
2022-03-08 00:14:30 +00:00
|
|
|
return task;
|
2018-11-29 00:27:54 +00:00
|
|
|
} else {
|
submodules: fix of regression on fetching of non-init subsub-repo
A regression has been introduced by a62387b (submodule.c: fetch in
submodules git directory instead of in worktree, 2018-11-28).
The scenario in which it triggers is when one has a repository with a
submodule inside a submodule like this:
superproject/middle_repo/inner_repo
Person A and B have both a clone of it, while Person B is not working
with the inner_repo and thus does not have it initialized in his working
copy.
Now person A introduces a change to the inner_repo and propagates it
through the middle_repo and the superproject.
Once person A pushed the changes and person B wants to fetch them using
"git fetch" at the superproject level, B's git call will return with
error saying:
Could not access submodule 'inner_repo'
Errors during submodule fetch:
middle_repo
Expectation is that in this case the inner submodule will be recognized
as uninitialized submodule and skipped by the git fetch command.
This used to work correctly before 'a62387b (submodule.c: fetch in
submodules git directory instead of in worktree, 2018-11-28)'.
Starting with a62387b the code wants to evaluate "is_empty_dir()" inside
.git/modules for a directory only existing in the worktree, delivering
then of course wrong return value.
This patch ensures is_empty_dir() is getting the correct path of the
uninitialized submodule by concatenation of the actual worktree and the
name of the uninitialized submodule.
The first attempt to fix this regression, in 1b7ac4e6d4 (submodules:
fix of regression on fetching of non-init subsub-repo, 2020-11-12), by
simply reverting a62387b, resulted in an infinite loop of submodule
fetches in the simpler case of a recursive fetch of a superproject with
uninitialized submodules, and so this commit was reverted in 7091499bc0
(Revert "submodules: fix of regression on fetching of non-init
subsub-repo", 2020-12-02).
To prevent future breakages, also add a regression test for this
scenario.
Signed-off-by: Peter Kaestle <peter.kaestle@nokia.com>
CC: Junio C Hamano <gitster@pobox.com>
CC: Philippe Blain <levraiphilippeblain@gmail.com>
CC: Ralf Thielow <ralf.thielow@gmail.com>
CC: Eric Sunshine <sunshine@sunshineco.us>
Reviewed-by: Philippe Blain <levraiphilippeblain@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-12-09 10:58:44 +00:00
|
|
|
struct strbuf empty_submodule_path = STRBUF_INIT;
|
2018-12-06 21:26:55 +00:00
|
|
|
|
|
|
|
fetch_task_release(task);
|
|
|
|
free(task);
|
|
|
|
|
2018-11-29 00:27:54 +00:00
|
|
|
/*
|
|
|
|
* An empty directory is normal,
|
|
|
|
* the submodule is not initialized
|
|
|
|
*/
|
submodules: fix of regression on fetching of non-init subsub-repo
A regression has been introduced by a62387b (submodule.c: fetch in
submodules git directory instead of in worktree, 2018-11-28).
The scenario in which it triggers is when one has a repository with a
submodule inside a submodule like this:
superproject/middle_repo/inner_repo
Person A and B have both a clone of it, while Person B is not working
with the inner_repo and thus does not have it initialized in his working
copy.
Now person A introduces a change to the inner_repo and propagates it
through the middle_repo and the superproject.
Once person A pushed the changes and person B wants to fetch them using
"git fetch" at the superproject level, B's git call will return with
error saying:
Could not access submodule 'inner_repo'
Errors during submodule fetch:
middle_repo
Expectation is that in this case the inner submodule will be recognized
as uninitialized submodule and skipped by the git fetch command.
This used to work correctly before 'a62387b (submodule.c: fetch in
submodules git directory instead of in worktree, 2018-11-28)'.
Starting with a62387b the code wants to evaluate "is_empty_dir()" inside
.git/modules for a directory only existing in the worktree, delivering
then of course wrong return value.
This patch ensures is_empty_dir() is getting the correct path of the
uninitialized submodule by concatenation of the actual worktree and the
name of the uninitialized submodule.
The first attempt to fix this regression, in 1b7ac4e6d4 (submodules:
fix of regression on fetching of non-init subsub-repo, 2020-11-12), by
simply reverting a62387b, resulted in an infinite loop of submodule
fetches in the simpler case of a recursive fetch of a superproject with
uninitialized submodules, and so this commit was reverted in 7091499bc0
(Revert "submodules: fix of regression on fetching of non-init
subsub-repo", 2020-12-02).
To prevent future breakages, also add a regression test for this
scenario.
Signed-off-by: Peter Kaestle <peter.kaestle@nokia.com>
CC: Junio C Hamano <gitster@pobox.com>
CC: Philippe Blain <levraiphilippeblain@gmail.com>
CC: Ralf Thielow <ralf.thielow@gmail.com>
CC: Eric Sunshine <sunshine@sunshineco.us>
Reviewed-by: Philippe Blain <levraiphilippeblain@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-12-09 10:58:44 +00:00
|
|
|
strbuf_addf(&empty_submodule_path, "%s/%s/",
|
|
|
|
spf->r->worktree,
|
|
|
|
ce->name);
|
2018-11-29 00:27:54 +00:00
|
|
|
if (S_ISGITLINK(ce->ce_mode) &&
|
submodules: fix of regression on fetching of non-init subsub-repo
A regression has been introduced by a62387b (submodule.c: fetch in
submodules git directory instead of in worktree, 2018-11-28).
The scenario in which it triggers is when one has a repository with a
submodule inside a submodule like this:
superproject/middle_repo/inner_repo
Person A and B have both a clone of it, while Person B is not working
with the inner_repo and thus does not have it initialized in his working
copy.
Now person A introduces a change to the inner_repo and propagates it
through the middle_repo and the superproject.
Once person A pushed the changes and person B wants to fetch them using
"git fetch" at the superproject level, B's git call will return with
error saying:
Could not access submodule 'inner_repo'
Errors during submodule fetch:
middle_repo
Expectation is that in this case the inner submodule will be recognized
as uninitialized submodule and skipped by the git fetch command.
This used to work correctly before 'a62387b (submodule.c: fetch in
submodules git directory instead of in worktree, 2018-11-28)'.
Starting with a62387b the code wants to evaluate "is_empty_dir()" inside
.git/modules for a directory only existing in the worktree, delivering
then of course wrong return value.
This patch ensures is_empty_dir() is getting the correct path of the
uninitialized submodule by concatenation of the actual worktree and the
name of the uninitialized submodule.
The first attempt to fix this regression, in 1b7ac4e6d4 (submodules:
fix of regression on fetching of non-init subsub-repo, 2020-11-12), by
simply reverting a62387b, resulted in an infinite loop of submodule
fetches in the simpler case of a recursive fetch of a superproject with
uninitialized submodules, and so this commit was reverted in 7091499bc0
(Revert "submodules: fix of regression on fetching of non-init
subsub-repo", 2020-12-02).
To prevent future breakages, also add a regression test for this
scenario.
Signed-off-by: Peter Kaestle <peter.kaestle@nokia.com>
CC: Junio C Hamano <gitster@pobox.com>
CC: Philippe Blain <levraiphilippeblain@gmail.com>
CC: Ralf Thielow <ralf.thielow@gmail.com>
CC: Eric Sunshine <sunshine@sunshineco.us>
Reviewed-by: Philippe Blain <levraiphilippeblain@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-12-09 10:58:44 +00:00
|
|
|
!is_empty_dir(empty_submodule_path.buf)) {
|
2018-11-29 00:27:54 +00:00
|
|
|
spf->result = 1;
|
|
|
|
strbuf_addf(err,
|
2020-02-07 00:48:33 +00:00
|
|
|
_("Could not access submodule '%s'\n"),
|
2018-11-29 00:27:54 +00:00
|
|
|
ce->name);
|
|
|
|
}
|
submodules: fix of regression on fetching of non-init subsub-repo
A regression has been introduced by a62387b (submodule.c: fetch in
submodules git directory instead of in worktree, 2018-11-28).
The scenario in which it triggers is when one has a repository with a
submodule inside a submodule like this:
superproject/middle_repo/inner_repo
Person A and B have both a clone of it, while Person B is not working
with the inner_repo and thus does not have it initialized in his working
copy.
Now person A introduces a change to the inner_repo and propagates it
through the middle_repo and the superproject.
Once person A pushed the changes and person B wants to fetch them using
"git fetch" at the superproject level, B's git call will return with
error saying:
Could not access submodule 'inner_repo'
Errors during submodule fetch:
middle_repo
Expectation is that in this case the inner submodule will be recognized
as uninitialized submodule and skipped by the git fetch command.
This used to work correctly before 'a62387b (submodule.c: fetch in
submodules git directory instead of in worktree, 2018-11-28)'.
Starting with a62387b the code wants to evaluate "is_empty_dir()" inside
.git/modules for a directory only existing in the worktree, delivering
then of course wrong return value.
This patch ensures is_empty_dir() is getting the correct path of the
uninitialized submodule by concatenation of the actual worktree and the
name of the uninitialized submodule.
The first attempt to fix this regression, in 1b7ac4e6d4 (submodules:
fix of regression on fetching of non-init subsub-repo, 2020-11-12), by
simply reverting a62387b, resulted in an infinite loop of submodule
fetches in the simpler case of a recursive fetch of a superproject with
uninitialized submodules, and so this commit was reverted in 7091499bc0
(Revert "submodules: fix of regression on fetching of non-init
subsub-repo", 2020-12-02).
To prevent future breakages, also add a regression test for this
scenario.
Signed-off-by: Peter Kaestle <peter.kaestle@nokia.com>
CC: Junio C Hamano <gitster@pobox.com>
CC: Philippe Blain <levraiphilippeblain@gmail.com>
CC: Ralf Thielow <ralf.thielow@gmail.com>
CC: Eric Sunshine <sunshine@sunshineco.us>
Reviewed-by: Philippe Blain <levraiphilippeblain@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-12-09 10:58:44 +00:00
|
|
|
strbuf_release(&empty_submodule_path);
|
2015-12-16 00:04:11 +00:00
|
|
|
}
|
2010-11-12 12:54:52 +00:00
|
|
|
}
|
2022-03-08 00:14:30 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2022-03-08 00:14:32 +00:00
|
|
|
static struct fetch_task *
|
|
|
|
get_fetch_task_from_changed(struct submodule_parallel_fetch *spf,
|
|
|
|
struct strbuf *err)
|
|
|
|
{
|
|
|
|
for (; spf->changed_count < spf->changed_submodule_names.nr;
|
|
|
|
spf->changed_count++) {
|
|
|
|
struct string_list_item item =
|
|
|
|
spf->changed_submodule_names.items[spf->changed_count];
|
|
|
|
struct changed_submodule_data *cs_data = item.util;
|
|
|
|
struct fetch_task *task;
|
|
|
|
|
|
|
|
if (!is_tree_submodule_active(spf->r, cs_data->super_oid,cs_data->path))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
task = fetch_task_create(spf, cs_data->path,
|
|
|
|
cs_data->super_oid);
|
|
|
|
if (!task)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!task->repo) {
|
|
|
|
strbuf_addf(err, _("Could not access submodule '%s' at commit %s\n"),
|
|
|
|
cs_data->path,
|
|
|
|
find_unique_abbrev(cs_data->super_oid, DEFAULT_ABBREV));
|
|
|
|
|
|
|
|
fetch_task_release(task);
|
|
|
|
free(task);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!spf->quiet)
|
|
|
|
strbuf_addf(err,
|
|
|
|
_("Fetching submodule %s%s at commit %s\n"),
|
|
|
|
spf->prefix, task->sub->path,
|
|
|
|
find_unique_abbrev(cs_data->super_oid,
|
|
|
|
DEFAULT_ABBREV));
|
|
|
|
|
|
|
|
spf->changed_count++;
|
|
|
|
/*
|
|
|
|
* NEEDSWORK: Submodules set/unset a value for
|
|
|
|
* core.worktree when they are populated/unpopulated by
|
|
|
|
* "git checkout" (and similar commands, see
|
|
|
|
* submodule_move_head() and
|
|
|
|
* connect_work_tree_and_git_dir()), but if the
|
|
|
|
* submodule is unpopulated in another way (e.g. "git
|
|
|
|
* rm", "rm -r"), core.worktree will still be set even
|
|
|
|
* though the directory doesn't exist, and the child
|
|
|
|
* process will crash while trying to chdir into the
|
|
|
|
* nonexistent directory.
|
|
|
|
*
|
|
|
|
* In this case, we know that the submodule has no
|
|
|
|
* working tree, so we can work around this by
|
|
|
|
* setting "--work-tree=." (--bare does not work because
|
|
|
|
* worktree settings take precedence over bare-ness).
|
|
|
|
* However, this is not necessarily true in other cases,
|
|
|
|
* so a generalized solution is still necessary.
|
|
|
|
*
|
|
|
|
* Possible solutions:
|
|
|
|
* - teach "git [add|rm]" to unset core.worktree and
|
|
|
|
* discourage users from removing submodules without
|
|
|
|
* using a Git command.
|
|
|
|
* - teach submodule child processes to ignore stale
|
|
|
|
* core.worktree values.
|
|
|
|
*/
|
|
|
|
strvec_push(&task->git_args, "--work-tree=.");
|
|
|
|
return task;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2022-03-08 00:14:30 +00:00
|
|
|
static int get_next_submodule(struct child_process *cp, struct strbuf *err,
|
|
|
|
void *data, void **task_cb)
|
|
|
|
{
|
|
|
|
struct submodule_parallel_fetch *spf = data;
|
2022-03-08 00:14:32 +00:00
|
|
|
struct fetch_task *task =
|
|
|
|
get_fetch_task_from_index(spf, err);
|
|
|
|
if (!task)
|
|
|
|
task = get_fetch_task_from_changed(spf, err);
|
2022-03-08 00:14:30 +00:00
|
|
|
|
|
|
|
if (task) {
|
|
|
|
struct strbuf submodule_prefix = STRBUF_INIT;
|
|
|
|
|
|
|
|
child_process_init(cp);
|
|
|
|
cp->dir = task->repo->gitdir;
|
2022-06-02 09:09:50 +00:00
|
|
|
prepare_submodule_repo_env_in_gitdir(&cp->env);
|
2022-03-08 00:14:30 +00:00
|
|
|
cp->git_cmd = 1;
|
|
|
|
strvec_init(&cp->args);
|
2022-03-08 00:14:32 +00:00
|
|
|
if (task->git_args.nr)
|
|
|
|
strvec_pushv(&cp->args, task->git_args.v);
|
2022-03-08 00:14:30 +00:00
|
|
|
strvec_pushv(&cp->args, spf->args.v);
|
|
|
|
strvec_push(&cp->args, task->default_argv);
|
|
|
|
strvec_push(&cp->args, "--submodule-prefix");
|
|
|
|
|
|
|
|
strbuf_addf(&submodule_prefix, "%s%s/",
|
|
|
|
spf->prefix,
|
|
|
|
task->sub->path);
|
|
|
|
strvec_push(&cp->args, submodule_prefix.buf);
|
|
|
|
*task_cb = task;
|
|
|
|
|
|
|
|
strbuf_release(&submodule_prefix);
|
2022-03-08 00:14:32 +00:00
|
|
|
string_list_insert(&spf->seen_submodule_names, task->sub->name);
|
2022-03-08 00:14:30 +00:00
|
|
|
return 1;
|
|
|
|
}
|
2018-12-06 21:26:55 +00:00
|
|
|
|
|
|
|
if (spf->oid_fetch_tasks_nr) {
|
|
|
|
struct fetch_task *task =
|
|
|
|
spf->oid_fetch_tasks[spf->oid_fetch_tasks_nr - 1];
|
|
|
|
struct strbuf submodule_prefix = STRBUF_INIT;
|
|
|
|
spf->oid_fetch_tasks_nr--;
|
|
|
|
|
|
|
|
strbuf_addf(&submodule_prefix, "%s%s/",
|
|
|
|
spf->prefix, task->sub->path);
|
|
|
|
|
|
|
|
child_process_init(cp);
|
2022-06-02 09:09:50 +00:00
|
|
|
prepare_submodule_repo_env_in_gitdir(&cp->env);
|
2018-12-06 21:26:55 +00:00
|
|
|
cp->git_cmd = 1;
|
|
|
|
cp->dir = task->repo->gitdir;
|
|
|
|
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_init(&cp->args);
|
2020-07-29 00:37:20 +00:00
|
|
|
strvec_pushv(&cp->args, spf->args.v);
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_push(&cp->args, "on-demand");
|
|
|
|
strvec_push(&cp->args, "--submodule-prefix");
|
|
|
|
strvec_push(&cp->args, submodule_prefix.buf);
|
2018-12-06 21:26:55 +00:00
|
|
|
|
|
|
|
/* NEEDSWORK: have get_default_remote from submodule--helper */
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_push(&cp->args, "origin");
|
2018-12-06 21:26:55 +00:00
|
|
|
oid_array_for_each_unique(task->commits,
|
|
|
|
append_oid_to_argv, &cp->args);
|
|
|
|
|
|
|
|
*task_cb = task;
|
2010-11-12 12:54:52 +00:00
|
|
|
strbuf_release(&submodule_prefix);
|
2018-12-06 21:26:55 +00:00
|
|
|
return 1;
|
2010-11-12 12:54:52 +00:00
|
|
|
}
|
2018-12-06 21:26:55 +00:00
|
|
|
|
2015-12-16 00:04:11 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-02-29 21:57:06 +00:00
|
|
|
static int fetch_start_failure(struct strbuf *err,
|
2015-12-16 00:04:11 +00:00
|
|
|
void *cb, void *task_cb)
|
|
|
|
{
|
|
|
|
struct submodule_parallel_fetch *spf = cb;
|
2018-12-06 21:26:55 +00:00
|
|
|
struct fetch_task *task = task_cb;
|
2015-12-16 00:04:11 +00:00
|
|
|
|
|
|
|
spf->result = 1;
|
|
|
|
|
2018-12-06 21:26:55 +00:00
|
|
|
fetch_task_release(task);
|
2015-12-16 00:04:11 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-12-06 21:26:55 +00:00
|
|
|
static int commit_missing_in_sub(const struct object_id *oid, void *data)
|
|
|
|
{
|
|
|
|
struct repository *subrepo = data;
|
|
|
|
|
|
|
|
enum object_type type = oid_object_info(subrepo, oid, NULL);
|
|
|
|
|
|
|
|
return type != OBJ_COMMIT;
|
|
|
|
}
|
|
|
|
|
2016-02-29 21:57:06 +00:00
|
|
|
static int fetch_finish(int retvalue, struct strbuf *err,
|
|
|
|
void *cb, void *task_cb)
|
2015-12-16 00:04:11 +00:00
|
|
|
{
|
|
|
|
struct submodule_parallel_fetch *spf = cb;
|
2018-12-06 21:26:55 +00:00
|
|
|
struct fetch_task *task = task_cb;
|
|
|
|
|
|
|
|
struct string_list_item *it;
|
2022-03-08 00:14:29 +00:00
|
|
|
struct changed_submodule_data *cs_data;
|
2015-12-16 00:04:11 +00:00
|
|
|
|
2020-01-16 22:20:12 +00:00
|
|
|
if (!task || !task->sub)
|
|
|
|
BUG("callback cookie bogus");
|
|
|
|
|
|
|
|
if (retvalue) {
|
submodule: explain first attempt failure clearly
When cloning with --recurse-submodules a superproject with at least one
submodule with HEAD pointing to an unborn branch, the clone goes
something like this:
Cloning into 'test'...
<messages about cloning of superproject>
Submodule '<name>' (<uri>) registered for path '<submodule path>'
Cloning into '<submodule path>'...
fatal: Couldn't find remote ref HEAD
Unable to fetch in submodule path '<submodule path>'
<messages about fetching with SHA-1>
From <uri>
* branch <hash> -> FETCH_HEAD
Submodule path '<submodule path>': checked out '<hash>'
In other words, first, a fetch is done with no hash arguments (that is,
a fetch of HEAD) resulting in a "Couldn't find remote ref HEAD" error;
then, a fetch is done given a hash, which succeeds.
The fetch given a hash was added in fb43e31f2b ("submodule: try harder
to fetch needed sha1 by direct fetching sha1", 2016-02-24), and the
"Unable to fetch..." message was downgraded from a fatal error to a
notice in e30d833671 ("git-submodule.sh: try harder to fetch a
submodule", 2018-05-16).
This commit improves the notice to be clearer that we are retrying the
fetch, and that the previous messages (in particular, the fatal errors
from fetch) do not necessarily indicate that the whole command fails. In
other words:
- If the HEAD-fetch succeeds and we then have the commit we want,
git-submodule prints no explanation.
- If the HEAD-fetch succeeds and we do not have the commit we want, but
the hash-fetch succeeds, git-submodule prints no explanation.
- If the HEAD-fetch succeeds and we do not have the commit we want, but
the hash-fetch fails, git-submodule prints a fatal error.
- If the HEAD-fetch fails, fetch prints a fatal error, and
git-submodule informs the user that it will retry by fetching
specific commits by hash.
- If the hash-fetch then succeeds, git-submodule prints no
explanation (besides the ones already printed).
- If the HEAD-fetch then fails, git-submodule prints a fatal error.
It could be said that we should just eliminate the HEAD-fetch
altogether, but that changes some behavior (in particular, some refs
that were opportunistically updated would no longer be), so I have left
that alone for now.
There is an analogous situation with the fetching code in fetch_finish()
and surrounding functions. For now, I have added a NEEDSWORK.
Signed-off-by: Jonathan Tan <jonathantanmy@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2019-03-13 17:57:38 +00:00
|
|
|
/*
|
|
|
|
* NEEDSWORK: This indicates that the overall fetch
|
|
|
|
* failed, even though there may be a subsequent fetch
|
|
|
|
* by commit hash that might work. It may be a good
|
|
|
|
* idea to not indicate failure in this case, and only
|
|
|
|
* indicate failure if the subsequent fetch fails.
|
|
|
|
*/
|
2015-12-16 00:04:11 +00:00
|
|
|
spf->result = 1;
|
|
|
|
|
2020-01-16 22:20:12 +00:00
|
|
|
strbuf_addf(&spf->submodules_with_errors, "\t%s\n",
|
|
|
|
task->sub->name);
|
|
|
|
}
|
2018-12-06 21:26:55 +00:00
|
|
|
|
|
|
|
/* Is this the second time we process this submodule? */
|
|
|
|
if (task->commits)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
it = string_list_lookup(&spf->changed_submodule_names, task->sub->name);
|
|
|
|
if (!it)
|
|
|
|
/* Could be an unchanged submodule, not contained in the list */
|
|
|
|
goto out;
|
|
|
|
|
2022-03-08 00:14:29 +00:00
|
|
|
cs_data = it->util;
|
|
|
|
oid_array_filter(&cs_data->new_commits,
|
2018-12-06 21:26:55 +00:00
|
|
|
commit_missing_in_sub,
|
|
|
|
task->repo);
|
|
|
|
|
|
|
|
/* Are there commits we want, but do not exist? */
|
2022-03-08 00:14:29 +00:00
|
|
|
if (cs_data->new_commits.nr) {
|
|
|
|
task->commits = &cs_data->new_commits;
|
2018-12-06 21:26:55 +00:00
|
|
|
ALLOC_GROW(spf->oid_fetch_tasks,
|
|
|
|
spf->oid_fetch_tasks_nr + 1,
|
|
|
|
spf->oid_fetch_tasks_alloc);
|
|
|
|
spf->oid_fetch_tasks[spf->oid_fetch_tasks_nr] = task;
|
|
|
|
spf->oid_fetch_tasks_nr++;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
fetch_task_release(task);
|
|
|
|
|
2015-12-16 00:04:11 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2022-03-08 00:14:32 +00:00
|
|
|
int fetch_submodules(struct repository *r,
|
|
|
|
const struct strvec *options,
|
|
|
|
const char *prefix, int command_line_option,
|
|
|
|
int default_option,
|
|
|
|
int quiet, int max_parallel_jobs)
|
2015-12-16 00:04:11 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct submodule_parallel_fetch spf = SPF_INIT;
|
2022-10-12 21:02:27 +00:00
|
|
|
const struct run_process_parallel_opts opts = {
|
|
|
|
.tr2_category = "submodule",
|
|
|
|
.tr2_label = "parallel/fetch",
|
|
|
|
|
|
|
|
.processes = max_parallel_jobs,
|
|
|
|
|
|
|
|
.get_next_task = get_next_submodule,
|
|
|
|
.start_failure = fetch_start_failure,
|
|
|
|
.task_finished = fetch_finish,
|
|
|
|
.data = &spf,
|
|
|
|
};
|
2015-12-16 00:04:11 +00:00
|
|
|
|
2017-12-12 19:53:52 +00:00
|
|
|
spf.r = r;
|
2015-12-16 00:04:11 +00:00
|
|
|
spf.command_line_option = command_line_option;
|
2017-08-02 19:49:19 +00:00
|
|
|
spf.default_option = default_option;
|
2015-12-16 00:04:11 +00:00
|
|
|
spf.quiet = quiet;
|
|
|
|
spf.prefix = prefix;
|
|
|
|
|
2017-12-12 19:53:52 +00:00
|
|
|
if (!r->worktree)
|
2015-12-16 00:04:11 +00:00
|
|
|
goto out;
|
|
|
|
|
2017-12-12 19:53:52 +00:00
|
|
|
if (repo_read_index(r) < 0)
|
2020-01-15 18:07:01 +00:00
|
|
|
die(_("index file corrupt"));
|
2015-12-16 00:04:11 +00:00
|
|
|
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_push(&spf.args, "fetch");
|
2020-07-29 00:37:20 +00:00
|
|
|
for (i = 0; i < options->nr; i++)
|
|
|
|
strvec_push(&spf.args, options->v[i]);
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_push(&spf.args, "--recurse-submodules-default");
|
2015-12-16 00:04:11 +00:00
|
|
|
/* default value, "--submodule-prefix" and its value are added later */
|
|
|
|
|
2018-11-29 00:27:51 +00:00
|
|
|
calculate_changed_submodule_paths(r, &spf.changed_submodule_names);
|
|
|
|
string_list_sort(&spf.changed_submodule_names);
|
2022-10-12 21:02:27 +00:00
|
|
|
run_processes_parallel(&opts);
|
2015-12-16 00:04:11 +00:00
|
|
|
|
2020-01-16 22:20:12 +00:00
|
|
|
if (spf.submodules_with_errors.len > 0)
|
|
|
|
fprintf(stderr, _("Errors during submodule fetch:\n%s"),
|
|
|
|
spf.submodules_with_errors.buf);
|
|
|
|
|
|
|
|
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_clear(&spf.args);
|
2011-03-06 22:10:46 +00:00
|
|
|
out:
|
2022-03-08 00:14:29 +00:00
|
|
|
free_submodules_data(&spf.changed_submodule_names);
|
2015-12-16 00:04:11 +00:00
|
|
|
return spf.result;
|
2010-11-12 12:54:52 +00:00
|
|
|
}
|
|
|
|
|
2010-03-13 22:00:27 +00:00
|
|
|
unsigned is_submodule_modified(const char *path, int ignore_untracked)
|
2010-01-16 17:42:24 +00:00
|
|
|
{
|
2014-08-19 19:09:35 +00:00
|
|
|
struct child_process cp = CHILD_PROCESS_INIT;
|
2010-01-16 17:42:24 +00:00
|
|
|
struct strbuf buf = STRBUF_INIT;
|
2017-03-25 00:36:06 +00:00
|
|
|
FILE *fp;
|
2010-03-04 21:20:33 +00:00
|
|
|
unsigned dirty_submodule = 0;
|
2010-04-10 17:01:12 +00:00
|
|
|
const char *git_dir;
|
2017-03-25 00:36:06 +00:00
|
|
|
int ignore_cp_exit_code = 0;
|
2010-01-16 17:42:24 +00:00
|
|
|
|
2010-04-10 17:01:12 +00:00
|
|
|
strbuf_addf(&buf, "%s/.git", path);
|
2011-08-22 21:04:56 +00:00
|
|
|
git_dir = read_gitfile(buf.buf);
|
2010-04-10 17:01:12 +00:00
|
|
|
if (!git_dir)
|
|
|
|
git_dir = buf.buf;
|
2017-03-25 00:36:08 +00:00
|
|
|
if (!is_git_directory(git_dir)) {
|
|
|
|
if (is_directory(git_dir))
|
|
|
|
die(_("'%s' not recognized as a git repository"), git_dir);
|
2010-01-16 17:42:24 +00:00
|
|
|
strbuf_release(&buf);
|
|
|
|
/* The submodule is not checked out, so it is not modified */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
strbuf_reset(&buf);
|
|
|
|
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_pushl(&cp.args, "status", "--porcelain=2", NULL);
|
2010-03-13 22:00:27 +00:00
|
|
|
if (ignore_untracked)
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_push(&cp.args, "-uno");
|
2010-03-13 22:00:27 +00:00
|
|
|
|
2022-06-02 09:09:50 +00:00
|
|
|
prepare_submodule_repo_env(&cp.env);
|
2010-01-16 17:42:24 +00:00
|
|
|
cp.git_cmd = 1;
|
|
|
|
cp.no_stdin = 1;
|
|
|
|
cp.out = -1;
|
2010-04-10 17:01:12 +00:00
|
|
|
cp.dir = path;
|
2010-01-16 17:42:24 +00:00
|
|
|
if (start_command(&cp))
|
2020-01-15 18:07:01 +00:00
|
|
|
die(_("Could not run 'git status --porcelain=2' in submodule %s"), path);
|
2010-01-16 17:42:24 +00:00
|
|
|
|
2017-03-25 00:36:06 +00:00
|
|
|
fp = xfdopen(cp.out, "r");
|
|
|
|
while (strbuf_getwholeline(&buf, fp, '\n') != EOF) {
|
2017-03-25 00:36:07 +00:00
|
|
|
/* regular untracked files */
|
|
|
|
if (buf.buf[0] == '?')
|
2010-03-04 21:20:33 +00:00
|
|
|
dirty_submodule |= DIRTY_SUBMODULE_UNTRACKED;
|
2017-03-29 22:26:16 +00:00
|
|
|
|
|
|
|
if (buf.buf[0] == 'u' ||
|
|
|
|
buf.buf[0] == '1' ||
|
|
|
|
buf.buf[0] == '2') {
|
|
|
|
/* T = line type, XY = status, SSSS = submodule state */
|
|
|
|
if (buf.len < strlen("T XY SSSS"))
|
2018-05-02 09:38:39 +00:00
|
|
|
BUG("invalid status --porcelain=2 line %s",
|
2017-03-29 22:26:16 +00:00
|
|
|
buf.buf);
|
|
|
|
|
|
|
|
if (buf.buf[5] == 'S' && buf.buf[8] == 'U')
|
|
|
|
/* nested untracked file */
|
|
|
|
dirty_submodule |= DIRTY_SUBMODULE_UNTRACKED;
|
|
|
|
|
|
|
|
if (buf.buf[0] == 'u' ||
|
|
|
|
buf.buf[0] == '2' ||
|
|
|
|
memcmp(buf.buf + 5, "S..U", 4))
|
|
|
|
/* other change */
|
|
|
|
dirty_submodule |= DIRTY_SUBMODULE_MODIFIED;
|
2010-03-04 21:20:33 +00:00
|
|
|
}
|
2017-03-25 00:36:05 +00:00
|
|
|
|
|
|
|
if ((dirty_submodule & DIRTY_SUBMODULE_MODIFIED) &&
|
|
|
|
((dirty_submodule & DIRTY_SUBMODULE_UNTRACKED) ||
|
2017-03-25 00:36:06 +00:00
|
|
|
ignore_untracked)) {
|
|
|
|
/*
|
|
|
|
* We're not interested in any further information from
|
|
|
|
* the child any more, neither output nor its exit code.
|
|
|
|
*/
|
|
|
|
ignore_cp_exit_code = 1;
|
2010-03-04 21:20:33 +00:00
|
|
|
break;
|
2017-03-25 00:36:06 +00:00
|
|
|
}
|
2010-03-04 21:20:33 +00:00
|
|
|
}
|
2017-03-25 00:36:06 +00:00
|
|
|
fclose(fp);
|
2010-01-16 17:42:24 +00:00
|
|
|
|
2017-03-25 00:36:06 +00:00
|
|
|
if (finish_command(&cp) && !ignore_cp_exit_code)
|
2020-01-15 18:07:01 +00:00
|
|
|
die(_("'git status --porcelain=2' failed in submodule %s"), path);
|
2010-01-16 17:42:24 +00:00
|
|
|
|
|
|
|
strbuf_release(&buf);
|
2010-03-04 21:20:33 +00:00
|
|
|
return dirty_submodule;
|
2010-01-16 17:42:24 +00:00
|
|
|
}
|
2010-07-07 13:39:13 +00:00
|
|
|
|
2012-09-26 18:21:13 +00:00
|
|
|
int submodule_uses_gitfile(const char *path)
|
|
|
|
{
|
2014-08-19 19:09:35 +00:00
|
|
|
struct child_process cp = CHILD_PROCESS_INIT;
|
2012-09-26 18:21:13 +00:00
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
const char *git_dir;
|
|
|
|
|
|
|
|
strbuf_addf(&buf, "%s/.git", path);
|
|
|
|
git_dir = read_gitfile(buf.buf);
|
|
|
|
if (!git_dir) {
|
|
|
|
strbuf_release(&buf);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
strbuf_release(&buf);
|
|
|
|
|
|
|
|
/* Now test that all nested submodules use a gitfile too */
|
2020-08-26 22:25:03 +00:00
|
|
|
strvec_pushl(&cp.args,
|
|
|
|
"submodule", "foreach", "--quiet", "--recursive",
|
|
|
|
"test -f .git", NULL);
|
|
|
|
|
2022-06-02 09:09:50 +00:00
|
|
|
prepare_submodule_repo_env(&cp.env);
|
2012-09-26 18:21:13 +00:00
|
|
|
cp.git_cmd = 1;
|
|
|
|
cp.no_stdin = 1;
|
|
|
|
cp.no_stderr = 1;
|
|
|
|
cp.no_stdout = 1;
|
|
|
|
cp.dir = path;
|
|
|
|
if (run_command(&cp))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2016-12-20 23:20:11 +00:00
|
|
|
/*
|
|
|
|
* Check if it is a bad idea to remove a submodule, i.e. if we'd lose data
|
|
|
|
* when doing so.
|
|
|
|
*
|
|
|
|
* Return 1 if we'd lose data, return 0 if the removal is fine,
|
|
|
|
* and negative values for errors.
|
|
|
|
*/
|
|
|
|
int bad_to_remove_submodule(const char *path, unsigned flags)
|
2012-09-26 18:21:13 +00:00
|
|
|
{
|
|
|
|
ssize_t len;
|
2014-08-19 19:09:35 +00:00
|
|
|
struct child_process cp = CHILD_PROCESS_INIT;
|
2012-09-26 18:21:13 +00:00
|
|
|
struct strbuf buf = STRBUF_INIT;
|
2016-12-20 23:20:11 +00:00
|
|
|
int ret = 0;
|
2012-09-26 18:21:13 +00:00
|
|
|
|
2015-05-19 21:44:23 +00:00
|
|
|
if (!file_exists(path) || is_empty_dir(path))
|
2016-12-20 23:20:11 +00:00
|
|
|
return 0;
|
2012-09-26 18:21:13 +00:00
|
|
|
|
|
|
|
if (!submodule_uses_gitfile(path))
|
2016-12-20 23:20:11 +00:00
|
|
|
return 1;
|
2012-09-26 18:21:13 +00:00
|
|
|
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_pushl(&cp.args, "status", "--porcelain",
|
strvec: fix indentation in renamed calls
Code which split an argv_array call across multiple lines, like:
argv_array_pushl(&args, "one argument",
"another argument", "and more",
NULL);
was recently mechanically renamed to use strvec, which results in
mis-matched indentation like:
strvec_pushl(&args, "one argument",
"another argument", "and more",
NULL);
Let's fix these up to align the arguments with the opening paren. I did
this manually by sifting through the results of:
git jump grep 'strvec_.*,$'
and liberally applying my editor's auto-format. Most of the changes are
of the form shown above, though I also normalized a few that had
originally used a single-tab indentation (rather than our usual style of
aligning with the open paren). I also rewrapped a couple of obvious
cases (e.g., where previously too-long lines became short enough to fit
on one), but I wasn't aggressive about it. In cases broken to three or
more lines, the grouping of arguments is sometimes meaningful, and it
wasn't worth my time or reviewer time to ponder each case individually.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-07-28 20:26:31 +00:00
|
|
|
"--ignore-submodules=none", NULL);
|
2016-12-20 23:20:11 +00:00
|
|
|
|
|
|
|
if (flags & SUBMODULE_REMOVAL_IGNORE_UNTRACKED)
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_push(&cp.args, "-uno");
|
2016-12-20 23:20:11 +00:00
|
|
|
else
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_push(&cp.args, "-uall");
|
2016-12-20 23:20:11 +00:00
|
|
|
|
|
|
|
if (!(flags & SUBMODULE_REMOVAL_IGNORE_IGNORED_UNTRACKED))
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_push(&cp.args, "--ignored");
|
2012-09-26 18:21:13 +00:00
|
|
|
|
2022-06-02 09:09:50 +00:00
|
|
|
prepare_submodule_repo_env(&cp.env);
|
2012-09-26 18:21:13 +00:00
|
|
|
cp.git_cmd = 1;
|
|
|
|
cp.no_stdin = 1;
|
|
|
|
cp.out = -1;
|
|
|
|
cp.dir = path;
|
2016-12-20 23:20:11 +00:00
|
|
|
if (start_command(&cp)) {
|
|
|
|
if (flags & SUBMODULE_REMOVAL_DIE_ON_ERROR)
|
2017-04-13 16:40:45 +00:00
|
|
|
die(_("could not start 'git status' in submodule '%s'"),
|
2016-12-20 23:20:11 +00:00
|
|
|
path);
|
|
|
|
ret = -1;
|
|
|
|
goto out;
|
|
|
|
}
|
2012-09-26 18:21:13 +00:00
|
|
|
|
|
|
|
len = strbuf_read(&buf, cp.out, 1024);
|
|
|
|
if (len > 2)
|
2016-12-20 23:20:11 +00:00
|
|
|
ret = 1;
|
2012-09-26 18:21:13 +00:00
|
|
|
close(cp.out);
|
|
|
|
|
2016-12-20 23:20:11 +00:00
|
|
|
if (finish_command(&cp)) {
|
|
|
|
if (flags & SUBMODULE_REMOVAL_DIE_ON_ERROR)
|
2017-04-13 16:40:45 +00:00
|
|
|
die(_("could not run 'git status' in submodule '%s'"),
|
2016-12-20 23:20:11 +00:00
|
|
|
path);
|
|
|
|
ret = -1;
|
|
|
|
}
|
|
|
|
out:
|
2012-09-26 18:21:13 +00:00
|
|
|
strbuf_release(&buf);
|
2016-12-20 23:20:11 +00:00
|
|
|
return ret;
|
2012-09-26 18:21:13 +00:00
|
|
|
}
|
|
|
|
|
submodule: unset core.worktree if no working tree is present
When a submodules work tree is removed, we should unset its core.worktree
setting as the worktree is no longer present. This is not just in line
with the conceptual view of submodules, but it fixes an inconvenience
for looking at submodules that are not checked out:
git clone --recurse-submodules git://github.com/git/git && cd git &&
git checkout --recurse-submodules v2.13.0
git -C .git/modules/sha1collisiondetection log
fatal: cannot chdir to '../../../sha1collisiondetection': \
No such file or directory
With this patch applied, the final call to git log works instead of dying
in its setup, as the checkout will unset the core.worktree setting such
that following log will be run in a bare repository.
This patch covers all commands that are in the unpack machinery, i.e.
checkout, read-tree, reset. A follow up patch will address
"git submodule deinit", which will also make use of the new function
submodule_unset_core_worktree(), which is why we expose it in this patch.
This patch was authored as 4fa4f90ccd (submodule: unset core.worktree if
no working tree is present, 2018-06-12), which was reverted as part of
f178c13fda (Revert "Merge branch 'sb/submodule-core-worktree'",
2018-09-07). The revert was needed as the nearby commit e98317508c
(submodule: ensure core.worktree is set after update, 2018-06-18) is
faulty and at the time of 7e25437d35 (Merge branch
'sb/submodule-core-worktree', 2018-07-18) we could not revert the faulty
commit only, as they were depending on each other: If core.worktree is
unset, we have to have ways to ensure that it is set again once
the working tree reappears again.
Now that 4d6d6ef1fc (Merge branch 'sb/submodule-update-in-c', 2018-09-17),
specifically 74d4731da1 (submodule--helper: replace
connect-gitdir-workingtree by ensure-core-worktree, 2018-08-13) is
present, we already check and ensure core.worktree is set when
populating a new work tree, such that we can re-introduce the commits
that unset core.worktree when removing the worktree.
Signed-off-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-12-14 23:59:43 +00:00
|
|
|
void submodule_unset_core_worktree(const struct submodule *sub)
|
|
|
|
{
|
2021-09-15 18:59:19 +00:00
|
|
|
struct strbuf config_path = STRBUF_INIT;
|
submodule: unset core.worktree if no working tree is present
When a submodules work tree is removed, we should unset its core.worktree
setting as the worktree is no longer present. This is not just in line
with the conceptual view of submodules, but it fixes an inconvenience
for looking at submodules that are not checked out:
git clone --recurse-submodules git://github.com/git/git && cd git &&
git checkout --recurse-submodules v2.13.0
git -C .git/modules/sha1collisiondetection log
fatal: cannot chdir to '../../../sha1collisiondetection': \
No such file or directory
With this patch applied, the final call to git log works instead of dying
in its setup, as the checkout will unset the core.worktree setting such
that following log will be run in a bare repository.
This patch covers all commands that are in the unpack machinery, i.e.
checkout, read-tree, reset. A follow up patch will address
"git submodule deinit", which will also make use of the new function
submodule_unset_core_worktree(), which is why we expose it in this patch.
This patch was authored as 4fa4f90ccd (submodule: unset core.worktree if
no working tree is present, 2018-06-12), which was reverted as part of
f178c13fda (Revert "Merge branch 'sb/submodule-core-worktree'",
2018-09-07). The revert was needed as the nearby commit e98317508c
(submodule: ensure core.worktree is set after update, 2018-06-18) is
faulty and at the time of 7e25437d35 (Merge branch
'sb/submodule-core-worktree', 2018-07-18) we could not revert the faulty
commit only, as they were depending on each other: If core.worktree is
unset, we have to have ways to ensure that it is set again once
the working tree reappears again.
Now that 4d6d6ef1fc (Merge branch 'sb/submodule-update-in-c', 2018-09-17),
specifically 74d4731da1 (submodule--helper: replace
connect-gitdir-workingtree by ensure-core-worktree, 2018-08-13) is
present, we already check and ensure core.worktree is set when
populating a new work tree, such that we can re-introduce the commits
that unset core.worktree when removing the worktree.
Signed-off-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-12-14 23:59:43 +00:00
|
|
|
|
2021-09-15 18:59:19 +00:00
|
|
|
submodule_name_to_gitdir(&config_path, the_repository, sub->name);
|
|
|
|
strbuf_addstr(&config_path, "/config");
|
|
|
|
|
|
|
|
if (git_config_set_in_file_gently(config_path.buf, "core.worktree", NULL))
|
submodule: unset core.worktree if no working tree is present
When a submodules work tree is removed, we should unset its core.worktree
setting as the worktree is no longer present. This is not just in line
with the conceptual view of submodules, but it fixes an inconvenience
for looking at submodules that are not checked out:
git clone --recurse-submodules git://github.com/git/git && cd git &&
git checkout --recurse-submodules v2.13.0
git -C .git/modules/sha1collisiondetection log
fatal: cannot chdir to '../../../sha1collisiondetection': \
No such file or directory
With this patch applied, the final call to git log works instead of dying
in its setup, as the checkout will unset the core.worktree setting such
that following log will be run in a bare repository.
This patch covers all commands that are in the unpack machinery, i.e.
checkout, read-tree, reset. A follow up patch will address
"git submodule deinit", which will also make use of the new function
submodule_unset_core_worktree(), which is why we expose it in this patch.
This patch was authored as 4fa4f90ccd (submodule: unset core.worktree if
no working tree is present, 2018-06-12), which was reverted as part of
f178c13fda (Revert "Merge branch 'sb/submodule-core-worktree'",
2018-09-07). The revert was needed as the nearby commit e98317508c
(submodule: ensure core.worktree is set after update, 2018-06-18) is
faulty and at the time of 7e25437d35 (Merge branch
'sb/submodule-core-worktree', 2018-07-18) we could not revert the faulty
commit only, as they were depending on each other: If core.worktree is
unset, we have to have ways to ensure that it is set again once
the working tree reappears again.
Now that 4d6d6ef1fc (Merge branch 'sb/submodule-update-in-c', 2018-09-17),
specifically 74d4731da1 (submodule--helper: replace
connect-gitdir-workingtree by ensure-core-worktree, 2018-08-13) is
present, we already check and ensure core.worktree is set when
populating a new work tree, such that we can re-introduce the commits
that unset core.worktree when removing the worktree.
Signed-off-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-12-14 23:59:43 +00:00
|
|
|
warning(_("Could not unset core.worktree setting in submodule '%s'"),
|
|
|
|
sub->path);
|
|
|
|
|
2021-09-15 18:59:19 +00:00
|
|
|
strbuf_release(&config_path);
|
submodule: unset core.worktree if no working tree is present
When a submodules work tree is removed, we should unset its core.worktree
setting as the worktree is no longer present. This is not just in line
with the conceptual view of submodules, but it fixes an inconvenience
for looking at submodules that are not checked out:
git clone --recurse-submodules git://github.com/git/git && cd git &&
git checkout --recurse-submodules v2.13.0
git -C .git/modules/sha1collisiondetection log
fatal: cannot chdir to '../../../sha1collisiondetection': \
No such file or directory
With this patch applied, the final call to git log works instead of dying
in its setup, as the checkout will unset the core.worktree setting such
that following log will be run in a bare repository.
This patch covers all commands that are in the unpack machinery, i.e.
checkout, read-tree, reset. A follow up patch will address
"git submodule deinit", which will also make use of the new function
submodule_unset_core_worktree(), which is why we expose it in this patch.
This patch was authored as 4fa4f90ccd (submodule: unset core.worktree if
no working tree is present, 2018-06-12), which was reverted as part of
f178c13fda (Revert "Merge branch 'sb/submodule-core-worktree'",
2018-09-07). The revert was needed as the nearby commit e98317508c
(submodule: ensure core.worktree is set after update, 2018-06-18) is
faulty and at the time of 7e25437d35 (Merge branch
'sb/submodule-core-worktree', 2018-07-18) we could not revert the faulty
commit only, as they were depending on each other: If core.worktree is
unset, we have to have ways to ensure that it is set again once
the working tree reappears again.
Now that 4d6d6ef1fc (Merge branch 'sb/submodule-update-in-c', 2018-09-17),
specifically 74d4731da1 (submodule--helper: replace
connect-gitdir-workingtree by ensure-core-worktree, 2018-08-13) is
present, we already check and ensure core.worktree is set when
populating a new work tree, such that we can re-introduce the commits
that unset core.worktree when removing the worktree.
Signed-off-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-12-14 23:59:43 +00:00
|
|
|
}
|
|
|
|
|
2017-03-14 21:46:36 +00:00
|
|
|
static const char *get_super_prefix_or_empty(void)
|
|
|
|
{
|
|
|
|
const char *s = get_super_prefix();
|
|
|
|
if (!s)
|
|
|
|
s = "";
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
2017-03-14 21:46:37 +00:00
|
|
|
static int submodule_has_dirty_index(const struct submodule *sub)
|
|
|
|
{
|
|
|
|
struct child_process cp = CHILD_PROCESS_INIT;
|
|
|
|
|
2022-06-02 09:09:50 +00:00
|
|
|
prepare_submodule_repo_env(&cp.env);
|
2017-03-14 21:46:37 +00:00
|
|
|
|
|
|
|
cp.git_cmd = 1;
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_pushl(&cp.args, "diff-index", "--quiet",
|
strvec: fix indentation in renamed calls
Code which split an argv_array call across multiple lines, like:
argv_array_pushl(&args, "one argument",
"another argument", "and more",
NULL);
was recently mechanically renamed to use strvec, which results in
mis-matched indentation like:
strvec_pushl(&args, "one argument",
"another argument", "and more",
NULL);
Let's fix these up to align the arguments with the opening paren. I did
this manually by sifting through the results of:
git jump grep 'strvec_.*,$'
and liberally applying my editor's auto-format. Most of the changes are
of the form shown above, though I also normalized a few that had
originally used a single-tab indentation (rather than our usual style of
aligning with the open paren). I also rewrapped a couple of obvious
cases (e.g., where previously too-long lines became short enough to fit
on one), but I wasn't aggressive about it. In cases broken to three or
more lines, the grouping of arguments is sometimes meaningful, and it
wasn't worth my time or reviewer time to ponder each case individually.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-07-28 20:26:31 +00:00
|
|
|
"--cached", "HEAD", NULL);
|
2017-03-14 21:46:37 +00:00
|
|
|
cp.no_stdin = 1;
|
|
|
|
cp.no_stdout = 1;
|
|
|
|
cp.dir = sub->path;
|
|
|
|
if (start_command(&cp))
|
2020-01-15 18:07:01 +00:00
|
|
|
die(_("could not recurse into submodule '%s'"), sub->path);
|
2017-03-14 21:46:37 +00:00
|
|
|
|
|
|
|
return finish_command(&cp);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void submodule_reset_index(const char *path)
|
|
|
|
{
|
|
|
|
struct child_process cp = CHILD_PROCESS_INIT;
|
2022-06-02 09:09:50 +00:00
|
|
|
prepare_submodule_repo_env(&cp.env);
|
2017-03-14 21:46:37 +00:00
|
|
|
|
|
|
|
cp.git_cmd = 1;
|
|
|
|
cp.no_stdin = 1;
|
|
|
|
cp.dir = path;
|
|
|
|
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_pushf(&cp.args, "--super-prefix=%s%s/",
|
strvec: fix indentation in renamed calls
Code which split an argv_array call across multiple lines, like:
argv_array_pushl(&args, "one argument",
"another argument", "and more",
NULL);
was recently mechanically renamed to use strvec, which results in
mis-matched indentation like:
strvec_pushl(&args, "one argument",
"another argument", "and more",
NULL);
Let's fix these up to align the arguments with the opening paren. I did
this manually by sifting through the results of:
git jump grep 'strvec_.*,$'
and liberally applying my editor's auto-format. Most of the changes are
of the form shown above, though I also normalized a few that had
originally used a single-tab indentation (rather than our usual style of
aligning with the open paren). I also rewrapped a couple of obvious
cases (e.g., where previously too-long lines became short enough to fit
on one), but I wasn't aggressive about it. In cases broken to three or
more lines, the grouping of arguments is sometimes meaningful, and it
wasn't worth my time or reviewer time to ponder each case individually.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-07-28 20:26:31 +00:00
|
|
|
get_super_prefix_or_empty(), path);
|
Comment important codepaths regarding nuking untracked files/dirs
In the last few commits we focused on code in unpack-trees.c that
mistakenly removed untracked files or directories. There may be more of
those, but in this commit we change our focus: callers of toplevel
commands that are expected to remove untracked files or directories.
As noted previously, we have toplevel commands that are expected to
delete untracked files such as 'read-tree --reset', 'reset --hard', and
'checkout --force'. However, that does not mean that other highlevel
commands that happen to call these other commands thought about or
conveyed to users the possibility that untracked files could be removed.
Audit the code for such callsites, and add comments near existing
callsites to mention whether these are safe or not.
My auditing is somewhat incomplete, though; it skipped several cases:
* git-rebase--preserve-merges.sh: is in the process of being
deprecated/removed, so I won't leave a note that there are
likely more bugs in that script.
* contrib/git-new-workdir: why is the -f flag being used in a new
empty directory?? It shouldn't hurt, but it seems useless.
* git-p4.py: Don't see why -f is needed for a new dir (maybe it's
not and is just superfluous), but I'm not at all familiar with
the p4 stuff
* git-archimport.perl: Don't care; arch is long since dead
* git-cvs*.perl: Don't care; cvs is long since dead
Also, the reset --hard in builtin/worktree.c looks safe, due to only
running in an empty directory.
Signed-off-by: Elijah Newren <newren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2021-09-27 16:33:47 +00:00
|
|
|
/* TODO: determine if this might overwright untracked files */
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_pushl(&cp.args, "read-tree", "-u", "--reset", NULL);
|
2017-03-14 21:46:37 +00:00
|
|
|
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_push(&cp.args, empty_tree_oid_hex());
|
2017-03-14 21:46:37 +00:00
|
|
|
|
|
|
|
if (run_command(&cp))
|
2020-01-15 18:07:01 +00:00
|
|
|
die(_("could not reset submodule index"));
|
2017-03-14 21:46:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Moves a submodule at a given path from a given head to another new head.
|
|
|
|
* For edge cases (a submodule coming into existence or removing a submodule)
|
|
|
|
* pass NULL for old or new respectively.
|
|
|
|
*/
|
|
|
|
int submodule_move_head(const char *path,
|
2018-02-14 18:59:49 +00:00
|
|
|
const char *old_head,
|
|
|
|
const char *new_head,
|
2017-03-14 21:46:37 +00:00
|
|
|
unsigned flags)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
struct child_process cp = CHILD_PROCESS_INIT;
|
|
|
|
const struct submodule *sub;
|
2017-04-18 21:37:24 +00:00
|
|
|
int *error_code_ptr, error_code;
|
2017-03-14 21:46:37 +00:00
|
|
|
|
2017-06-22 18:43:46 +00:00
|
|
|
if (!is_submodule_active(the_repository, path))
|
2017-04-18 21:37:23 +00:00
|
|
|
return 0;
|
|
|
|
|
2017-04-18 21:37:24 +00:00
|
|
|
if (flags & SUBMODULE_MOVE_HEAD_FORCE)
|
|
|
|
/*
|
|
|
|
* Pass non NULL pointer to is_submodule_populated_gently
|
|
|
|
* to prevent die()-ing. We'll use connect_work_tree_and_git_dir
|
|
|
|
* to fixup the submodule in the force case later.
|
|
|
|
*/
|
|
|
|
error_code_ptr = &error_code;
|
|
|
|
else
|
|
|
|
error_code_ptr = NULL;
|
|
|
|
|
2018-02-14 18:59:49 +00:00
|
|
|
if (old_head && !is_submodule_populated_gently(path, error_code_ptr))
|
2017-04-18 21:37:24 +00:00
|
|
|
return 0;
|
2017-03-14 21:46:37 +00:00
|
|
|
|
2021-04-26 01:02:56 +00:00
|
|
|
sub = submodule_from_path(the_repository, null_oid(), path);
|
2017-03-14 21:46:37 +00:00
|
|
|
|
|
|
|
if (!sub)
|
2018-05-02 09:38:39 +00:00
|
|
|
BUG("could not get submodule information for '%s'", path);
|
2017-03-14 21:46:37 +00:00
|
|
|
|
2018-02-14 18:59:49 +00:00
|
|
|
if (old_head && !(flags & SUBMODULE_MOVE_HEAD_FORCE)) {
|
2017-03-14 21:46:37 +00:00
|
|
|
/* Check if the submodule has a dirty index. */
|
|
|
|
if (submodule_has_dirty_index(sub))
|
|
|
|
return error(_("submodule '%s' has dirty index"), path);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(flags & SUBMODULE_MOVE_HEAD_DRY_RUN)) {
|
2018-02-14 18:59:49 +00:00
|
|
|
if (old_head) {
|
2017-03-14 21:46:37 +00:00
|
|
|
if (!submodule_uses_gitfile(path))
|
2019-05-09 21:27:31 +00:00
|
|
|
absorb_git_dir_into_superproject(path,
|
2017-03-14 21:46:37 +00:00
|
|
|
ABSORB_GITDIR_RECURSE_SUBMODULES);
|
|
|
|
} else {
|
2021-09-15 18:59:19 +00:00
|
|
|
struct strbuf gitdir = STRBUF_INIT;
|
|
|
|
submodule_name_to_gitdir(&gitdir, the_repository,
|
|
|
|
sub->name);
|
|
|
|
connect_work_tree_and_git_dir(path, gitdir.buf, 0);
|
|
|
|
strbuf_release(&gitdir);
|
2017-03-14 21:46:37 +00:00
|
|
|
|
|
|
|
/* make sure the index is clean as well */
|
|
|
|
submodule_reset_index(path);
|
|
|
|
}
|
2017-04-18 21:37:24 +00:00
|
|
|
|
2018-02-14 18:59:49 +00:00
|
|
|
if (old_head && (flags & SUBMODULE_MOVE_HEAD_FORCE)) {
|
2021-09-15 18:59:19 +00:00
|
|
|
struct strbuf gitdir = STRBUF_INIT;
|
|
|
|
submodule_name_to_gitdir(&gitdir, the_repository,
|
|
|
|
sub->name);
|
|
|
|
connect_work_tree_and_git_dir(path, gitdir.buf, 1);
|
|
|
|
strbuf_release(&gitdir);
|
2017-04-18 21:37:24 +00:00
|
|
|
}
|
2017-03-14 21:46:37 +00:00
|
|
|
}
|
|
|
|
|
2022-06-02 09:09:50 +00:00
|
|
|
prepare_submodule_repo_env(&cp.env);
|
2017-03-14 21:46:37 +00:00
|
|
|
|
|
|
|
cp.git_cmd = 1;
|
|
|
|
cp.no_stdin = 1;
|
|
|
|
cp.dir = path;
|
|
|
|
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_pushf(&cp.args, "--super-prefix=%s%s/",
|
strvec: fix indentation in renamed calls
Code which split an argv_array call across multiple lines, like:
argv_array_pushl(&args, "one argument",
"another argument", "and more",
NULL);
was recently mechanically renamed to use strvec, which results in
mis-matched indentation like:
strvec_pushl(&args, "one argument",
"another argument", "and more",
NULL);
Let's fix these up to align the arguments with the opening paren. I did
this manually by sifting through the results of:
git jump grep 'strvec_.*,$'
and liberally applying my editor's auto-format. Most of the changes are
of the form shown above, though I also normalized a few that had
originally used a single-tab indentation (rather than our usual style of
aligning with the open paren). I also rewrapped a couple of obvious
cases (e.g., where previously too-long lines became short enough to fit
on one), but I wasn't aggressive about it. In cases broken to three or
more lines, the grouping of arguments is sometimes meaningful, and it
wasn't worth my time or reviewer time to ponder each case individually.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-07-28 20:26:31 +00:00
|
|
|
get_super_prefix_or_empty(), path);
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_pushl(&cp.args, "read-tree", "--recurse-submodules", NULL);
|
2017-03-14 21:46:37 +00:00
|
|
|
|
|
|
|
if (flags & SUBMODULE_MOVE_HEAD_DRY_RUN)
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_push(&cp.args, "-n");
|
2017-03-14 21:46:37 +00:00
|
|
|
else
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_push(&cp.args, "-u");
|
2017-03-14 21:46:37 +00:00
|
|
|
|
|
|
|
if (flags & SUBMODULE_MOVE_HEAD_FORCE)
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_push(&cp.args, "--reset");
|
2017-03-14 21:46:37 +00:00
|
|
|
else
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_push(&cp.args, "-m");
|
2017-03-14 21:46:37 +00:00
|
|
|
|
2018-01-05 20:03:04 +00:00
|
|
|
if (!(flags & SUBMODULE_MOVE_HEAD_FORCE))
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_push(&cp.args, old_head ? old_head : empty_tree_oid_hex());
|
2018-01-05 20:03:04 +00:00
|
|
|
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_push(&cp.args, new_head ? new_head : empty_tree_oid_hex());
|
2017-03-14 21:46:37 +00:00
|
|
|
|
|
|
|
if (run_command(&cp)) {
|
2018-06-20 22:32:53 +00:00
|
|
|
ret = error(_("Submodule '%s' could not be updated."), path);
|
2017-03-14 21:46:37 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(flags & SUBMODULE_MOVE_HEAD_DRY_RUN)) {
|
2018-02-14 18:59:49 +00:00
|
|
|
if (new_head) {
|
2017-05-02 19:32:12 +00:00
|
|
|
child_process_init(&cp);
|
2017-03-14 21:46:37 +00:00
|
|
|
/* also set the HEAD accordingly */
|
2017-05-02 19:32:12 +00:00
|
|
|
cp.git_cmd = 1;
|
|
|
|
cp.no_stdin = 1;
|
|
|
|
cp.dir = path;
|
2017-03-14 21:46:37 +00:00
|
|
|
|
2022-06-02 09:09:50 +00:00
|
|
|
prepare_submodule_repo_env(&cp.env);
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_pushl(&cp.args, "update-ref", "HEAD",
|
strvec: fix indentation in renamed calls
Code which split an argv_array call across multiple lines, like:
argv_array_pushl(&args, "one argument",
"another argument", "and more",
NULL);
was recently mechanically renamed to use strvec, which results in
mis-matched indentation like:
strvec_pushl(&args, "one argument",
"another argument", "and more",
NULL);
Let's fix these up to align the arguments with the opening paren. I did
this manually by sifting through the results of:
git jump grep 'strvec_.*,$'
and liberally applying my editor's auto-format. Most of the changes are
of the form shown above, though I also normalized a few that had
originally used a single-tab indentation (rather than our usual style of
aligning with the open paren). I also rewrapped a couple of obvious
cases (e.g., where previously too-long lines became short enough to fit
on one), but I wasn't aggressive about it. In cases broken to three or
more lines, the grouping of arguments is sometimes meaningful, and it
wasn't worth my time or reviewer time to ponder each case individually.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-07-28 20:26:31 +00:00
|
|
|
"--no-deref", new_head, NULL);
|
2017-03-14 21:46:37 +00:00
|
|
|
|
2017-05-02 19:32:12 +00:00
|
|
|
if (run_command(&cp)) {
|
2017-03-14 21:46:37 +00:00
|
|
|
ret = -1;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
struct strbuf sb = STRBUF_INIT;
|
|
|
|
|
|
|
|
strbuf_addf(&sb, "%s/.git", path);
|
|
|
|
unlink_or_warn(sb.buf);
|
|
|
|
strbuf_release(&sb);
|
|
|
|
|
|
|
|
if (is_empty_dir(path))
|
|
|
|
rmdir_or_warn(path);
|
submodule: unset core.worktree if no working tree is present
When a submodules work tree is removed, we should unset its core.worktree
setting as the worktree is no longer present. This is not just in line
with the conceptual view of submodules, but it fixes an inconvenience
for looking at submodules that are not checked out:
git clone --recurse-submodules git://github.com/git/git && cd git &&
git checkout --recurse-submodules v2.13.0
git -C .git/modules/sha1collisiondetection log
fatal: cannot chdir to '../../../sha1collisiondetection': \
No such file or directory
With this patch applied, the final call to git log works instead of dying
in its setup, as the checkout will unset the core.worktree setting such
that following log will be run in a bare repository.
This patch covers all commands that are in the unpack machinery, i.e.
checkout, read-tree, reset. A follow up patch will address
"git submodule deinit", which will also make use of the new function
submodule_unset_core_worktree(), which is why we expose it in this patch.
This patch was authored as 4fa4f90ccd (submodule: unset core.worktree if
no working tree is present, 2018-06-12), which was reverted as part of
f178c13fda (Revert "Merge branch 'sb/submodule-core-worktree'",
2018-09-07). The revert was needed as the nearby commit e98317508c
(submodule: ensure core.worktree is set after update, 2018-06-18) is
faulty and at the time of 7e25437d35 (Merge branch
'sb/submodule-core-worktree', 2018-07-18) we could not revert the faulty
commit only, as they were depending on each other: If core.worktree is
unset, we have to have ways to ensure that it is set again once
the working tree reappears again.
Now that 4d6d6ef1fc (Merge branch 'sb/submodule-update-in-c', 2018-09-17),
specifically 74d4731da1 (submodule--helper: replace
connect-gitdir-workingtree by ensure-core-worktree, 2018-08-13) is
present, we already check and ensure core.worktree is set when
populating a new work tree, such that we can re-introduce the commits
that unset core.worktree when removing the worktree.
Signed-off-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-12-14 23:59:43 +00:00
|
|
|
|
|
|
|
submodule_unset_core_worktree(sub);
|
2017-03-14 21:46:37 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2019-10-01 21:27:18 +00:00
|
|
|
int validate_submodule_git_dir(char *git_dir, const char *submodule_name)
|
|
|
|
{
|
|
|
|
size_t len = strlen(git_dir), suffix_len = strlen(submodule_name);
|
|
|
|
char *p;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (len <= suffix_len || (p = git_dir + len - suffix_len)[-1] != '/' ||
|
|
|
|
strcmp(p, submodule_name))
|
|
|
|
BUG("submodule name '%s' not a suffix of git dir '%s'",
|
|
|
|
submodule_name, git_dir);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We prevent the contents of sibling submodules' git directories to
|
|
|
|
* clash.
|
|
|
|
*
|
|
|
|
* Example: having a submodule named `hippo` and another one named
|
|
|
|
* `hippo/hooks` would result in the git directories
|
|
|
|
* `.git/modules/hippo/` and `.git/modules/hippo/hooks/`, respectively,
|
|
|
|
* but the latter directory is already designated to contain the hooks
|
|
|
|
* of the former.
|
|
|
|
*/
|
|
|
|
for (; *p; p++) {
|
|
|
|
if (is_dir_sep(*p)) {
|
|
|
|
char c = *p;
|
|
|
|
|
|
|
|
*p = '\0';
|
|
|
|
if (is_git_directory(git_dir))
|
|
|
|
ret = -1;
|
|
|
|
*p = c;
|
|
|
|
|
|
|
|
if (ret < 0)
|
|
|
|
return error(_("submodule git dir '%s' is "
|
|
|
|
"inside git dir '%.*s'"),
|
|
|
|
git_dir,
|
|
|
|
(int)(p - git_dir), git_dir);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-12-12 19:04:35 +00:00
|
|
|
/*
|
|
|
|
* Embeds a single submodules git directory into the superprojects git dir,
|
|
|
|
* non recursively.
|
|
|
|
*/
|
2019-05-09 21:27:31 +00:00
|
|
|
static void relocate_single_git_dir_into_superproject(const char *path)
|
2016-12-12 19:04:35 +00:00
|
|
|
{
|
|
|
|
char *old_git_dir = NULL, *real_old_git_dir = NULL, *real_new_git_dir = NULL;
|
2021-09-15 18:59:19 +00:00
|
|
|
struct strbuf new_gitdir = STRBUF_INIT;
|
2016-12-12 19:04:35 +00:00
|
|
|
const struct submodule *sub;
|
|
|
|
|
|
|
|
if (submodule_uses_worktrees(path))
|
|
|
|
die(_("relocate_gitdir for submodule '%s' with "
|
|
|
|
"more than one worktree not supported"), path);
|
|
|
|
|
|
|
|
old_git_dir = xstrfmt("%s/.git", path);
|
|
|
|
if (read_gitfile(old_git_dir))
|
|
|
|
/* If it is an actual gitfile, it doesn't need migration. */
|
|
|
|
return;
|
|
|
|
|
2017-03-08 15:43:40 +00:00
|
|
|
real_old_git_dir = real_pathdup(old_git_dir, 1);
|
2016-12-12 19:04:35 +00:00
|
|
|
|
2021-04-26 01:02:56 +00:00
|
|
|
sub = submodule_from_path(the_repository, null_oid(), path);
|
2016-12-12 19:04:35 +00:00
|
|
|
if (!sub)
|
|
|
|
die(_("could not lookup name for submodule '%s'"), path);
|
|
|
|
|
2021-09-15 18:59:19 +00:00
|
|
|
submodule_name_to_gitdir(&new_gitdir, the_repository, sub->name);
|
|
|
|
if (validate_submodule_git_dir(new_gitdir.buf, sub->name) < 0)
|
2019-10-01 21:27:18 +00:00
|
|
|
die(_("refusing to move '%s' into an existing git dir"),
|
|
|
|
real_old_git_dir);
|
2021-09-15 18:59:19 +00:00
|
|
|
if (safe_create_leading_directories_const(new_gitdir.buf) < 0)
|
|
|
|
die(_("could not create directory '%s'"), new_gitdir.buf);
|
|
|
|
real_new_git_dir = real_pathdup(new_gitdir.buf, 1);
|
2016-12-12 19:04:35 +00:00
|
|
|
|
|
|
|
fprintf(stderr, _("Migrating git directory of '%s%s' from\n'%s' to\n'%s'\n"),
|
2017-03-14 21:46:36 +00:00
|
|
|
get_super_prefix_or_empty(), path,
|
2016-12-12 19:04:35 +00:00
|
|
|
real_old_git_dir, real_new_git_dir);
|
|
|
|
|
|
|
|
relocate_gitdir(path, real_old_git_dir, real_new_git_dir);
|
|
|
|
|
|
|
|
free(old_git_dir);
|
|
|
|
free(real_old_git_dir);
|
|
|
|
free(real_new_git_dir);
|
2021-09-15 18:59:19 +00:00
|
|
|
strbuf_release(&new_gitdir);
|
2016-12-12 19:04:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Migrate the git directory of the submodule given by path from
|
|
|
|
* having its git directory within the working tree to the git dir nested
|
|
|
|
* in its superprojects git dir under modules/.
|
|
|
|
*/
|
2019-05-09 21:27:31 +00:00
|
|
|
void absorb_git_dir_into_superproject(const char *path,
|
2016-12-12 19:04:35 +00:00
|
|
|
unsigned flags)
|
|
|
|
{
|
2017-01-25 23:04:50 +00:00
|
|
|
int err_code;
|
|
|
|
const char *sub_git_dir;
|
2016-12-12 19:04:35 +00:00
|
|
|
struct strbuf gitdir = STRBUF_INIT;
|
|
|
|
strbuf_addf(&gitdir, "%s/.git", path);
|
2017-01-25 23:04:50 +00:00
|
|
|
sub_git_dir = resolve_gitdir_gently(gitdir.buf, &err_code);
|
2016-12-12 19:04:35 +00:00
|
|
|
|
|
|
|
/* Not populated? */
|
2017-01-25 23:04:50 +00:00
|
|
|
if (!sub_git_dir) {
|
|
|
|
const struct submodule *sub;
|
2021-09-15 18:59:19 +00:00
|
|
|
struct strbuf sub_gitdir = STRBUF_INIT;
|
2017-01-25 23:04:50 +00:00
|
|
|
|
|
|
|
if (err_code == READ_GITFILE_ERR_STAT_FAILED) {
|
|
|
|
/* unpopulated as expected */
|
|
|
|
strbuf_release(&gitdir);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (err_code != READ_GITFILE_ERR_NOT_A_REPO)
|
|
|
|
/* We don't know what broke here. */
|
|
|
|
read_gitfile_error_die(err_code, path, NULL);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Maybe populated, but no git directory was found?
|
|
|
|
* This can happen if the superproject is a submodule
|
|
|
|
* itself and was just absorbed. The absorption of the
|
|
|
|
* superproject did not rewrite the git file links yet,
|
|
|
|
* fix it now.
|
|
|
|
*/
|
2021-04-26 01:02:56 +00:00
|
|
|
sub = submodule_from_path(the_repository, null_oid(), path);
|
2017-01-25 23:04:50 +00:00
|
|
|
if (!sub)
|
|
|
|
die(_("could not lookup name for submodule '%s'"), path);
|
2021-09-15 18:59:19 +00:00
|
|
|
submodule_name_to_gitdir(&sub_gitdir, the_repository, sub->name);
|
|
|
|
connect_work_tree_and_git_dir(path, sub_gitdir.buf, 0);
|
|
|
|
strbuf_release(&sub_gitdir);
|
2017-01-25 23:04:50 +00:00
|
|
|
} else {
|
|
|
|
/* Is it already absorbed into the superprojects git dir? */
|
2017-03-08 15:43:40 +00:00
|
|
|
char *real_sub_git_dir = real_pathdup(sub_git_dir, 1);
|
|
|
|
char *real_common_git_dir = real_pathdup(get_git_common_dir(), 1);
|
2016-12-12 19:04:35 +00:00
|
|
|
|
2017-01-25 23:04:50 +00:00
|
|
|
if (!starts_with(real_sub_git_dir, real_common_git_dir))
|
2019-05-09 21:27:31 +00:00
|
|
|
relocate_single_git_dir_into_superproject(path);
|
2017-01-25 23:04:50 +00:00
|
|
|
|
|
|
|
free(real_sub_git_dir);
|
|
|
|
free(real_common_git_dir);
|
|
|
|
}
|
|
|
|
strbuf_release(&gitdir);
|
2016-12-12 19:04:35 +00:00
|
|
|
|
|
|
|
if (flags & ABSORB_GITDIR_RECURSE_SUBMODULES) {
|
|
|
|
struct child_process cp = CHILD_PROCESS_INIT;
|
|
|
|
|
|
|
|
if (flags & ~ABSORB_GITDIR_RECURSE_SUBMODULES)
|
2018-05-02 09:38:39 +00:00
|
|
|
BUG("we don't know how to pass the flags down?");
|
2016-12-12 19:04:35 +00:00
|
|
|
|
|
|
|
cp.dir = path;
|
|
|
|
cp.git_cmd = 1;
|
|
|
|
cp.no_stdin = 1;
|
2022-10-23 06:47:35 +00:00
|
|
|
strvec_pushf(&cp.args, "--super-prefix=%s%s/",
|
|
|
|
get_super_prefix_or_empty(), path);
|
|
|
|
strvec_pushl(&cp.args, "submodule--helper",
|
2022-06-28 10:05:29 +00:00
|
|
|
"absorbgitdirs", NULL);
|
2022-06-02 09:09:50 +00:00
|
|
|
prepare_submodule_repo_env(&cp.env);
|
2016-12-12 19:04:35 +00:00
|
|
|
if (run_command(&cp))
|
|
|
|
die(_("could not recurse into submodule '%s'"), path);
|
|
|
|
}
|
|
|
|
}
|
2017-03-08 23:07:42 +00:00
|
|
|
|
2020-03-10 13:11:24 +00:00
|
|
|
int get_superproject_working_tree(struct strbuf *buf)
|
2017-03-08 23:07:42 +00:00
|
|
|
{
|
|
|
|
struct child_process cp = CHILD_PROCESS_INIT;
|
|
|
|
struct strbuf sb = STRBUF_INIT;
|
2020-03-10 13:11:23 +00:00
|
|
|
struct strbuf one_up = STRBUF_INIT;
|
2022-07-01 10:42:52 +00:00
|
|
|
char *cwd = xgetcwd();
|
2020-03-10 13:11:24 +00:00
|
|
|
int ret = 0;
|
2017-03-08 23:07:42 +00:00
|
|
|
const char *subpath;
|
|
|
|
int code;
|
|
|
|
ssize_t len;
|
|
|
|
|
|
|
|
if (!is_inside_work_tree())
|
|
|
|
/*
|
|
|
|
* FIXME:
|
|
|
|
* We might have a superproject, but it is harder
|
|
|
|
* to determine.
|
|
|
|
*/
|
2020-03-10 13:11:24 +00:00
|
|
|
return 0;
|
2017-03-08 23:07:42 +00:00
|
|
|
|
2020-03-10 13:11:23 +00:00
|
|
|
if (!strbuf_realpath(&one_up, "../", 0))
|
2020-03-10 13:11:24 +00:00
|
|
|
return 0;
|
2017-03-08 23:07:42 +00:00
|
|
|
|
2020-03-10 13:11:23 +00:00
|
|
|
subpath = relative_path(cwd, one_up.buf, &sb);
|
|
|
|
strbuf_release(&one_up);
|
2017-03-08 23:07:42 +00:00
|
|
|
|
2022-06-02 09:09:50 +00:00
|
|
|
prepare_submodule_repo_env(&cp.env);
|
|
|
|
strvec_pop(&cp.env);
|
2017-03-08 23:07:42 +00:00
|
|
|
|
2020-07-28 20:25:12 +00:00
|
|
|
strvec_pushl(&cp.args, "--literal-pathspecs", "-C", "..",
|
strvec: fix indentation in renamed calls
Code which split an argv_array call across multiple lines, like:
argv_array_pushl(&args, "one argument",
"another argument", "and more",
NULL);
was recently mechanically renamed to use strvec, which results in
mis-matched indentation like:
strvec_pushl(&args, "one argument",
"another argument", "and more",
NULL);
Let's fix these up to align the arguments with the opening paren. I did
this manually by sifting through the results of:
git jump grep 'strvec_.*,$'
and liberally applying my editor's auto-format. Most of the changes are
of the form shown above, though I also normalized a few that had
originally used a single-tab indentation (rather than our usual style of
aligning with the open paren). I also rewrapped a couple of obvious
cases (e.g., where previously too-long lines became short enough to fit
on one), but I wasn't aggressive about it. In cases broken to three or
more lines, the grouping of arguments is sometimes meaningful, and it
wasn't worth my time or reviewer time to ponder each case individually.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2020-07-28 20:26:31 +00:00
|
|
|
"ls-files", "-z", "--stage", "--full-name", "--",
|
|
|
|
subpath, NULL);
|
2017-03-08 23:07:42 +00:00
|
|
|
strbuf_reset(&sb);
|
|
|
|
|
|
|
|
cp.no_stdin = 1;
|
|
|
|
cp.no_stderr = 1;
|
|
|
|
cp.out = -1;
|
|
|
|
cp.git_cmd = 1;
|
|
|
|
|
|
|
|
if (start_command(&cp))
|
|
|
|
die(_("could not start ls-files in .."));
|
|
|
|
|
|
|
|
len = strbuf_read(&sb, cp.out, PATH_MAX);
|
|
|
|
close(cp.out);
|
|
|
|
|
|
|
|
if (starts_with(sb.buf, "160000")) {
|
|
|
|
int super_sub_len;
|
|
|
|
int cwd_len = strlen(cwd);
|
|
|
|
char *super_sub, *super_wt;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* There is a superproject having this repo as a submodule.
|
|
|
|
* The format is <mode> SP <hash> SP <stage> TAB <full name> \0,
|
|
|
|
* We're only interested in the name after the tab.
|
|
|
|
*/
|
|
|
|
super_sub = strchr(sb.buf, '\t') + 1;
|
2018-09-27 18:10:54 +00:00
|
|
|
super_sub_len = strlen(super_sub);
|
2017-03-08 23:07:42 +00:00
|
|
|
|
|
|
|
if (super_sub_len > cwd_len ||
|
|
|
|
strcmp(&cwd[cwd_len - super_sub_len], super_sub))
|
2018-05-02 09:38:41 +00:00
|
|
|
BUG("returned path string doesn't match cwd?");
|
2017-03-08 23:07:42 +00:00
|
|
|
|
|
|
|
super_wt = xstrdup(cwd);
|
|
|
|
super_wt[cwd_len - super_sub_len] = '\0';
|
|
|
|
|
2020-03-10 13:11:24 +00:00
|
|
|
strbuf_realpath(buf, super_wt, 1);
|
|
|
|
ret = 1;
|
2017-03-08 23:07:42 +00:00
|
|
|
free(super_wt);
|
|
|
|
}
|
2022-07-01 10:42:52 +00:00
|
|
|
free(cwd);
|
2017-03-08 23:07:42 +00:00
|
|
|
strbuf_release(&sb);
|
|
|
|
|
|
|
|
code = finish_command(&cp);
|
|
|
|
|
|
|
|
if (code == 128)
|
|
|
|
/* '../' is not a git repository */
|
2020-03-10 13:11:24 +00:00
|
|
|
return 0;
|
2017-03-08 23:07:42 +00:00
|
|
|
if (code == 0 && len == 0)
|
|
|
|
/* There is an unrelated git repository at '../' */
|
2020-03-10 13:11:24 +00:00
|
|
|
return 0;
|
2017-03-08 23:07:42 +00:00
|
|
|
if (code)
|
|
|
|
die(_("ls-tree returned unexpected return code %d"), code);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2017-03-26 02:42:30 +00:00
|
|
|
|
2017-09-25 15:59:26 +00:00
|
|
|
/*
|
|
|
|
* Put the gitdir for a submodule (given relative to the main
|
|
|
|
* repository worktree) into `buf`, or return -1 on error.
|
|
|
|
*/
|
2017-03-26 02:42:30 +00:00
|
|
|
int submodule_to_gitdir(struct strbuf *buf, const char *submodule)
|
|
|
|
{
|
|
|
|
const struct submodule *sub;
|
|
|
|
const char *git_dir;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
strbuf_reset(buf);
|
|
|
|
strbuf_addstr(buf, submodule);
|
|
|
|
strbuf_complete(buf, '/');
|
|
|
|
strbuf_addstr(buf, ".git");
|
|
|
|
|
|
|
|
git_dir = read_gitfile(buf->buf);
|
|
|
|
if (git_dir) {
|
|
|
|
strbuf_reset(buf);
|
|
|
|
strbuf_addstr(buf, git_dir);
|
|
|
|
}
|
|
|
|
if (!is_git_directory(buf->buf)) {
|
2021-04-26 01:02:56 +00:00
|
|
|
sub = submodule_from_path(the_repository, null_oid(),
|
|
|
|
submodule);
|
2017-03-26 02:42:30 +00:00
|
|
|
if (!sub) {
|
|
|
|
ret = -1;
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
strbuf_reset(buf);
|
2021-09-15 18:59:19 +00:00
|
|
|
submodule_name_to_gitdir(buf, the_repository, sub->name);
|
2017-03-26 02:42:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
return ret;
|
|
|
|
}
|
2021-09-15 18:59:19 +00:00
|
|
|
|
|
|
|
void submodule_name_to_gitdir(struct strbuf *buf, struct repository *r,
|
|
|
|
const char *submodule_name)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* NEEDSWORK: The current way of mapping a submodule's name to
|
|
|
|
* its location in .git/modules/ has problems with some naming
|
|
|
|
* schemes. For example, if a submodule is named "foo" and
|
|
|
|
* another is named "foo/bar" (whether present in the same
|
|
|
|
* superproject commit or not - the problem will arise if both
|
|
|
|
* superproject commits have been checked out at any point in
|
|
|
|
* time), or if two submodule names only have different cases in
|
|
|
|
* a case-insensitive filesystem.
|
|
|
|
*
|
|
|
|
* There are several solutions, including encoding the path in
|
|
|
|
* some way, introducing a submodule.<name>.gitdir config in
|
|
|
|
* .git/config (not .gitmodules) that allows overriding what the
|
|
|
|
* gitdir of a submodule would be (and teach Git, upon noticing
|
|
|
|
* a clash, to automatically determine a non-clashing name and
|
|
|
|
* to write such a config), or introducing a
|
|
|
|
* submodule.<name>.gitdir config in .gitmodules that repo
|
|
|
|
* administrators can explicitly set. Nothing has been decided,
|
|
|
|
* so for now, just append the name at the end of the path.
|
|
|
|
*/
|
|
|
|
strbuf_repo_git_path(buf, r, "modules/");
|
|
|
|
strbuf_addstr(buf, submodule_name);
|
|
|
|
}
|