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"
|
2011-09-12 19:56:52 +00:00
|
|
|
#include "sha1-array.h"
|
2011-09-13 21:57:57 +00:00
|
|
|
#include "argv-array.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"
|
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;
|
2017-04-28 23:54:00 +00:00
|
|
|
static struct string_list changed_submodule_paths = STRING_LIST_INIT_DUP;
|
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
|
|
|
*/
|
2017-08-02 19:49:21 +00:00
|
|
|
int is_gitmodules_unmerged(const struct index_state *istate)
|
|
|
|
{
|
|
|
|
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
|
|
|
|
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-08-02 19:49:20 +00:00
|
|
|
int is_staging_gitmodules_ok(const 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 &&
|
|
|
|
ce_match_stat(istate->cache[pos], &st, 0) & DATA_CHANGED)
|
|
|
|
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;
|
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;
|
|
|
|
|
2017-08-02 19:49:21 +00:00
|
|
|
if (is_gitmodules_unmerged(&the_index))
|
2013-08-06 19:15:11 +00:00
|
|
|
die(_("Cannot change unmerged .gitmodules, resolve merge conflicts first"));
|
|
|
|
|
2017-07-13 23:49:20 +00:00
|
|
|
submodule = submodule_from_path(&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");
|
2017-08-02 19:49:16 +00:00
|
|
|
if (git_config_set_in_file_gently(GITMODULES_FILE, entry.buf, newpath) < 0) {
|
2013-08-06 19:15:11 +00:00
|
|
|
/* Maybe the user already did that, don't error out here */
|
|
|
|
warning(_("Could not update .gitmodules entry %s"), entry.buf);
|
|
|
|
strbuf_release(&entry);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
strbuf_release(&entry);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
|
2017-08-02 19:49:21 +00:00
|
|
|
if (is_gitmodules_unmerged(&the_index))
|
2013-08-06 19:15:25 +00:00
|
|
|
die(_("Cannot change unmerged .gitmodules, resolve merge conflicts first"));
|
|
|
|
|
2017-07-13 23:49:20 +00:00
|
|
|
submodule = submodule_from_path(&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;
|
|
|
|
}
|
|
|
|
|
2013-07-30 19:50:34 +00:00
|
|
|
void stage_updated_gitmodules(void)
|
|
|
|
{
|
2017-08-02 19:49:16 +00:00
|
|
|
if (add_file_to_cache(GITMODULES_FILE, 0))
|
2013-07-30 19:50:34 +00:00
|
|
|
die(_("staging updated .gitmodules failed"));
|
|
|
|
}
|
|
|
|
|
2010-01-12 06:31:58 +00:00
|
|
|
static int add_submodule_odb(const char *path)
|
2009-10-19 12:38:32 +00:00
|
|
|
{
|
|
|
|
struct strbuf objects_directory = STRBUF_INIT;
|
2010-01-31 16:43:49 +00:00
|
|
|
int ret = 0;
|
2009-10-19 12:38:32 +00:00
|
|
|
|
2016-08-31 23:27:22 +00:00
|
|
|
ret = strbuf_git_path_submodule(&objects_directory, path, "objects/");
|
|
|
|
if (ret)
|
|
|
|
goto done;
|
2010-01-31 16:43:49 +00:00
|
|
|
if (!is_directory(objects_directory.buf)) {
|
|
|
|
ret = -1;
|
|
|
|
goto done;
|
|
|
|
}
|
2016-10-03 20:35:03 +00:00
|
|
|
add_to_alternates_memory(objects_directory.buf);
|
2010-01-31 16:43:49 +00:00
|
|
|
done:
|
|
|
|
strbuf_release(&objects_directory);
|
|
|
|
return ret;
|
2009-10-19 12:38:32 +00:00
|
|
|
}
|
|
|
|
|
2010-08-05 22:39:25 +00:00
|
|
|
void set_diffopt_flags_from_submodule_config(struct diff_options *diffopt,
|
|
|
|
const char *path)
|
|
|
|
{
|
2017-07-13 23:49:20 +00:00
|
|
|
const struct submodule *submodule = submodule_from_path(&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);
|
|
|
|
if (repo_config_get_string_const(the_repository, key, &ignore))
|
|
|
|
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);
|
2017-08-02 19:49:21 +00:00
|
|
|
else if (is_gitmodules_unmerged(&the_index))
|
2011-05-14 16:26:58 +00:00
|
|
|
DIFF_OPT_SET(diffopt, IGNORE_SUBMODULES);
|
2017-06-01 00:30:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Cheap function that only determines if we're interested in submodules at all */
|
|
|
|
int git_default_submodule_config(const char *var, const char *value, void *cb)
|
|
|
|
{
|
|
|
|
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'
|
|
|
|
*/
|
2017-06-22 18:43:46 +00:00
|
|
|
int is_submodule_active(struct repository *repo, 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;
|
|
|
|
|
2017-07-13 23:49:20 +00:00
|
|
|
module = submodule_from_cache(repo, &null_oid, 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;
|
|
|
|
struct argv_array args = ARGV_ARRAY_INIT;
|
|
|
|
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) {
|
|
|
|
argv_array_push(&args, item->string);
|
|
|
|
}
|
|
|
|
|
|
|
|
parse_pathspec(&ps, 0, 0, NULL, args.argv);
|
|
|
|
ret = match_pathspec(&ps, path, strlen(path), 0, NULL, 1);
|
|
|
|
|
|
|
|
argv_array_clear(&args);
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
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
|
|
|
|
*/
|
|
|
|
void die_in_unpopulated_submodule(const struct index_state *istate,
|
|
|
|
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
|
|
|
|
*/
|
|
|
|
void die_path_inside_submodule(const struct index_state *istate,
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
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
|
|
|
const char *submodule_strategy_to_string(const struct submodule_update_strategy *s)
|
|
|
|
{
|
|
|
|
struct strbuf sb = STRBUF_INIT;
|
|
|
|
switch (s->type) {
|
|
|
|
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:
|
|
|
|
return NULL;
|
|
|
|
case SM_UPDATE_COMMAND:
|
|
|
|
strbuf_addf(&sb, "!%s", s->command);
|
|
|
|
return strbuf_detach(&sb, NULL);
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2010-06-25 14:56:47 +00:00
|
|
|
void handle_ignore_submodules_arg(struct diff_options *diffopt,
|
|
|
|
const char *arg)
|
|
|
|
{
|
2010-08-05 08:49:55 +00:00
|
|
|
DIFF_OPT_CLR(diffopt, IGNORE_SUBMODULES);
|
|
|
|
DIFF_OPT_CLR(diffopt, IGNORE_UNTRACKED_IN_SUBMODULES);
|
|
|
|
DIFF_OPT_CLR(diffopt, IGNORE_DIRTY_SUBMODULES);
|
|
|
|
|
2010-06-25 14:56:47 +00:00
|
|
|
if (!strcmp(arg, "all"))
|
|
|
|
DIFF_OPT_SET(diffopt, IGNORE_SUBMODULES);
|
|
|
|
else if (!strcmp(arg, "untracked"))
|
|
|
|
DIFF_OPT_SET(diffopt, IGNORE_UNTRACKED_IN_SUBMODULES);
|
|
|
|
else if (!strcmp(arg, "dirty"))
|
|
|
|
DIFF_OPT_SET(diffopt, IGNORE_DIRTY_SUBMODULES);
|
2010-08-05 22:39:25 +00:00
|
|
|
else if (strcmp(arg, "none"))
|
2010-06-25 14:56:47 +00:00
|
|
|
die("bad --ignore-submodules argument: %s", arg);
|
|
|
|
}
|
|
|
|
|
2011-03-16 07:14:11 +00:00
|
|
|
static int prepare_submodule_summary(struct rev_info *rev, const char *path,
|
|
|
|
struct commit *left, struct commit *right,
|
2016-08-31 23:27:24 +00:00
|
|
|
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
|
|
|
|
|
|
|
init_revisions(rev, NULL);
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2017-06-30 00:07:00 +00:00
|
|
|
static void print_submodule_summary(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);
|
|
|
|
format_commit_message(commit, format, &sb, &ctx);
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2017-03-14 21:46:35 +00:00
|
|
|
static void prepare_submodule_repo_env_no_git_dir(struct argv_array *out)
|
|
|
|
{
|
|
|
|
const char * const *var;
|
|
|
|
|
|
|
|
for (var = local_repo_env; *var; var++) {
|
|
|
|
if (strcmp(*var, CONFIG_DATA_ENVIRONMENT))
|
|
|
|
argv_array_push(out, *var);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void prepare_submodule_repo_env(struct argv_array *out)
|
|
|
|
{
|
|
|
|
prepare_submodule_repo_env_no_git_dir(out);
|
|
|
|
argv_array_pushf(out, "%s=%s", GIT_DIR_ENVIRONMENT,
|
|
|
|
DEFAULT_GIT_DIR_ENVIRONMENT);
|
|
|
|
}
|
|
|
|
|
2016-08-31 23:27:24 +00:00
|
|
|
/* Helper function to display the submodule header line prior to the full
|
|
|
|
* summary output. If it can locate the submodule objects directory it will
|
|
|
|
* attempt to lookup both the left and right commits and put them into the
|
|
|
|
* left and right pointers.
|
|
|
|
*/
|
2017-06-30 00:07:00 +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,
|
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)";
|
|
|
|
|
|
|
|
if (add_submodule_odb(path)) {
|
|
|
|
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.
|
|
|
|
*/
|
Convert lookup_commit* to struct object_id
Convert lookup_commit, lookup_commit_or_die,
lookup_commit_reference, and lookup_commit_reference_gently to take
struct object_id arguments.
Introduce a temporary in parse_object buffer in order to convert this
function. This is required since in order to convert parse_object and
parse_object_buffer, lookup_commit_reference_gently and
lookup_commit_or_die would need to be converted. Not introducing a
temporary would therefore require that lookup_commit_or_die take a
struct object_id *, but lookup_commit would take unsigned char *,
leaving a confusing and hard-to-use interface.
parse_object_buffer will lose this temporary in a later patch.
This commit was created with manual changes to commit.c, commit.h, and
object.c, plus the following semantic patch:
@@
expression E1, E2;
@@
- lookup_commit_reference_gently(E1.hash, E2)
+ lookup_commit_reference_gently(&E1, E2)
@@
expression E1, E2;
@@
- lookup_commit_reference_gently(E1->hash, E2)
+ lookup_commit_reference_gently(E1, E2)
@@
expression E1;
@@
- lookup_commit_reference(E1.hash)
+ lookup_commit_reference(&E1)
@@
expression E1;
@@
- lookup_commit_reference(E1->hash)
+ lookup_commit_reference(E1)
@@
expression E1;
@@
- lookup_commit(E1.hash)
+ lookup_commit(&E1)
@@
expression E1;
@@
- lookup_commit(E1->hash)
+ lookup_commit(E1)
@@
expression E1, E2;
@@
- lookup_commit_or_die(E1.hash, E2)
+ lookup_commit_or_die(&E1, E2)
@@
expression E1, E2;
@@
- lookup_commit_or_die(E1->hash, E2)
+ lookup_commit_or_die(E1, E2)
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-05-06 22:10:10 +00:00
|
|
|
*left = lookup_commit_reference(one);
|
|
|
|
*right = lookup_commit_reference(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)";
|
|
|
|
|
|
|
|
*merge_bases = get_merge_bases(*left, *right);
|
|
|
|
if (*merge_bases) {
|
|
|
|
if ((*merge_bases)->item == *left)
|
|
|
|
fast_forward = 1;
|
|
|
|
else if ((*merge_bases)->item == *right)
|
|
|
|
fast_backward = 1;
|
|
|
|
}
|
|
|
|
|
2016-08-31 23:27:23 +00:00
|
|
|
if (!oidcmp(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);
|
2016-10-17 20:25:21 +00:00
|
|
|
strbuf_add_unique_abbrev(&sb, one->hash, DEFAULT_ABBREV);
|
2016-10-08 15:38:47 +00:00
|
|
|
strbuf_addstr(&sb, (fast_backward || fast_forward) ? ".." : "...");
|
2016-10-06 21:53:12 +00:00
|
|
|
strbuf_add_unique_abbrev(&sb, two->hash, 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
|
|
|
|
2017-06-30 00:07:00 +00:00
|
|
|
void show_submodule_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
|
|
|
{
|
|
|
|
struct rev_info rev;
|
|
|
|
struct commit *left = NULL, *right = NULL;
|
|
|
|
struct commit_list *merge_bases = NULL;
|
|
|
|
|
2017-06-30 00:07:00 +00:00
|
|
|
show_submodule_header(o, path, one, two, dirty_submodule,
|
|
|
|
&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.
|
|
|
|
*/
|
|
|
|
if (!left || !right)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* Treat revision walker failure the same as missing commits */
|
|
|
|
if (prepare_submodule_summary(&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;
|
|
|
|
}
|
|
|
|
|
2017-06-30 00:07:00 +00:00
|
|
|
print_submodule_summary(&rev, o);
|
2016-08-31 23:27:24 +00:00
|
|
|
|
|
|
|
out:
|
|
|
|
if (merge_bases)
|
|
|
|
free_commit_list(merge_bases);
|
|
|
|
clear_commit_marks(left, ~0);
|
|
|
|
clear_commit_marks(right, ~0);
|
|
|
|
}
|
|
|
|
|
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
|
|
|
{
|
|
|
|
const struct object_id *old = &empty_tree_oid, *new = &empty_tree_oid;
|
|
|
|
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;
|
2016-08-31 23:27:25 +00:00
|
|
|
|
2017-06-30 00:07:00 +00:00
|
|
|
show_submodule_header(o, path, one, two, dirty_submodule,
|
|
|
|
&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)
|
|
|
|
old = one;
|
|
|
|
if (right)
|
|
|
|
new = two;
|
|
|
|
|
|
|
|
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. */
|
2017-05-04 21:43:55 +00:00
|
|
|
argv_array_pushl(&cp.args, "diff", "--submodule=diff", NULL);
|
2017-06-30 00:07:00 +00:00
|
|
|
argv_array_pushf(&cp.args, "--color=%s", want_color(o->use_color) ?
|
|
|
|
"always" : "never");
|
2017-05-04 21:43:55 +00:00
|
|
|
|
2016-08-31 23:27:25 +00:00
|
|
|
if (DIFF_OPT_TST(o, REVERSE_DIFF)) {
|
|
|
|
argv_array_pushf(&cp.args, "--src-prefix=%s%s/",
|
|
|
|
o->b_prefix, path);
|
|
|
|
argv_array_pushf(&cp.args, "--dst-prefix=%s%s/",
|
|
|
|
o->a_prefix, path);
|
|
|
|
} else {
|
|
|
|
argv_array_pushf(&cp.args, "--src-prefix=%s%s/",
|
|
|
|
o->a_prefix, path);
|
|
|
|
argv_array_pushf(&cp.args, "--dst-prefix=%s%s/",
|
|
|
|
o->b_prefix, path);
|
|
|
|
}
|
|
|
|
argv_array_push(&cp.args, oid_to_hex(old));
|
|
|
|
/*
|
|
|
|
* 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))
|
|
|
|
argv_array_push(&cp.args, oid_to_hex(new));
|
|
|
|
|
2017-03-31 23:17:32 +00:00
|
|
|
prepare_submodule_repo_env(&cp.env_array);
|
2017-06-30 00:07:00 +00:00
|
|
|
if (start_command(&cp))
|
|
|
|
diff_emit_submodule_error(o, "(diff failed)\n");
|
|
|
|
|
|
|
|
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);
|
2016-08-31 23:27:25 +00:00
|
|
|
if (merge_bases)
|
|
|
|
free_commit_list(merge_bases);
|
|
|
|
if (left)
|
|
|
|
clear_commit_marks(left, ~0);
|
|
|
|
if (right)
|
|
|
|
clear_commit_marks(right, ~0);
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
|
2017-07-13 23:49:20 +00:00
|
|
|
return submodule_from_path(&null_oid, ce->name);
|
2017-03-14 21:46:34 +00:00
|
|
|
}
|
|
|
|
|
2017-05-02 01:02:39 +00:00
|
|
|
static struct oid_array *submodule_commits(struct string_list *submodules,
|
|
|
|
const char *path)
|
|
|
|
{
|
|
|
|
struct string_list_item *item;
|
|
|
|
|
|
|
|
item = string_list_insert(submodules, path);
|
|
|
|
if (item->util)
|
|
|
|
return (struct oid_array *) item->util;
|
|
|
|
|
|
|
|
/* NEEDSWORK: should we have oid_array_init()? */
|
|
|
|
item->util = xcalloc(1, sizeof(struct oid_array));
|
|
|
|
return (struct oid_array *) item->util;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void collect_changed_submodules_cb(struct diff_queue_struct *q,
|
|
|
|
struct diff_options *options,
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct string_list *changed = data;
|
|
|
|
|
|
|
|
for (i = 0; i < q->nr; i++) {
|
|
|
|
struct diff_filepair *p = q->queue[i];
|
|
|
|
struct oid_array *commits;
|
|
|
|
if (!S_ISGITLINK(p->two->mode))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (S_ISGITLINK(p->one->mode)) {
|
|
|
|
/*
|
|
|
|
* NEEDSWORK: We should honor the name configured in
|
|
|
|
* the .gitmodules file of the commit we are examining
|
|
|
|
* here to be able to correctly follow submodules
|
|
|
|
* being moved around.
|
|
|
|
*/
|
|
|
|
commits = submodule_commits(changed, p->two->path);
|
|
|
|
oid_array_append(commits, &p->two->oid);
|
|
|
|
} else {
|
|
|
|
/* Submodule is new or was moved here */
|
|
|
|
/*
|
|
|
|
* NEEDSWORK: When the .git directories of submodules
|
|
|
|
* live inside the superprojects .git directory some
|
|
|
|
* day we should fetch new submodules directly into
|
|
|
|
* that location too when config or options request
|
|
|
|
* that so they can be checked out from there.
|
|
|
|
*/
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
static void collect_changed_submodules(struct string_list *changed,
|
|
|
|
struct argv_array *argv)
|
|
|
|
{
|
|
|
|
struct rev_info rev;
|
|
|
|
const struct commit *commit;
|
|
|
|
|
|
|
|
init_revisions(&rev, NULL);
|
|
|
|
setup_revisions(argv->argc, argv->argv, &rev, NULL);
|
|
|
|
if (prepare_revision_walk(&rev))
|
|
|
|
die("revision walk setup failed");
|
|
|
|
|
|
|
|
while ((commit = get_revision(&rev))) {
|
|
|
|
struct rev_info diff_rev;
|
|
|
|
|
|
|
|
init_revisions(&diff_rev, NULL);
|
|
|
|
diff_rev.diffopt.output_format |= DIFF_FORMAT_CALLBACK;
|
|
|
|
diff_rev.diffopt.format_callback = collect_changed_submodules_cb;
|
|
|
|
diff_rev.diffopt.format_callback_data = changed;
|
|
|
|
diff_tree_combined_merge(commit, 1, &diff_rev);
|
|
|
|
}
|
|
|
|
|
|
|
|
reset_revision_walk();
|
|
|
|
}
|
|
|
|
|
|
|
|
static void free_submodules_oids(struct string_list *submodules)
|
|
|
|
{
|
|
|
|
struct string_list_item *item;
|
|
|
|
for_each_string_list_item(item, submodules)
|
|
|
|
oid_array_clear((struct oid_array *) item->util);
|
|
|
|
string_list_clear(submodules, 1);
|
|
|
|
}
|
|
|
|
|
2015-05-25 18:39:07 +00:00
|
|
|
static int has_remote(const char *refname, const struct object_id *oid,
|
|
|
|
int flags, void *cb_data)
|
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
|
|
|
{
|
2016-11-16 15:11:05 +00:00
|
|
|
struct argv_array *argv = data;
|
2017-03-31 01:39:59 +00:00
|
|
|
argv_array_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 {
|
|
|
|
int result;
|
|
|
|
const char *path;
|
|
|
|
};
|
|
|
|
|
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;
|
2016-11-16 15:11:06 +00:00
|
|
|
|
2017-09-12 17:30:27 +00:00
|
|
|
enum object_type type = sha1_object_info(oid->hash, NULL);
|
2016-11-16 15:11:06 +00:00
|
|
|
|
2017-09-12 17:30:27 +00:00
|
|
|
switch (type) {
|
|
|
|
case OBJ_COMMIT:
|
|
|
|
return 0;
|
|
|
|
case OBJ_BAD:
|
|
|
|
/*
|
|
|
|
* Object is missing or invalid. If invalid, an error message
|
|
|
|
* has already been printed.
|
|
|
|
*/
|
|
|
|
cb->result = 0;
|
|
|
|
return 0;
|
|
|
|
default:
|
|
|
|
die(_("submodule entry '%s' (%s) is a %s, not a commit"),
|
|
|
|
cb->path, oid_to_hex(oid), typename(type));
|
|
|
|
}
|
2016-11-16 15:11:06 +00:00
|
|
|
}
|
|
|
|
|
2017-03-31 01:40:00 +00:00
|
|
|
static int submodule_has_commits(const char *path, struct oid_array *commits)
|
2016-11-16 15:11:06 +00:00
|
|
|
{
|
2017-09-12 17:30:27 +00:00
|
|
|
struct has_commit_data has_commit = { 1, path };
|
2016-11-16 15:11:06 +00:00
|
|
|
|
2017-05-02 01:02:38 +00:00
|
|
|
/*
|
2017-06-25 10:20:41 +00:00
|
|
|
* Perform a cheap, but incorrect check for the existence of 'commits'.
|
2017-05-02 01:02:38 +00:00
|
|
|
* This is done by adding the submodule's object store to the in-core
|
2017-06-25 10:20:41 +00:00
|
|
|
* object store, and then querying for each commit's existence. If we
|
2017-05-02 01:02:38 +00:00
|
|
|
* do not have the commit object anywhere, there is no chance we have
|
|
|
|
* it in the object store of the correct submodule and have it
|
|
|
|
* reachable from a ref, so we can fail early without spawning rev-list
|
|
|
|
* which is expensive.
|
|
|
|
*/
|
2016-11-16 15:11:06 +00:00
|
|
|
if (add_submodule_odb(path))
|
|
|
|
return 0;
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
argv_array_pushl(&cp.args, "rev-list", "-n", "1", NULL);
|
|
|
|
oid_array_for_each_unique(commits, append_oid_to_argv, &cp.args);
|
|
|
|
argv_array_pushl(&cp.args, "--not", "--all", NULL);
|
|
|
|
|
|
|
|
prepare_submodule_repo_env(&cp.env_array);
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2017-03-31 01:40:00 +00:00
|
|
|
static int submodule_needs_pushing(const char *path, struct oid_array *commits)
|
2016-11-16 15:11:06 +00:00
|
|
|
{
|
|
|
|
if (!submodule_has_commits(path, 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;
|
|
|
|
|
2016-11-16 15:11:06 +00:00
|
|
|
argv_array_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);
|
2016-11-16 15:11:06 +00:00
|
|
|
argv_array_pushl(&cp.args, "--not", "--remotes", "-n", "1" , NULL);
|
|
|
|
|
2016-04-28 13:39:15 +00:00
|
|
|
prepare_submodule_repo_env(&cp.env_array);
|
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))
|
2016-11-16 15:11:06 +00:00
|
|
|
die("Could not run 'git rev-list <commits> --not --remotes -n 1' command in submodule %s",
|
|
|
|
path);
|
2011-08-19 22:08:47 +00:00
|
|
|
if (strbuf_read(&buf, cp.out, 41))
|
|
|
|
needs_pushing = 1;
|
|
|
|
finish_command(&cp);
|
|
|
|
close(cp.out);
|
|
|
|
strbuf_release(&buf);
|
|
|
|
return needs_pushing;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-03-31 01:40:00 +00:00
|
|
|
int find_unpushed_submodules(struct oid_array *commits,
|
2012-03-29 07:21:23 +00:00
|
|
|
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;
|
|
|
|
struct string_list_item *submodule;
|
2016-11-16 15:11:05 +00:00
|
|
|
struct argv_array argv = ARGV_ARRAY_INIT;
|
2012-03-29 07:21:23 +00:00
|
|
|
|
2016-11-16 15:11:05 +00:00
|
|
|
/* argv.argv[0] will be ignored by setup_revisions */
|
|
|
|
argv_array_push(&argv, "find_unpushed_submodules");
|
2017-03-31 01:40:00 +00:00
|
|
|
oid_array_for_each_unique(commits, append_oid_to_argv, &argv);
|
2016-11-16 15:11:05 +00:00
|
|
|
argv_array_push(&argv, "--not");
|
|
|
|
argv_array_pushf(&argv, "--remotes=%s", remotes_name);
|
|
|
|
|
2017-05-02 01:02:39 +00:00
|
|
|
collect_changed_submodules(&submodules, &argv);
|
2011-08-19 22:08:47 +00:00
|
|
|
|
2016-11-16 15:11:04 +00:00
|
|
|
for_each_string_list_item(submodule, &submodules) {
|
2017-05-02 01:02:39 +00:00
|
|
|
struct oid_array *commits = submodule->util;
|
|
|
|
const char *path = submodule->string;
|
2016-11-16 15:11:06 +00:00
|
|
|
|
2017-05-02 01:02:39 +00:00
|
|
|
if (submodule_needs_pushing(path, commits))
|
|
|
|
string_list_insert(needs_pushing, path);
|
2016-11-16 15:11:04 +00:00
|
|
|
}
|
2017-04-28 23:53:58 +00:00
|
|
|
|
|
|
|
free_submodules_oids(&submodules);
|
2017-05-02 01:02:39 +00:00
|
|
|
argv_array_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,
|
|
|
|
const char **refspec, int refspec_nr,
|
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 (add_submodule_odb(path))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
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;
|
2016-11-17 18:46:04 +00:00
|
|
|
argv_array_push(&cp.args, "push");
|
|
|
|
if (dry_run)
|
|
|
|
argv_array_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)
|
|
|
|
argv_array_pushf(&cp.args, "--push-option=%s",
|
|
|
|
item->string);
|
|
|
|
}
|
2017-04-05 17:47:19 +00:00
|
|
|
|
|
|
|
if (remote->origin != REMOTE_UNCONFIGURED) {
|
|
|
|
int i;
|
|
|
|
argv_array_push(&cp.args, remote->name);
|
|
|
|
for (i = 0; i < refspec_nr; i++)
|
|
|
|
argv_array_push(&cp.args, refspec[i]);
|
|
|
|
}
|
|
|
|
|
2016-04-28 13:39:15 +00:00
|
|
|
prepare_submodule_repo_env(&cp.env_array);
|
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,
|
2017-04-05 17:47:19 +00:00
|
|
|
const char **refspec, int refspec_nr)
|
|
|
|
{
|
|
|
|
struct child_process cp = CHILD_PROCESS_INIT;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
argv_array_push(&cp.args, "submodule--helper");
|
|
|
|
argv_array_push(&cp.args, "push-check");
|
2017-07-20 17:40:37 +00:00
|
|
|
argv_array_push(&cp.args, head);
|
2017-04-05 17:47:19 +00:00
|
|
|
argv_array_push(&cp.args, remote->name);
|
|
|
|
|
|
|
|
for (i = 0; i < refspec_nr; i++)
|
|
|
|
argv_array_push(&cp.args, refspec[i]);
|
|
|
|
|
|
|
|
prepare_submodule_repo_env(&cp.env_array);
|
|
|
|
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))
|
|
|
|
die("process for submodule '%s' failed", path);
|
|
|
|
}
|
|
|
|
|
2017-03-31 01:40:00 +00:00
|
|
|
int push_unpushed_submodules(struct oid_array *commits,
|
2017-04-05 17:47:19 +00:00
|
|
|
const struct remote *remote,
|
|
|
|
const char **refspec, int refspec_nr,
|
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
|
|
|
|
2017-04-05 17:47:19 +00:00
|
|
|
if (!find_unpushed_submodules(commits, 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,
|
2017-07-20 17:40:37 +00:00
|
|
|
head, remote,
|
|
|
|
refspec, refspec_nr);
|
|
|
|
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;
|
|
|
|
fprintf(stderr, "Pushing submodule '%s'\n", path);
|
2017-04-05 17:47:19 +00:00
|
|
|
if (!push_submodule(path, remote, refspec, refspec_nr,
|
|
|
|
push_options, dry_run)) {
|
2012-03-29 07:21:24 +00:00
|
|
|
fprintf(stderr, "Unable to push submodule '%s'\n", path);
|
|
|
|
ret = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
string_list_clear(&needs_pushing, 0);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-04-28 23:53:57 +00:00
|
|
|
static int append_oid_to_array(const char *ref, const struct object_id *oid,
|
|
|
|
int flags, 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
|
|
|
}
|
|
|
|
|
|
|
|
static void calculate_changed_submodule_paths(void)
|
2011-03-06 22:10:46 +00:00
|
|
|
{
|
2011-09-13 21:57:57 +00:00
|
|
|
struct argv_array argv = ARGV_ARRAY_INIT;
|
2017-05-02 01:02:39 +00:00
|
|
|
struct string_list changed_submodules = STRING_LIST_INIT_DUP;
|
|
|
|
const struct string_list_item *item;
|
2011-03-06 22:10:46 +00:00
|
|
|
|
2011-09-09 18:22:03 +00:00
|
|
|
/* No need to check if there are no submodules configured */
|
2015-08-18 00:21:59 +00:00
|
|
|
if (!submodule_from_path(NULL, NULL))
|
2011-09-09 18:22:03 +00:00
|
|
|
return;
|
|
|
|
|
2011-09-13 21:57:57 +00:00
|
|
|
argv_array_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);
|
2011-09-13 21:57:57 +00:00
|
|
|
argv_array_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
|
|
|
|
* commits have been recorded upstream in "changed_submodule_paths".
|
|
|
|
*/
|
2017-05-02 01:02:39 +00:00
|
|
|
collect_changed_submodules(&changed_submodules, &argv);
|
|
|
|
|
|
|
|
for_each_string_list_item(item, &changed_submodules) {
|
|
|
|
struct oid_array *commits = item->util;
|
|
|
|
const char *path = item->string;
|
|
|
|
|
|
|
|
if (!submodule_has_commits(path, commits))
|
|
|
|
string_list_append(&changed_submodule_paths, path);
|
2011-03-06 22:10:46 +00:00
|
|
|
}
|
2011-09-12 19:56:52 +00:00
|
|
|
|
2017-05-02 01:02:39 +00:00
|
|
|
free_submodules_oids(&changed_submodules);
|
2011-09-13 21:57:57 +00:00
|
|
|
argv_array_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
|
|
|
}
|
|
|
|
|
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 submodule_touches_in_range(struct object_id *excl_oid,
|
|
|
|
struct object_id *incl_oid)
|
|
|
|
{
|
|
|
|
struct string_list subs = STRING_LIST_INIT_DUP;
|
|
|
|
struct argv_array args = ARGV_ARRAY_INIT;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* No need to check if there are no submodules configured */
|
|
|
|
if (!submodule_from_path(NULL, NULL))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
argv_array_push(&args, "--"); /* args[0] program name */
|
|
|
|
argv_array_push(&args, oid_to_hex(incl_oid));
|
|
|
|
argv_array_push(&args, "--not");
|
|
|
|
argv_array_push(&args, oid_to_hex(excl_oid));
|
|
|
|
|
|
|
|
collect_changed_submodules(&subs, &args);
|
|
|
|
ret = subs.nr;
|
|
|
|
|
|
|
|
argv_array_clear(&args);
|
|
|
|
|
|
|
|
free_submodules_oids(&subs);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-12-16 00:04:11 +00:00
|
|
|
struct submodule_parallel_fetch {
|
|
|
|
int count;
|
|
|
|
struct argv_array args;
|
|
|
|
const char *work_tree;
|
|
|
|
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;
|
|
|
|
};
|
2017-08-02 19:49:19 +00:00
|
|
|
#define SPF_INIT {0, ARGV_ARRAY_INIT, NULL, NULL, 0, 0, 0, 0}
|
2015-12-16 00:04:11 +00:00
|
|
|
|
|
|
|
static int get_next_submodule(struct child_process *cp,
|
|
|
|
struct strbuf *err, void *data, void **task_cb)
|
2010-11-12 12:54:52 +00:00
|
|
|
{
|
2015-12-16 00:04:11 +00:00
|
|
|
int ret = 0;
|
|
|
|
struct submodule_parallel_fetch *spf = data;
|
2011-09-12 19:56:52 +00:00
|
|
|
|
2015-12-16 00:04:11 +00:00
|
|
|
for (; spf->count < active_nr; spf->count++) {
|
2010-11-12 12:54:52 +00:00
|
|
|
struct strbuf submodule_path = STRBUF_INIT;
|
|
|
|
struct strbuf submodule_git_dir = STRBUF_INIT;
|
|
|
|
struct strbuf submodule_prefix = STRBUF_INIT;
|
2015-12-16 00:04:11 +00:00
|
|
|
const struct cache_entry *ce = active_cache[spf->count];
|
2015-08-18 00:21:59 +00:00
|
|
|
const char *git_dir, *default_argv;
|
|
|
|
const struct submodule *submodule;
|
2010-11-12 12:54:52 +00:00
|
|
|
|
|
|
|
if (!S_ISGITLINK(ce->ce_mode))
|
|
|
|
continue;
|
|
|
|
|
2017-07-13 23:49:20 +00:00
|
|
|
submodule = submodule_from_path(&null_oid, ce->name);
|
2010-11-12 12:54:52 +00:00
|
|
|
|
2011-03-06 22:10:46 +00:00
|
|
|
default_argv = "yes";
|
2015-12-16 00:04:11 +00:00
|
|
|
if (spf->command_line_option == RECURSE_SUBMODULES_DEFAULT) {
|
2017-08-03 18:19:51 +00:00
|
|
|
int fetch_recurse = RECURSE_SUBMODULES_NONE;
|
|
|
|
|
|
|
|
if (submodule) {
|
|
|
|
char *key;
|
|
|
|
const char *value;
|
|
|
|
|
|
|
|
fetch_recurse = submodule->fetch_recurse;
|
|
|
|
key = xstrfmt("submodule.%s.fetchRecurseSubmodules", submodule->name);
|
|
|
|
if (!repo_config_get_string_const(the_repository, key, &value)) {
|
|
|
|
fetch_recurse = parse_fetch_recurse_submodules_arg(key, value);
|
|
|
|
}
|
|
|
|
free(key);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (fetch_recurse != RECURSE_SUBMODULES_NONE) {
|
|
|
|
if (fetch_recurse == RECURSE_SUBMODULES_OFF)
|
2010-11-10 23:55:41 +00:00
|
|
|
continue;
|
2017-08-03 18:19:51 +00:00
|
|
|
if (fetch_recurse == RECURSE_SUBMODULES_ON_DEMAND) {
|
2011-03-06 22:12:19 +00:00
|
|
|
if (!unsorted_string_list_lookup(&changed_submodule_paths, ce->name))
|
|
|
|
continue;
|
|
|
|
default_argv = "on-demand";
|
|
|
|
}
|
2010-11-10 23:55:41 +00:00
|
|
|
} else {
|
2017-08-02 19:49:21 +00:00
|
|
|
if (spf->default_option == RECURSE_SUBMODULES_OFF)
|
2010-11-10 23:55:41 +00:00
|
|
|
continue;
|
2017-08-02 19:49:19 +00:00
|
|
|
if (spf->default_option == RECURSE_SUBMODULES_ON_DEMAND) {
|
2011-03-06 22:10:46 +00:00
|
|
|
if (!unsorted_string_list_lookup(&changed_submodule_paths, ce->name))
|
|
|
|
continue;
|
|
|
|
default_argv = "on-demand";
|
|
|
|
}
|
2010-11-10 23:55:41 +00:00
|
|
|
}
|
2015-12-16 00:04:11 +00:00
|
|
|
} else if (spf->command_line_option == RECURSE_SUBMODULES_ON_DEMAND) {
|
2011-03-06 22:11:21 +00:00
|
|
|
if (!unsorted_string_list_lookup(&changed_submodule_paths, ce->name))
|
|
|
|
continue;
|
|
|
|
default_argv = "on-demand";
|
2010-11-10 23:55:02 +00:00
|
|
|
}
|
|
|
|
|
2015-12-16 00:04:11 +00:00
|
|
|
strbuf_addf(&submodule_path, "%s/%s", spf->work_tree, ce->name);
|
2010-11-12 12:54:52 +00:00
|
|
|
strbuf_addf(&submodule_git_dir, "%s/.git", submodule_path.buf);
|
2015-12-16 00:04:11 +00:00
|
|
|
strbuf_addf(&submodule_prefix, "%s%s/", spf->prefix, ce->name);
|
2011-08-22 21:04:56 +00:00
|
|
|
git_dir = read_gitfile(submodule_git_dir.buf);
|
2010-11-12 12:54:52 +00:00
|
|
|
if (!git_dir)
|
|
|
|
git_dir = submodule_git_dir.buf;
|
|
|
|
if (is_directory(git_dir)) {
|
2015-12-16 00:04:11 +00:00
|
|
|
child_process_init(cp);
|
|
|
|
cp->dir = strbuf_detach(&submodule_path, NULL);
|
2016-04-28 13:39:15 +00:00
|
|
|
prepare_submodule_repo_env(&cp->env_array);
|
2015-12-16 00:04:11 +00:00
|
|
|
cp->git_cmd = 1;
|
|
|
|
if (!spf->quiet)
|
|
|
|
strbuf_addf(err, "Fetching submodule %s%s\n",
|
|
|
|
spf->prefix, ce->name);
|
|
|
|
argv_array_init(&cp->args);
|
|
|
|
argv_array_pushv(&cp->args, spf->args.argv);
|
|
|
|
argv_array_push(&cp->args, default_argv);
|
|
|
|
argv_array_push(&cp->args, "--submodule-prefix");
|
|
|
|
argv_array_push(&cp->args, submodule_prefix.buf);
|
|
|
|
ret = 1;
|
2010-11-12 12:54:52 +00:00
|
|
|
}
|
|
|
|
strbuf_release(&submodule_path);
|
|
|
|
strbuf_release(&submodule_git_dir);
|
|
|
|
strbuf_release(&submodule_prefix);
|
2015-12-16 00:04:11 +00:00
|
|
|
if (ret) {
|
|
|
|
spf->count++;
|
|
|
|
return 1;
|
|
|
|
}
|
2010-11-12 12:54:52 +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;
|
|
|
|
|
|
|
|
spf->result = 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
if (retvalue)
|
|
|
|
spf->result = 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int fetch_populated_submodules(const struct argv_array *options,
|
|
|
|
const char *prefix, int command_line_option,
|
2017-08-02 19:49:19 +00:00
|
|
|
int default_option,
|
2015-12-16 00:04:12 +00:00
|
|
|
int quiet, int max_parallel_jobs)
|
2015-12-16 00:04:11 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct submodule_parallel_fetch spf = SPF_INIT;
|
|
|
|
|
|
|
|
spf.work_tree = get_git_work_tree();
|
|
|
|
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;
|
|
|
|
|
|
|
|
if (!spf.work_tree)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (read_cache() < 0)
|
|
|
|
die("index file corrupt");
|
|
|
|
|
|
|
|
argv_array_push(&spf.args, "fetch");
|
|
|
|
for (i = 0; i < options->argc; i++)
|
|
|
|
argv_array_push(&spf.args, options->argv[i]);
|
|
|
|
argv_array_push(&spf.args, "--recurse-submodules-default");
|
|
|
|
/* default value, "--submodule-prefix" and its value are added later */
|
|
|
|
|
|
|
|
calculate_changed_submodule_paths();
|
|
|
|
run_processes_parallel(max_parallel_jobs,
|
|
|
|
get_next_submodule,
|
|
|
|
fetch_start_failure,
|
|
|
|
fetch_finish,
|
|
|
|
&spf);
|
|
|
|
|
|
|
|
argv_array_clear(&spf.args);
|
2011-03-06 22:10:46 +00:00
|
|
|
out:
|
|
|
|
string_list_clear(&changed_submodule_paths, 1);
|
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);
|
|
|
|
|
2017-03-25 00:36:07 +00:00
|
|
|
argv_array_pushl(&cp.args, "status", "--porcelain=2", NULL);
|
2010-03-13 22:00:27 +00:00
|
|
|
if (ignore_untracked)
|
2017-03-25 00:36:04 +00:00
|
|
|
argv_array_push(&cp.args, "-uno");
|
2010-03-13 22:00:27 +00:00
|
|
|
|
2016-04-28 13:39:15 +00:00
|
|
|
prepare_submodule_repo_env(&cp.env_array);
|
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))
|
2017-03-25 00:36:07 +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"))
|
|
|
|
die("BUG: invalid status --porcelain=2 line %s",
|
|
|
|
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)
|
2017-03-25 00:36:07 +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
|
|
|
const char *argv[] = {
|
|
|
|
"submodule",
|
|
|
|
"foreach",
|
|
|
|
"--quiet",
|
|
|
|
"--recursive",
|
|
|
|
"test -f .git",
|
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
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 */
|
|
|
|
cp.argv = argv;
|
2016-04-28 13:39:15 +00:00
|
|
|
prepare_submodule_repo_env(&cp.env_array);
|
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
|
|
|
|
2016-12-20 23:20:11 +00:00
|
|
|
argv_array_pushl(&cp.args, "status", "--porcelain",
|
2016-12-20 23:20:10 +00:00
|
|
|
"--ignore-submodules=none", NULL);
|
2016-12-20 23:20:11 +00:00
|
|
|
|
|
|
|
if (flags & SUBMODULE_REMOVAL_IGNORE_UNTRACKED)
|
|
|
|
argv_array_push(&cp.args, "-uno");
|
|
|
|
else
|
|
|
|
argv_array_push(&cp.args, "-uall");
|
|
|
|
|
|
|
|
if (!(flags & SUBMODULE_REMOVAL_IGNORE_IGNORED_UNTRACKED))
|
|
|
|
argv_array_push(&cp.args, "--ignored");
|
2012-09-26 18:21:13 +00:00
|
|
|
|
2016-04-28 13:39:15 +00:00
|
|
|
prepare_submodule_repo_env(&cp.env_array);
|
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
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
|
2017-05-02 19:32:13 +00:00
|
|
|
prepare_submodule_repo_env(&cp.env_array);
|
2017-03-14 21:46:37 +00:00
|
|
|
|
|
|
|
cp.git_cmd = 1;
|
|
|
|
argv_array_pushl(&cp.args, "diff-index", "--quiet",
|
|
|
|
"--cached", "HEAD", NULL);
|
|
|
|
cp.no_stdin = 1;
|
|
|
|
cp.no_stdout = 1;
|
|
|
|
cp.dir = sub->path;
|
|
|
|
if (start_command(&cp))
|
|
|
|
die("could not recurse into submodule '%s'", sub->path);
|
|
|
|
|
|
|
|
return finish_command(&cp);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void submodule_reset_index(const char *path)
|
|
|
|
{
|
|
|
|
struct child_process cp = CHILD_PROCESS_INIT;
|
2017-05-02 19:32:13 +00:00
|
|
|
prepare_submodule_repo_env(&cp.env_array);
|
2017-03-14 21:46:37 +00:00
|
|
|
|
|
|
|
cp.git_cmd = 1;
|
|
|
|
cp.no_stdin = 1;
|
|
|
|
cp.dir = path;
|
|
|
|
|
|
|
|
argv_array_pushf(&cp.args, "--super-prefix=%s%s/",
|
|
|
|
get_super_prefix_or_empty(), path);
|
|
|
|
argv_array_pushl(&cp.args, "read-tree", "-u", "--reset", NULL);
|
|
|
|
|
|
|
|
argv_array_push(&cp.args, EMPTY_TREE_SHA1_HEX);
|
|
|
|
|
|
|
|
if (run_command(&cp))
|
|
|
|
die("could not reset submodule index");
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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,
|
|
|
|
const char *old,
|
|
|
|
const char *new,
|
|
|
|
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;
|
|
|
|
|
|
|
|
if (old && !is_submodule_populated_gently(path, error_code_ptr))
|
|
|
|
return 0;
|
2017-03-14 21:46:37 +00:00
|
|
|
|
2017-07-13 23:49:20 +00:00
|
|
|
sub = submodule_from_path(&null_oid, path);
|
2017-03-14 21:46:37 +00:00
|
|
|
|
|
|
|
if (!sub)
|
|
|
|
die("BUG: could not get submodule information for '%s'", path);
|
|
|
|
|
|
|
|
if (old && !(flags & SUBMODULE_MOVE_HEAD_FORCE)) {
|
|
|
|
/* 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)) {
|
|
|
|
if (old) {
|
|
|
|
if (!submodule_uses_gitfile(path))
|
|
|
|
absorb_git_dir_into_superproject("", path,
|
|
|
|
ABSORB_GITDIR_RECURSE_SUBMODULES);
|
|
|
|
} else {
|
2017-04-18 21:37:24 +00:00
|
|
|
char *gitdir = xstrfmt("%s/modules/%s",
|
2017-03-14 21:46:37 +00:00
|
|
|
get_git_common_dir(), sub->name);
|
2017-04-18 21:37:24 +00:00
|
|
|
connect_work_tree_and_git_dir(path, gitdir);
|
|
|
|
free(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
|
|
|
|
|
|
|
if (old && (flags & SUBMODULE_MOVE_HEAD_FORCE)) {
|
|
|
|
char *gitdir = xstrfmt("%s/modules/%s",
|
|
|
|
get_git_common_dir(), sub->name);
|
|
|
|
connect_work_tree_and_git_dir(path, gitdir);
|
|
|
|
free(gitdir);
|
|
|
|
}
|
2017-03-14 21:46:37 +00:00
|
|
|
}
|
|
|
|
|
2017-05-02 19:32:13 +00:00
|
|
|
prepare_submodule_repo_env(&cp.env_array);
|
2017-03-14 21:46:37 +00:00
|
|
|
|
|
|
|
cp.git_cmd = 1;
|
|
|
|
cp.no_stdin = 1;
|
|
|
|
cp.dir = path;
|
|
|
|
|
|
|
|
argv_array_pushf(&cp.args, "--super-prefix=%s%s/",
|
|
|
|
get_super_prefix_or_empty(), path);
|
2017-05-02 19:32:14 +00:00
|
|
|
argv_array_pushl(&cp.args, "read-tree", "--recurse-submodules", NULL);
|
2017-03-14 21:46:37 +00:00
|
|
|
|
|
|
|
if (flags & SUBMODULE_MOVE_HEAD_DRY_RUN)
|
|
|
|
argv_array_push(&cp.args, "-n");
|
|
|
|
else
|
|
|
|
argv_array_push(&cp.args, "-u");
|
|
|
|
|
|
|
|
if (flags & SUBMODULE_MOVE_HEAD_FORCE)
|
|
|
|
argv_array_push(&cp.args, "--reset");
|
|
|
|
else
|
|
|
|
argv_array_push(&cp.args, "-m");
|
|
|
|
|
|
|
|
argv_array_push(&cp.args, old ? old : EMPTY_TREE_SHA1_HEX);
|
|
|
|
argv_array_push(&cp.args, new ? new : EMPTY_TREE_SHA1_HEX);
|
|
|
|
|
|
|
|
if (run_command(&cp)) {
|
|
|
|
ret = -1;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(flags & SUBMODULE_MOVE_HEAD_DRY_RUN)) {
|
|
|
|
if (new) {
|
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
|
|
|
|
2017-05-02 19:32:14 +00:00
|
|
|
prepare_submodule_repo_env(&cp.env_array);
|
2017-05-02 19:32:12 +00:00
|
|
|
argv_array_pushl(&cp.args, "update-ref", "HEAD", new, 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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-07-07 13:39:13 +00:00
|
|
|
static int find_first_merges(struct object_array *result, const char *path,
|
|
|
|
struct commit *a, struct commit *b)
|
|
|
|
{
|
|
|
|
int i, j;
|
2013-05-25 09:08:12 +00:00
|
|
|
struct object_array merges = OBJECT_ARRAY_INIT;
|
2010-07-07 13:39:13 +00:00
|
|
|
struct commit *commit;
|
|
|
|
int contains_another;
|
|
|
|
|
|
|
|
char merged_revision[42];
|
|
|
|
const char *rev_args[] = { "rev-list", "--merges", "--ancestry-path",
|
|
|
|
"--all", merged_revision, NULL };
|
|
|
|
struct rev_info revs;
|
|
|
|
struct setup_revision_opt rev_opts;
|
|
|
|
|
|
|
|
memset(result, 0, sizeof(struct object_array));
|
|
|
|
memset(&rev_opts, 0, sizeof(rev_opts));
|
|
|
|
|
|
|
|
/* get all revisions that merge commit a */
|
2017-03-28 19:46:56 +00:00
|
|
|
xsnprintf(merged_revision, sizeof(merged_revision), "^%s",
|
2015-11-10 02:22:28 +00:00
|
|
|
oid_to_hex(&a->object.oid));
|
2010-07-07 13:39:13 +00:00
|
|
|
init_revisions(&revs, NULL);
|
|
|
|
rev_opts.submodule = path;
|
2017-08-23 12:36:59 +00:00
|
|
|
/* FIXME: can't handle linked worktrees in submodules yet */
|
|
|
|
revs.single_worktree = path != NULL;
|
2014-06-27 12:11:39 +00:00
|
|
|
setup_revisions(ARRAY_SIZE(rev_args)-1, rev_args, &revs, &rev_opts);
|
2010-07-07 13:39:13 +00:00
|
|
|
|
|
|
|
/* save all revisions from the above list that contain b */
|
|
|
|
if (prepare_revision_walk(&revs))
|
|
|
|
die("revision walk setup failed");
|
|
|
|
while ((commit = get_revision(&revs)) != NULL) {
|
|
|
|
struct object *o = &(commit->object);
|
2012-08-27 21:46:01 +00:00
|
|
|
if (in_merge_bases(b, commit))
|
2010-07-07 13:39:13 +00:00
|
|
|
add_object_array(o, NULL, &merges);
|
|
|
|
}
|
2012-03-29 07:21:21 +00:00
|
|
|
reset_revision_walk();
|
2010-07-07 13:39:13 +00:00
|
|
|
|
|
|
|
/* Now we've got all merges that contain a and b. Prune all
|
|
|
|
* merges that contain another found merge and save them in
|
|
|
|
* result.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < merges.nr; i++) {
|
|
|
|
struct commit *m1 = (struct commit *) merges.objects[i].item;
|
|
|
|
|
|
|
|
contains_another = 0;
|
|
|
|
for (j = 0; j < merges.nr; j++) {
|
|
|
|
struct commit *m2 = (struct commit *) merges.objects[j].item;
|
2012-08-27 21:46:01 +00:00
|
|
|
if (i != j && in_merge_bases(m2, m1)) {
|
2010-07-07 13:39:13 +00:00
|
|
|
contains_another = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!contains_another)
|
2013-05-25 09:08:13 +00:00
|
|
|
add_object_array(merges.objects[i].item, NULL, result);
|
2010-07-07 13:39:13 +00:00
|
|
|
}
|
|
|
|
|
2017-09-22 23:34:52 +00:00
|
|
|
object_array_clear(&merges);
|
2010-07-07 13:39:13 +00:00
|
|
|
return result->nr;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void print_commit(struct commit *commit)
|
|
|
|
{
|
|
|
|
struct strbuf sb = STRBUF_INIT;
|
|
|
|
struct pretty_print_context ctx = {0};
|
convert "enum date_mode" into a struct
In preparation for adding date modes that may carry extra
information beyond the mode itself, this patch converts the
date_mode enum into a struct.
Most of the conversion is fairly straightforward; we pass
the struct as a pointer and dereference the type field where
necessary. Locations that declare a date_mode can use a "{}"
constructor. However, the tricky case is where we use the
enum labels as constants, like:
show_date(t, tz, DATE_NORMAL);
Ideally we could say:
show_date(t, tz, &{ DATE_NORMAL });
but of course C does not allow that. Likewise, we cannot
cast the constant to a struct, because we need to pass an
actual address. Our options are basically:
1. Manually add a "struct date_mode d = { DATE_NORMAL }"
definition to each caller, and pass "&d". This makes
the callers uglier, because they sometimes do not even
have their own scope (e.g., they are inside a switch
statement).
2. Provide a pre-made global "date_normal" struct that can
be passed by address. We'd also need "date_rfc2822",
"date_iso8601", and so forth. But at least the ugliness
is defined in one place.
3. Provide a wrapper that generates the correct struct on
the fly. The big downside is that we end up pointing to
a single global, which makes our wrapper non-reentrant.
But show_date is already not reentrant, so it does not
matter.
This patch implements 3, along with a minor macro to keep
the size of the callers sane.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2015-06-25 16:55:02 +00:00
|
|
|
ctx.date_mode.type = DATE_NORMAL;
|
2010-07-07 13:39:13 +00:00
|
|
|
format_commit_message(commit, " %h: %m %s", &sb, &ctx);
|
|
|
|
fprintf(stderr, "%s\n", sb.buf);
|
|
|
|
strbuf_release(&sb);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define MERGE_WARNING(path, msg) \
|
|
|
|
warning("Failed to merge submodule %s (%s)", path, msg);
|
|
|
|
|
2017-05-06 22:09:57 +00:00
|
|
|
int merge_submodule(struct object_id *result, const char *path,
|
|
|
|
const struct object_id *base, const struct object_id *a,
|
|
|
|
const struct object_id *b, int search)
|
2010-07-07 13:39:13 +00:00
|
|
|
{
|
|
|
|
struct commit *commit_base, *commit_a, *commit_b;
|
|
|
|
int parent_count;
|
|
|
|
struct object_array merges;
|
|
|
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* store a in result in case we fail */
|
2017-05-06 22:09:57 +00:00
|
|
|
oidcpy(result, a);
|
2010-07-07 13:39:13 +00:00
|
|
|
|
|
|
|
/* we can not handle deletion conflicts */
|
2017-05-06 22:09:57 +00:00
|
|
|
if (is_null_oid(base))
|
2010-07-07 13:39:13 +00:00
|
|
|
return 0;
|
2017-05-06 22:09:57 +00:00
|
|
|
if (is_null_oid(a))
|
2010-07-07 13:39:13 +00:00
|
|
|
return 0;
|
2017-05-06 22:09:57 +00:00
|
|
|
if (is_null_oid(b))
|
2010-07-07 13:39:13 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (add_submodule_odb(path)) {
|
|
|
|
MERGE_WARNING(path, "not checked out");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(commit_base = lookup_commit_reference(base)) ||
|
|
|
|
!(commit_a = lookup_commit_reference(a)) ||
|
|
|
|
!(commit_b = lookup_commit_reference(b))) {
|
|
|
|
MERGE_WARNING(path, "commits not present");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* check whether both changes are forward */
|
2012-08-27 21:46:01 +00:00
|
|
|
if (!in_merge_bases(commit_base, commit_a) ||
|
|
|
|
!in_merge_bases(commit_base, commit_b)) {
|
2010-07-07 13:39:13 +00:00
|
|
|
MERGE_WARNING(path, "commits don't follow merge-base");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Case #1: a is contained in b or vice versa */
|
2012-08-27 21:46:01 +00:00
|
|
|
if (in_merge_bases(commit_a, commit_b)) {
|
2017-05-06 22:09:57 +00:00
|
|
|
oidcpy(result, b);
|
2010-07-07 13:39:13 +00:00
|
|
|
return 1;
|
|
|
|
}
|
2012-08-27 21:46:01 +00:00
|
|
|
if (in_merge_bases(commit_b, commit_a)) {
|
2017-05-06 22:09:57 +00:00
|
|
|
oidcpy(result, a);
|
2010-07-07 13:39:13 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Case #2: There are one or more merges that contain a and b in
|
|
|
|
* the submodule. If there is only one, then present it as a
|
|
|
|
* suggestion to the user, but leave it marked unmerged so the
|
|
|
|
* user needs to confirm the resolution.
|
|
|
|
*/
|
|
|
|
|
2011-10-13 12:59:05 +00:00
|
|
|
/* Skip the search if makes no sense to the calling context. */
|
|
|
|
if (!search)
|
|
|
|
return 0;
|
|
|
|
|
2010-07-07 13:39:13 +00:00
|
|
|
/* find commit which merges them */
|
|
|
|
parent_count = find_first_merges(&merges, path, commit_a, commit_b);
|
|
|
|
switch (parent_count) {
|
|
|
|
case 0:
|
|
|
|
MERGE_WARNING(path, "merge following commits not found");
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 1:
|
|
|
|
MERGE_WARNING(path, "not fast-forward");
|
|
|
|
fprintf(stderr, "Found a possible merge resolution "
|
|
|
|
"for the submodule:\n");
|
|
|
|
print_commit((struct commit *) merges.objects[0].item);
|
|
|
|
fprintf(stderr,
|
|
|
|
"If this is correct simply add it to the index "
|
|
|
|
"for example\n"
|
|
|
|
"by using:\n\n"
|
|
|
|
" git update-index --cacheinfo 160000 %s \"%s\"\n\n"
|
|
|
|
"which will accept this suggestion.\n",
|
2015-11-10 02:22:28 +00:00
|
|
|
oid_to_hex(&merges.objects[0].item->oid), path);
|
2010-07-07 13:39:13 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
MERGE_WARNING(path, "multiple merges found");
|
|
|
|
for (i = 0; i < merges.nr; i++)
|
|
|
|
print_commit((struct commit *) merges.objects[i].item);
|
|
|
|
}
|
|
|
|
|
2017-09-22 23:34:52 +00:00
|
|
|
object_array_clear(&merges);
|
2010-07-07 13:39:13 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2013-07-30 19:50:03 +00:00
|
|
|
|
2016-12-12 19:04:35 +00:00
|
|
|
/*
|
|
|
|
* Embeds a single submodules git directory into the superprojects git dir,
|
|
|
|
* non recursively.
|
|
|
|
*/
|
|
|
|
static void relocate_single_git_dir_into_superproject(const char *prefix,
|
|
|
|
const char *path)
|
|
|
|
{
|
|
|
|
char *old_git_dir = NULL, *real_old_git_dir = NULL, *real_new_git_dir = NULL;
|
|
|
|
const char *new_git_dir;
|
|
|
|
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
|
|
|
|
2017-07-13 23:49:20 +00:00
|
|
|
sub = submodule_from_path(&null_oid, path);
|
2016-12-12 19:04:35 +00:00
|
|
|
if (!sub)
|
|
|
|
die(_("could not lookup name for submodule '%s'"), path);
|
|
|
|
|
|
|
|
new_git_dir = git_path("modules/%s", sub->name);
|
|
|
|
if (safe_create_leading_directories_const(new_git_dir) < 0)
|
|
|
|
die(_("could not create directory '%s'"), new_git_dir);
|
2017-03-08 15:43:40 +00:00
|
|
|
real_new_git_dir = real_pathdup(new_git_dir, 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);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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/.
|
|
|
|
*/
|
|
|
|
void absorb_git_dir_into_superproject(const char *prefix,
|
|
|
|
const char *path,
|
|
|
|
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;
|
|
|
|
|
|
|
|
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.
|
|
|
|
*/
|
2017-07-13 23:49:20 +00:00
|
|
|
sub = submodule_from_path(&null_oid, path);
|
2017-01-25 23:04:50 +00:00
|
|
|
if (!sub)
|
|
|
|
die(_("could not lookup name for submodule '%s'"), path);
|
2017-03-14 21:46:24 +00:00
|
|
|
connect_work_tree_and_git_dir(path,
|
|
|
|
git_path("modules/%s", sub->name));
|
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))
|
|
|
|
relocate_single_git_dir_into_superproject(prefix, path);
|
|
|
|
|
|
|
|
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;
|
|
|
|
struct strbuf sb = STRBUF_INIT;
|
|
|
|
|
|
|
|
if (flags & ~ABSORB_GITDIR_RECURSE_SUBMODULES)
|
|
|
|
die("BUG: we don't know how to pass the flags down?");
|
|
|
|
|
2017-03-14 21:46:36 +00:00
|
|
|
strbuf_addstr(&sb, get_super_prefix_or_empty());
|
2016-12-12 19:04:35 +00:00
|
|
|
strbuf_addstr(&sb, path);
|
|
|
|
strbuf_addch(&sb, '/');
|
|
|
|
|
|
|
|
cp.dir = path;
|
|
|
|
cp.git_cmd = 1;
|
|
|
|
cp.no_stdin = 1;
|
|
|
|
argv_array_pushl(&cp.args, "--super-prefix", sb.buf,
|
|
|
|
"submodule--helper",
|
|
|
|
"absorb-git-dirs", NULL);
|
|
|
|
prepare_submodule_repo_env(&cp.env_array);
|
|
|
|
if (run_command(&cp))
|
|
|
|
die(_("could not recurse into submodule '%s'"), path);
|
|
|
|
|
|
|
|
strbuf_release(&sb);
|
|
|
|
}
|
|
|
|
}
|
2017-03-08 23:07:42 +00:00
|
|
|
|
|
|
|
const char *get_superproject_working_tree(void)
|
|
|
|
{
|
|
|
|
struct child_process cp = CHILD_PROCESS_INIT;
|
|
|
|
struct strbuf sb = STRBUF_INIT;
|
|
|
|
const char *one_up = real_path_if_valid("../");
|
|
|
|
const char *cwd = xgetcwd();
|
|
|
|
const char *ret = NULL;
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (!one_up)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
subpath = relative_path(cwd, one_up, &sb);
|
|
|
|
|
|
|
|
prepare_submodule_repo_env(&cp.env_array);
|
|
|
|
argv_array_pop(&cp.env_array);
|
|
|
|
|
|
|
|
argv_array_pushl(&cp.args, "--literal-pathspecs", "-C", "..",
|
|
|
|
"ls-files", "-z", "--stage", "--full-name", "--",
|
|
|
|
subpath, NULL);
|
|
|
|
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;
|
|
|
|
super_sub_len = sb.buf + sb.len - super_sub - 1;
|
|
|
|
|
|
|
|
if (super_sub_len > cwd_len ||
|
|
|
|
strcmp(&cwd[cwd_len - super_sub_len], super_sub))
|
|
|
|
die (_("BUG: returned path string doesn't match cwd?"));
|
|
|
|
|
|
|
|
super_wt = xstrdup(cwd);
|
|
|
|
super_wt[cwd_len - super_sub_len] = '\0';
|
|
|
|
|
|
|
|
ret = real_path(super_wt);
|
|
|
|
free(super_wt);
|
|
|
|
}
|
|
|
|
strbuf_release(&sb);
|
|
|
|
|
|
|
|
code = finish_command(&cp);
|
|
|
|
|
|
|
|
if (code == 128)
|
|
|
|
/* '../' is not a git repository */
|
|
|
|
return NULL;
|
|
|
|
if (code == 0 && len == 0)
|
|
|
|
/* There is an unrelated git repository at '../' */
|
|
|
|
return NULL;
|
|
|
|
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)) {
|
2017-07-13 23:49:20 +00:00
|
|
|
sub = submodule_from_path(&null_oid, submodule);
|
2017-03-26 02:42:30 +00:00
|
|
|
if (!sub) {
|
|
|
|
ret = -1;
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
strbuf_reset(buf);
|
|
|
|
strbuf_git_path(buf, "%s/%s", "modules", sub->name);
|
|
|
|
}
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
return ret;
|
|
|
|
}
|