* [PATCH 1/7] submodule: implement a config API for lookup of .gitmodules values
2015-08-18 0:21 [PATCH 0/7] Submodule improvements Stefan Beller
@ 2015-08-18 0:21 ` Stefan Beller
2015-08-18 0:21 ` [PATCH 2/7] submodule: extract functions for config set and lookup Stefan Beller
` (6 subsequent siblings)
7 siblings, 0 replies; 19+ messages in thread
From: Stefan Beller @ 2015-08-18 0:21 UTC (permalink / raw)
To: git; +Cc: gitster, Jens.Lehmann, hvoigt, Stefan Beller
From: Heiko Voigt <hvoigt@hvoigt.net>
In a superproject some commands need to interact with submodules. They
need to query values from the .gitmodules file either from the worktree
of from certain revisions. At the moment this is quite hard since a
caller would need to read the .gitmodules file from the history and then
parse the values. We want to provide an API for this so we have one
place to get values from .gitmodules from any revision (including the
worktree).
The API is realized as a cache which allows us to lazily read
.gitmodules configurations by commit into a runtime cache which can then
be used to easily lookup values from it. Currently only the values for
path or name are stored but it can be extended for any value needed.
It is expected that .gitmodules files do not change often between
commits. Thats why we lookup the .gitmodules sha1 from a commit and then
either lookup an already parsed configuration or parse and cache an
unknown one for each sha1. The cache is lazily build on demand for each
requested commit.
This cache can be used for all purposes which need knowledge about
submodule configurations. Example use cases are:
* Recursive submodule checkout needs to lookup a submodule name from
its path when a submodule first appears. This needs be done before
this configuration exists in the worktree.
* The implementation of submodule support for 'git archive' needs to
lookup the submodule name to generate the archive when given a
revision that is not checked out.
* 'git fetch' when given the --recurse-submodules=on-demand option (or
configuration) needs to lookup submodule names by path from the
database rather than reading from the worktree. For new submodule it
needs to lookup the name from its path to allow cloning new
submodules into the .git folder so they can be checked out without
any network interaction when the user does a checkout of that
revision.
Signed-off-by: Heiko Voigt <hvoigt@hvoigt.net>
Signed-off-by: Stefan Beller <sbeller@google.com>
---
.gitignore | 1 +
Documentation/technical/api-submodule-config.txt | 45 +++
Makefile | 2 +
submodule-config.c | 443 +++++++++++++++++++++++
submodule-config.h | 27 ++
submodule.c | 1 +
submodule.h | 1 +
t/t7411-submodule-config.sh | 85 +++++
test-submodule-config.c | 66 ++++
9 files changed, 671 insertions(+)
create mode 100644 Documentation/technical/api-submodule-config.txt
create mode 100644 submodule-config.c
create mode 100644 submodule-config.h
create mode 100755 t/t7411-submodule-config.sh
create mode 100644 test-submodule-config.c
diff --git a/.gitignore b/.gitignore
index a685ec1..4fd81ba 100644
--- a/.gitignore
+++ b/.gitignore
@@ -205,6 +205,7 @@
/test-sha1-array
/test-sigchain
/test-string-list
+/test-submodule-config
/test-subprocess
/test-svn-fe
/test-urlmatch-normalization
diff --git a/Documentation/technical/api-submodule-config.txt b/Documentation/technical/api-submodule-config.txt
new file mode 100644
index 0000000..1fbde41
--- /dev/null
+++ b/Documentation/technical/api-submodule-config.txt
@@ -0,0 +1,45 @@
+submodule config cache API
+==========================
+
+The submodule config cache API allows to read submodule
+configurations/information from specified revisions. Internally
+information is lazily read into a cache that is used to avoid
+unnecessary parsing of the same .gitmodule files. Lookups can be done by
+submodule path or name.
+
+Usage
+-----
+
+The caller can look up information about submodules by using the
+`submodule_from_path()` or `submodule_from_name()` functions. They return
+a `struct submodule` which contains the values. The API automatically
+initializes and allocates the needed infrastructure on-demand.
+
+If the internal cache might grow too big or when the caller is done with
+the API, all internally cached values can be freed with submodule_free().
+
+Data Structures
+---------------
+
+`struct submodule`::
+
+ This structure is used to return the information about one
+ submodule for a certain revision. It is returned by the lookup
+ functions.
+
+Functions
+---------
+
+`void submodule_free()`::
+
+ Use these to free the internally cached values.
+
+`const struct submodule *submodule_from_path(const unsigned char *commit_sha1, const char *path)`::
+
+ Lookup values for one submodule by its commit_sha1 and path.
+
+`const struct submodule *submodule_from_name(const unsigned char *commit_sha1, const char *name)`::
+
+ The same as above but lookup by name.
+
+For an example usage see test-submodule-config.c.
diff --git a/Makefile b/Makefile
index 7efedbe..24b636d 100644
--- a/Makefile
+++ b/Makefile
@@ -594,6 +594,7 @@ TEST_PROGRAMS_NEED_X += test-sha1
TEST_PROGRAMS_NEED_X += test-sha1-array
TEST_PROGRAMS_NEED_X += test-sigchain
TEST_PROGRAMS_NEED_X += test-string-list
+TEST_PROGRAMS_NEED_X += test-submodule-config
TEST_PROGRAMS_NEED_X += test-subprocess
TEST_PROGRAMS_NEED_X += test-svn-fe
TEST_PROGRAMS_NEED_X += test-urlmatch-normalization
@@ -785,6 +786,7 @@ LIB_OBJS += strbuf.o
LIB_OBJS += streaming.o
LIB_OBJS += string-list.o
LIB_OBJS += submodule.o
+LIB_OBJS += submodule-config.o
LIB_OBJS += symlinks.o
LIB_OBJS += tag.o
LIB_OBJS += trace.o
diff --git a/submodule-config.c b/submodule-config.c
new file mode 100644
index 0000000..ea82edb
--- /dev/null
+++ b/submodule-config.c
@@ -0,0 +1,443 @@
+#include "cache.h"
+#include "submodule-config.h"
+#include "submodule.h"
+#include "strbuf.h"
+
+/*
+ * submodule cache lookup structure
+ * There is one shared set of 'struct submodule' entries which can be
+ * looked up by their sha1 blob id of the .gitmodule file and either
+ * using path or name as key.
+ * for_path stores submodule entries with path as key
+ * for_name stores submodule entries with name as key
+ */
+struct submodule_cache {
+ struct hashmap for_path;
+ struct hashmap for_name;
+};
+
+/*
+ * thin wrapper struct needed to insert 'struct submodule' entries to
+ * the hashmap
+ */
+struct submodule_entry {
+ struct hashmap_entry ent;
+ struct submodule *config;
+};
+
+enum lookup_type {
+ lookup_name,
+ lookup_path
+};
+
+static struct submodule_cache cache;
+static int is_cache_init;
+
+static int config_path_cmp(const struct submodule_entry *a,
+ const struct submodule_entry *b,
+ const void *unused)
+{
+ return strcmp(a->config->path, b->config->path) ||
+ hashcmp(a->config->gitmodules_sha1, b->config->gitmodules_sha1);
+}
+
+static int config_name_cmp(const struct submodule_entry *a,
+ const struct submodule_entry *b,
+ const void *unused)
+{
+ return strcmp(a->config->name, b->config->name) ||
+ hashcmp(a->config->gitmodules_sha1, b->config->gitmodules_sha1);
+}
+
+static void cache_init(struct submodule_cache *cache)
+{
+ hashmap_init(&cache->for_path, (hashmap_cmp_fn) config_path_cmp, 0);
+ hashmap_init(&cache->for_name, (hashmap_cmp_fn) config_name_cmp, 0);
+}
+
+static void free_one_config(struct submodule_entry *entry)
+{
+ free((void *) entry->config->path);
+ free((void *) entry->config->name);
+ free(entry->config);
+}
+
+static void cache_free(struct submodule_cache *cache)
+{
+ struct hashmap_iter iter;
+ struct submodule_entry *entry;
+
+ /*
+ * We iterate over the name hash here to be symmetric with the
+ * allocation of struct submodule entries. Each is allocated by
+ * their .gitmodule blob sha1 and submodule name.
+ */
+ hashmap_iter_init(&cache->for_name, &iter);
+ while ((entry = hashmap_iter_next(&iter)))
+ free_one_config(entry);
+
+ hashmap_free(&cache->for_path, 1);
+ hashmap_free(&cache->for_name, 1);
+}
+
+static unsigned int hash_sha1_string(const unsigned char *sha1,
+ const char *string)
+{
+ return memhash(sha1, 20) + strhash(string);
+}
+
+static void cache_put_path(struct submodule_cache *cache,
+ struct submodule *submodule)
+{
+ unsigned int hash = hash_sha1_string(submodule->gitmodules_sha1,
+ submodule->path);
+ struct submodule_entry *e = xmalloc(sizeof(*e));
+ hashmap_entry_init(e, hash);
+ e->config = submodule;
+ hashmap_put(&cache->for_path, e);
+}
+
+static void cache_remove_path(struct submodule_cache *cache,
+ struct submodule *submodule)
+{
+ unsigned int hash = hash_sha1_string(submodule->gitmodules_sha1,
+ submodule->path);
+ struct submodule_entry e;
+ struct submodule_entry *removed;
+ hashmap_entry_init(&e, hash);
+ e.config = submodule;
+ removed = hashmap_remove(&cache->for_path, &e, NULL);
+ free(removed);
+}
+
+static void cache_add(struct submodule_cache *cache,
+ struct submodule *submodule)
+{
+ unsigned int hash = hash_sha1_string(submodule->gitmodules_sha1,
+ submodule->name);
+ struct submodule_entry *e = xmalloc(sizeof(*e));
+ hashmap_entry_init(e, hash);
+ e->config = submodule;
+ hashmap_add(&cache->for_name, e);
+}
+
+static const struct submodule *cache_lookup_path(struct submodule_cache *cache,
+ const unsigned char *gitmodules_sha1, const char *path)
+{
+ struct submodule_entry *entry;
+ unsigned int hash = hash_sha1_string(gitmodules_sha1, path);
+ struct submodule_entry key;
+ struct submodule key_config;
+
+ hashcpy(key_config.gitmodules_sha1, gitmodules_sha1);
+ key_config.path = path;
+
+ hashmap_entry_init(&key, hash);
+ key.config = &key_config;
+
+ entry = hashmap_get(&cache->for_path, &key, NULL);
+ if (entry)
+ return entry->config;
+ return NULL;
+}
+
+static struct submodule *cache_lookup_name(struct submodule_cache *cache,
+ const unsigned char *gitmodules_sha1, const char *name)
+{
+ struct submodule_entry *entry;
+ unsigned int hash = hash_sha1_string(gitmodules_sha1, name);
+ struct submodule_entry key;
+ struct submodule key_config;
+
+ hashcpy(key_config.gitmodules_sha1, gitmodules_sha1);
+ key_config.name = name;
+
+ hashmap_entry_init(&key, hash);
+ key.config = &key_config;
+
+ entry = hashmap_get(&cache->for_name, &key, NULL);
+ if (entry)
+ return entry->config;
+ return NULL;
+}
+
+static int name_and_item_from_var(const char *var, struct strbuf *name,
+ struct strbuf *item)
+{
+ const char *subsection, *key;
+ int subsection_len, parse;
+ parse = parse_config_key(var, "submodule", &subsection,
+ &subsection_len, &key);
+ if (parse < 0 || !subsection)
+ return 0;
+
+ strbuf_add(name, subsection, subsection_len);
+ strbuf_addstr(item, key);
+
+ return 1;
+}
+
+static struct submodule *lookup_or_create_by_name(struct submodule_cache *cache,
+ const unsigned char *gitmodules_sha1, const char *name)
+{
+ struct submodule *submodule;
+ struct strbuf name_buf = STRBUF_INIT;
+
+ submodule = cache_lookup_name(cache, gitmodules_sha1, name);
+ if (submodule)
+ return submodule;
+
+ submodule = xmalloc(sizeof(*submodule));
+
+ strbuf_addstr(&name_buf, name);
+ submodule->name = strbuf_detach(&name_buf, NULL);
+
+ submodule->path = NULL;
+ submodule->url = NULL;
+ submodule->fetch_recurse = RECURSE_SUBMODULES_NONE;
+ submodule->ignore = NULL;
+
+ hashcpy(submodule->gitmodules_sha1, gitmodules_sha1);
+
+ cache_add(cache, submodule);
+
+ return submodule;
+}
+
+static void warn_multiple_config(const unsigned char *commit_sha1,
+ const char *name, const char *option)
+{
+ const char *commit_string = "WORKTREE";
+ if (commit_sha1)
+ commit_string = sha1_to_hex(commit_sha1);
+ warning("%s:.gitmodules, multiple configurations found for "
+ "'submodule.%s.%s'. Skipping second one!",
+ commit_string, name, option);
+}
+
+struct parse_config_parameter {
+ struct submodule_cache *cache;
+ const unsigned char *commit_sha1;
+ const unsigned char *gitmodules_sha1;
+ int overwrite;
+};
+
+static int parse_config(const char *var, const char *value, void *data)
+{
+ struct parse_config_parameter *me = data;
+ struct submodule *submodule;
+ struct strbuf name = STRBUF_INIT, item = STRBUF_INIT;
+ int ret = 0;
+
+ /* this also ensures that we only parse submodule entries */
+ if (!name_and_item_from_var(var, &name, &item))
+ return 0;
+
+ submodule = lookup_or_create_by_name(me->cache, me->gitmodules_sha1,
+ name.buf);
+
+ if (!strcmp(item.buf, "path")) {
+ struct strbuf path = STRBUF_INIT;
+ if (!value) {
+ ret = config_error_nonbool(var);
+ goto release_return;
+ }
+ if (!me->overwrite && submodule->path != NULL) {
+ warn_multiple_config(me->commit_sha1, submodule->name,
+ "path");
+ goto release_return;
+ }
+
+ if (submodule->path)
+ cache_remove_path(me->cache, submodule);
+ free((void *) submodule->path);
+ strbuf_addstr(&path, value);
+ submodule->path = strbuf_detach(&path, NULL);
+ cache_put_path(me->cache, submodule);
+ } else if (!strcmp(item.buf, "fetchrecursesubmodules")) {
+ if (!me->overwrite &&
+ submodule->fetch_recurse != RECURSE_SUBMODULES_NONE) {
+ warn_multiple_config(me->commit_sha1, submodule->name,
+ "fetchrecursesubmodules");
+ goto release_return;
+ }
+
+ submodule->fetch_recurse = parse_fetch_recurse_submodules_arg(var, value);
+ } else if (!strcmp(item.buf, "ignore")) {
+ struct strbuf ignore = STRBUF_INIT;
+ if (!me->overwrite && submodule->ignore != NULL) {
+ warn_multiple_config(me->commit_sha1, submodule->name,
+ "ignore");
+ goto release_return;
+ }
+ if (!value) {
+ ret = config_error_nonbool(var);
+ goto release_return;
+ }
+ if (strcmp(value, "untracked") && strcmp(value, "dirty") &&
+ strcmp(value, "all") && strcmp(value, "none")) {
+ warning("Invalid parameter '%s' for config option "
+ "'submodule.%s.ignore'", value, var);
+ goto release_return;
+ }
+
+ free((void *) submodule->ignore);
+ strbuf_addstr(&ignore, value);
+ submodule->ignore = strbuf_detach(&ignore, NULL);
+ } else if (!strcmp(item.buf, "url")) {
+ struct strbuf url = STRBUF_INIT;
+ if (!value) {
+ ret = config_error_nonbool(var);
+ goto release_return;
+ }
+ if (!me->overwrite && submodule->url != NULL) {
+ warn_multiple_config(me->commit_sha1, submodule->name,
+ "url");
+ goto release_return;
+ }
+
+ free((void *) submodule->url);
+ strbuf_addstr(&url, value);
+ submodule->url = strbuf_detach(&url, NULL);
+ }
+
+release_return:
+ strbuf_release(&name);
+ strbuf_release(&item);
+
+ return ret;
+}
+
+static int gitmodule_sha1_from_commit(const unsigned char *commit_sha1,
+ unsigned char *gitmodules_sha1)
+{
+ struct strbuf rev = STRBUF_INIT;
+ int ret = 0;
+
+ if (is_null_sha1(commit_sha1)) {
+ hashcpy(gitmodules_sha1, null_sha1);
+ return 1;
+ }
+
+ strbuf_addf(&rev, "%s:.gitmodules", sha1_to_hex(commit_sha1));
+ if (get_sha1(rev.buf, gitmodules_sha1) >= 0)
+ ret = 1;
+
+ strbuf_release(&rev);
+ return ret;
+}
+
+/* This does a lookup of a submodule configuration by name or by path
+ * (key) with on-demand reading of the appropriate .gitmodules from
+ * revisions.
+ */
+static const struct submodule *config_from(struct submodule_cache *cache,
+ const unsigned char *commit_sha1, const char *key,
+ enum lookup_type lookup_type)
+{
+ struct strbuf rev = STRBUF_INIT;
+ unsigned long config_size;
+ char *config;
+ unsigned char sha1[20];
+ enum object_type type;
+ const struct submodule *submodule = NULL;
+ struct parse_config_parameter parameter;
+
+ /*
+ * If any parameter except the cache is a NULL pointer just
+ * return the first submodule. Can be used to check whether
+ * there are any submodules parsed.
+ */
+ if (!commit_sha1 || !key) {
+ struct hashmap_iter iter;
+ struct submodule_entry *entry;
+
+ hashmap_iter_init(&cache->for_name, &iter);
+ entry = hashmap_iter_next(&iter);
+ if (!entry)
+ return NULL;
+ return entry->config;
+ }
+
+ if (!gitmodule_sha1_from_commit(commit_sha1, sha1))
+ return NULL;
+
+ switch (lookup_type) {
+ case lookup_name:
+ submodule = cache_lookup_name(cache, sha1, key);
+ break;
+ case lookup_path:
+ submodule = cache_lookup_path(cache, sha1, key);
+ break;
+ }
+ if (submodule)
+ return submodule;
+
+ config = read_sha1_file(sha1, &type, &config_size);
+ if (!config)
+ return NULL;
+
+ if (type != OBJ_BLOB) {
+ free(config);
+ return NULL;
+ }
+
+ /* fill the submodule config into the cache */
+ parameter.cache = cache;
+ parameter.commit_sha1 = commit_sha1;
+ parameter.gitmodules_sha1 = sha1;
+ parameter.overwrite = 0;
+ git_config_from_buf(parse_config, rev.buf, config, config_size,
+ ¶meter);
+ free(config);
+
+ switch (lookup_type) {
+ case lookup_name:
+ return cache_lookup_name(cache, sha1, key);
+ case lookup_path:
+ return cache_lookup_path(cache, sha1, key);
+ default:
+ return NULL;
+ }
+}
+
+static const struct submodule *config_from_path(struct submodule_cache *cache,
+ const unsigned char *commit_sha1, const char *path)
+{
+ return config_from(cache, commit_sha1, path, lookup_path);
+}
+
+static const struct submodule *config_from_name(struct submodule_cache *cache,
+ const unsigned char *commit_sha1, const char *name)
+{
+ return config_from(cache, commit_sha1, name, lookup_name);
+}
+
+static void ensure_cache_init(void)
+{
+ if (is_cache_init)
+ return;
+
+ cache_init(&cache);
+ is_cache_init = 1;
+}
+
+const struct submodule *submodule_from_name(const unsigned char *commit_sha1,
+ const char *name)
+{
+ ensure_cache_init();
+ return config_from_name(&cache, commit_sha1, name);
+}
+
+const struct submodule *submodule_from_path(const unsigned char *commit_sha1,
+ const char *path)
+{
+ ensure_cache_init();
+ return config_from_path(&cache, commit_sha1, path);
+}
+
+void submodule_free(void)
+{
+ cache_free(&cache);
+ is_cache_init = 0;
+}
diff --git a/submodule-config.h b/submodule-config.h
new file mode 100644
index 0000000..cd68030
--- /dev/null
+++ b/submodule-config.h
@@ -0,0 +1,27 @@
+#ifndef SUBMODULE_CONFIG_CACHE_H
+#define SUBMODULE_CONFIG_CACHE_H
+
+#include "hashmap.h"
+#include "strbuf.h"
+
+/*
+ * Submodule entry containing the information about a certain submodule
+ * in a certain revision.
+ */
+struct submodule {
+ const char *path;
+ const char *name;
+ const char *url;
+ int fetch_recurse;
+ const char *ignore;
+ /* the sha1 blob id of the responsible .gitmodules file */
+ unsigned char gitmodules_sha1[20];
+};
+
+const struct submodule *submodule_from_name(const unsigned char *commit_sha1,
+ const char *name);
+const struct submodule *submodule_from_path(const unsigned char *commit_sha1,
+ const char *path);
+void submodule_free(void);
+
+#endif /* SUBMODULE_CONFIG_H */
diff --git a/submodule.c b/submodule.c
index 700bbf4..17b54e4 100644
--- a/submodule.c
+++ b/submodule.c
@@ -355,6 +355,7 @@ int parse_fetch_recurse_submodules_arg(const char *opt, const char *arg)
default:
if (!strcmp(arg, "on-demand"))
return RECURSE_SUBMODULES_ON_DEMAND;
+ /* TODO: remove the die for history parsing here */
die("bad %s argument: %s", opt, arg);
}
}
diff --git a/submodule.h b/submodule.h
index 7beec48..920fef3 100644
--- a/submodule.h
+++ b/submodule.h
@@ -5,6 +5,7 @@ struct diff_options;
struct argv_array;
enum {
+ RECURSE_SUBMODULES_NONE = -2,
RECURSE_SUBMODULES_ON_DEMAND = -1,
RECURSE_SUBMODULES_OFF = 0,
RECURSE_SUBMODULES_DEFAULT = 1,
diff --git a/t/t7411-submodule-config.sh b/t/t7411-submodule-config.sh
new file mode 100755
index 0000000..2602bc5
--- /dev/null
+++ b/t/t7411-submodule-config.sh
@@ -0,0 +1,85 @@
+#!/bin/sh
+#
+# Copyright (c) 2014 Heiko Voigt
+#
+
+test_description='Test submodules config cache infrastructure
+
+This test verifies that parsing .gitmodules configuration directly
+from the database works.
+'
+
+TEST_NO_CREATE_REPO=1
+. ./test-lib.sh
+
+test_expect_success 'submodule config cache setup' '
+ mkdir submodule &&
+ (cd submodule &&
+ git init &&
+ echo a >a &&
+ git add . &&
+ git commit -ma
+ ) &&
+ mkdir super &&
+ (cd super &&
+ git init &&
+ git submodule add ../submodule &&
+ git submodule add ../submodule a &&
+ git commit -m "add as submodule and as a" &&
+ git mv a b &&
+ git commit -m "move a to b"
+ )
+'
+
+cat >super/expect <<EOF
+Submodule name: 'a' for path 'a'
+Submodule name: 'a' for path 'b'
+Submodule name: 'submodule' for path 'submodule'
+Submodule name: 'submodule' for path 'submodule'
+EOF
+
+test_expect_success 'test parsing and lookup of submodule config by path' '
+ (cd super &&
+ test-submodule-config \
+ HEAD^ a \
+ HEAD b \
+ HEAD^ submodule \
+ HEAD submodule \
+ >actual &&
+ test_cmp expect actual
+ )
+'
+
+test_expect_success 'test parsing and lookup of submodule config by name' '
+ (cd super &&
+ test-submodule-config --name \
+ HEAD^ a \
+ HEAD a \
+ HEAD^ submodule \
+ HEAD submodule \
+ >actual &&
+ test_cmp expect actual
+ )
+'
+
+cat >super/expect_error <<EOF
+Submodule name: 'a' for path 'b'
+Submodule name: 'submodule' for path 'submodule'
+EOF
+
+test_expect_success 'error in one submodule config lets continue' '
+ (cd super &&
+ cp .gitmodules .gitmodules.bak &&
+ echo " value = \"" >>.gitmodules &&
+ git add .gitmodules &&
+ mv .gitmodules.bak .gitmodules &&
+ git commit -m "add error" &&
+ test-submodule-config \
+ HEAD b \
+ HEAD submodule \
+ >actual &&
+ test_cmp expect_error actual
+ )
+'
+
+test_done
diff --git a/test-submodule-config.c b/test-submodule-config.c
new file mode 100644
index 0000000..f3c3918
--- /dev/null
+++ b/test-submodule-config.c
@@ -0,0 +1,66 @@
+#include "cache.h"
+#include "submodule-config.h"
+
+static void die_usage(int argc, char **argv, const char *msg)
+{
+ fprintf(stderr, "%s\n", msg);
+ fprintf(stderr, "Usage: %s [<commit> <submodulepath>] ...\n", argv[0]);
+ exit(1);
+}
+
+int main(int argc, char **argv)
+{
+ char **arg = argv;
+ int my_argc = argc;
+ int output_url = 0;
+ int lookup_name = 0;
+
+ arg++;
+ my_argc--;
+ while (starts_with(arg[0], "--")) {
+ if (!strcmp(arg[0], "--url"))
+ output_url = 1;
+ if (!strcmp(arg[0], "--name"))
+ lookup_name = 1;
+ arg++;
+ my_argc--;
+ }
+
+ if (my_argc % 2 != 0)
+ die_usage(argc, argv, "Wrong number of arguments.");
+
+ while (*arg) {
+ unsigned char commit_sha1[20];
+ const struct submodule *submodule;
+ const char *commit;
+ const char *path_or_name;
+
+ commit = arg[0];
+ path_or_name = arg[1];
+
+ if (commit[0] == '\0')
+ hashcpy(commit_sha1, null_sha1);
+ else if (get_sha1(commit, commit_sha1) < 0)
+ die_usage(argc, argv, "Commit not found.");
+
+ if (lookup_name) {
+ submodule = submodule_from_name(commit_sha1, path_or_name);
+ } else
+ submodule = submodule_from_path(commit_sha1, path_or_name);
+ if (!submodule)
+ die_usage(argc, argv, "Submodule not found.");
+
+ if (output_url)
+ printf("Submodule url: '%s' for path '%s'\n",
+ submodule->url, submodule->path);
+ else
+ printf("Submodule name: '%s' for path '%s'\n",
+ submodule->name, submodule->path);
+
+ arg += 2;
+ }
+
+ submodule_free();
+
+ return 0;
+}
--
2.5.0.330.g130be8e.dirty
^ permalink raw reply related [flat|nested] 19+ messages in thread* [PATCH 2/7] submodule: extract functions for config set and lookup
2015-08-18 0:21 [PATCH 0/7] Submodule improvements Stefan Beller
2015-08-18 0:21 ` [PATCH 1/7] submodule: implement a config API for lookup of .gitmodules values Stefan Beller
@ 2015-08-18 0:21 ` Stefan Beller
2015-08-18 0:21 ` [PATCH 3/7] submodule: use new config API for worktree configurations Stefan Beller
` (5 subsequent siblings)
7 siblings, 0 replies; 19+ messages in thread
From: Stefan Beller @ 2015-08-18 0:21 UTC (permalink / raw)
To: git; +Cc: gitster, Jens.Lehmann, hvoigt, Stefan Beller
From: Heiko Voigt <hvoigt@hvoigt.net>
This is one step towards using the new configuration API. We just
extract these functions to make replacing the actual code easier.
Signed-off-by: Heiko Voigt <hvoigt@hvoigt.net>
Signed-off-by: Stefan Beller <sbeller@google.com>
---
submodule.c | 142 +++++++++++++++++++++++++++++++++++++++++-------------------
1 file changed, 97 insertions(+), 45 deletions(-)
diff --git a/submodule.c b/submodule.c
index 17b54e4..307fa43 100644
--- a/submodule.c
+++ b/submodule.c
@@ -41,6 +41,76 @@ static int gitmodules_is_unmerged;
*/
static int gitmodules_is_modified;
+static const char *get_name_for_path(const char *path)
+{
+ struct string_list_item *path_option;
+ if (path == NULL) {
+ if (config_name_for_path.nr > 0)
+ return config_name_for_path.items[0].util;
+ else
+ return NULL;
+ }
+ path_option = unsorted_string_list_lookup(&config_name_for_path, path);
+ if (!path_option)
+ return NULL;
+ return path_option->util;
+}
+
+static void set_name_for_path(const char *path, const char *name, int namelen)
+{
+ struct string_list_item *config;
+ config = unsorted_string_list_lookup(&config_name_for_path, path);
+ if (config)
+ free(config->util);
+ else
+ config = string_list_append(&config_name_for_path, xstrdup(path));
+ config->util = xmemdupz(name, namelen);
+}
+
+static const char *get_ignore_for_name(const char *name)
+{
+ struct string_list_item *ignore_option;
+ ignore_option = unsorted_string_list_lookup(&config_ignore_for_name, name);
+ if (!ignore_option)
+ return NULL;
+
+ return ignore_option->util;
+}
+
+static void set_ignore_for_name(const char *name, int namelen, const char *ignore)
+{
+ struct string_list_item *config;
+ char *name_cstr = xmemdupz(name, namelen);
+ config = unsorted_string_list_lookup(&config_ignore_for_name, name_cstr);
+ if (config) {
+ free(config->util);
+ free(name_cstr);
+ } else
+ config = string_list_append(&config_ignore_for_name, name_cstr);
+ config->util = xstrdup(ignore);
+}
+
+static int get_fetch_recurse_for_name(const char *name)
+{
+ struct string_list_item *fetch_recurse;
+ fetch_recurse = unsorted_string_list_lookup(&config_fetch_recurse_submodules_for_name, name);
+ if (!fetch_recurse)
+ return RECURSE_SUBMODULES_NONE;
+
+ return (intptr_t) fetch_recurse->util;
+}
+
+static void set_fetch_recurse_for_name(const char *name, int namelen, int fetch_recurse)
+{
+ struct string_list_item *config;
+ char *name_cstr = xmemdupz(name, namelen);
+ config = unsorted_string_list_lookup(&config_fetch_recurse_submodules_for_name, name_cstr);
+ if (!config)
+ config = string_list_append(&config_fetch_recurse_submodules_for_name, name_cstr);
+ else
+ free(name_cstr);
+ config->util = (void *)(intptr_t) fetch_recurse;
+}
int is_staging_gitmodules_ok(void)
{
@@ -55,7 +125,7 @@ int is_staging_gitmodules_ok(void)
int update_path_in_gitmodules(const char *oldpath, const char *newpath)
{
struct strbuf entry = STRBUF_INIT;
- struct string_list_item *path_option;
+ const char *path;
if (!file_exists(".gitmodules")) /* Do nothing without .gitmodules */
return -1;
@@ -63,13 +133,13 @@ int update_path_in_gitmodules(const char *oldpath, const char *newpath)
if (gitmodules_is_unmerged)
die(_("Cannot change unmerged .gitmodules, resolve merge conflicts first"));
- path_option = unsorted_string_list_lookup(&config_name_for_path, oldpath);
- if (!path_option) {
+ path = get_name_for_path(oldpath);
+ if (!path) {
warning(_("Could not find section in .gitmodules where path=%s"), oldpath);
return -1;
}
strbuf_addstr(&entry, "submodule.");
- strbuf_addstr(&entry, path_option->util);
+ strbuf_addstr(&entry, path);
strbuf_addstr(&entry, ".path");
if (git_config_set_in_file(".gitmodules", entry.buf, newpath) < 0) {
/* Maybe the user already did that, don't error out here */
@@ -89,7 +159,7 @@ int update_path_in_gitmodules(const char *oldpath, const char *newpath)
int remove_path_from_gitmodules(const char *path)
{
struct strbuf sect = STRBUF_INIT;
- struct string_list_item *path_option;
+ const char *path_option;
if (!file_exists(".gitmodules")) /* Do nothing without .gitmodules */
return -1;
@@ -97,13 +167,13 @@ int remove_path_from_gitmodules(const char *path)
if (gitmodules_is_unmerged)
die(_("Cannot change unmerged .gitmodules, resolve merge conflicts first"));
- path_option = unsorted_string_list_lookup(&config_name_for_path, path);
+ path_option = get_name_for_path(path);
if (!path_option) {
warning(_("Could not find section in .gitmodules where path=%s"), path);
return -1;
}
strbuf_addstr(§, "submodule.");
- strbuf_addstr(§, path_option->util);
+ strbuf_addstr(§, path_option);
if (git_config_rename_section_in_file(".gitmodules", sect.buf, NULL) < 0) {
/* Maybe the user already did that, don't error out here */
warning(_("Could not remove .gitmodules entry for %s"), path);
@@ -165,12 +235,11 @@ done:
void set_diffopt_flags_from_submodule_config(struct diff_options *diffopt,
const char *path)
{
- struct string_list_item *path_option, *ignore_option;
- path_option = unsorted_string_list_lookup(&config_name_for_path, path);
- if (path_option) {
- ignore_option = unsorted_string_list_lookup(&config_ignore_for_name, path_option->util);
- if (ignore_option)
- handle_ignore_submodules_arg(diffopt, ignore_option->util);
+ const char *name = get_name_for_path(path);
+ if (name) {
+ const char *ignore = get_ignore_for_name(name);
+ if (ignore)
+ handle_ignore_submodules_arg(diffopt, ignore);
else if (gitmodules_is_unmerged)
DIFF_OPT_SET(diffopt, IGNORE_SUBMODULES);
}
@@ -221,7 +290,6 @@ void gitmodules_config(void)
int parse_submodule_config_option(const char *var, const char *value)
{
- struct string_list_item *config;
const char *name, *key;
int namelen;
@@ -232,22 +300,14 @@ int parse_submodule_config_option(const char *var, const char *value)
if (!value)
return config_error_nonbool(var);
- config = unsorted_string_list_lookup(&config_name_for_path, value);
- if (config)
- free(config->util);
- else
- config = string_list_append(&config_name_for_path, xstrdup(value));
- config->util = xmemdupz(name, namelen);
+ set_name_for_path(value, name, namelen);
+
} else if (!strcmp(key, "fetchrecursesubmodules")) {
- char *name_cstr = xmemdupz(name, namelen);
- config = unsorted_string_list_lookup(&config_fetch_recurse_submodules_for_name, name_cstr);
- if (!config)
- config = string_list_append(&config_fetch_recurse_submodules_for_name, name_cstr);
- else
- free(name_cstr);
- config->util = (void *)(intptr_t)parse_fetch_recurse_submodules_arg(var, value);
+ int fetch_recurse = parse_fetch_recurse_submodules_arg(var, value);
+
+ set_fetch_recurse_for_name(name, namelen, fetch_recurse);
+
} else if (!strcmp(key, "ignore")) {
- char *name_cstr;
if (!value)
return config_error_nonbool(var);
@@ -258,14 +318,7 @@ int parse_submodule_config_option(const char *var, const char *value)
return 0;
}
- name_cstr = xmemdupz(name, namelen);
- config = unsorted_string_list_lookup(&config_ignore_for_name, name_cstr);
- if (config) {
- free(config->util);
- free(name_cstr);
- } else
- config = string_list_append(&config_ignore_for_name, name_cstr);
- config->util = xstrdup(value);
+ set_ignore_for_name(name, namelen, value);
return 0;
}
return 0;
@@ -647,7 +700,7 @@ static void calculate_changed_submodule_paths(void)
struct argv_array argv = ARGV_ARRAY_INIT;
/* No need to check if there are no submodules configured */
- if (!config_name_for_path.nr)
+ if (!get_name_for_path(NULL))
return;
init_revisions(&rev, NULL);
@@ -694,7 +747,7 @@ int fetch_populated_submodules(const struct argv_array *options,
int i, result = 0;
struct child_process cp = CHILD_PROCESS_INIT;
struct argv_array argv = ARGV_ARRAY_INIT;
- struct string_list_item *name_for_path;
+ const char *name_for_path;
const char *work_tree = get_git_work_tree();
if (!work_tree)
goto out;
@@ -725,18 +778,17 @@ int fetch_populated_submodules(const struct argv_array *options,
continue;
name = ce->name;
- name_for_path = unsorted_string_list_lookup(&config_name_for_path, ce->name);
+ name_for_path = get_name_for_path(ce->name);
if (name_for_path)
- name = name_for_path->util;
+ name = name_for_path;
default_argv = "yes";
if (command_line_option == RECURSE_SUBMODULES_DEFAULT) {
- struct string_list_item *fetch_recurse_submodules_option;
- fetch_recurse_submodules_option = unsorted_string_list_lookup(&config_fetch_recurse_submodules_for_name, name);
- if (fetch_recurse_submodules_option) {
- if ((intptr_t)fetch_recurse_submodules_option->util == RECURSE_SUBMODULES_OFF)
+ int fetch_recurse_option = get_fetch_recurse_for_name(name);
+ if (fetch_recurse_option != RECURSE_SUBMODULES_NONE) {
+ if (fetch_recurse_option == RECURSE_SUBMODULES_OFF)
continue;
- if ((intptr_t)fetch_recurse_submodules_option->util == RECURSE_SUBMODULES_ON_DEMAND) {
+ if (fetch_recurse_option == RECURSE_SUBMODULES_ON_DEMAND) {
if (!unsorted_string_list_lookup(&changed_submodule_paths, ce->name))
continue;
default_argv = "on-demand";
--
2.5.0.330.g130be8e.dirty
^ permalink raw reply related [flat|nested] 19+ messages in thread* [PATCH 3/7] submodule: use new config API for worktree configurations
2015-08-18 0:21 [PATCH 0/7] Submodule improvements Stefan Beller
2015-08-18 0:21 ` [PATCH 1/7] submodule: implement a config API for lookup of .gitmodules values Stefan Beller
2015-08-18 0:21 ` [PATCH 2/7] submodule: extract functions for config set and lookup Stefan Beller
@ 2015-08-18 0:21 ` Stefan Beller
2015-08-18 0:22 ` [PATCH 4/7] submodule: Allow errornous values for the fetchrecursesubmodules option Stefan Beller
` (4 subsequent siblings)
7 siblings, 0 replies; 19+ messages in thread
From: Stefan Beller @ 2015-08-18 0:21 UTC (permalink / raw)
To: git; +Cc: gitster, Jens.Lehmann, hvoigt, Stefan Beller
From: Heiko Voigt <hvoigt@hvoigt.net>
We remove the extracted functions and directly parse into and read out
of the cache. This allows us to have one unified way of accessing
submodule configuration values specific to single submodules. Regardless
whether we need to access a configuration from history or from the
worktree.
Signed-off-by: Heiko Voigt <hvoigt@hvoigt.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Stefan Beller <sbeller@google.com>
---
Documentation/technical/api-submodule-config.txt | 19 ++-
builtin/checkout.c | 1 +
diff.c | 1 +
submodule-config.c | 12 ++
submodule-config.h | 1 +
submodule.c | 160 ++++-------------------
submodule.h | 1 -
t/t7411-submodule-config.sh | 37 +++++-
test-submodule-config.c | 10 ++
9 files changed, 104 insertions(+), 138 deletions(-)
diff --git a/Documentation/technical/api-submodule-config.txt b/Documentation/technical/api-submodule-config.txt
index 1fbde41..941fa17 100644
--- a/Documentation/technical/api-submodule-config.txt
+++ b/Documentation/technical/api-submodule-config.txt
@@ -10,10 +10,18 @@ submodule path or name.
Usage
-----
+To initialize the cache with configurations from the worktree the caller
+typically first calls `gitmodules_config()` to read values from the
+worktree .gitmodules and then to overlay the local git config values
+`parse_submodule_config_option()` from the config parsing
+infrastructure.
+
The caller can look up information about submodules by using the
`submodule_from_path()` or `submodule_from_name()` functions. They return
a `struct submodule` which contains the values. The API automatically
-initializes and allocates the needed infrastructure on-demand.
+initializes and allocates the needed infrastructure on-demand. If the
+caller does only want to lookup values from revisions the initialization
+can be skipped.
If the internal cache might grow too big or when the caller is done with
the API, all internally cached values can be freed with submodule_free().
@@ -34,6 +42,11 @@ Functions
Use these to free the internally cached values.
+`int parse_submodule_config_option(const char *var, const char *value)`::
+
+ Can be passed to the config parsing infrastructure to parse
+ local (worktree) submodule configurations.
+
`const struct submodule *submodule_from_path(const unsigned char *commit_sha1, const char *path)`::
Lookup values for one submodule by its commit_sha1 and path.
@@ -42,4 +55,8 @@ Functions
The same as above but lookup by name.
+If given the null_sha1 as commit_sha1 the local configuration of a
+submodule will be returned (e.g. consolidated values from local git
+configuration and the .gitmodules file in the worktree).
+
For an example usage see test-submodule-config.c.
diff --git a/builtin/checkout.c b/builtin/checkout.c
index 9ff5ca4..7ea533e 100644
--- a/builtin/checkout.c
+++ b/builtin/checkout.c
@@ -18,6 +18,7 @@
#include "xdiff-interface.h"
#include "ll-merge.h"
#include "resolve-undo.h"
+#include "submodule-config.h"
#include "submodule.h"
static const char * const checkout_usage[] = {
diff --git a/diff.c b/diff.c
index 7deac90..8b382c2 100644
--- a/diff.c
+++ b/diff.c
@@ -13,6 +13,7 @@
#include "utf8.h"
#include "userdiff.h"
#include "sigchain.h"
+#include "submodule-config.h"
#include "submodule.h"
#include "ll-merge.h"
#include "string-list.h"
diff --git a/submodule-config.c b/submodule-config.c
index ea82edb..c64faf3 100644
--- a/submodule-config.c
+++ b/submodule-config.c
@@ -422,6 +422,18 @@ static void ensure_cache_init(void)
is_cache_init = 1;
}
+int parse_submodule_config_option(const char *var, const char *value)
+{
+ struct parse_config_parameter parameter;
+ parameter.cache = &cache;
+ parameter.commit_sha1 = NULL;
+ parameter.gitmodules_sha1 = null_sha1;
+ parameter.overwrite = 1;
+
+ ensure_cache_init();
+ return parse_config(var, value, ¶meter);
+}
+
const struct submodule *submodule_from_name(const unsigned char *commit_sha1,
const char *name)
{
diff --git a/submodule-config.h b/submodule-config.h
index cd68030..5fe44ce 100644
--- a/submodule-config.h
+++ b/submodule-config.h
@@ -18,6 +18,7 @@ struct submodule {
unsigned char gitmodules_sha1[20];
};
+int parse_submodule_config_option(const char *var, const char *value);
const struct submodule *submodule_from_name(const unsigned char *commit_sha1,
const char *name);
const struct submodule *submodule_from_path(const unsigned char *commit_sha1,
diff --git a/submodule.c b/submodule.c
index 307fa43..a382677 100644
--- a/submodule.c
+++ b/submodule.c
@@ -1,4 +1,5 @@
#include "cache.h"
+#include "submodule-config.h"
#include "submodule.h"
#include "dir.h"
#include "diff.h"
@@ -12,9 +13,6 @@
#include "argv-array.h"
#include "blob.h"
-static struct string_list config_name_for_path;
-static struct string_list config_fetch_recurse_submodules_for_name;
-static struct string_list config_ignore_for_name;
static int config_fetch_recurse_submodules = RECURSE_SUBMODULES_ON_DEMAND;
static struct string_list changed_submodule_paths;
static int initialized_fetch_ref_tips;
@@ -41,77 +39,6 @@ static int gitmodules_is_unmerged;
*/
static int gitmodules_is_modified;
-static const char *get_name_for_path(const char *path)
-{
- struct string_list_item *path_option;
- if (path == NULL) {
- if (config_name_for_path.nr > 0)
- return config_name_for_path.items[0].util;
- else
- return NULL;
- }
- path_option = unsorted_string_list_lookup(&config_name_for_path, path);
- if (!path_option)
- return NULL;
- return path_option->util;
-}
-
-static void set_name_for_path(const char *path, const char *name, int namelen)
-{
- struct string_list_item *config;
- config = unsorted_string_list_lookup(&config_name_for_path, path);
- if (config)
- free(config->util);
- else
- config = string_list_append(&config_name_for_path, xstrdup(path));
- config->util = xmemdupz(name, namelen);
-}
-
-static const char *get_ignore_for_name(const char *name)
-{
- struct string_list_item *ignore_option;
- ignore_option = unsorted_string_list_lookup(&config_ignore_for_name, name);
- if (!ignore_option)
- return NULL;
-
- return ignore_option->util;
-}
-
-static void set_ignore_for_name(const char *name, int namelen, const char *ignore)
-{
- struct string_list_item *config;
- char *name_cstr = xmemdupz(name, namelen);
- config = unsorted_string_list_lookup(&config_ignore_for_name, name_cstr);
- if (config) {
- free(config->util);
- free(name_cstr);
- } else
- config = string_list_append(&config_ignore_for_name, name_cstr);
- config->util = xstrdup(ignore);
-}
-
-static int get_fetch_recurse_for_name(const char *name)
-{
- struct string_list_item *fetch_recurse;
- fetch_recurse = unsorted_string_list_lookup(&config_fetch_recurse_submodules_for_name, name);
- if (!fetch_recurse)
- return RECURSE_SUBMODULES_NONE;
-
- return (intptr_t) fetch_recurse->util;
-}
-
-static void set_fetch_recurse_for_name(const char *name, int namelen, int fetch_recurse)
-{
- struct string_list_item *config;
- char *name_cstr = xmemdupz(name, namelen);
- config = unsorted_string_list_lookup(&config_fetch_recurse_submodules_for_name, name_cstr);
- if (!config)
- config = string_list_append(&config_fetch_recurse_submodules_for_name, name_cstr);
- else
- free(name_cstr);
- config->util = (void *)(intptr_t) fetch_recurse;
-}
-
int is_staging_gitmodules_ok(void)
{
return !gitmodules_is_modified;
@@ -125,7 +52,7 @@ int is_staging_gitmodules_ok(void)
int update_path_in_gitmodules(const char *oldpath, const char *newpath)
{
struct strbuf entry = STRBUF_INIT;
- const char *path;
+ const struct submodule *submodule;
if (!file_exists(".gitmodules")) /* Do nothing without .gitmodules */
return -1;
@@ -133,13 +60,13 @@ int update_path_in_gitmodules(const char *oldpath, const char *newpath)
if (gitmodules_is_unmerged)
die(_("Cannot change unmerged .gitmodules, resolve merge conflicts first"));
- path = get_name_for_path(oldpath);
- if (!path) {
+ submodule = submodule_from_path(null_sha1, oldpath);
+ if (!submodule || !submodule->name) {
warning(_("Could not find section in .gitmodules where path=%s"), oldpath);
return -1;
}
strbuf_addstr(&entry, "submodule.");
- strbuf_addstr(&entry, path);
+ strbuf_addstr(&entry, submodule->name);
strbuf_addstr(&entry, ".path");
if (git_config_set_in_file(".gitmodules", entry.buf, newpath) < 0) {
/* Maybe the user already did that, don't error out here */
@@ -159,7 +86,7 @@ int update_path_in_gitmodules(const char *oldpath, const char *newpath)
int remove_path_from_gitmodules(const char *path)
{
struct strbuf sect = STRBUF_INIT;
- const char *path_option;
+ const struct submodule *submodule;
if (!file_exists(".gitmodules")) /* Do nothing without .gitmodules */
return -1;
@@ -167,13 +94,13 @@ int remove_path_from_gitmodules(const char *path)
if (gitmodules_is_unmerged)
die(_("Cannot change unmerged .gitmodules, resolve merge conflicts first"));
- path_option = get_name_for_path(path);
- if (!path_option) {
+ submodule = submodule_from_path(null_sha1, path);
+ if (!submodule || !submodule->name) {
warning(_("Could not find section in .gitmodules where path=%s"), path);
return -1;
}
strbuf_addstr(§, "submodule.");
- strbuf_addstr(§, path_option);
+ strbuf_addstr(§, submodule->name);
if (git_config_rename_section_in_file(".gitmodules", sect.buf, NULL) < 0) {
/* Maybe the user already did that, don't error out here */
warning(_("Could not remove .gitmodules entry for %s"), path);
@@ -235,11 +162,10 @@ done:
void set_diffopt_flags_from_submodule_config(struct diff_options *diffopt,
const char *path)
{
- const char *name = get_name_for_path(path);
- if (name) {
- const char *ignore = get_ignore_for_name(name);
- if (ignore)
- handle_ignore_submodules_arg(diffopt, ignore);
+ const struct submodule *submodule = submodule_from_path(null_sha1, path);
+ if (submodule) {
+ if (submodule->ignore)
+ handle_ignore_submodules_arg(diffopt, submodule->ignore);
else if (gitmodules_is_unmerged)
DIFF_OPT_SET(diffopt, IGNORE_SUBMODULES);
}
@@ -288,42 +214,6 @@ void gitmodules_config(void)
}
}
-int parse_submodule_config_option(const char *var, const char *value)
-{
- const char *name, *key;
- int namelen;
-
- if (parse_config_key(var, "submodule", &name, &namelen, &key) < 0 || !name)
- return 0;
-
- if (!strcmp(key, "path")) {
- if (!value)
- return config_error_nonbool(var);
-
- set_name_for_path(value, name, namelen);
-
- } else if (!strcmp(key, "fetchrecursesubmodules")) {
- int fetch_recurse = parse_fetch_recurse_submodules_arg(var, value);
-
- set_fetch_recurse_for_name(name, namelen, fetch_recurse);
-
- } else if (!strcmp(key, "ignore")) {
-
- if (!value)
- return config_error_nonbool(var);
-
- if (strcmp(value, "untracked") && strcmp(value, "dirty") &&
- strcmp(value, "all") && strcmp(value, "none")) {
- warning("Invalid parameter \"%s\" for config option \"submodule.%s.ignore\"", value, var);
- return 0;
- }
-
- set_ignore_for_name(name, namelen, value);
- return 0;
- }
- return 0;
-}
-
void handle_ignore_submodules_arg(struct diff_options *diffopt,
const char *arg)
{
@@ -700,7 +590,7 @@ static void calculate_changed_submodule_paths(void)
struct argv_array argv = ARGV_ARRAY_INIT;
/* No need to check if there are no submodules configured */
- if (!get_name_for_path(NULL))
+ if (!submodule_from_path(NULL, NULL))
return;
init_revisions(&rev, NULL);
@@ -747,7 +637,6 @@ int fetch_populated_submodules(const struct argv_array *options,
int i, result = 0;
struct child_process cp = CHILD_PROCESS_INIT;
struct argv_array argv = ARGV_ARRAY_INIT;
- const char *name_for_path;
const char *work_tree = get_git_work_tree();
if (!work_tree)
goto out;
@@ -772,23 +661,26 @@ int fetch_populated_submodules(const struct argv_array *options,
struct strbuf submodule_git_dir = STRBUF_INIT;
struct strbuf submodule_prefix = STRBUF_INIT;
const struct cache_entry *ce = active_cache[i];
- const char *git_dir, *name, *default_argv;
+ const char *git_dir, *default_argv;
+ const struct submodule *submodule;
if (!S_ISGITLINK(ce->ce_mode))
continue;
- name = ce->name;
- name_for_path = get_name_for_path(ce->name);
- if (name_for_path)
- name = name_for_path;
+ submodule = submodule_from_path(null_sha1, ce->name);
+ if (!submodule)
+ submodule = submodule_from_name(null_sha1, ce->name);
default_argv = "yes";
if (command_line_option == RECURSE_SUBMODULES_DEFAULT) {
- int fetch_recurse_option = get_fetch_recurse_for_name(name);
- if (fetch_recurse_option != RECURSE_SUBMODULES_NONE) {
- if (fetch_recurse_option == RECURSE_SUBMODULES_OFF)
+ if (submodule &&
+ submodule->fetch_recurse !=
+ RECURSE_SUBMODULES_NONE) {
+ if (submodule->fetch_recurse ==
+ RECURSE_SUBMODULES_OFF)
continue;
- if (fetch_recurse_option == RECURSE_SUBMODULES_ON_DEMAND) {
+ if (submodule->fetch_recurse ==
+ RECURSE_SUBMODULES_ON_DEMAND) {
if (!unsorted_string_list_lookup(&changed_submodule_paths, ce->name))
continue;
default_argv = "on-demand";
diff --git a/submodule.h b/submodule.h
index 920fef3..547219d 100644
--- a/submodule.h
+++ b/submodule.h
@@ -20,7 +20,6 @@ void set_diffopt_flags_from_submodule_config(struct diff_options *diffopt,
const char *path);
int submodule_config(const char *var, const char *value, void *cb);
void gitmodules_config(void);
-int parse_submodule_config_option(const char *var, const char *value);
void handle_ignore_submodules_arg(struct diff_options *diffopt, const char *);
int parse_fetch_recurse_submodules_arg(const char *opt, const char *arg);
void show_submodule_summary(FILE *f, const char *path,
diff --git a/t/t7411-submodule-config.sh b/t/t7411-submodule-config.sh
index 2602bc5..7229978 100755
--- a/t/t7411-submodule-config.sh
+++ b/t/t7411-submodule-config.sh
@@ -5,8 +5,8 @@
test_description='Test submodules config cache infrastructure
-This test verifies that parsing .gitmodules configuration directly
-from the database works.
+This test verifies that parsing .gitmodules configurations directly
+from the database and from the worktree works.
'
TEST_NO_CREATE_REPO=1
@@ -82,4 +82,37 @@ test_expect_success 'error in one submodule config lets continue' '
)
'
+cat >super/expect_url <<EOF
+Submodule url: 'git@somewhere.else.net:a.git' for path 'b'
+Submodule url: 'git@somewhere.else.net:submodule.git' for path 'submodule'
+EOF
+
+cat >super/expect_local_path <<EOF
+Submodule name: 'a' for path 'c'
+Submodule name: 'submodule' for path 'submodule'
+EOF
+
+test_expect_success 'reading of local configuration' '
+ (cd super &&
+ old_a=$(git config submodule.a.url) &&
+ old_submodule=$(git config submodule.submodule.url) &&
+ git config submodule.a.url git@somewhere.else.net:a.git &&
+ git config submodule.submodule.url git@somewhere.else.net:submodule.git &&
+ test-submodule-config --url \
+ "" b \
+ "" submodule \
+ >actual &&
+ test_cmp expect_url actual &&
+ git config submodule.a.path c &&
+ test-submodule-config \
+ "" c \
+ "" submodule \
+ >actual &&
+ test_cmp expect_local_path actual &&
+ git config submodule.a.url $old_a &&
+ git config submodule.submodule.url $old_submodule &&
+ git config --unset submodule.a.path c
+ )
+'
+
test_done
diff --git a/test-submodule-config.c b/test-submodule-config.c
index f3c3918..dab8c27 100644
--- a/test-submodule-config.c
+++ b/test-submodule-config.c
@@ -1,5 +1,6 @@
#include "cache.h"
#include "submodule-config.h"
+#include "submodule.h"
static void die_usage(int argc, char **argv, const char *msg)
{
@@ -8,6 +9,11 @@ static void die_usage(int argc, char **argv, const char *msg)
exit(1);
}
+static int git_test_config(const char *var, const char *value, void *cb)
+{
+ return parse_submodule_config_option(var, value);
+}
+
int main(int argc, char **argv)
{
char **arg = argv;
@@ -29,6 +35,10 @@ int main(int argc, char **argv)
if (my_argc % 2 != 0)
die_usage(argc, argv, "Wrong number of arguments.");
+ setup_git_directory();
+ gitmodules_config();
+ git_config(git_test_config, NULL);
+
while (*arg) {
unsigned char commit_sha1[20];
const struct submodule *submodule;
--
2.5.0.330.g130be8e.dirty
^ permalink raw reply related [flat|nested] 19+ messages in thread* [PATCH 4/7] submodule: Allow errornous values for the fetchrecursesubmodules option
2015-08-18 0:21 [PATCH 0/7] Submodule improvements Stefan Beller
` (2 preceding siblings ...)
2015-08-18 0:21 ` [PATCH 3/7] submodule: use new config API for worktree configurations Stefan Beller
@ 2015-08-18 0:22 ` Stefan Beller
2015-08-19 18:09 ` Junio C Hamano
2015-08-18 0:22 ` [PATCH 5/7] submodule: implement `module_list` as a builtin helper Stefan Beller
` (3 subsequent siblings)
7 siblings, 1 reply; 19+ messages in thread
From: Stefan Beller @ 2015-08-18 0:22 UTC (permalink / raw)
To: git; +Cc: gitster, Jens.Lehmann, hvoigt, Stefan Beller
From: Heiko Voigt <hvoigt@hvoigt.net>
We should not die when reading the submodule config cache since the user
might not be able to get out of that situation when the configuration is
part of the history.
We should handle this condition later when the value is about to be
used.
Signed-off-by: Heiko Voigt <hvoigt@hvoigt.net>
Signed-off-by: Stefan Beller <sbeller@google.com>
---
builtin/fetch.c | 1 +
submodule-config.c | 29 ++++++++++++++++++++++++++++-
submodule-config.h | 1 +
submodule.c | 15 ---------------
submodule.h | 2 +-
t/t7411-submodule-config.sh | 35 +++++++++++++++++++++++++++++++++++
6 files changed, 66 insertions(+), 17 deletions(-)
diff --git a/builtin/fetch.c b/builtin/fetch.c
index df16d0a..ee1f1a9 100644
--- a/builtin/fetch.c
+++ b/builtin/fetch.c
@@ -11,6 +11,7 @@
#include "run-command.h"
#include "parse-options.h"
#include "sigchain.h"
+#include "submodule-config.h"
#include "submodule.h"
#include "connected.h"
#include "argv-array.h"
diff --git a/submodule-config.c b/submodule-config.c
index c64faf3..393de53 100644
--- a/submodule-config.c
+++ b/submodule-config.c
@@ -204,6 +204,30 @@ static struct submodule *lookup_or_create_by_name(struct submodule_cache *cache,
return submodule;
}
+static int parse_fetch_recurse(const char *opt, const char *arg,
+ int die_on_error)
+{
+ switch (git_config_maybe_bool(opt, arg)) {
+ case 1:
+ return RECURSE_SUBMODULES_ON;
+ case 0:
+ return RECURSE_SUBMODULES_OFF;
+ default:
+ if (!strcmp(arg, "on-demand"))
+ return RECURSE_SUBMODULES_ON_DEMAND;
+
+ if (die_on_error)
+ die("bad %s argument: %s", opt, arg);
+ else
+ return RECURSE_SUBMODULES_ERROR;
+ }
+}
+
+int parse_fetch_recurse_submodules_arg(const char *opt, const char *arg)
+{
+ return parse_fetch_recurse(opt, arg, 1);
+}
+
static void warn_multiple_config(const unsigned char *commit_sha1,
const char *name, const char *option)
{
@@ -255,6 +279,8 @@ static int parse_config(const char *var, const char *value, void *data)
submodule->path = strbuf_detach(&path, NULL);
cache_put_path(me->cache, submodule);
} else if (!strcmp(item.buf, "fetchrecursesubmodules")) {
+ /* when parsing worktree configurations we can die early */
+ int die_on_error = is_null_sha1(me->gitmodules_sha1);
if (!me->overwrite &&
submodule->fetch_recurse != RECURSE_SUBMODULES_NONE) {
warn_multiple_config(me->commit_sha1, submodule->name,
@@ -262,7 +288,8 @@ static int parse_config(const char *var, const char *value, void *data)
goto release_return;
}
- submodule->fetch_recurse = parse_fetch_recurse_submodules_arg(var, value);
+ submodule->fetch_recurse = parse_fetch_recurse(var, value,
+ die_on_error);
} else if (!strcmp(item.buf, "ignore")) {
struct strbuf ignore = STRBUF_INIT;
if (!me->overwrite && submodule->ignore != NULL) {
diff --git a/submodule-config.h b/submodule-config.h
index 5fe44ce..9061e4e 100644
--- a/submodule-config.h
+++ b/submodule-config.h
@@ -18,6 +18,7 @@ struct submodule {
unsigned char gitmodules_sha1[20];
};
+int parse_fetch_recurse_submodules_arg(const char *opt, const char *arg);
int parse_submodule_config_option(const char *var, const char *value);
const struct submodule *submodule_from_name(const unsigned char *commit_sha1,
const char *name);
diff --git a/submodule.c b/submodule.c
index a382677..9fcc86f 100644
--- a/submodule.c
+++ b/submodule.c
@@ -288,21 +288,6 @@ static void print_submodule_summary(struct rev_info *rev, FILE *f,
strbuf_release(&sb);
}
-int parse_fetch_recurse_submodules_arg(const char *opt, const char *arg)
-{
- switch (git_config_maybe_bool(opt, arg)) {
- case 1:
- return RECURSE_SUBMODULES_ON;
- case 0:
- return RECURSE_SUBMODULES_OFF;
- default:
- if (!strcmp(arg, "on-demand"))
- return RECURSE_SUBMODULES_ON_DEMAND;
- /* TODO: remove the die for history parsing here */
- die("bad %s argument: %s", opt, arg);
- }
-}
-
void show_submodule_summary(FILE *f, const char *path,
const char *line_prefix,
unsigned char one[20], unsigned char two[20],
diff --git a/submodule.h b/submodule.h
index 547219d..5507c3d 100644
--- a/submodule.h
+++ b/submodule.h
@@ -5,6 +5,7 @@ struct diff_options;
struct argv_array;
enum {
+ RECURSE_SUBMODULES_ERROR = -3,
RECURSE_SUBMODULES_NONE = -2,
RECURSE_SUBMODULES_ON_DEMAND = -1,
RECURSE_SUBMODULES_OFF = 0,
@@ -21,7 +22,6 @@ void set_diffopt_flags_from_submodule_config(struct diff_options *diffopt,
int submodule_config(const char *var, const char *value, void *cb);
void gitmodules_config(void);
void handle_ignore_submodules_arg(struct diff_options *diffopt, const char *);
-int parse_fetch_recurse_submodules_arg(const char *opt, const char *arg);
void show_submodule_summary(FILE *f, const char *path,
const char *line_prefix,
unsigned char one[20], unsigned char two[20],
diff --git a/t/t7411-submodule-config.sh b/t/t7411-submodule-config.sh
index 7229978..fc97c33 100755
--- a/t/t7411-submodule-config.sh
+++ b/t/t7411-submodule-config.sh
@@ -115,4 +115,39 @@ test_expect_success 'reading of local configuration' '
)
'
+cat >super/expect_fetchrecurse_die.err <<EOF
+fatal: bad submodule.submodule.fetchrecursesubmodules argument: blabla
+EOF
+
+test_expect_success 'local error in fetchrecursesubmodule dies early' '
+ (cd super &&
+ git config submodule.submodule.fetchrecursesubmodules blabla &&
+ test_must_fail test-submodule-config \
+ "" b \
+ "" submodule \
+ >actual.out 2>actual.err &&
+ touch expect_fetchrecurse_die.out &&
+ test_cmp expect_fetchrecurse_die.out actual.out &&
+ test_cmp expect_fetchrecurse_die.err actual.err &&
+ git config --unset submodule.submodule.fetchrecursesubmodules
+ )
+'
+
+test_expect_success 'error in history in fetchrecursesubmodule lets continue' '
+ (cd super &&
+ git config -f .gitmodules \
+ submodule.submodule.fetchrecursesubmodules blabla &&
+ git add .gitmodules &&
+ git config --unset -f .gitmodules \
+ submodule.submodule.fetchrecursesubmodules &&
+ git commit -m "add error in fetchrecursesubmodules" &&
+ test-submodule-config \
+ HEAD b \
+ HEAD submodule \
+ >actual &&
+ test_cmp expect_error actual &&
+ git reset --hard HEAD^
+ )
+'
+
test_done
--
2.5.0.330.g130be8e.dirty
^ permalink raw reply related [flat|nested] 19+ messages in thread* Re: [PATCH 4/7] submodule: Allow errornous values for the fetchrecursesubmodules option
2015-08-18 0:22 ` [PATCH 4/7] submodule: Allow errornous values for the fetchrecursesubmodules option Stefan Beller
@ 2015-08-19 18:09 ` Junio C Hamano
0 siblings, 0 replies; 19+ messages in thread
From: Junio C Hamano @ 2015-08-19 18:09 UTC (permalink / raw)
To: Stefan Beller; +Cc: git, Jens.Lehmann, hvoigt
Stefan Beller <sbeller@google.com> writes:
> From: Heiko Voigt <hvoigt@hvoigt.net>
>
> We should not die when reading the submodule config cache since the user
> might not be able to get out of that situation when the configuration is
> part of the history.
>
> We should handle this condition later when the value is about to be
> used.
>
> Signed-off-by: Heiko Voigt <hvoigt@hvoigt.net>
> Signed-off-by: Stefan Beller <sbeller@google.com>
> ---
The retitle is good but we'd need to typofix erroneous there, I
think (will do so while queuing, no need to resend).
^ permalink raw reply [flat|nested] 19+ messages in thread
* [PATCH 5/7] submodule: implement `module_list` as a builtin helper
2015-08-18 0:21 [PATCH 0/7] Submodule improvements Stefan Beller
` (3 preceding siblings ...)
2015-08-18 0:22 ` [PATCH 4/7] submodule: Allow errornous values for the fetchrecursesubmodules option Stefan Beller
@ 2015-08-18 0:22 ` Stefan Beller
2015-08-19 18:17 ` Junio C Hamano
2015-08-18 0:22 ` [PATCH 6/7] submodule: implement `module_name` " Stefan Beller
` (2 subsequent siblings)
7 siblings, 1 reply; 19+ messages in thread
From: Stefan Beller @ 2015-08-18 0:22 UTC (permalink / raw)
To: git; +Cc: gitster, Jens.Lehmann, hvoigt, Stefan Beller
Most of the submodule operations work on a set of submodules.
Calculating and using this set is usually done via:
module_list "$@" | {
while read mode sha1 stage sm_path
do
# the actual operation
done
}
Currently the function `module_list` is implemented in the
git-submodule.sh as a shell script wrapping a perl script.
The rewrite is in C, such that it is faster and can later be
easily adapted when other functions are rewritten in C.
git-submodule.sh similar to the builtin commands will navigate
to the top most directory of the repository and keeping the
subdirectories as a variable. As the helper is called from
within the git-submodule.sh script, we are already navigated
to the root level, but the path arguments are stil relative
to the subdirectory we were in when calling git-submodule.sh.
That's why there is a `--prefix` option pointing to an alternative
path where to anchor relative path arguments.
Signed-off-by: Stefan Beller <sbeller@google.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
---
.gitignore | 1 +
Makefile | 1 +
builtin.h | 1 +
builtin/submodule--helper.c | 114 ++++++++++++++++++++++++++++++++++++++++++++
git-submodule.sh | 54 +++------------------
git.c | 1 +
6 files changed, 124 insertions(+), 48 deletions(-)
create mode 100644 builtin/submodule--helper.c
diff --git a/.gitignore b/.gitignore
index 4fd81ba..1c2f832 100644
--- a/.gitignore
+++ b/.gitignore
@@ -155,6 +155,7 @@
/git-status
/git-stripspace
/git-submodule
+/git-submodule--helper
/git-svn
/git-symbolic-ref
/git-tag
diff --git a/Makefile b/Makefile
index 24b636d..d434e73 100644
--- a/Makefile
+++ b/Makefile
@@ -901,6 +901,7 @@ BUILTIN_OBJS += builtin/shortlog.o
BUILTIN_OBJS += builtin/show-branch.o
BUILTIN_OBJS += builtin/show-ref.o
BUILTIN_OBJS += builtin/stripspace.o
+BUILTIN_OBJS += builtin/submodule--helper.o
BUILTIN_OBJS += builtin/symbolic-ref.o
BUILTIN_OBJS += builtin/tag.o
BUILTIN_OBJS += builtin/unpack-file.o
diff --git a/builtin.h b/builtin.h
index 839483d..924e6c4 100644
--- a/builtin.h
+++ b/builtin.h
@@ -119,6 +119,7 @@ extern int cmd_show(int argc, const char **argv, const char *prefix);
extern int cmd_show_branch(int argc, const char **argv, const char *prefix);
extern int cmd_status(int argc, const char **argv, const char *prefix);
extern int cmd_stripspace(int argc, const char **argv, const char *prefix);
+extern int cmd_submodule__helper(int argc, const char **argv, const char *prefix);
extern int cmd_symbolic_ref(int argc, const char **argv, const char *prefix);
extern int cmd_tag(int argc, const char **argv, const char *prefix);
extern int cmd_tar_tree(int argc, const char **argv, const char *prefix);
diff --git a/builtin/submodule--helper.c b/builtin/submodule--helper.c
new file mode 100644
index 0000000..610ec51
--- /dev/null
+++ b/builtin/submodule--helper.c
@@ -0,0 +1,114 @@
+#include "builtin.h"
+#include "cache.h"
+#include "parse-options.h"
+#include "quote.h"
+#include "pathspec.h"
+#include "dir.h"
+#include "utf8.h"
+
+static const struct cache_entry **ce_entries;
+static int ce_alloc, ce_used;
+static const char *alternative_path;
+
+static int module_list_compute(int argc, const char **argv,
+ const char *prefix,
+ struct pathspec *pathspec)
+{
+ int i;
+ char *max_prefix, *ps_matched = NULL;
+ int max_prefix_len;
+ parse_pathspec(pathspec, 0,
+ PATHSPEC_PREFER_FULL |
+ PATHSPEC_STRIP_SUBMODULE_SLASH_CHEAP,
+ prefix, argv);
+
+ /* Find common prefix for all pathspec's */
+ max_prefix = common_prefix(pathspec);
+ max_prefix_len = max_prefix ? strlen(max_prefix) : 0;
+
+ if (pathspec->nr)
+ ps_matched = xcalloc(1, pathspec->nr);
+
+ if (read_cache() < 0)
+ die("index file corrupt");
+
+ for (i = 0; i < active_nr; i++) {
+ const struct cache_entry *ce = active_cache[i];
+
+ if (!match_pathspec(pathspec, ce->name, ce_namelen(ce),
+ max_prefix_len, ps_matched,
+ S_ISGITLINK(ce->ce_mode) | S_ISDIR(ce->ce_mode)))
+ continue;
+
+ if (S_ISGITLINK(ce->ce_mode)) {
+ ALLOC_GROW(ce_entries, ce_used + 1, ce_alloc);
+ ce_entries[ce_used++] = 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++;
+ }
+ free(max_prefix);
+
+ if (ps_matched && report_path_error(ps_matched, pathspec, prefix))
+ return -1;
+
+ return 0;
+}
+
+static int module_list(int argc, const char **argv, const char *prefix)
+{
+ int i;
+ static struct pathspec pathspec;
+
+ struct option module_list_options[] = {
+ OPT_STRING(0, "prefix", &alternative_path,
+ N_("path"),
+ N_("alternative anchor for relative paths")),
+ OPT_END()
+ };
+
+ static const char * const git_submodule_helper_usage[] = {
+ N_("git submodule--helper module_list [--prefix=<path>] [<path>...]"),
+ NULL
+ };
+
+ argc = parse_options(argc, argv, prefix, module_list_options,
+ git_submodule_helper_usage, 0);
+
+ if (module_list_compute(argc, argv, alternative_path
+ ? alternative_path
+ : prefix, &pathspec) < 0) {
+ printf("#unmatched\n");
+ return 1;
+ }
+
+ for (i = 0; i < ce_used; i++) {
+ const struct cache_entry *ce = ce_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;
+}
+
+int cmd_submodule__helper(int argc, const char **argv, const char *prefix)
+{
+ if (argc < 2)
+ goto usage;
+
+ if (!strcmp(argv[1], "module_list"))
+ return module_list(argc - 1, argv + 1, prefix);
+
+usage:
+ usage("git submodule--helper module_list\n");
+}
diff --git a/git-submodule.sh b/git-submodule.sh
index 36797c3..af9ecef 100755
--- a/git-submodule.sh
+++ b/git-submodule.sh
@@ -145,48 +145,6 @@ relative_path ()
echo "$result$target"
}
-#
-# Get submodule info for registered submodules
-# $@ = path to limit submodule list
-#
-module_list()
-{
- eval "set $(git rev-parse --sq --prefix "$wt_prefix" -- "$@")"
- (
- git ls-files -z --error-unmatch --stage -- "$@" ||
- echo "unmatched pathspec exists"
- ) |
- @@PERL@@ -e '
- my %unmerged = ();
- my ($null_sha1) = ("0" x 40);
- my @out = ();
- my $unmatched = 0;
- $/ = "\0";
- while (<STDIN>) {
- if (/^unmatched pathspec/) {
- $unmatched = 1;
- next;
- }
- chomp;
- my ($mode, $sha1, $stage, $path) =
- /^([0-7]+) ([0-9a-f]{40}) ([0-3])\t(.*)$/;
- next unless $mode eq "160000";
- if ($stage ne "0") {
- if (!$unmerged{$path}++) {
- push @out, "$mode $null_sha1 U\t$path\n";
- }
- next;
- }
- push @out, "$_\n";
- }
- if ($unmatched) {
- print "#unmatched\n";
- } else {
- print for (@out);
- }
- '
-}
-
die_if_unmatched ()
{
if test "$1" = "#unmatched"
@@ -532,7 +490,7 @@ cmd_foreach()
# command in the subshell (and a recursive call to this function)
exec 3<&0
- module_list |
+ git submodule--helper module_list --prefix "$wt_prefix"|
while read mode sha1 stage sm_path
do
die_if_unmatched "$mode"
@@ -592,7 +550,7 @@ cmd_init()
shift
done
- module_list "$@" |
+ git submodule--helper module_list --prefix "$wt_prefix" "$@" |
while read mode sha1 stage sm_path
do
die_if_unmatched "$mode"
@@ -674,7 +632,7 @@ cmd_deinit()
die "$(eval_gettext "Use '.' if you really want to deinitialize all submodules")"
fi
- module_list "$@" |
+ git submodule--helper module_list --prefix "$wt_prefix" "$@" |
while read mode sha1 stage sm_path
do
die_if_unmatched "$mode"
@@ -790,7 +748,7 @@ cmd_update()
fi
cloned_modules=
- module_list "$@" | {
+ git submodule--helper module_list --prefix "$wt_prefix" "$@" | {
err=
while read mode sha1 stage sm_path
do
@@ -1222,7 +1180,7 @@ cmd_status()
shift
done
- module_list "$@" |
+ git submodule--helper module_list --prefix "$wt_prefix" "$@" |
while read mode sha1 stage sm_path
do
die_if_unmatched "$mode"
@@ -1299,7 +1257,7 @@ cmd_sync()
esac
done
cd_to_toplevel
- module_list "$@" |
+ git submodule--helper module_list --prefix "$wt_prefix" "$@" |
while read mode sha1 stage sm_path
do
die_if_unmatched "$mode"
diff --git a/git.c b/git.c
index 55c327c..deecba0 100644
--- a/git.c
+++ b/git.c
@@ -469,6 +469,7 @@ static struct cmd_struct commands[] = {
{ "stage", cmd_add, RUN_SETUP | NEED_WORK_TREE },
{ "status", cmd_status, RUN_SETUP | NEED_WORK_TREE },
{ "stripspace", cmd_stripspace },
+ { "submodule--helper", cmd_submodule__helper, RUN_SETUP },
{ "symbolic-ref", cmd_symbolic_ref, RUN_SETUP },
{ "tag", cmd_tag, RUN_SETUP },
{ "unpack-file", cmd_unpack_file, RUN_SETUP },
--
2.5.0.330.g130be8e.dirty
^ permalink raw reply related [flat|nested] 19+ messages in thread* Re: [PATCH 5/7] submodule: implement `module_list` as a builtin helper
2015-08-18 0:22 ` [PATCH 5/7] submodule: implement `module_list` as a builtin helper Stefan Beller
@ 2015-08-19 18:17 ` Junio C Hamano
2015-08-19 18:22 ` Junio C Hamano
2015-08-19 18:23 ` Stefan Beller
0 siblings, 2 replies; 19+ messages in thread
From: Junio C Hamano @ 2015-08-19 18:17 UTC (permalink / raw)
To: Stefan Beller; +Cc: git, Jens.Lehmann, hvoigt
Stefan Beller <sbeller@google.com> writes:
> +static int module_list_compute(int argc, const char **argv,
> + const char *prefix,
> + struct pathspec *pathspec)
> +{
> + int i;
> + char *max_prefix, *ps_matched = NULL;
> + int max_prefix_len;
> + parse_pathspec(pathspec, 0,
> + PATHSPEC_PREFER_FULL |
> + PATHSPEC_STRIP_SUBMODULE_SLASH_CHEAP,
> + prefix, argv);
> +
> + /* Find common prefix for all pathspec's */
> + max_prefix = common_prefix(pathspec);
> + max_prefix_len = max_prefix ? strlen(max_prefix) : 0;
> +
> + if (pathspec->nr)
> + ps_matched = xcalloc(1, pathspec->nr);
Micronit. Even though multiplication is commutative, the order of
arguments to xcalloc() looks odd. It lets you say "I want an array
with nmemb elements, and each of its is size-bytes long" by giving
it nmemb and then size.
No need to resend; will fix it up while queuing.
Thanks.
^ permalink raw reply [flat|nested] 19+ messages in thread* Re: [PATCH 5/7] submodule: implement `module_list` as a builtin helper
2015-08-19 18:17 ` Junio C Hamano
@ 2015-08-19 18:22 ` Junio C Hamano
2015-08-19 18:25 ` Stefan Beller
2015-08-19 18:23 ` Stefan Beller
1 sibling, 1 reply; 19+ messages in thread
From: Junio C Hamano @ 2015-08-19 18:22 UTC (permalink / raw)
To: Stefan Beller; +Cc: git, Jens.Lehmann, hvoigt
Junio C Hamano <gitster@pobox.com> writes:
> Micronit. Even though multiplication is commutative, the order of
> arguments to xcalloc() looks odd. It lets you say "I want an array
> with nmemb elements, and each of its is size-bytes long" by giving
> it nmemb and then size.
Unrelated tangent, but while I have output from "git grep 'calloc.*pathspec'"
on my screen... ;-)
builtin/checkout.c | 2 +-
builtin/ls-files.c | 2 +-
2 files changed, 2 insertions(+), 2 deletions(-)
diff --git a/builtin/checkout.c b/builtin/checkout.c
index 7ea533e..e3b28e4 100644
--- a/builtin/checkout.c
+++ b/builtin/checkout.c
@@ -283,7 +283,7 @@ static int checkout_paths(const struct checkout_opts *opts,
if (opts->source_tree)
read_tree_some(opts->source_tree, &opts->pathspec);
- ps_matched = xcalloc(1, opts->pathspec.nr);
+ ps_matched = xcalloc(opts->pathspec.nr, 1);
/*
* Make sure all pathspecs participated in locating the paths
diff --git a/builtin/ls-files.c b/builtin/ls-files.c
index 6fa2205..b6a7cb0 100644
--- a/builtin/ls-files.c
+++ b/builtin/ls-files.c
@@ -516,7 +516,7 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
/* Treat unmatching pathspec elements as errors */
if (pathspec.nr && error_unmatch)
- ps_matched = xcalloc(1, pathspec.nr);
+ ps_matched = xcalloc(pathspec.nr, 1);
if ((dir.flags & DIR_SHOW_IGNORED) && !exc_given)
die("ls-files --ignored needs some exclude pattern");
^ permalink raw reply related [flat|nested] 19+ messages in thread* Re: [PATCH 5/7] submodule: implement `module_list` as a builtin helper
2015-08-19 18:22 ` Junio C Hamano
@ 2015-08-19 18:25 ` Stefan Beller
0 siblings, 0 replies; 19+ messages in thread
From: Stefan Beller @ 2015-08-19 18:25 UTC (permalink / raw)
To: Junio C Hamano; +Cc: git@vger.kernel.org, Jens Lehmann, Heiko Voigt
On Wed, Aug 19, 2015 at 11:22 AM, Junio C Hamano <gitster@pobox.com> wrote:
> Junio C Hamano <gitster@pobox.com> writes:
>
>> Micronit. Even though multiplication is commutative, the order of
>> arguments to xcalloc() looks odd. It lets you say "I want an array
>> with nmemb elements, and each of its is size-bytes long" by giving
>> it nmemb and then size.
>
> Unrelated tangent, but while I have output from "git grep 'calloc.*pathspec'"
> on my screen... ;-)
>
> builtin/checkout.c | 2 +-
> builtin/ls-files.c | 2 +-
> 2 files changed, 2 insertions(+), 2 deletions(-)
>
> diff --git a/builtin/checkout.c b/builtin/checkout.c
> index 7ea533e..e3b28e4 100644
> --- a/builtin/checkout.c
> +++ b/builtin/checkout.c
> @@ -283,7 +283,7 @@ static int checkout_paths(const struct checkout_opts *opts,
> if (opts->source_tree)
> read_tree_some(opts->source_tree, &opts->pathspec);
>
> - ps_matched = xcalloc(1, opts->pathspec.nr);
> + ps_matched = xcalloc(opts->pathspec.nr, 1);
>
> /*
> * Make sure all pathspecs participated in locating the paths
> diff --git a/builtin/ls-files.c b/builtin/ls-files.c
> index 6fa2205..b6a7cb0 100644
> --- a/builtin/ls-files.c
> +++ b/builtin/ls-files.c
> @@ -516,7 +516,7 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
>
> /* Treat unmatching pathspec elements as errors */
> if (pathspec.nr && error_unmatch)
> - ps_matched = xcalloc(1, pathspec.nr);
> + ps_matched = xcalloc(pathspec.nr, 1);
>
> if ((dir.flags & DIR_SHOW_IGNORED) && !exc_given)
> die("ls-files --ignored needs some exclude pattern");
Looks good to me.
^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: [PATCH 5/7] submodule: implement `module_list` as a builtin helper
2015-08-19 18:17 ` Junio C Hamano
2015-08-19 18:22 ` Junio C Hamano
@ 2015-08-19 18:23 ` Stefan Beller
1 sibling, 0 replies; 19+ messages in thread
From: Stefan Beller @ 2015-08-19 18:23 UTC (permalink / raw)
To: Junio C Hamano; +Cc: git@vger.kernel.org, Jens Lehmann, Heiko Voigt
On Wed, Aug 19, 2015 at 11:17 AM, Junio C Hamano <gitster@pobox.com> wrote:
> Stefan Beller <sbeller@google.com> writes:
>
>> +static int module_list_compute(int argc, const char **argv,
>> + const char *prefix,
>> + struct pathspec *pathspec)
>> +{
>> + int i;
>> + char *max_prefix, *ps_matched = NULL;
>> + int max_prefix_len;
>> + parse_pathspec(pathspec, 0,
>> + PATHSPEC_PREFER_FULL |
>> + PATHSPEC_STRIP_SUBMODULE_SLASH_CHEAP,
>> + prefix, argv);
>> +
>> + /* Find common prefix for all pathspec's */
>> + max_prefix = common_prefix(pathspec);
>> + max_prefix_len = max_prefix ? strlen(max_prefix) : 0;
>> +
>> + if (pathspec->nr)
>> + ps_matched = xcalloc(1, pathspec->nr);
>
> Micronit. Even though multiplication is commutative, the order of
> arguments to xcalloc() looks odd. It lets you say "I want an array
> with nmemb elements, and each of its is size-bytes long" by giving
> it nmemb and then size.
Thanks for pointing that out!
I think this would be an alignment issue in theory, if the items were larger and
the number of items not dividable by the size of items.
So because 1 char has no alignment problems, we can happily allocate
just one block of the member size here.
>
> No need to resend; will fix it up while queuing.
>
> Thanks.
^ permalink raw reply [flat|nested] 19+ messages in thread
* [PATCH 6/7] submodule: implement `module_name` as a builtin helper
2015-08-18 0:21 [PATCH 0/7] Submodule improvements Stefan Beller
` (4 preceding siblings ...)
2015-08-18 0:22 ` [PATCH 5/7] submodule: implement `module_list` as a builtin helper Stefan Beller
@ 2015-08-18 0:22 ` Stefan Beller
2015-08-18 0:22 ` [PATCH 7/7] submodule: implement `module_clone` " Stefan Beller
2015-08-18 0:38 ` [PATCH 0/7] Submodule improvements Stefan Beller
7 siblings, 0 replies; 19+ messages in thread
From: Stefan Beller @ 2015-08-18 0:22 UTC (permalink / raw)
To: git; +Cc: gitster, Jens.Lehmann, hvoigt, Stefan Beller
This implements the helper `module_name` in C instead of shell,
yielding a nice performance boost.
Before this patch, I measured a time (best out of three):
$ time ./t7400-submodule-basic.sh >/dev/null
real 0m11.066s
user 0m3.348s
sys 0m8.534s
With this patch applied I measured (also best out of three)
$ time ./t7400-submodule-basic.sh >/dev/null
real 0m10.063s
user 0m3.044s
sys 0m7.487s
Signed-off-by: Stefan Beller <sbeller@google.com>
---
builtin/submodule--helper.c | 28 +++++++++++++++++++++++++++-
git-submodule.sh | 32 +++++++-------------------------
2 files changed, 34 insertions(+), 26 deletions(-)
diff --git a/builtin/submodule--helper.c b/builtin/submodule--helper.c
index 610ec51..80d13f5 100644
--- a/builtin/submodule--helper.c
+++ b/builtin/submodule--helper.c
@@ -5,6 +5,9 @@
#include "pathspec.h"
#include "dir.h"
#include "utf8.h"
+#include "submodule.h"
+#include "submodule-config.h"
+#include "string-list.h"
static const struct cache_entry **ce_entries;
static int ce_alloc, ce_used;
@@ -101,6 +104,26 @@ static int module_list(int argc, const char **argv, const char *prefix)
return 0;
}
+static int module_name(int argc, const char **argv, const char *prefix)
+{
+ const char *name;
+ const struct submodule *sub;
+
+ if (argc != 1)
+ usage("git submodule--helper module_name <path>\n");
+
+ gitmodules_config();
+ sub = submodule_from_path(null_sha1, argv[0]);
+
+ if (!sub)
+ die("No submodule mapping found in .gitmodules for path '%s'", argv[0]);
+
+ name = sub->name;
+ printf("%s\n", name);
+
+ return 0;
+}
+
int cmd_submodule__helper(int argc, const char **argv, const char *prefix)
{
if (argc < 2)
@@ -109,6 +132,9 @@ int cmd_submodule__helper(int argc, const char **argv, const char *prefix)
if (!strcmp(argv[1], "module_list"))
return module_list(argc - 1, argv + 1, prefix);
+ if (!strcmp(argv[1], "module_name"))
+ return module_name(argc - 2, argv + 2, prefix);
+
usage:
- usage("git submodule--helper module_list\n");
+ usage("git submodule--helper [module_list module_name]\n");
}
diff --git a/git-submodule.sh b/git-submodule.sh
index af9ecef..e6ff38d 100755
--- a/git-submodule.sh
+++ b/git-submodule.sh
@@ -178,24 +178,6 @@ get_submodule_config () {
printf '%s' "${value:-$default}"
}
-
-#
-# Map submodule path to submodule name
-#
-# $1 = path
-#
-module_name()
-{
- # Do we have "submodule.<something>.path = $1" defined in .gitmodules file?
- sm_path="$1"
- re=$(printf '%s\n' "$1" | sed -e 's/[].[^$\\*]/\\&/g')
- name=$( git config -f .gitmodules --get-regexp '^submodule\..*\.path$' |
- sed -n -e 's|^submodule\.\(.*\)\.path '"$re"'$|\1|p' )
- test -z "$name" &&
- die "$(eval_gettext "No submodule mapping found in .gitmodules for path '\$sm_path'")"
- printf '%s\n' "$name"
-}
-
#
# Clone a submodule
#
@@ -498,7 +480,7 @@ cmd_foreach()
then
displaypath=$(relative_path "$sm_path")
say "$(eval_gettext "Entering '\$prefix\$displaypath'")"
- name=$(module_name "$sm_path")
+ name=$(git submodule--helper module_name "$sm_path")
(
prefix="$prefix$sm_path/"
clear_local_git_env
@@ -554,7 +536,7 @@ cmd_init()
while read mode sha1 stage sm_path
do
die_if_unmatched "$mode"
- name=$(module_name "$sm_path") || exit
+ name=$(git submodule--helper module_name "$sm_path") || exit
displaypath=$(relative_path "$sm_path")
@@ -636,7 +618,7 @@ cmd_deinit()
while read mode sha1 stage sm_path
do
die_if_unmatched "$mode"
- name=$(module_name "$sm_path") || exit
+ name=$(git submodule--helper module_name "$sm_path") || exit
displaypath=$(relative_path "$sm_path")
@@ -758,7 +740,7 @@ cmd_update()
echo >&2 "Skipping unmerged submodule $prefix$sm_path"
continue
fi
- name=$(module_name "$sm_path") || exit
+ name=$(git submodule--helper module_name "$sm_path") || exit
url=$(git config submodule."$name".url)
branch=$(get_submodule_config "$name" branch master)
if ! test -z "$update"
@@ -1022,7 +1004,7 @@ cmd_summary() {
# Respect the ignore setting for --for-status.
if test -n "$for_status"
then
- name=$(module_name "$sm_path")
+ name=$(git submodule--helper module_name "$sm_path")
ignore_config=$(get_submodule_config "$name" ignore none)
test $status != A && test $ignore_config = all && continue
fi
@@ -1184,7 +1166,7 @@ cmd_status()
while read mode sha1 stage sm_path
do
die_if_unmatched "$mode"
- name=$(module_name "$sm_path") || exit
+ name=$(git submodule--helper module_name "$sm_path") || exit
url=$(git config submodule."$name".url)
displaypath=$(relative_path "$prefix$sm_path")
if test "$stage" = U
@@ -1261,7 +1243,7 @@ cmd_sync()
while read mode sha1 stage sm_path
do
die_if_unmatched "$mode"
- name=$(module_name "$sm_path")
+ name=$(git submodule--helper module_name "$sm_path")
url=$(git config -f .gitmodules --get submodule."$name".url)
# Possibly a url relative to parent
--
2.5.0.330.g130be8e.dirty
^ permalink raw reply related [flat|nested] 19+ messages in thread* [PATCH 7/7] submodule: implement `module_clone` as a builtin helper
2015-08-18 0:21 [PATCH 0/7] Submodule improvements Stefan Beller
` (5 preceding siblings ...)
2015-08-18 0:22 ` [PATCH 6/7] submodule: implement `module_name` " Stefan Beller
@ 2015-08-18 0:22 ` Stefan Beller
2015-08-18 0:26 ` Stefan Beller
` (2 more replies)
2015-08-18 0:38 ` [PATCH 0/7] Submodule improvements Stefan Beller
7 siblings, 3 replies; 19+ messages in thread
From: Stefan Beller @ 2015-08-18 0:22 UTC (permalink / raw)
To: git; +Cc: gitster, Jens.Lehmann, hvoigt, Stefan Beller
`module_clone` is part of the update command, which I want to convert
to C next.
Signed-off-by: Stefan Beller <sbeller@google.com>
---
builtin/submodule--helper.c | 161 +++++++++++++++++++++++++++++++++++++++++++-
git-submodule.sh | 78 +--------------------
2 files changed, 162 insertions(+), 77 deletions(-)
diff --git a/builtin/submodule--helper.c b/builtin/submodule--helper.c
index 80d13f5..44ff935 100644
--- a/builtin/submodule--helper.c
+++ b/builtin/submodule--helper.c
@@ -8,6 +8,7 @@
#include "submodule.h"
#include "submodule-config.h"
#include "string-list.h"
+#include "run-command.h"
static const struct cache_entry **ce_entries;
static int ce_alloc, ce_used;
@@ -124,6 +125,156 @@ static int module_name(int argc, const char **argv, const char *prefix)
return 0;
}
+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 && strcmp(depth, "")) {
+ argv_array_push(&cp.args, "--depth");
+ argv_array_push(&cp.args, depth);
+ }
+ if (reference && strcmp(reference, "")) {
+ argv_array_push(&cp.args, "--reference");
+ argv_array_push(&cp.args, reference);
+ }
+ if (gitdir) {
+ argv_array_push(&cp.args, "--separate-git-dir");
+ argv_array_push(&cp.args, gitdir);
+ }
+ argv_array_push(&cp.args, url);
+ argv_array_push(&cp.args, path);
+
+ cp.git_cmd = 1;
+ cp.env = local_repo_env;
+
+ cp.no_stdin = 1;
+ cp.no_stdout = 1;
+ cp.no_stderr = 1;
+ return run_command(&cp);
+}
+
+/*
+ * Clone a submodule
+ *
+ * $1 = submodule path
+ * $2 = submodule name
+ * $3 = URL to clone
+ * $4 = reference repository to reuse (empty for independent)
+ * $5 = depth argument for shallow clones (empty for deep)
+ *
+ * Prior to calling, cmd_update checks that a possibly existing
+ * path is not a git repository.
+ * Likewise, cmd_add checks that path does not exist at all,
+ * since it is the location of a new submodule.
+ */
+static int module_clone(int argc, const char **argv, const char *prefix)
+{
+ const char *path = NULL, *name = NULL, *url = NULL, *reference = NULL, *depth = NULL;
+ int quiet = 0;
+ FILE *submodule_dot_git;
+ const char *sm_gitdir, *p;
+ struct strbuf rel_path = STRBUF_INIT;
+ struct strbuf sb = STRBUF_INIT;
+
+ struct option module_update_options[] = {
+ OPT_STRING(0, "prefix", &alternative_path,
+ 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_END()
+ };
+
+ static const char * const git_submodule_helper_usage[] = {
+ N_("git submodule--helper update [--prefix=<path>] [--quiet] [--remote] [-N|--no-fetch]"
+ "[-f|--force] [--rebase|--merge] [--reference <repository>]"
+ "[--depth <depth>] [--recursive] [--] [<path>...]"),
+ NULL
+ };
+
+ argc = parse_options(argc, argv, prefix, module_update_options,
+ git_submodule_helper_usage, 0);
+
+ if (getenv("GIT_QUIET"))
+ quiet = 1;
+
+ strbuf_addf(&sb, "%s/modules/%s", get_git_dir(), name);
+ sm_gitdir = strbuf_detach(&sb, NULL);
+ strbuf_reset(&sb);
+
+ if (!file_exists(sm_gitdir)) {
+ safe_create_leading_directories_const(sm_gitdir);
+ if (clone_submodule(path, sm_gitdir, url, depth, reference, quiet))
+ die(N_("Clone of '%s' into submodule path '%s' failed"),
+ url, path);
+ } else {
+ safe_create_leading_directories_const(path);
+ unlink(sm_gitdir);
+ }
+
+ /* Write a .git file in the submodule to redirect to the superproject. */
+ const char *t;
+ if (alternative_path && !strcmp(alternative_path, "")) {
+ t = relative_path(path, alternative_path, &sb);
+ strbuf_reset(&sb);
+ } else
+ t = path;
+
+ if (safe_create_leading_directories_const(t) < 0)
+ die("Could not create directory '%s'", t);
+
+ strbuf_addf(&sb, "%s/.git", t);
+
+ 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 ("Cannot open file '%s': %s", sb.buf, strerror(errno) );
+
+ fprintf(submodule_dot_git, "gitdir: %s\n",
+ relative_path(sm_gitdir, path, &rel_path));
+ if (fclose(submodule_dot_git))
+ die("Could not close file %s", sb.buf);
+ strbuf_reset(&sb);
+
+ /* Redirect the worktree of the submodule in the superprojects config */
+ if (!is_absolute_path(sm_gitdir)) {
+ char *s = (char*)sm_gitdir;
+ strbuf_addf(&sb, "%s/%s", xgetcwd(), sm_gitdir);
+ sm_gitdir = strbuf_detach(&sb, NULL);
+ strbuf_reset(&sb);
+ free(s);
+ }
+ strbuf_addf(&sb, "%s/%s", xgetcwd(), path);
+ t = relative_path(sb.buf, sm_gitdir, &rel_path);
+
+ 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", t);
+ strbuf_release(&sb);
+ return 0;
+}
+
int cmd_submodule__helper(int argc, const char **argv, const char *prefix)
{
if (argc < 2)
@@ -135,6 +286,14 @@ int cmd_submodule__helper(int argc, const char **argv, const char *prefix)
if (!strcmp(argv[1], "module_name"))
return module_name(argc - 2, argv + 2, prefix);
+ if (!strcmp(argv[1], "module_clone"))
+ return module_clone(argc - 1, argv + 1, prefix);
+ if (!strcmp(argv[1], "test")) {
+ struct strbuf sb = STRBUF_INIT;
+
+ relative_path(".git/modules/example", "init", &sb);
+ return 0;
+ }
usage:
- usage("git submodule--helper [module_list module_name]\n");
+ usage("git submodule--helper [module_list module_name module_clone]\n");
}
diff --git a/git-submodule.sh b/git-submodule.sh
index e6ff38d..6e8561e 100755
--- a/git-submodule.sh
+++ b/git-submodule.sh
@@ -178,80 +178,6 @@ get_submodule_config () {
printf '%s' "${value:-$default}"
}
-#
-# Clone a submodule
-#
-# $1 = submodule path
-# $2 = submodule name
-# $3 = URL to clone
-# $4 = reference repository to reuse (empty for independent)
-# $5 = depth argument for shallow clones (empty for deep)
-#
-# Prior to calling, cmd_update checks that a possibly existing
-# path is not a git repository.
-# Likewise, cmd_add checks that path does not exist at all,
-# since it is the location of a new submodule.
-#
-module_clone()
-{
- sm_path=$1
- name=$2
- url=$3
- reference="$4"
- depth="$5"
- quiet=
- if test -n "$GIT_QUIET"
- then
- quiet=-q
- fi
-
- gitdir=
- gitdir_base=
- base_name=$(dirname "$name")
-
- gitdir=$(git rev-parse --git-dir)
- gitdir_base="$gitdir/modules/$base_name"
- gitdir="$gitdir/modules/$name"
-
- if test -d "$gitdir"
- then
- mkdir -p "$sm_path"
- rm -f "$gitdir/index"
- else
- mkdir -p "$gitdir_base"
- (
- clear_local_git_env
- git clone $quiet ${depth:+"$depth"} -n ${reference:+"$reference"} \
- --separate-git-dir "$gitdir" "$url" "$sm_path"
- ) ||
- die "$(eval_gettext "Clone of '\$url' into submodule path '\$sm_path' failed")"
- fi
-
- # We already are at the root of the work tree but cd_to_toplevel will
- # resolve any symlinks that might be present in $PWD
- a=$(cd_to_toplevel && cd "$gitdir" && pwd)/
- b=$(cd_to_toplevel && cd "$sm_path" && pwd)/
- # Remove all common leading directories after a sanity check
- if test "${a#$b}" != "$a" || test "${b#$a}" != "$b"; then
- die "$(eval_gettext "Gitdir '\$a' is part of the submodule path '\$b' or vice versa")"
- fi
- while test "${a%%/*}" = "${b%%/*}"
- do
- a=${a#*/}
- b=${b#*/}
- done
- # Now chop off the trailing '/'s that were added in the beginning
- a=${a%/}
- b=${b%/}
-
- # Turn each leading "*/" component into "../"
- rel=$(printf '%s\n' "$b" | sed -e 's|[^/][^/]*|..|g')
- printf '%s\n' "gitdir: $rel/$a" >"$sm_path/.git"
-
- rel=$(printf '%s\n' "$a" | sed -e 's|[^/][^/]*|..|g')
- (clear_local_git_env; cd "$sm_path" && GIT_WORK_TREE=. git config core.worktree "$rel/$b")
-}
-
isnumber()
{
n=$(($1 + 0)) 2>/dev/null && test "$n" = "$1"
@@ -412,7 +338,7 @@ Use -f if you really want to add it." >&2
echo "$(eval_gettext "Reactivating local git directory for submodule '\$sm_name'.")"
fi
fi
- module_clone "$sm_path" "$sm_name" "$realrepo" "$reference" "$depth" || exit
+ git submodule--helper module_clone --prefix "$wt_prefix" --path "$sm_path" --name "$sm_name" --url "$realrepo" --reference "$reference_path" --depth "$depth" || exit
(
clear_local_git_env
cd "$sm_path" &&
@@ -774,7 +700,7 @@ Maybe you want to use 'update --init'?")"
if ! test -d "$sm_path"/.git && ! test -f "$sm_path"/.git
then
- module_clone "$sm_path" "$name" "$url" "$reference" "$depth" || exit
+ git submodule--helper module_clone --prefix "$prefix" --path "$sm_path" --name "$name" --url "$url" "$reference" "$depth" || exit
cloned_modules="$cloned_modules;$name"
subsha1=
else
--
2.5.0.330.g130be8e.dirty
^ permalink raw reply related [flat|nested] 19+ messages in thread* Re: [PATCH 7/7] submodule: implement `module_clone` as a builtin helper
2015-08-18 0:22 ` [PATCH 7/7] submodule: implement `module_clone` " Stefan Beller
@ 2015-08-18 0:26 ` Stefan Beller
2015-08-18 22:13 ` Stefan Beller
2015-08-21 14:22 ` Jeff King
2 siblings, 0 replies; 19+ messages in thread
From: Stefan Beller @ 2015-08-18 0:26 UTC (permalink / raw)
To: git@vger.kernel.org
Cc: Junio C Hamano, Jens Lehmann, Heiko Voigt, Stefan Beller
On Mon, Aug 17, 2015 at 5:22 PM, Stefan Beller <sbeller@google.com> wrote:
> `module_clone` is part of the update command, which I want to convert
> to C next.
>
> Signed-off-by: Stefan Beller <sbeller@google.com>
> ---
> builtin/submodule--helper.c | 161 +++++++++++++++++++++++++++++++++++++++++++-
> git-submodule.sh | 78 +--------------------
> 2 files changed, 162 insertions(+), 77 deletions(-)
>
> diff --git a/builtin/submodule--helper.c b/builtin/submodule--helper.c
> index 80d13f5..44ff935 100644
> --- a/builtin/submodule--helper.c
> +++ b/builtin/submodule--helper.c
> @@ -8,6 +8,7 @@
> #include "submodule.h"
> #include "submodule-config.h"
> #include "string-list.h"
> +#include "run-command.h"
>
> static const struct cache_entry **ce_entries;
> static int ce_alloc, ce_used;
> @@ -124,6 +125,156 @@ static int module_name(int argc, const char **argv, const char *prefix)
> return 0;
> }
>
> +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 && strcmp(depth, "")) {
> + argv_array_push(&cp.args, "--depth");
> + argv_array_push(&cp.args, depth);
> + }
> + if (reference && strcmp(reference, "")) {
> + argv_array_push(&cp.args, "--reference");
> + argv_array_push(&cp.args, reference);
> + }
> + if (gitdir) {
> + argv_array_push(&cp.args, "--separate-git-dir");
> + argv_array_push(&cp.args, gitdir);
> + }
> + argv_array_push(&cp.args, url);
> + argv_array_push(&cp.args, path);
> +
> + cp.git_cmd = 1;
> + cp.env = local_repo_env;
> +
> + cp.no_stdin = 1;
> + cp.no_stdout = 1;
> + cp.no_stderr = 1;
> + return run_command(&cp);
> +}
> +
> +/*
> + * Clone a submodule
> + *
> + * $1 = submodule path
> + * $2 = submodule name
> + * $3 = URL to clone
> + * $4 = reference repository to reuse (empty for independent)
> + * $5 = depth argument for shallow clones (empty for deep)
> + *
> + * Prior to calling, cmd_update checks that a possibly existing
> + * path is not a git repository.
> + * Likewise, cmd_add checks that path does not exist at all,
> + * since it is the location of a new submodule.
> + */
> +static int module_clone(int argc, const char **argv, const char *prefix)
> +{
> + const char *path = NULL, *name = NULL, *url = NULL, *reference = NULL, *depth = NULL;
> + int quiet = 0;
> + FILE *submodule_dot_git;
> + const char *sm_gitdir, *p;
> + struct strbuf rel_path = STRBUF_INIT;
> + struct strbuf sb = STRBUF_INIT;
> +
> + struct option module_update_options[] = {
> + OPT_STRING(0, "prefix", &alternative_path,
> + 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_END()
> + };
> +
> + static const char * const git_submodule_helper_usage[] = {
> + N_("git submodule--helper update [--prefix=<path>] [--quiet] [--remote] [-N|--no-fetch]"
> + "[-f|--force] [--rebase|--merge] [--reference <repository>]"
> + "[--depth <depth>] [--recursive] [--] [<path>...]"),
> + NULL
> + };
> +
> + argc = parse_options(argc, argv, prefix, module_update_options,
> + git_submodule_helper_usage, 0);
> +
> + if (getenv("GIT_QUIET"))
> + quiet = 1;
> +
> + strbuf_addf(&sb, "%s/modules/%s", get_git_dir(), name);
> + sm_gitdir = strbuf_detach(&sb, NULL);
> + strbuf_reset(&sb);
> +
> + if (!file_exists(sm_gitdir)) {
> + safe_create_leading_directories_const(sm_gitdir);
> + if (clone_submodule(path, sm_gitdir, url, depth, reference, quiet))
> + die(N_("Clone of '%s' into submodule path '%s' failed"),
> + url, path);
> + } else {
> + safe_create_leading_directories_const(path);
> + unlink(sm_gitdir);
> + }
> +
> + /* Write a .git file in the submodule to redirect to the superproject. */
> + const char *t;
declaration after statement.
> + if (alternative_path && !strcmp(alternative_path, "")) {
> + t = relative_path(path, alternative_path, &sb);
> + strbuf_reset(&sb);
> + } else
> + t = path;
> +
> + if (safe_create_leading_directories_const(t) < 0)
> + die("Could not create directory '%s'", t);
> +
> + strbuf_addf(&sb, "%s/.git", t);
> +
> + 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 ("Cannot open file '%s': %s", sb.buf, strerror(errno) );
> +
> + fprintf(submodule_dot_git, "gitdir: %s\n",
> + relative_path(sm_gitdir, path, &rel_path));
> + if (fclose(submodule_dot_git))
> + die("Could not close file %s", sb.buf);
> + strbuf_reset(&sb);
> +
> + /* Redirect the worktree of the submodule in the superprojects config */
> + if (!is_absolute_path(sm_gitdir)) {
> + char *s = (char*)sm_gitdir;
> + strbuf_addf(&sb, "%s/%s", xgetcwd(), sm_gitdir);
> + sm_gitdir = strbuf_detach(&sb, NULL);
> + strbuf_reset(&sb);
> + free(s);
> + }
> + strbuf_addf(&sb, "%s/%s", xgetcwd(), path);
> + t = relative_path(sb.buf, sm_gitdir, &rel_path);
> +
> + 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", t);
> + strbuf_release(&sb);
> + return 0;
> +}
> +
> int cmd_submodule__helper(int argc, const char **argv, const char *prefix)
> {
> if (argc < 2)
> @@ -135,6 +286,14 @@ int cmd_submodule__helper(int argc, const char **argv, const char *prefix)
> if (!strcmp(argv[1], "module_name"))
> return module_name(argc - 2, argv + 2, prefix);
>
> + if (!strcmp(argv[1], "module_clone"))
> + return module_clone(argc - 1, argv + 1, prefix);
> + if (!strcmp(argv[1], "test")) {
> + struct strbuf sb = STRBUF_INIT;
> +
> + relative_path(".git/modules/example", "init", &sb);
> + return 0;
> + }
> usage:
> - usage("git submodule--helper [module_list module_name]\n");
> + usage("git submodule--helper [module_list module_name module_clone]\n");
> }
> diff --git a/git-submodule.sh b/git-submodule.sh
> index e6ff38d..6e8561e 100755
> --- a/git-submodule.sh
> +++ b/git-submodule.sh
> @@ -178,80 +178,6 @@ get_submodule_config () {
> printf '%s' "${value:-$default}"
> }
>
> -#
> -# Clone a submodule
> -#
> -# $1 = submodule path
> -# $2 = submodule name
> -# $3 = URL to clone
> -# $4 = reference repository to reuse (empty for independent)
> -# $5 = depth argument for shallow clones (empty for deep)
> -#
> -# Prior to calling, cmd_update checks that a possibly existing
> -# path is not a git repository.
> -# Likewise, cmd_add checks that path does not exist at all,
> -# since it is the location of a new submodule.
> -#
> -module_clone()
> -{
> - sm_path=$1
> - name=$2
> - url=$3
> - reference="$4"
> - depth="$5"
> - quiet=
> - if test -n "$GIT_QUIET"
> - then
> - quiet=-q
> - fi
> -
> - gitdir=
> - gitdir_base=
> - base_name=$(dirname "$name")
> -
> - gitdir=$(git rev-parse --git-dir)
> - gitdir_base="$gitdir/modules/$base_name"
> - gitdir="$gitdir/modules/$name"
> -
> - if test -d "$gitdir"
> - then
> - mkdir -p "$sm_path"
> - rm -f "$gitdir/index"
> - else
> - mkdir -p "$gitdir_base"
> - (
> - clear_local_git_env
> - git clone $quiet ${depth:+"$depth"} -n ${reference:+"$reference"} \
> - --separate-git-dir "$gitdir" "$url" "$sm_path"
> - ) ||
> - die "$(eval_gettext "Clone of '\$url' into submodule path '\$sm_path' failed")"
> - fi
> -
> - # We already are at the root of the work tree but cd_to_toplevel will
> - # resolve any symlinks that might be present in $PWD
> - a=$(cd_to_toplevel && cd "$gitdir" && pwd)/
> - b=$(cd_to_toplevel && cd "$sm_path" && pwd)/
> - # Remove all common leading directories after a sanity check
> - if test "${a#$b}" != "$a" || test "${b#$a}" != "$b"; then
> - die "$(eval_gettext "Gitdir '\$a' is part of the submodule path '\$b' or vice versa")"
> - fi
> - while test "${a%%/*}" = "${b%%/*}"
> - do
> - a=${a#*/}
> - b=${b#*/}
> - done
> - # Now chop off the trailing '/'s that were added in the beginning
> - a=${a%/}
> - b=${b%/}
> -
> - # Turn each leading "*/" component into "../"
> - rel=$(printf '%s\n' "$b" | sed -e 's|[^/][^/]*|..|g')
> - printf '%s\n' "gitdir: $rel/$a" >"$sm_path/.git"
> -
> - rel=$(printf '%s\n' "$a" | sed -e 's|[^/][^/]*|..|g')
> - (clear_local_git_env; cd "$sm_path" && GIT_WORK_TREE=. git config core.worktree "$rel/$b")
> -}
> -
> isnumber()
> {
> n=$(($1 + 0)) 2>/dev/null && test "$n" = "$1"
> @@ -412,7 +338,7 @@ Use -f if you really want to add it." >&2
> echo "$(eval_gettext "Reactivating local git directory for submodule '\$sm_name'.")"
> fi
> fi
> - module_clone "$sm_path" "$sm_name" "$realrepo" "$reference" "$depth" || exit
> + git submodule--helper module_clone --prefix "$wt_prefix" --path "$sm_path" --name "$sm_name" --url "$realrepo" --reference "$reference_path" --depth "$depth" || exit
> (
> clear_local_git_env
> cd "$sm_path" &&
> @@ -774,7 +700,7 @@ Maybe you want to use 'update --init'?")"
>
> if ! test -d "$sm_path"/.git && ! test -f "$sm_path"/.git
> then
> - module_clone "$sm_path" "$name" "$url" "$reference" "$depth" || exit
> + git submodule--helper module_clone --prefix "$prefix" --path "$sm_path" --name "$name" --url "$url" "$reference" "$depth" || exit
> cloned_modules="$cloned_modules;$name"
> subsha1=
> else
> --
> 2.5.0.330.g130be8e.dirty
>
^ permalink raw reply [flat|nested] 19+ messages in thread* [PATCH 7/7] submodule: implement `module_clone` as a builtin helper
2015-08-18 0:22 ` [PATCH 7/7] submodule: implement `module_clone` " Stefan Beller
2015-08-18 0:26 ` Stefan Beller
@ 2015-08-18 22:13 ` Stefan Beller
2015-08-19 19:08 ` Junio C Hamano
2015-08-21 14:22 ` Jeff King
2 siblings, 1 reply; 19+ messages in thread
From: Stefan Beller @ 2015-08-18 22:13 UTC (permalink / raw)
To: git; +Cc: gitster, Jens.Lehmann, hvoigt, Stefan Beller
`module_clone` is part of the update command, which I want to convert
to C next.
Signed-off-by: Stefan Beller <sbeller@google.com>
---
This is the only patch that broke by a last minute fix,
so this replaces the previous PATCH 7/7.
builtin/submodule--helper.c | 161 +++++++++++++++++++++++++++++++++++++++++++-
git-submodule.sh | 80 +---------------------
2 files changed, 163 insertions(+), 78 deletions(-)
diff --git a/builtin/submodule--helper.c b/builtin/submodule--helper.c
index 80d13f5..930aa04 100644
--- a/builtin/submodule--helper.c
+++ b/builtin/submodule--helper.c
@@ -8,6 +8,7 @@
#include "submodule.h"
#include "submodule-config.h"
#include "string-list.h"
+#include "run-command.h"
static const struct cache_entry **ce_entries;
static int ce_alloc, ce_used;
@@ -124,6 +125,156 @@ static int module_name(int argc, const char **argv, const char *prefix)
return 0;
}
+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 && strcmp(depth, "")) {
+ argv_array_push(&cp.args, "--depth");
+ argv_array_push(&cp.args, depth);
+ }
+ if (reference && strcmp(reference, "")) {
+ argv_array_push(&cp.args, "--reference");
+ argv_array_push(&cp.args, reference);
+ }
+ if (gitdir) {
+ argv_array_push(&cp.args, "--separate-git-dir");
+ argv_array_push(&cp.args, gitdir);
+ }
+ argv_array_push(&cp.args, url);
+ argv_array_push(&cp.args, path);
+
+ cp.git_cmd = 1;
+ cp.env = local_repo_env;
+
+ cp.no_stdin = 1;
+ cp.no_stdout = 1;
+ cp.no_stderr = 1;
+
+ return run_command(&cp);
+}
+
+/*
+ * Clone a submodule
+ *
+ * $1 = submodule path
+ * $2 = submodule name
+ * $3 = URL to clone
+ * $4 = reference repository to reuse (empty for independent)
+ * $5 = depth argument for shallow clones (empty for deep)
+ *
+ * Prior to calling, cmd_update checks that a possibly existing
+ * path is not a git repository.
+ * Likewise, cmd_add checks that path does not exist at all,
+ * since it is the location of a new submodule.
+ */
+static int module_clone(int argc, const char **argv, const char *prefix)
+{
+ const char *path = NULL, *name = NULL, *url = NULL, *reference = NULL, *depth = NULL;
+ int quiet = 0;
+ FILE *submodule_dot_git;
+ const char *sm_gitdir, *p;
+ struct strbuf rel_path = STRBUF_INIT;
+ struct strbuf sb = STRBUF_INIT;
+
+ struct option module_update_options[] = {
+ OPT_STRING(0, "prefix", &alternative_path,
+ 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_END()
+ };
+
+ static const char * const git_submodule_helper_usage[] = {
+ N_("git submodule--helper update [--prefix=<path>] [--quiet] [--remote] [-N|--no-fetch]"
+ "[-f|--force] [--rebase|--merge] [--reference <repository>]"
+ "[--depth <depth>] [--recursive] [--] [<path>...]"),
+ NULL
+ };
+
+ argc = parse_options(argc, argv, prefix, module_update_options,
+ git_submodule_helper_usage, 0);
+
+ if (getenv("GIT_QUIET"))
+ quiet = 1;
+
+ strbuf_addf(&sb, "%s/modules/%s", get_git_dir(), name);
+ sm_gitdir = strbuf_detach(&sb, NULL);
+ strbuf_reset(&sb);
+
+ if (!file_exists(sm_gitdir)) {
+ safe_create_leading_directories_const(sm_gitdir);
+ if (clone_submodule(path, sm_gitdir, url, depth, reference, quiet))
+ die(N_("Clone of '%s' into submodule path '%s' failed"),
+ url, path);
+ } else {
+ safe_create_leading_directories_const(path);
+ unlink(sm_gitdir);
+ }
+
+ /* Write a .git file in the submodule to redirect to the superproject. */
+ if (alternative_path && !strcmp(alternative_path, "")) {
+ p = relative_path(path, alternative_path, &sb);
+ strbuf_reset(&sb);
+ } else
+ p = path;
+
+ if (safe_create_leading_directories_const(p) < 0)
+ die("Could not create directory '%s'", p);
+
+ strbuf_addf(&sb, "%s/.git", p);
+
+ 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 ("Cannot open file '%s': %s", sb.buf, strerror(errno));
+
+ fprintf(submodule_dot_git, "gitdir: %s\n",
+ relative_path(sm_gitdir, path, &rel_path));
+ if (fclose(submodule_dot_git))
+ die("Could not close file %s", sb.buf);
+ strbuf_reset(&sb);
+
+ /* Redirect the worktree of the submodule in the superprojects config */
+ if (!is_absolute_path(sm_gitdir)) {
+ char *s = (char*)sm_gitdir;
+ strbuf_addf(&sb, "%s/%s", xgetcwd(), sm_gitdir);
+ sm_gitdir = strbuf_detach(&sb, NULL);
+ strbuf_reset(&sb);
+ free(s);
+ }
+ strbuf_addf(&sb, "%s/%s", xgetcwd(), path);
+
+ 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",
+ relative_path(sb.buf, sm_gitdir, &rel_path));
+ strbuf_release(&sb);
+ return 0;
+}
+
int cmd_submodule__helper(int argc, const char **argv, const char *prefix)
{
if (argc < 2)
@@ -135,6 +286,14 @@ int cmd_submodule__helper(int argc, const char **argv, const char *prefix)
if (!strcmp(argv[1], "module_name"))
return module_name(argc - 2, argv + 2, prefix);
+ if (!strcmp(argv[1], "module_clone"))
+ return module_clone(argc - 1, argv + 1, prefix);
+ if (!strcmp(argv[1], "test")) {
+ struct strbuf sb = STRBUF_INIT;
+
+ relative_path(".git/modules/example", "init", &sb);
+ return 0;
+ }
usage:
- usage("git submodule--helper [module_list module_name]\n");
+ usage("git submodule--helper [module_list module_name module_clone]\n");
}
diff --git a/git-submodule.sh b/git-submodule.sh
index e6ff38d..e50451b 100755
--- a/git-submodule.sh
+++ b/git-submodule.sh
@@ -178,80 +178,6 @@ get_submodule_config () {
printf '%s' "${value:-$default}"
}
-#
-# Clone a submodule
-#
-# $1 = submodule path
-# $2 = submodule name
-# $3 = URL to clone
-# $4 = reference repository to reuse (empty for independent)
-# $5 = depth argument for shallow clones (empty for deep)
-#
-# Prior to calling, cmd_update checks that a possibly existing
-# path is not a git repository.
-# Likewise, cmd_add checks that path does not exist at all,
-# since it is the location of a new submodule.
-#
-module_clone()
-{
- sm_path=$1
- name=$2
- url=$3
- reference="$4"
- depth="$5"
- quiet=
- if test -n "$GIT_QUIET"
- then
- quiet=-q
- fi
-
- gitdir=
- gitdir_base=
- base_name=$(dirname "$name")
-
- gitdir=$(git rev-parse --git-dir)
- gitdir_base="$gitdir/modules/$base_name"
- gitdir="$gitdir/modules/$name"
-
- if test -d "$gitdir"
- then
- mkdir -p "$sm_path"
- rm -f "$gitdir/index"
- else
- mkdir -p "$gitdir_base"
- (
- clear_local_git_env
- git clone $quiet ${depth:+"$depth"} -n ${reference:+"$reference"} \
- --separate-git-dir "$gitdir" "$url" "$sm_path"
- ) ||
- die "$(eval_gettext "Clone of '\$url' into submodule path '\$sm_path' failed")"
- fi
-
- # We already are at the root of the work tree but cd_to_toplevel will
- # resolve any symlinks that might be present in $PWD
- a=$(cd_to_toplevel && cd "$gitdir" && pwd)/
- b=$(cd_to_toplevel && cd "$sm_path" && pwd)/
- # Remove all common leading directories after a sanity check
- if test "${a#$b}" != "$a" || test "${b#$a}" != "$b"; then
- die "$(eval_gettext "Gitdir '\$a' is part of the submodule path '\$b' or vice versa")"
- fi
- while test "${a%%/*}" = "${b%%/*}"
- do
- a=${a#*/}
- b=${b#*/}
- done
- # Now chop off the trailing '/'s that were added in the beginning
- a=${a%/}
- b=${b%/}
-
- # Turn each leading "*/" component into "../"
- rel=$(printf '%s\n' "$b" | sed -e 's|[^/][^/]*|..|g')
- printf '%s\n' "gitdir: $rel/$a" >"$sm_path/.git"
-
- rel=$(printf '%s\n' "$a" | sed -e 's|[^/][^/]*|..|g')
- (clear_local_git_env; cd "$sm_path" && GIT_WORK_TREE=. git config core.worktree "$rel/$b")
-}
-
isnumber()
{
n=$(($1 + 0)) 2>/dev/null && test "$n" = "$1"
@@ -301,7 +227,7 @@ cmd_add()
shift
;;
--depth=*)
- depth=$1
+ depth="$1"
;;
--)
shift
@@ -412,7 +338,7 @@ Use -f if you really want to add it." >&2
echo "$(eval_gettext "Reactivating local git directory for submodule '\$sm_name'.")"
fi
fi
- module_clone "$sm_path" "$sm_name" "$realrepo" "$reference" "$depth" || exit
+ git submodule--helper module_clone --prefix "$wt_prefix" --path "$sm_path" --name "$sm_name" --url "$realrepo" --reference "$reference_path" --depth "$depth" || exit
(
clear_local_git_env
cd "$sm_path" &&
@@ -774,7 +700,7 @@ Maybe you want to use 'update --init'?")"
if ! test -d "$sm_path"/.git && ! test -f "$sm_path"/.git
then
- module_clone "$sm_path" "$name" "$url" "$reference" "$depth" || exit
+ git submodule--helper module_clone --prefix "$prefix" --path "$sm_path" --name "$name" --url "$url" "$reference" "$depth" || exit
cloned_modules="$cloned_modules;$name"
subsha1=
else
--
2.5.0.342.g44e0223
^ permalink raw reply related [flat|nested] 19+ messages in thread* Re: [PATCH 7/7] submodule: implement `module_clone` as a builtin helper
2015-08-18 22:13 ` Stefan Beller
@ 2015-08-19 19:08 ` Junio C Hamano
2015-08-19 19:20 ` Stefan Beller
0 siblings, 1 reply; 19+ messages in thread
From: Junio C Hamano @ 2015-08-19 19:08 UTC (permalink / raw)
To: Stefan Beller; +Cc: git, Jens.Lehmann, hvoigt
Stefan Beller <sbeller@google.com> writes:
> `module_clone` is part of the update command, which I want to convert
> to C next.
>
> Signed-off-by: Stefan Beller <sbeller@google.com>
> ---
>
> This is the only patch that broke by a last minute fix,
> so this replaces the previous PATCH 7/7.
... which still breaks 7400.82, though.
Output from running it with "-i -v" ends like this:
expecting success:
mkdir super &&
pwd=$(pwd) &&
(
cd super &&
git init &&
git submodule add --depth=1 file://"$pwd"/example2 submodule &&
(
cd submodule &&
test 1 = $(git log --oneline | wc -l)
)
)
Initialized empty Git repository in /home/gitster/w/git.git/t/trash directory.t7400-submodule-basic/super/.git/
fatal: Clone of 'file:///home/gitster/w/git.git/t/trash directory.t7400-submodule-basic/example2' into submodule path 'submodule' failed
not ok 82 - submodule add clone shallow submodule
#
# mkdir super &&
# pwd=$(pwd) &&
# (
# cd super &&
# git init &&
# git submodule add --depth=1 file://"$pwd"/example2 submodule &&
# (
# cd submodule &&
# test 1 = $(git log --oneline | wc -l)
# )
# )
#
^ permalink raw reply [flat|nested] 19+ messages in thread* Re: [PATCH 7/7] submodule: implement `module_clone` as a builtin helper
2015-08-19 19:08 ` Junio C Hamano
@ 2015-08-19 19:20 ` Stefan Beller
0 siblings, 0 replies; 19+ messages in thread
From: Stefan Beller @ 2015-08-19 19:20 UTC (permalink / raw)
To: Junio C Hamano; +Cc: git@vger.kernel.org, Jens Lehmann, Heiko Voigt
On Wed, Aug 19, 2015 at 12:08 PM, Junio C Hamano <gitster@pobox.com> wrote:
> Stefan Beller <sbeller@google.com> writes:
>
>> `module_clone` is part of the update command, which I want to convert
>> to C next.
>>
>> Signed-off-by: Stefan Beller <sbeller@google.com>
>> ---
>>
>> This is the only patch that broke by a last minute fix,
>> so this replaces the previous PATCH 7/7.
>
> ... which still breaks 7400.82, though.
because I messed up the resending. :(
Squashing in this fixes it:
---8<---
diff --git a/git-submodule.sh b/git-submodule.sh
index e50451b..e7d221e 100755
--- a/git-submodule.sh
+++ b/git-submodule.sh
@@ -338,7 +338,7 @@ Use -f if you really want to add it." >&2
echo "$(eval_gettext "Reactivating
local git directory for submodule '\$sm_name'.")"
fi
fi
- git submodule--helper module_clone --prefix
"$wt_prefix" --path "$sm_path" --name "$sm_name" --url "$realrepo"
--reference "$reference_path" --depth "$depth" || exit
+ git submodule--helper module_clone --prefix
"$wt_prefix" --path "$sm_path" --name "$sm_name" --url "$realrepo"
"$reference_path" "$depth" || exit
(
clear_local_git_env
cd "$sm_path" &&
@@ -634,7 +634,7 @@ cmd_update()
shift
;;
--depth=*)
- depth=$1
+ depth="$1"
;;
--)
shift
---
because both depth and reference are either empty string or containing
both key and value
(i.e. $depth will be "--depth=5" and we should not pass --depth into
submodule--helper module_clone
twice)
I can resend the patch as a whole if you'd like. I'd send it together
in the next series later today, which will demonstrate a possible
implementation of `git submodule foreach-parallel`
>
> Output from running it with "-i -v" ends like this:
>
> expecting success:
> mkdir super &&
> pwd=$(pwd) &&
> (
> cd super &&
> git init &&
> git submodule add --depth=1 file://"$pwd"/example2 submodule &&
> (
> cd submodule &&
> test 1 = $(git log --oneline | wc -l)
> )
> )
>
> Initialized empty Git repository in /home/gitster/w/git.git/t/trash directory.t7400-submodule-basic/super/.git/
> fatal: Clone of 'file:///home/gitster/w/git.git/t/trash directory.t7400-submodule-basic/example2' into submodule path 'submodule' failed
> not ok 82 - submodule add clone shallow submodule
> #
> # mkdir super &&
> # pwd=$(pwd) &&
> # (
> # cd super &&
> # git init &&
> # git submodule add --depth=1 file://"$pwd"/example2 submodule &&
> # (
> # cd submodule &&
> # test 1 = $(git log --oneline | wc -l)
> # )
> # )
> #
^ permalink raw reply related [flat|nested] 19+ messages in thread
* Re: [PATCH 7/7] submodule: implement `module_clone` as a builtin helper
2015-08-18 0:22 ` [PATCH 7/7] submodule: implement `module_clone` " Stefan Beller
2015-08-18 0:26 ` Stefan Beller
2015-08-18 22:13 ` Stefan Beller
@ 2015-08-21 14:22 ` Jeff King
2 siblings, 0 replies; 19+ messages in thread
From: Jeff King @ 2015-08-21 14:22 UTC (permalink / raw)
To: Stefan Beller; +Cc: git, gitster, Jens.Lehmann, hvoigt
On Mon, Aug 17, 2015 at 05:22:03PM -0700, Stefan Beller wrote:
> +static int module_clone(int argc, const char **argv, const char *prefix)
> [...]
> + /* Redirect the worktree of the submodule in the superprojects config */
> + if (!is_absolute_path(sm_gitdir)) {
> + char *s = (char*)sm_gitdir;
> + strbuf_addf(&sb, "%s/%s", xgetcwd(), sm_gitdir);
Coverity noticed that this is a leak; xgetcwd actually returns a newly
allocated buffer. I think you just want:
if (strbuf_getcwd(&sb))
die_errno("unable to get current working directory");
strbuf_addf("/%s", sm_gitdir);
> + sm_gitdir = strbuf_detach(&sb, NULL);
> + strbuf_reset(&sb);
This reset is a noop after you've detached. It's not technically
documented, but I do not think it is reasonable for it to work any other
way. Maybe strbuf.h should make that promise.
> + strbuf_addf(&sb, "%s/%s", xgetcwd(), path);
Ditto on the xgetcwd issue here.
-Peff
^ permalink raw reply [flat|nested] 19+ messages in thread
* Re: [PATCH 0/7] Submodule improvements
2015-08-18 0:21 [PATCH 0/7] Submodule improvements Stefan Beller
` (6 preceding siblings ...)
2015-08-18 0:22 ` [PATCH 7/7] submodule: implement `module_clone` " Stefan Beller
@ 2015-08-18 0:38 ` Stefan Beller
7 siblings, 0 replies; 19+ messages in thread
From: Stefan Beller @ 2015-08-18 0:38 UTC (permalink / raw)
To: git@vger.kernel.org
Cc: Junio C Hamano, Jens Lehmann, Heiko Voigt, Stefan Beller
A last minute change in the last patch broke t7400-submodule-basic.sh, test 82
^ permalink raw reply [flat|nested] 19+ messages in thread