#include "cache.h"
+#include "repository.h"
#include "config.h"
#include "submodule-config.h"
#include "submodule.h"
static int config_fetch_recurse_submodules = RECURSE_SUBMODULES_ON_DEMAND;
static int config_update_recurse_submodules = RECURSE_SUBMODULES_OFF;
-static int parallel_jobs = 1;
static struct string_list changed_submodule_paths = STRING_LIST_INIT_DUP;
static int initialized_fetch_ref_tips;
static struct oid_array ref_tips_before_fetch;
struct strbuf entry = STRBUF_INIT;
const struct submodule *submodule;
- if (!file_exists(".gitmodules")) /* Do nothing without .gitmodules */
+ if (!file_exists(GITMODULES_FILE)) /* Do nothing without .gitmodules */
return -1;
if (gitmodules_is_unmerged)
strbuf_addstr(&entry, "submodule.");
strbuf_addstr(&entry, submodule->name);
strbuf_addstr(&entry, ".path");
- if (git_config_set_in_file_gently(".gitmodules", entry.buf, newpath) < 0) {
+ if (git_config_set_in_file_gently(GITMODULES_FILE, entry.buf, newpath) < 0) {
/* Maybe the user already did that, don't error out here */
warning(_("Could not update .gitmodules entry %s"), entry.buf);
strbuf_release(&entry);
struct strbuf sect = STRBUF_INIT;
const struct submodule *submodule;
- if (!file_exists(".gitmodules")) /* Do nothing without .gitmodules */
+ if (!file_exists(GITMODULES_FILE)) /* Do nothing without .gitmodules */
return -1;
if (gitmodules_is_unmerged)
}
strbuf_addstr(§, "submodule.");
strbuf_addstr(§, submodule->name);
- if (git_config_rename_section_in_file(".gitmodules", sect.buf, NULL) < 0) {
+ if (git_config_rename_section_in_file(GITMODULES_FILE, sect.buf, NULL) < 0) {
/* Maybe the user already did that, don't error out here */
warning(_("Could not remove .gitmodules entry for %s"), path);
strbuf_release(§);
void stage_updated_gitmodules(void)
{
- if (add_file_to_cache(".gitmodules", 0))
+ if (add_file_to_cache(GITMODULES_FILE, 0))
die(_("staging updated .gitmodules failed"));
}
/* For loading from the .gitmodules file. */
static int git_modules_config(const char *var, const char *value, void *cb)
{
- if (!strcmp(var, "submodule.fetchjobs")) {
- parallel_jobs = git_config_int(var, value);
- if (parallel_jobs < 0)
- die(_("negative values not allowed for submodule.fetchJobs"));
- return 0;
- } else if (starts_with(var, "submodule."))
+ if (starts_with(var, "submodule."))
return parse_submodule_config_option(var, value);
else if (!strcmp(var, "fetch.recursesubmodules")) {
config_fetch_recurse_submodules = parse_fetch_recurse_submodules_arg(var, value);
struct strbuf gitmodules_path = STRBUF_INIT;
int pos;
strbuf_addstr(&gitmodules_path, work_tree);
- strbuf_addstr(&gitmodules_path, "/.gitmodules");
+ strbuf_addstr(&gitmodules_path, "/" GITMODULES_FILE);
if (read_cache() < 0)
die("index file corrupt");
- pos = cache_name_pos(".gitmodules", 11);
+ pos = cache_name_pos(GITMODULES_FILE, 11);
if (pos < 0) { /* .gitmodules not found or isn't merged */
pos = -1 - pos;
if (active_nr > pos) { /* there is a .gitmodules */
const struct cache_entry *ce = active_cache[pos];
if (ce_namelen(ce) == 11 &&
- !memcmp(ce->name, ".gitmodules", 11))
+ !memcmp(ce->name, GITMODULES_FILE, 11))
gitmodules_is_unmerged = 1;
}
} else if (pos < active_nr) {
struct stat st;
- if (lstat(".gitmodules", &st) == 0 &&
+ if (lstat(GITMODULES_FILE, &st) == 0 &&
ce_match_stat(active_cache[pos], &st, 0) & DATA_CHANGED)
gitmodules_is_modified = 1;
}
}
}
+static int gitmodules_cb(const char *var, const char *value, void *data)
+{
+ struct repository *repo = data;
+ return submodule_config_option(repo, var, value);
+}
+
+void repo_read_gitmodules(struct repository *repo)
+{
+ char *gitmodules_path = repo_worktree_path(repo, GITMODULES_FILE);
+
+ git_config_from_file(gitmodules_cb, gitmodules_path, repo);
+ free(gitmodules_path);
+}
+
void gitmodules_config_sha1(const unsigned char *commit_sha1)
{
struct strbuf rev = STRBUF_INIT;
}
/*
- * NEEDSWORK: With the addition of different configuration options to determine
- * if a submodule is of interests, the validity of this function's name comes
- * into question. Once the dust has settled and more concrete terminology is
- * decided upon, come up with a more proper name for this function. One
- * potential candidate could be 'is_submodule_active()'.
- *
* Determine if a submodule has been initialized at a given 'path'
*/
-int is_submodule_initialized(const char *path)
+int is_submodule_active(struct repository *repo, const char *path)
{
int ret = 0;
char *key = NULL;
char *value = NULL;
const struct string_list *sl;
- const struct submodule *module = submodule_from_path(null_sha1, path);
+ const struct submodule *module;
+
+ module = submodule_from_cache(repo, null_sha1, path);
/* early return if there isn't a path->module mapping */
if (!module)
/* submodule.<name>.active is set */
key = xstrfmt("submodule.%s.active", module->name);
- if (!git_config_get_bool(key, &ret)) {
+ if (!repo_config_get_bool(repo, key, &ret)) {
free(key);
return ret;
}
free(key);
/* submodule.active is set */
- sl = git_config_get_value_multi("submodule.active");
+ sl = repo_config_get_value_multi(repo, "submodule.active");
if (sl) {
struct pathspec ps;
struct argv_array args = ARGV_ARRAY_INIT;
/* fallback to checking if the URL is set */
key = xstrfmt("submodule.%s.url", module->name);
- ret = !git_config_get_string(key, &value);
+ ret = !repo_config_get_string(repo, key, &value);
free(value);
free(key);
int has_commit = 1;
/*
- * Perform a cheap, but incorrect check for the existance of 'commits'.
+ * Perform a cheap, but incorrect check for the existence of 'commits'.
* This is done by adding the submodule's object store to the in-core
- * object store, and then querying for each commit's existance. If we
+ * object store, and then querying for each commit's existence. If we
* do not have the commit object anywhere, there is no chance we have
* it in the object store of the correct submodule and have it
* reachable from a ref, so we can fail early without spawning rev-list
initialized_fetch_ref_tips = 0;
}
+int submodule_touches_in_range(struct object_id *excl_oid,
+ struct object_id *incl_oid)
+{
+ struct string_list subs = STRING_LIST_INIT_DUP;
+ struct argv_array args = ARGV_ARRAY_INIT;
+ int ret;
+
+ gitmodules_config();
+ /* No need to check if there are no submodules configured */
+ if (!submodule_from_path(NULL, NULL))
+ return 0;
+
+ argv_array_push(&args, "--"); /* args[0] program name */
+ argv_array_push(&args, oid_to_hex(incl_oid));
+ argv_array_push(&args, "--not");
+ argv_array_push(&args, oid_to_hex(excl_oid));
+
+ collect_changed_submodules(&subs, &args);
+ ret = subs.nr;
+
+ argv_array_clear(&args);
+
+ free_submodules_oids(&subs);
+ return ret;
+}
+
struct submodule_parallel_fetch {
int count;
struct argv_array args;
argv_array_push(&spf.args, "--recurse-submodules-default");
/* default value, "--submodule-prefix" and its value are added later */
- if (max_parallel_jobs < 0)
- max_parallel_jobs = parallel_jobs;
-
calculate_changed_submodule_paths();
run_processes_parallel(max_parallel_jobs,
get_next_submodule,
const struct submodule *sub;
int *error_code_ptr, error_code;
- if (!is_submodule_initialized(path))
+ if (!is_submodule_active(the_repository, path))
return 0;
if (flags & SUBMODULE_MOVE_HEAD_FORCE)
return 0;
}
-int parallel_submodules(void)
-{
- return parallel_jobs;
-}
-
/*
* Embeds a single submodules git directory into the superprojects git dir,
* non recursively.