2015-09-02 21:42:24 +00:00
|
|
|
#include "builtin.h"
|
|
|
|
#include "cache.h"
|
|
|
|
#include "parse-options.h"
|
|
|
|
#include "quote.h"
|
|
|
|
#include "pathspec.h"
|
|
|
|
#include "dir.h"
|
|
|
|
#include "utf8.h"
|
2015-09-02 21:42:25 +00:00
|
|
|
#include "submodule.h"
|
|
|
|
#include "submodule-config.h"
|
|
|
|
#include "string-list.h"
|
2015-09-08 18:57:45 +00:00
|
|
|
#include "run-command.h"
|
2016-04-16 00:50:12 +00:00
|
|
|
#include "remote.h"
|
|
|
|
#include "refs.h"
|
|
|
|
#include "connect.h"
|
|
|
|
|
|
|
|
static char *get_default_remote(void)
|
|
|
|
{
|
|
|
|
char *dest = NULL, *ret;
|
|
|
|
unsigned char sha1[20];
|
|
|
|
struct strbuf sb = STRBUF_INIT;
|
|
|
|
const char *refname = resolve_ref_unsafe("HEAD", 0, sha1, NULL);
|
|
|
|
|
|
|
|
if (!refname)
|
|
|
|
die(_("No such ref: %s"), "HEAD");
|
|
|
|
|
|
|
|
/* detached HEAD */
|
|
|
|
if (!strcmp(refname, "HEAD"))
|
|
|
|
return xstrdup("origin");
|
|
|
|
|
|
|
|
if (!skip_prefix(refname, "refs/heads/", &refname))
|
|
|
|
die(_("Expecting a full ref name, got %s"), refname);
|
|
|
|
|
|
|
|
strbuf_addf(&sb, "branch.%s.remote", refname);
|
|
|
|
if (git_config_get_string(sb.buf, &dest))
|
|
|
|
ret = xstrdup("origin");
|
|
|
|
else
|
|
|
|
ret = dest;
|
|
|
|
|
|
|
|
strbuf_release(&sb);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int starts_with_dot_slash(const char *str)
|
|
|
|
{
|
|
|
|
return str[0] == '.' && is_dir_sep(str[1]);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int starts_with_dot_dot_slash(const char *str)
|
|
|
|
{
|
|
|
|
return str[0] == '.' && str[1] == '.' && is_dir_sep(str[2]);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Returns 1 if it was the last chop before ':'.
|
|
|
|
*/
|
|
|
|
static int chop_last_dir(char **remoteurl, int is_relative)
|
|
|
|
{
|
|
|
|
char *rfind = find_last_dir_sep(*remoteurl);
|
|
|
|
if (rfind) {
|
|
|
|
*rfind = '\0';
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
rfind = strrchr(*remoteurl, ':');
|
|
|
|
if (rfind) {
|
|
|
|
*rfind = '\0';
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (is_relative || !strcmp(".", *remoteurl))
|
|
|
|
die(_("cannot strip one component off url '%s'"),
|
|
|
|
*remoteurl);
|
|
|
|
|
|
|
|
free(*remoteurl);
|
|
|
|
*remoteurl = xstrdup(".");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The `url` argument is the URL that navigates to the submodule origin
|
|
|
|
* repo. When relative, this URL is relative to the superproject origin
|
|
|
|
* URL repo. The `up_path` argument, if specified, is the relative
|
|
|
|
* path that navigates from the submodule working tree to the superproject
|
|
|
|
* working tree. Returns the origin URL of the submodule.
|
|
|
|
*
|
|
|
|
* Return either an absolute URL or filesystem path (if the superproject
|
|
|
|
* origin URL is an absolute URL or filesystem path, respectively) or a
|
|
|
|
* relative file system path (if the superproject origin URL is a relative
|
|
|
|
* file system path).
|
|
|
|
*
|
|
|
|
* When the output is a relative file system path, the path is either
|
|
|
|
* relative to the submodule working tree, if up_path is specified, or to
|
|
|
|
* the superproject working tree otherwise.
|
|
|
|
*
|
|
|
|
* NEEDSWORK: This works incorrectly on the domain and protocol part.
|
|
|
|
* remote_url url outcome expectation
|
|
|
|
* http://a.com/b ../c http://a.com/c as is
|
|
|
|
* http://a.com/b ../../c http://c error out
|
|
|
|
* http://a.com/b ../../../c http:/c error out
|
|
|
|
* http://a.com/b ../../../../c http:c error out
|
|
|
|
* http://a.com/b ../../../../../c .:c error out
|
|
|
|
* NEEDSWORK: Given how chop_last_dir() works, this function is broken
|
|
|
|
* when a local part has a colon in its path component, too.
|
|
|
|
*/
|
|
|
|
static char *relative_url(const char *remote_url,
|
|
|
|
const char *url,
|
|
|
|
const char *up_path)
|
|
|
|
{
|
|
|
|
int is_relative = 0;
|
|
|
|
int colonsep = 0;
|
|
|
|
char *out;
|
|
|
|
char *remoteurl = xstrdup(remote_url);
|
|
|
|
struct strbuf sb = STRBUF_INIT;
|
|
|
|
size_t len = strlen(remoteurl);
|
|
|
|
|
|
|
|
if (is_dir_sep(remoteurl[len]))
|
|
|
|
remoteurl[len] = '\0';
|
|
|
|
|
|
|
|
if (!url_is_local_not_ssh(remoteurl) || is_absolute_path(remoteurl))
|
|
|
|
is_relative = 0;
|
|
|
|
else {
|
|
|
|
is_relative = 1;
|
|
|
|
/*
|
|
|
|
* Prepend a './' to ensure all relative
|
|
|
|
* remoteurls start with './' or '../'
|
|
|
|
*/
|
|
|
|
if (!starts_with_dot_slash(remoteurl) &&
|
|
|
|
!starts_with_dot_dot_slash(remoteurl)) {
|
|
|
|
strbuf_reset(&sb);
|
|
|
|
strbuf_addf(&sb, "./%s", remoteurl);
|
|
|
|
free(remoteurl);
|
|
|
|
remoteurl = strbuf_detach(&sb, NULL);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* When the url starts with '../', remove that and the
|
|
|
|
* last directory in remoteurl.
|
|
|
|
*/
|
|
|
|
while (url) {
|
|
|
|
if (starts_with_dot_dot_slash(url)) {
|
|
|
|
url += 3;
|
|
|
|
colonsep |= chop_last_dir(&remoteurl, is_relative);
|
|
|
|
} else if (starts_with_dot_slash(url))
|
|
|
|
url += 2;
|
|
|
|
else
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
strbuf_reset(&sb);
|
|
|
|
strbuf_addf(&sb, "%s%s%s", remoteurl, colonsep ? ":" : "/", url);
|
|
|
|
free(remoteurl);
|
|
|
|
|
|
|
|
if (starts_with_dot_slash(sb.buf))
|
|
|
|
out = xstrdup(sb.buf + 2);
|
|
|
|
else
|
|
|
|
out = xstrdup(sb.buf);
|
|
|
|
strbuf_reset(&sb);
|
|
|
|
|
|
|
|
if (!up_path || !is_relative)
|
|
|
|
return out;
|
|
|
|
|
|
|
|
strbuf_addf(&sb, "%s%s", up_path, out);
|
|
|
|
free(out);
|
|
|
|
return strbuf_detach(&sb, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int resolve_relative_url(int argc, const char **argv, const char *prefix)
|
|
|
|
{
|
|
|
|
char *remoteurl = NULL;
|
|
|
|
char *remote = get_default_remote();
|
|
|
|
const char *up_path = NULL;
|
|
|
|
char *res;
|
|
|
|
const char *url;
|
|
|
|
struct strbuf sb = STRBUF_INIT;
|
|
|
|
|
|
|
|
if (argc != 2 && argc != 3)
|
|
|
|
die("resolve-relative-url only accepts one or two arguments");
|
|
|
|
|
|
|
|
url = argv[1];
|
|
|
|
strbuf_addf(&sb, "remote.%s.url", remote);
|
|
|
|
free(remote);
|
|
|
|
|
|
|
|
if (git_config_get_string(sb.buf, &remoteurl))
|
|
|
|
/* the repository is its own authoritative upstream */
|
|
|
|
remoteurl = xgetcwd();
|
|
|
|
|
|
|
|
if (argc == 3)
|
|
|
|
up_path = argv[2];
|
|
|
|
|
|
|
|
res = relative_url(remoteurl, url, up_path);
|
|
|
|
puts(res);
|
|
|
|
free(res);
|
|
|
|
free(remoteurl);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int resolve_relative_url_test(int argc, const char **argv, const char *prefix)
|
|
|
|
{
|
|
|
|
char *remoteurl, *res;
|
|
|
|
const char *up_path, *url;
|
|
|
|
|
|
|
|
if (argc != 4)
|
|
|
|
die("resolve-relative-url-test only accepts three arguments: <up_path> <remoteurl> <url>");
|
|
|
|
|
|
|
|
up_path = argv[1];
|
|
|
|
remoteurl = xstrdup(argv[2]);
|
|
|
|
url = argv[3];
|
|
|
|
|
|
|
|
if (!strcmp(up_path, "(null)"))
|
|
|
|
up_path = NULL;
|
|
|
|
|
|
|
|
res = relative_url(remoteurl, url, up_path);
|
|
|
|
puts(res);
|
|
|
|
free(res);
|
|
|
|
free(remoteurl);
|
|
|
|
return 0;
|
|
|
|
}
|
2015-09-02 21:42:24 +00:00
|
|
|
|
|
|
|
struct module_list {
|
|
|
|
const struct cache_entry **entries;
|
|
|
|
int alloc, nr;
|
|
|
|
};
|
|
|
|
#define MODULE_LIST_INIT { NULL, 0, 0 }
|
|
|
|
|
|
|
|
static int module_list_compute(int argc, const char **argv,
|
|
|
|
const char *prefix,
|
|
|
|
struct pathspec *pathspec,
|
|
|
|
struct module_list *list)
|
|
|
|
{
|
|
|
|
int i, result = 0;
|
2016-02-24 21:15:02 +00:00
|
|
|
char *ps_matched = NULL;
|
2015-09-02 21:42:24 +00:00
|
|
|
parse_pathspec(pathspec, 0,
|
|
|
|
PATHSPEC_PREFER_FULL |
|
|
|
|
PATHSPEC_STRIP_SUBMODULE_SLASH_CHEAP,
|
|
|
|
prefix, argv);
|
|
|
|
|
|
|
|
if (pathspec->nr)
|
|
|
|
ps_matched = xcalloc(pathspec->nr, 1);
|
|
|
|
|
|
|
|
if (read_cache() < 0)
|
|
|
|
die(_("index file corrupt"));
|
|
|
|
|
|
|
|
for (i = 0; i < active_nr; i++) {
|
|
|
|
const struct cache_entry *ce = active_cache[i];
|
|
|
|
|
submodule: fix regression for deinit without submodules
Per Cederqvist wrote:
> It used to be possible to run
>
> git submodule deinit -f .
>
> to remove any submodules, no matter how many submodules you had. That
> is no longer possible in projects that don't have any submodules at
> all. The command will fail with:
>
> error: pathspec '.' did not match any file(s) known to git.
This regression was introduced in 74703a1e4dfc (submodule: rewrite
`module_list` shell function in C, 2015-09-02), as we changed the
order of checking in new module listing to first check whether it is
a gitlin before feeding it to match_pathspec(). It used to be that
a pathspec that does not match any path were diagnosed as an error,
but the new code complains for a pathspec that does not match any
submodule path.
Arguably the new behaviour may give us a better diagnosis, but that
is inconsistent with the suggestion "deinit" gives, and also this
was an unintended accident. The new behaviour hopefully can be
redesigned and implemented better in future releases, but for now,
switch these two checks to restore the same behavior as before. In
an empty repository, giving the pathspec '.' will still get the same
"did not match" error, but that is the same bug we had before 1.7.0.
Reported-by: Per Cederqvist <cederp@opera.com>
Signed-off-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-03-22 23:42:14 +00:00
|
|
|
if (!match_pathspec(pathspec, ce->name, ce_namelen(ce),
|
|
|
|
0, ps_matched, 1) ||
|
|
|
|
!S_ISGITLINK(ce->ce_mode))
|
2015-09-02 21:42:24 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
ALLOC_GROW(list->entries, list->nr + 1, list->alloc);
|
|
|
|
list->entries[list->nr++] = ce;
|
|
|
|
while (i + 1 < active_nr &&
|
|
|
|
!strcmp(ce->name, active_cache[i + 1]->name))
|
|
|
|
/*
|
|
|
|
* Skip entries with the same name in different stages
|
|
|
|
* to make sure an entry is returned only once.
|
|
|
|
*/
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ps_matched && report_path_error(ps_matched, pathspec, prefix))
|
|
|
|
result = -1;
|
|
|
|
|
|
|
|
free(ps_matched);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int module_list(int argc, const char **argv, const char *prefix)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct pathspec pathspec;
|
|
|
|
struct module_list list = MODULE_LIST_INIT;
|
|
|
|
|
|
|
|
struct option module_list_options[] = {
|
|
|
|
OPT_STRING(0, "prefix", &prefix,
|
|
|
|
N_("path"),
|
|
|
|
N_("alternative anchor for relative paths")),
|
|
|
|
OPT_END()
|
|
|
|
};
|
|
|
|
|
|
|
|
const char *const git_submodule_helper_usage[] = {
|
|
|
|
N_("git submodule--helper list [--prefix=<path>] [<path>...]"),
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
argc = parse_options(argc, argv, prefix, module_list_options,
|
|
|
|
git_submodule_helper_usage, 0);
|
|
|
|
|
2016-05-31 23:59:33 +00:00
|
|
|
if (module_list_compute(argc, argv, prefix, &pathspec, &list) < 0)
|
2015-09-02 21:42:24 +00:00
|
|
|
return 1;
|
|
|
|
|
|
|
|
for (i = 0; i < list.nr; i++) {
|
|
|
|
const struct cache_entry *ce = list.entries[i];
|
|
|
|
|
|
|
|
if (ce_stage(ce))
|
|
|
|
printf("%06o %s U\t", ce->ce_mode, sha1_to_hex(null_sha1));
|
|
|
|
else
|
|
|
|
printf("%06o %s %d\t", ce->ce_mode, sha1_to_hex(ce->sha1), ce_stage(ce));
|
|
|
|
|
|
|
|
utf8_fprintf(stdout, "%s\n", ce->name);
|
|
|
|
}
|
|
|
|
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
|
|
|
static void init_submodule(const char *path, const char *prefix, int quiet)
|
|
|
|
{
|
|
|
|
const struct submodule *sub;
|
|
|
|
struct strbuf sb = STRBUF_INIT;
|
|
|
|
char *upd = NULL, *url = NULL, *displaypath;
|
|
|
|
|
|
|
|
/* Only loads from .gitmodules, no overlay with .git/config */
|
|
|
|
gitmodules_config();
|
|
|
|
|
|
|
|
if (prefix) {
|
|
|
|
strbuf_addf(&sb, "%s%s", prefix, path);
|
|
|
|
displaypath = strbuf_detach(&sb, NULL);
|
|
|
|
} else
|
2016-04-28 20:02:45 +00:00
|
|
|
displaypath = xstrdup(path);
|
|
|
|
|
|
|
|
sub = submodule_from_path(null_sha1, path);
|
|
|
|
|
|
|
|
if (!sub)
|
|
|
|
die(_("No url found for submodule path '%s' in .gitmodules"),
|
|
|
|
displaypath);
|
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
|
|
|
|
|
|
|
/*
|
|
|
|
* Copy url setting when it is not set yet.
|
|
|
|
* To look up the url in .git/config, we must not fall back to
|
|
|
|
* .gitmodules, so look it up directly.
|
|
|
|
*/
|
|
|
|
strbuf_reset(&sb);
|
|
|
|
strbuf_addf(&sb, "submodule.%s.url", sub->name);
|
|
|
|
if (git_config_get_string(sb.buf, &url)) {
|
|
|
|
url = xstrdup(sub->url);
|
|
|
|
|
|
|
|
if (!url)
|
|
|
|
die(_("No url found for submodule path '%s' in .gitmodules"),
|
|
|
|
displaypath);
|
|
|
|
|
|
|
|
/* Possibly a url relative to parent */
|
|
|
|
if (starts_with_dot_dot_slash(url) ||
|
|
|
|
starts_with_dot_slash(url)) {
|
|
|
|
char *remoteurl, *relurl;
|
|
|
|
char *remote = get_default_remote();
|
|
|
|
struct strbuf remotesb = STRBUF_INIT;
|
|
|
|
strbuf_addf(&remotesb, "remote.%s.url", remote);
|
|
|
|
free(remote);
|
|
|
|
|
|
|
|
if (git_config_get_string(remotesb.buf, &remoteurl))
|
|
|
|
/*
|
|
|
|
* The repository is its own
|
|
|
|
* authoritative upstream
|
|
|
|
*/
|
|
|
|
remoteurl = xgetcwd();
|
|
|
|
relurl = relative_url(remoteurl, url, NULL);
|
|
|
|
strbuf_release(&remotesb);
|
|
|
|
free(remoteurl);
|
|
|
|
free(url);
|
|
|
|
url = relurl;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (git_config_set_gently(sb.buf, url))
|
|
|
|
die(_("Failed to register url for submodule path '%s'"),
|
|
|
|
displaypath);
|
|
|
|
if (!quiet)
|
2016-05-02 22:24:04 +00:00
|
|
|
fprintf(stderr,
|
|
|
|
_("Submodule '%s' (%s) registered for path '%s'\n"),
|
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
|
|
|
sub->name, url, displaypath);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Copy "update" setting when it is not set yet */
|
|
|
|
strbuf_reset(&sb);
|
|
|
|
strbuf_addf(&sb, "submodule.%s.update", sub->name);
|
|
|
|
if (git_config_get_string(sb.buf, &upd) &&
|
|
|
|
sub->update_strategy.type != SM_UPDATE_UNSPECIFIED) {
|
|
|
|
if (sub->update_strategy.type == SM_UPDATE_COMMAND) {
|
|
|
|
fprintf(stderr, _("warning: command update mode suggested for submodule '%s'\n"),
|
|
|
|
sub->name);
|
|
|
|
upd = xstrdup("none");
|
|
|
|
} else
|
|
|
|
upd = xstrdup(submodule_strategy_to_string(&sub->update_strategy));
|
|
|
|
|
|
|
|
if (git_config_set_gently(sb.buf, upd))
|
|
|
|
die(_("Failed to register update mode for submodule path '%s'"), displaypath);
|
|
|
|
}
|
|
|
|
strbuf_release(&sb);
|
|
|
|
free(displaypath);
|
|
|
|
free(url);
|
|
|
|
free(upd);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int module_init(int argc, const char **argv, const char *prefix)
|
|
|
|
{
|
|
|
|
struct pathspec pathspec;
|
|
|
|
struct module_list list = MODULE_LIST_INIT;
|
|
|
|
int quiet = 0;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
struct option module_init_options[] = {
|
|
|
|
OPT_STRING(0, "prefix", &prefix,
|
|
|
|
N_("path"),
|
|
|
|
N_("alternative anchor for relative paths")),
|
|
|
|
OPT__QUIET(&quiet, N_("Suppress output for initializing a submodule")),
|
|
|
|
OPT_END()
|
|
|
|
};
|
|
|
|
|
|
|
|
const char *const git_submodule_helper_usage[] = {
|
|
|
|
N_("git submodule--helper init [<path>]"),
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
argc = parse_options(argc, argv, prefix, module_init_options,
|
|
|
|
git_submodule_helper_usage, 0);
|
|
|
|
|
|
|
|
if (module_list_compute(argc, argv, prefix, &pathspec, &list) < 0)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
for (i = 0; i < list.nr; i++)
|
|
|
|
init_submodule(list.entries[i]->name, prefix, quiet);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-09-02 21:42:25 +00:00
|
|
|
static int module_name(int argc, const char **argv, const char *prefix)
|
|
|
|
{
|
|
|
|
const struct submodule *sub;
|
|
|
|
|
|
|
|
if (argc != 2)
|
|
|
|
usage(_("git submodule--helper name <path>"));
|
|
|
|
|
|
|
|
gitmodules_config();
|
|
|
|
sub = submodule_from_path(null_sha1, argv[1]);
|
|
|
|
|
|
|
|
if (!sub)
|
|
|
|
die(_("no submodule mapping found in .gitmodules for path '%s'"),
|
|
|
|
argv[1]);
|
|
|
|
|
|
|
|
printf("%s\n", sub->name);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2016-02-29 22:58:35 +00:00
|
|
|
|
2015-09-08 18:57:45 +00:00
|
|
|
static int clone_submodule(const char *path, const char *gitdir, const char *url,
|
|
|
|
const char *depth, const char *reference, int quiet)
|
|
|
|
{
|
|
|
|
struct child_process cp;
|
|
|
|
child_process_init(&cp);
|
|
|
|
|
|
|
|
argv_array_push(&cp.args, "clone");
|
|
|
|
argv_array_push(&cp.args, "--no-checkout");
|
|
|
|
if (quiet)
|
|
|
|
argv_array_push(&cp.args, "--quiet");
|
|
|
|
if (depth && *depth)
|
|
|
|
argv_array_pushl(&cp.args, "--depth", depth, NULL);
|
|
|
|
if (reference && *reference)
|
|
|
|
argv_array_pushl(&cp.args, "--reference", reference, NULL);
|
|
|
|
if (gitdir && *gitdir)
|
|
|
|
argv_array_pushl(&cp.args, "--separate-git-dir", gitdir, NULL);
|
|
|
|
|
|
|
|
argv_array_push(&cp.args, url);
|
|
|
|
argv_array_push(&cp.args, path);
|
|
|
|
|
|
|
|
cp.git_cmd = 1;
|
2016-02-29 22:58:35 +00:00
|
|
|
prepare_submodule_repo_env(&cp.env_array);
|
2015-09-08 18:57:45 +00:00
|
|
|
cp.no_stdin = 1;
|
|
|
|
|
|
|
|
return run_command(&cp);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int module_clone(int argc, const char **argv, const char *prefix)
|
|
|
|
{
|
2016-04-01 00:17:28 +00:00
|
|
|
const char *name = NULL, *url = NULL;
|
2015-09-08 18:57:45 +00:00
|
|
|
const char *reference = NULL, *depth = NULL;
|
|
|
|
int quiet = 0;
|
|
|
|
FILE *submodule_dot_git;
|
2016-04-01 19:23:16 +00:00
|
|
|
char *p, *path = NULL, *sm_gitdir;
|
2015-09-08 18:57:45 +00:00
|
|
|
struct strbuf rel_path = STRBUF_INIT;
|
|
|
|
struct strbuf sb = STRBUF_INIT;
|
|
|
|
|
|
|
|
struct option module_clone_options[] = {
|
|
|
|
OPT_STRING(0, "prefix", &prefix,
|
|
|
|
N_("path"),
|
|
|
|
N_("alternative anchor for relative paths")),
|
|
|
|
OPT_STRING(0, "path", &path,
|
|
|
|
N_("path"),
|
|
|
|
N_("where the new submodule will be cloned to")),
|
|
|
|
OPT_STRING(0, "name", &name,
|
|
|
|
N_("string"),
|
|
|
|
N_("name of the new submodule")),
|
|
|
|
OPT_STRING(0, "url", &url,
|
|
|
|
N_("string"),
|
|
|
|
N_("url where to clone the submodule from")),
|
|
|
|
OPT_STRING(0, "reference", &reference,
|
|
|
|
N_("string"),
|
|
|
|
N_("reference repository")),
|
|
|
|
OPT_STRING(0, "depth", &depth,
|
|
|
|
N_("string"),
|
|
|
|
N_("depth for shallow clones")),
|
|
|
|
OPT__QUIET(&quiet, "Suppress output for cloning a submodule"),
|
|
|
|
OPT_END()
|
|
|
|
};
|
|
|
|
|
|
|
|
const char *const git_submodule_helper_usage[] = {
|
|
|
|
N_("git submodule--helper clone [--prefix=<path>] [--quiet] "
|
2016-02-29 22:58:33 +00:00
|
|
|
"[--reference <repository>] [--name <name>] [--depth <depth>] "
|
|
|
|
"--url <url> --path <path>"),
|
2015-09-08 18:57:45 +00:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
argc = parse_options(argc, argv, prefix, module_clone_options,
|
|
|
|
git_submodule_helper_usage, 0);
|
|
|
|
|
2016-04-22 22:45:03 +00:00
|
|
|
if (argc || !url || !path || !*path)
|
2016-02-29 22:58:31 +00:00
|
|
|
usage_with_options(git_submodule_helper_usage,
|
|
|
|
module_clone_options);
|
|
|
|
|
2015-09-08 18:57:45 +00:00
|
|
|
strbuf_addf(&sb, "%s/modules/%s", get_git_dir(), name);
|
2016-04-01 19:23:16 +00:00
|
|
|
sm_gitdir = xstrdup(absolute_path(sb.buf));
|
|
|
|
strbuf_reset(&sb);
|
2016-04-01 00:17:28 +00:00
|
|
|
|
|
|
|
if (!is_absolute_path(path)) {
|
|
|
|
strbuf_addf(&sb, "%s/%s", get_git_work_tree(), path);
|
|
|
|
path = strbuf_detach(&sb, NULL);
|
|
|
|
} else
|
|
|
|
path = xstrdup(path);
|
2015-09-08 18:57:45 +00:00
|
|
|
|
|
|
|
if (!file_exists(sm_gitdir)) {
|
|
|
|
if (safe_create_leading_directories_const(sm_gitdir) < 0)
|
|
|
|
die(_("could not create directory '%s'"), sm_gitdir);
|
|
|
|
if (clone_submodule(path, sm_gitdir, url, depth, reference, quiet))
|
|
|
|
die(_("clone of '%s' into submodule path '%s' failed"),
|
|
|
|
url, path);
|
|
|
|
} else {
|
|
|
|
if (safe_create_leading_directories_const(path) < 0)
|
|
|
|
die(_("could not create directory '%s'"), path);
|
|
|
|
strbuf_addf(&sb, "%s/index", sm_gitdir);
|
|
|
|
unlink_or_warn(sb.buf);
|
|
|
|
strbuf_reset(&sb);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Write a .git file in the submodule to redirect to the superproject. */
|
2016-03-31 21:04:37 +00:00
|
|
|
strbuf_addf(&sb, "%s/.git", path);
|
2015-09-08 18:57:45 +00:00
|
|
|
if (safe_create_leading_directories_const(sb.buf) < 0)
|
|
|
|
die(_("could not create leading directories of '%s'"), sb.buf);
|
|
|
|
submodule_dot_git = fopen(sb.buf, "w");
|
|
|
|
if (!submodule_dot_git)
|
|
|
|
die_errno(_("cannot open file '%s'"), sb.buf);
|
|
|
|
|
2016-04-01 00:17:29 +00:00
|
|
|
fprintf_or_die(submodule_dot_git, "gitdir: %s\n",
|
|
|
|
relative_path(sm_gitdir, path, &rel_path));
|
2015-09-08 18:57:45 +00:00
|
|
|
if (fclose(submodule_dot_git))
|
|
|
|
die(_("could not close file %s"), sb.buf);
|
|
|
|
strbuf_reset(&sb);
|
|
|
|
strbuf_reset(&rel_path);
|
|
|
|
|
|
|
|
/* Redirect the worktree of the submodule in the superproject's config */
|
|
|
|
p = git_pathdup_submodule(path, "config");
|
|
|
|
if (!p)
|
|
|
|
die(_("could not get submodule directory for '%s'"), path);
|
|
|
|
git_config_set_in_file(p, "core.worktree",
|
2016-04-01 00:17:28 +00:00
|
|
|
relative_path(path, sm_gitdir, &rel_path));
|
2015-09-08 18:57:45 +00:00
|
|
|
strbuf_release(&sb);
|
|
|
|
strbuf_release(&rel_path);
|
|
|
|
free(sm_gitdir);
|
2016-04-01 00:17:28 +00:00
|
|
|
free(path);
|
2015-09-08 18:57:45 +00:00
|
|
|
free(p);
|
|
|
|
return 0;
|
|
|
|
}
|
2015-09-02 21:42:24 +00:00
|
|
|
|
2016-03-01 02:07:17 +00:00
|
|
|
struct submodule_update_clone {
|
|
|
|
/* index into 'list', the list of submodules to look into for cloning */
|
|
|
|
int current;
|
|
|
|
struct module_list list;
|
|
|
|
unsigned warn_if_uninitialized : 1;
|
|
|
|
|
|
|
|
/* update parameter passed via commandline */
|
|
|
|
struct submodule_update_strategy update;
|
|
|
|
|
|
|
|
/* configuration parameters which are passed on to the children */
|
|
|
|
int quiet;
|
2016-05-26 21:59:43 +00:00
|
|
|
int recommend_shallow;
|
2016-03-01 02:07:17 +00:00
|
|
|
const char *reference;
|
|
|
|
const char *depth;
|
|
|
|
const char *recursive_prefix;
|
|
|
|
const char *prefix;
|
|
|
|
|
|
|
|
/* Machine-readable status lines to be consumed by git-submodule.sh */
|
|
|
|
struct string_list projectlines;
|
|
|
|
|
|
|
|
/* If we want to stop as fast as possible and return an error */
|
|
|
|
unsigned quickstop : 1;
|
|
|
|
};
|
|
|
|
#define SUBMODULE_UPDATE_CLONE_INIT {0, MODULE_LIST_INIT, 0, \
|
2016-05-26 21:59:43 +00:00
|
|
|
SUBMODULE_UPDATE_STRATEGY_INIT, 0, -1, NULL, NULL, NULL, NULL, \
|
2016-03-01 02:07:17 +00:00
|
|
|
STRING_LIST_INIT_DUP, 0}
|
|
|
|
|
2016-04-28 20:02:46 +00:00
|
|
|
|
|
|
|
static void next_submodule_warn_missing(struct submodule_update_clone *suc,
|
|
|
|
struct strbuf *out, const char *displaypath)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Only mention uninitialized submodules when their
|
|
|
|
* paths have been specified.
|
|
|
|
*/
|
|
|
|
if (suc->warn_if_uninitialized) {
|
|
|
|
strbuf_addf(out,
|
|
|
|
_("Submodule path '%s' not initialized"),
|
|
|
|
displaypath);
|
|
|
|
strbuf_addch(out, '\n');
|
|
|
|
strbuf_addstr(out,
|
|
|
|
_("Maybe you want to use 'update --init'?"));
|
|
|
|
strbuf_addch(out, '\n');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-03-01 02:07:17 +00:00
|
|
|
/**
|
|
|
|
* Determine whether 'ce' needs to be cloned. If so, prepare the 'child' to
|
|
|
|
* run the clone. Returns 1 if 'ce' needs to be cloned, 0 otherwise.
|
|
|
|
*/
|
|
|
|
static int prepare_to_clone_next_submodule(const struct cache_entry *ce,
|
|
|
|
struct child_process *child,
|
|
|
|
struct submodule_update_clone *suc,
|
|
|
|
struct strbuf *out)
|
|
|
|
{
|
|
|
|
const struct submodule *sub = NULL;
|
|
|
|
struct strbuf displaypath_sb = STRBUF_INIT;
|
|
|
|
struct strbuf sb = STRBUF_INIT;
|
|
|
|
const char *displaypath = NULL;
|
|
|
|
char *url = NULL;
|
|
|
|
int needs_cloning = 0;
|
|
|
|
|
|
|
|
if (ce_stage(ce)) {
|
|
|
|
if (suc->recursive_prefix)
|
|
|
|
strbuf_addf(&sb, "%s/%s", suc->recursive_prefix, ce->name);
|
|
|
|
else
|
|
|
|
strbuf_addf(&sb, "%s", ce->name);
|
|
|
|
strbuf_addf(out, _("Skipping unmerged submodule %s"), sb.buf);
|
|
|
|
strbuf_addch(out, '\n');
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
sub = submodule_from_path(null_sha1, ce->name);
|
|
|
|
|
|
|
|
if (suc->recursive_prefix)
|
|
|
|
displaypath = relative_path(suc->recursive_prefix,
|
|
|
|
ce->name, &displaypath_sb);
|
|
|
|
else
|
|
|
|
displaypath = ce->name;
|
|
|
|
|
2016-04-28 20:02:46 +00:00
|
|
|
if (!sub) {
|
|
|
|
next_submodule_warn_missing(suc, out, displaypath);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2016-03-01 02:07:17 +00:00
|
|
|
if (suc->update.type == SM_UPDATE_NONE
|
|
|
|
|| (suc->update.type == SM_UPDATE_UNSPECIFIED
|
|
|
|
&& sub->update_strategy.type == SM_UPDATE_NONE)) {
|
|
|
|
strbuf_addf(out, _("Skipping submodule '%s'"), displaypath);
|
|
|
|
strbuf_addch(out, '\n');
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Looking up the url in .git/config.
|
|
|
|
* We must not fall back to .gitmodules as we only want
|
|
|
|
* to process configured submodules.
|
|
|
|
*/
|
|
|
|
strbuf_reset(&sb);
|
|
|
|
strbuf_addf(&sb, "submodule.%s.url", sub->name);
|
|
|
|
git_config_get_string(sb.buf, &url);
|
|
|
|
if (!url) {
|
2016-04-28 20:02:46 +00:00
|
|
|
next_submodule_warn_missing(suc, out, displaypath);
|
2016-03-01 02:07:17 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
strbuf_reset(&sb);
|
|
|
|
strbuf_addf(&sb, "%s/.git", ce->name);
|
|
|
|
needs_cloning = !file_exists(sb.buf);
|
|
|
|
|
|
|
|
strbuf_reset(&sb);
|
|
|
|
strbuf_addf(&sb, "%06o %s %d %d\t%s\n", ce->ce_mode,
|
|
|
|
sha1_to_hex(ce->sha1), ce_stage(ce),
|
|
|
|
needs_cloning, ce->name);
|
|
|
|
string_list_append(&suc->projectlines, sb.buf);
|
|
|
|
|
|
|
|
if (!needs_cloning)
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
child->git_cmd = 1;
|
|
|
|
child->no_stdin = 1;
|
|
|
|
child->stdout_to_stderr = 1;
|
|
|
|
child->err = -1;
|
|
|
|
argv_array_push(&child->args, "submodule--helper");
|
|
|
|
argv_array_push(&child->args, "clone");
|
|
|
|
if (suc->quiet)
|
|
|
|
argv_array_push(&child->args, "--quiet");
|
|
|
|
if (suc->prefix)
|
|
|
|
argv_array_pushl(&child->args, "--prefix", suc->prefix, NULL);
|
2016-05-26 21:59:43 +00:00
|
|
|
if (suc->recommend_shallow && sub->recommend_shallow == 1)
|
|
|
|
argv_array_push(&child->args, "--depth=1");
|
2016-03-01 02:07:17 +00:00
|
|
|
argv_array_pushl(&child->args, "--path", sub->path, NULL);
|
|
|
|
argv_array_pushl(&child->args, "--name", sub->name, NULL);
|
|
|
|
argv_array_pushl(&child->args, "--url", url, NULL);
|
|
|
|
if (suc->reference)
|
|
|
|
argv_array_push(&child->args, suc->reference);
|
|
|
|
if (suc->depth)
|
|
|
|
argv_array_push(&child->args, suc->depth);
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
free(url);
|
|
|
|
strbuf_reset(&displaypath_sb);
|
|
|
|
strbuf_reset(&sb);
|
|
|
|
|
|
|
|
return needs_cloning;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int update_clone_get_next_task(struct child_process *child,
|
|
|
|
struct strbuf *err,
|
|
|
|
void *suc_cb,
|
|
|
|
void **void_task_cb)
|
|
|
|
{
|
|
|
|
struct submodule_update_clone *suc = suc_cb;
|
|
|
|
|
|
|
|
for (; suc->current < suc->list.nr; suc->current++) {
|
|
|
|
const struct cache_entry *ce = suc->list.entries[suc->current];
|
|
|
|
if (prepare_to_clone_next_submodule(ce, child, suc, err)) {
|
|
|
|
suc->current++;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int update_clone_start_failure(struct strbuf *err,
|
|
|
|
void *suc_cb,
|
|
|
|
void *void_task_cb)
|
|
|
|
{
|
|
|
|
struct submodule_update_clone *suc = suc_cb;
|
|
|
|
suc->quickstop = 1;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int update_clone_task_finished(int result,
|
|
|
|
struct strbuf *err,
|
|
|
|
void *suc_cb,
|
|
|
|
void *void_task_cb)
|
|
|
|
{
|
|
|
|
struct submodule_update_clone *suc = suc_cb;
|
|
|
|
|
|
|
|
if (!result)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
suc->quickstop = 1;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int update_clone(int argc, const char **argv, const char *prefix)
|
|
|
|
{
|
|
|
|
const char *update = NULL;
|
2016-03-01 02:07:19 +00:00
|
|
|
int max_jobs = -1;
|
2016-03-01 02:07:17 +00:00
|
|
|
struct string_list_item *item;
|
|
|
|
struct pathspec pathspec;
|
|
|
|
struct submodule_update_clone suc = SUBMODULE_UPDATE_CLONE_INIT;
|
|
|
|
|
|
|
|
struct option module_update_clone_options[] = {
|
|
|
|
OPT_STRING(0, "prefix", &prefix,
|
|
|
|
N_("path"),
|
|
|
|
N_("path into the working tree")),
|
|
|
|
OPT_STRING(0, "recursive-prefix", &suc.recursive_prefix,
|
|
|
|
N_("path"),
|
|
|
|
N_("path into the working tree, across nested "
|
|
|
|
"submodule boundaries")),
|
|
|
|
OPT_STRING(0, "update", &update,
|
|
|
|
N_("string"),
|
|
|
|
N_("rebase, merge, checkout or none")),
|
|
|
|
OPT_STRING(0, "reference", &suc.reference, N_("repo"),
|
|
|
|
N_("reference repository")),
|
|
|
|
OPT_STRING(0, "depth", &suc.depth, "<depth>",
|
|
|
|
N_("Create a shallow clone truncated to the "
|
|
|
|
"specified number of revisions")),
|
2016-03-01 02:07:19 +00:00
|
|
|
OPT_INTEGER('j', "jobs", &max_jobs,
|
|
|
|
N_("parallel jobs")),
|
2016-05-26 21:59:43 +00:00
|
|
|
OPT_BOOL(0, "recommend-shallow", &suc.recommend_shallow,
|
|
|
|
N_("whether the initial clone should follow the shallow recommendation")),
|
2016-03-01 02:07:17 +00:00
|
|
|
OPT__QUIET(&suc.quiet, N_("don't print cloning progress")),
|
|
|
|
OPT_END()
|
|
|
|
};
|
|
|
|
|
|
|
|
const char *const git_submodule_helper_usage[] = {
|
|
|
|
N_("git submodule--helper update_clone [--prefix=<path>] [<path>...]"),
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
suc.prefix = prefix;
|
|
|
|
|
|
|
|
argc = parse_options(argc, argv, prefix, module_update_clone_options,
|
|
|
|
git_submodule_helper_usage, 0);
|
|
|
|
|
|
|
|
if (update)
|
|
|
|
if (parse_submodule_update_strategy(update, &suc.update) < 0)
|
|
|
|
die(_("bad value for update parameter"));
|
|
|
|
|
|
|
|
if (module_list_compute(argc, argv, prefix, &pathspec, &suc.list) < 0)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
if (pathspec.nr)
|
|
|
|
suc.warn_if_uninitialized = 1;
|
|
|
|
|
|
|
|
/* Overlay the parsed .gitmodules file with .git/config */
|
|
|
|
gitmodules_config();
|
|
|
|
git_config(submodule_config, NULL);
|
|
|
|
|
2016-03-01 02:07:19 +00:00
|
|
|
if (max_jobs < 0)
|
|
|
|
max_jobs = parallel_submodules();
|
|
|
|
|
|
|
|
run_processes_parallel(max_jobs,
|
2016-03-01 02:07:17 +00:00
|
|
|
update_clone_get_next_task,
|
|
|
|
update_clone_start_failure,
|
|
|
|
update_clone_task_finished,
|
|
|
|
&suc);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We saved the output and put it out all at once now.
|
|
|
|
* That means:
|
|
|
|
* - the listener does not have to interleave their (checkout)
|
|
|
|
* work with our fetching. The writes involved in a
|
|
|
|
* checkout involve more straightforward sequential I/O.
|
|
|
|
* - the listener can avoid doing any work if fetching failed.
|
|
|
|
*/
|
|
|
|
if (suc.quickstop)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
for_each_string_list_item(item, &suc.projectlines)
|
|
|
|
utf8_fprintf(stdout, "%s", item->string);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-06-01 00:27:59 +00:00
|
|
|
static int resolve_relative_path(int argc, const char **argv, const char *prefix)
|
|
|
|
{
|
|
|
|
struct strbuf sb = STRBUF_INIT;
|
|
|
|
if (argc != 3)
|
|
|
|
die("submodule--helper relative_path takes exactly 2 arguments, got %d", argc);
|
|
|
|
|
|
|
|
printf("%s", relative_path(argv[1], argv[2], &sb));
|
|
|
|
strbuf_release(&sb);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-09-02 21:42:24 +00:00
|
|
|
struct cmd_struct {
|
|
|
|
const char *cmd;
|
|
|
|
int (*fn)(int, const char **, const char *);
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct cmd_struct commands[] = {
|
|
|
|
{"list", module_list},
|
2015-09-02 21:42:25 +00:00
|
|
|
{"name", module_name},
|
2015-09-08 18:57:45 +00:00
|
|
|
{"clone", module_clone},
|
2016-04-16 00:50:12 +00:00
|
|
|
{"update-clone", update_clone},
|
2016-06-01 00:27:59 +00:00
|
|
|
{"relative-path", resolve_relative_path},
|
2016-04-16 00:50:12 +00:00
|
|
|
{"resolve-relative-url", resolve_relative_url},
|
|
|
|
{"resolve-relative-url-test", resolve_relative_url_test},
|
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
|
|
|
{"init", module_init}
|
2015-09-02 21:42:24 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
int cmd_submodule__helper(int argc, const char **argv, const char *prefix)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
if (argc < 2)
|
2016-03-01 02:07:18 +00:00
|
|
|
die(_("submodule--helper subcommand must be "
|
2015-09-02 21:42:24 +00:00
|
|
|
"called with a subcommand"));
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(commands); i++)
|
|
|
|
if (!strcmp(argv[1], commands[i].cmd))
|
|
|
|
return commands[i].fn(argc - 1, argv + 1, prefix);
|
|
|
|
|
2016-03-01 02:07:18 +00:00
|
|
|
die(_("'%s' is not a valid submodule--helper "
|
2015-09-02 21:42:24 +00:00
|
|
|
"subcommand"), argv[1]);
|
|
|
|
}
|