mirrors/git
1
0
Fork 0
mirror of https://github.com/git/git.git synced 2024-10-28 04:49:43 +01:00
Code Activity

Merge branch 'ps/config-wo-the-repository'

Browse source 
Use of API functions that implicitly depend on the_repository
object in the config subsystem has been rewritten to pass a
repository object through the callchain.

* ps/config-wo-the-repository:
  config: hide functions using `the_repository` by default
  global: prepare for hiding away repo-less config functions
  config: don't depend on `the_repository` with branch conditions
  config: don't have setters depend on `the_repository`
  config: pass repo to functions that rename or copy sections
  config: pass repo to `git_die_config()`
  config: pass repo to `git_config_get_expiry_in_days()`
  config: pass repo to `git_config_get_expiry()`
  config: pass repo to `git_config_get_max_percent_split_change()`
  config: pass repo to `git_config_get_split_index()`
  config: pass repo to `git_config_get_index_threads()`
  config: expose `repo_config_clear()`
  config: introduce missing setters that take repo as parameter
  path: hide functions using `the_repository` by default
  path: stop relying on `the_repository` in `worktree_git_path()`
  path: stop relying on `the_repository` when reporting garbage
  hooks: remove implicit dependency on `the_repository`
  editor: do not rely on `the_repository` for interactive edits
  path: expose `do_git_common_path()` as `repo_common_pathv()`
  path: expose `do_git_path()` as `repo_git_pathv()`
This commit is contained in:
Junio C Hamano 2024-08-23 09:02:34 -07:00
commit 5e56a39e6a
60 changed files with 570 additions and 457 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
add-patch.c
View file

@ -1142,7 +1142,8 @@ static int edit_hunk_manually(struct add_p_state *s, struct hunk *hunk)
"removed, then the edit is\n"
"aborted and the hunk is left unchanged.\n"));
if (strbuf_edit_interactively(&s->buf, "addp-hunk-edit.diff", NULL) < 0)
if (strbuf_edit_interactively(the_repository, &s->buf,
"addp-hunk-edit.diff", NULL) < 0)
return -1;
/* strip out commented lines */

9
builtin/am.c
View file

@ -490,7 +490,8 @@ static int run_applypatch_msg_hook(struct am_state *state)
assert(state->msg);
if (!state->no_verify)
ret = run_hooks_l("applypatch-msg", am_path(state, "final-commit"), NULL);
ret = run_hooks_l(the_repository, "applypatch-msg",
am_path(state, "final-commit"), NULL);
if (!ret) {
FREE_AND_NULL(state->msg);
@ -512,7 +513,7 @@ static int run_post_rewrite_hook(const struct am_state *state)
strvec_push(&opt.args, "rebase");
opt.path_to_stdin = am_path(state, "rewritten");
return run_hooks_opt("post-rewrite", &opt);
return run_hooks_opt(the_repository, "post-rewrite", &opt);
}
/**
@ -1663,7 +1664,7 @@ static void do_commit(const struct am_state *state)
const char *reflog_msg, *author, *committer = NULL;
struct strbuf sb = STRBUF_INIT;
if (!state->no_verify && run_hooks("pre-applypatch"))
if (!state->no_verify && run_hooks(the_repository, "pre-applypatch"))
exit(1);
if (write_index_as_tree(&tree, the_repository->index, get_index_file(), 0, NULL))
@ -1716,7 +1717,7 @@ static void do_commit(const struct am_state *state)
fclose(fp);
}
run_hooks("post-applypatch");
run_hooks(the_repository, "post-applypatch");
free_commit_list(parents);
strbuf_release(&sb);

7
builtin/branch.c
View file

@ -210,7 +210,7 @@ static void delete_branch_config(const char *branchname)
{
struct strbuf buf = STRBUF_INIT;
strbuf_addf(&buf, "branch.%s", branchname);
if (git_config_rename_section(buf.buf, NULL) < 0)
if (repo_config_rename_section(the_repository, buf.buf, NULL) < 0)
warning(_("update of config-file failed"));
strbuf_release(&buf);
}
@ -659,9 +659,10 @@ static void copy_or_rename_branch(const char *oldname, const char *newname, int
strbuf_addf(&oldsection, "branch.%s", interpreted_oldname);
strbuf_addf(&newsection, "branch.%s", interpreted_newname);
if (!copy && git_config_rename_section(oldsection.buf, newsection.buf) < 0)
if (!copy && repo_config_rename_section(the_repository, oldsection.buf, newsection.buf) < 0)
die(_("branch is renamed, but update of config-file failed"));
if (copy && strcmp(interpreted_oldname, interpreted_newname) && git_config_copy_section(oldsection.buf, newsection.buf) < 0)
if (copy && strcmp(interpreted_oldname, interpreted_newname) &&
repo_config_copy_section(the_repository, oldsection.buf, newsection.buf) < 0)
die(_("branch is copied, but update of config-file failed"));
strbuf_release(&oldref);
strbuf_release(&newref);

2
builtin/bugreport.c
View file

@ -58,7 +58,7 @@ static void get_populated_hooks(struct strbuf *hook_info, int nongit)
for (p = hook_name_list; *p; p++) {
const char *hook = *p;
if (hook_exists(hook))
if (hook_exists(the_repository, hook))
strbuf_addf(hook_info, "%s\n", hook);
}
}

2
builtin/checkout.c
View file

@ -125,7 +125,7 @@ static void branch_info_release(struct branch_info *info)
static int post_checkout_hook(struct commit *old_commit, struct commit *new_commit,
int changed)
{
return run_hooks_l("post-checkout",
return run_hooks_l(the_repository, "post-checkout",
oid_to_hex(old_commit ? &old_commit->object.oid : null_oid()),
oid_to_hex(new_commit ? &new_commit->object.oid : null_oid()),
changed ? "1" : "0", NULL);

2
builtin/clone.c
View file

@ -789,7 +789,7 @@ static int checkout(int submodule_progress, int filter_submodules,
if (write_locked_index(the_repository->index, &lock_file, COMMIT_LOCK))
die(_("unable to write new index file"));
err |= run_hooks_l("post-checkout", oid_to_hex(null_oid()),
err |= run_hooks_l(the_repository, "post-checkout", oid_to_hex(null_oid()),
oid_to_hex(&oid), "1", NULL);
if (!err && (option_recurse_submodules.nr > 0)) {

16
builtin/config.c
View file

@ -1026,8 +1026,8 @@ static int cmd_config_rename_section(int argc, const char **argv, const char *pr
location_options_init(&location_opts, prefix);
check_write(&location_opts.source);
ret = git_config_rename_section_in_file(location_opts.source.file,
argv[0], argv[1]);
ret = repo_config_rename_section_in_file(the_repository, location_opts.source.file,
argv[0], argv[1]);
if (ret < 0)
goto out;
else if (!ret)
@ -1055,8 +1055,8 @@ static int cmd_config_remove_section(int argc, const char **argv, const char *pr
location_options_init(&location_opts, prefix);
check_write(&location_opts.source);
ret = git_config_rename_section_in_file(location_opts.source.file,
argv[0], NULL);
ret = repo_config_rename_section_in_file(the_repository, location_opts.source.file,
argv[0], NULL);
if (ret < 0)
goto out;
else if (!ret)
@ -1353,8 +1353,8 @@ static int cmd_config_actions(int argc, const char **argv, const char *prefix)
else if (actions == ACTION_RENAME_SECTION) {
check_write(&location_opts.source);
check_argc(argc, 2, 2);
ret = git_config_rename_section_in_file(location_opts.source.file,
argv[0], argv[1]);
ret = repo_config_rename_section_in_file(the_repository, location_opts.source.file,
argv[0], argv[1]);
if (ret < 0)
goto out;
else if (!ret)
@ -1365,8 +1365,8 @@ static int cmd_config_actions(int argc, const char **argv, const char *prefix)
else if (actions == ACTION_REMOVE_SECTION) {
check_write(&location_opts.source);
check_argc(argc, 1, 1);
ret = git_config_rename_section_in_file(location_opts.source.file,
argv[0], NULL);
ret = repo_config_rename_section_in_file(the_repository, location_opts.source.file,
argv[0], NULL);
if (ret < 0)
goto out;
else if (!ret)

2
builtin/count-objects.c
View file

@ -113,7 +113,7 @@ int cmd_count_objects(int argc, const char **argv, const char *prefix)
usage_with_options(count_objects_usage, opts);
if (verbose) {
report_garbage = real_report_garbage;
report_linked_checkout_garbage();
report_linked_checkout_garbage(the_repository);
}
for_each_loose_file_in_objdir(get_object_directory(),

4
builtin/fast-import.c
View file

@ -3485,8 +3485,8 @@ static void git_pack_config(void)
if (!git_config_get_int("pack.indexversion", &indexversion_value)) {
pack_idx_opts.version = indexversion_value;
if (pack_idx_opts.version > 2)
git_die_config("pack.indexversion",
"bad pack.indexVersion=%"PRIu32, pack_idx_opts.version);
git_die_config(the_repository, "pack.indexversion",
"bad pack.indexVersion=%"PRIu32, pack_idx_opts.version);
}
if (!git_config_get_ulong("pack.packsizelimit", &packsizelimit_value))
max_packsize = packsizelimit_value;

2
builtin/fsck.c
View file

@ -1053,7 +1053,7 @@ int cmd_fsck(int argc, const char **argv, const char *prefix)
* and may get overwritten by other calls
* while we're examining the index.
*/
path = xstrdup(worktree_git_path(wt, "index"));
path = xstrdup(worktree_git_path(the_repository, wt, "index"));
read_index_from(&istate, path, get_worktree_git_dir(wt));
fsck_index(&istate, path, wt->is_current);
discard_index(&istate);

8
builtin/gc.c
View file

@ -167,9 +167,9 @@ static void gc_config(void)
git_config_get_bool("gc.autodetach", &detach_auto);
git_config_get_bool("gc.cruftpacks", &cruft_packs);
git_config_get_ulong("gc.maxcruftsize", &max_cruft_size);
git_config_get_expiry("gc.pruneexpire", &prune_expire);
git_config_get_expiry("gc.worktreepruneexpire", &prune_worktrees_expire);
git_config_get_expiry("gc.logexpiry", &gc_log_expire);
repo_config_get_expiry(the_repository, "gc.pruneexpire", &prune_expire);
repo_config_get_expiry(the_repository, "gc.worktreepruneexpire", &prune_worktrees_expire);
repo_config_get_expiry(the_repository, "gc.logexpiry", &gc_log_expire);
git_config_get_ulong("gc.bigpackthreshold", &big_pack_threshold);
git_config_get_ulong("pack.deltacachesize", &max_delta_cache_size);
@ -463,7 +463,7 @@ static int need_to_gc(void)
else
return 0;
if (run_hooks("pre-auto-gc"))
if (run_hooks(the_repository, "pre-auto-gc"))
return 0;
return 1;
}

2
builtin/hook.c
View file

@ -58,7 +58,7 @@ static int run(int argc, const char **argv, const char *prefix)
hook_name = argv[0];
if (!ignore_missing)
opt.error_if_missing = 1;
ret = run_hooks_opt(hook_name, &opt);
ret = run_hooks_opt(the_repository, hook_name, &opt);
if (ret < 0) /* error() return */
ret = 1;
return ret;

2
builtin/merge.c
View file

@ -478,7 +478,7 @@ static void finish(struct commit *head_commit,
}
/* Run a post-merge hook */
run_hooks_l("post-merge", squash ? "1" : "0", NULL);
run_hooks_l(the_repository, "post-merge", squash ? "1" : "0", NULL);
if (new_head)
apply_autostash_ref(the_repository, "MERGE_AUTOSTASH");

2
builtin/notes.c
View file

@ -865,7 +865,7 @@ static int git_config_get_notes_strategy(const char *key,
if (git_config_get_string(key, &value))
return 1;
if (parse_notes_merge_strategy(value, strategy))
git_die_config(key, _("unknown notes merge strategy %s"), value);
git_die_config(the_repository, key, _("unknown notes merge strategy %s"), value);
free(value);
return 0;

2
builtin/rebase.c
View file

@ -1775,7 +1775,7 @@ int cmd_rebase(int argc, const char **argv, const char *prefix)
/* If a hook exists, give it a chance to interrupt*/
if (!ok_to_skip_pre_rebase &&
run_hooks_l("pre-rebase", options.upstream_arg,
run_hooks_l(the_repository, "pre-rebase", options.upstream_arg,
argc ? argv[0] : NULL, NULL))
die(_("The pre-rebase hook refused to rebase."));

10
builtin/receive-pack.c
View file

@ -792,7 +792,7 @@ static int run_and_feed_hook(const char *hook_name, feed_fn feed,
struct child_process proc = CHILD_PROCESS_INIT;
struct async muxer;
int code;
const char *hook_path = find_hook(hook_name);
const char *hook_path = find_hook(the_repository, hook_name);
if (!hook_path)
return 0;
@ -922,7 +922,7 @@ static int run_update_hook(struct command *cmd)
{
struct child_process proc = CHILD_PROCESS_INIT;
int code;
const char *hook_path = find_hook("update");
const char *hook_path = find_hook(the_repository, "update");
if (!hook_path)
return 0;
@ -1098,7 +1098,7 @@ static int run_proc_receive_hook(struct command *commands,
int hook_use_push_options = 0;
int version = 0;
int code;
const char *hook_path = find_hook("proc-receive");
const char *hook_path = find_hook(the_repository, "proc-receive");
if (!hook_path) {
rp_error("cannot find hook 'proc-receive'");
@ -1409,7 +1409,7 @@ static const char *push_to_checkout(unsigned char *hash,
strvec_pushf(env, "GIT_WORK_TREE=%s", absolute_path(work_tree));
strvec_pushv(&opt.env, env->v);
strvec_push(&opt.args, hash_to_hex(hash));
if (run_hooks_opt(push_to_checkout_hook, &opt))
if (run_hooks_opt(the_repository, push_to_checkout_hook, &opt))
return "push-to-checkout hook declined";
else
return NULL;
@ -1618,7 +1618,7 @@ static void run_update_post_hook(struct command *commands)
struct child_process proc = CHILD_PROCESS_INIT;
const char *hook;
hook = find_hook("post-update");
hook = find_hook(the_repository, "post-update");
if (!hook)
return;

4
builtin/remote.c
View file

@ -747,7 +747,7 @@ static int mv(int argc, const char **argv, const char *prefix)
strbuf_addf(&buf, "remote.%s", rename.old_name);
strbuf_addf(&buf2, "remote.%s", rename.new_name);
if (git_config_rename_section(buf.buf, buf2.buf) < 1)
if (repo_config_rename_section(the_repository, buf.buf, buf2.buf) < 1)
return error(_("Could not rename config section '%s' to '%s'"),
buf.buf, buf2.buf);
@ -960,7 +960,7 @@ static int rm(int argc, const char **argv, const char *prefix)
if (!result) {
strbuf_addf(&buf, "remote.%s", remote->name);
if (git_config_rename_section(buf.buf, NULL) < 1) {
if (repo_config_rename_section(the_repository, buf.buf, NULL) < 1) {
result = error(_("Could not remove config section '%s'"), buf.buf);
goto out;
}

2
builtin/submodule--helper.c
View file

@ -1456,7 +1456,7 @@ static void deinit_submodule(const char *path, const char *prefix,
* remove the whole section so we have a clean state when
* the user later decides to init this submodule again
*/
git_config_rename_section_in_file(NULL, sub_key, NULL);
repo_config_rename_section_in_file(the_repository, NULL, sub_key, NULL);
if (!(flags & OPT_QUIET))
printf(_("Submodule '%s' (%s) unregistered for path '%s'\n"),
sub->name, sub->url, displaypath);

4
builtin/update-index.c
View file

@ -1156,7 +1156,7 @@ int cmd_update_index(int argc, const char **argv, const char *prefix)
end_odb_transaction();
if (split_index > 0) {
if (git_config_get_split_index() == 0)
if (repo_config_get_split_index(the_repository) == 0)
warning(_("core.splitIndex is set to false; "
"remove or change it, if you really want to "
"enable split index"));
@ -1165,7 +1165,7 @@ int cmd_update_index(int argc, const char **argv, const char *prefix)
else
add_split_index(the_repository->index);
} else if (!split_index) {
if (git_config_get_split_index() == 1)
if (repo_config_get_split_index(the_repository) == 1)
warning(_("core.splitIndex is set to true; "
"remove or change it, if you really want to "
"disable split index"));

6
builtin/worktree.c
View file

@ -573,7 +573,7 @@ static int add_worktree(const char *path, const char *refname,
NULL);
opt.dir = path;
ret = run_hooks_opt("post-checkout", &opt);
ret = run_hooks_opt(the_repository, "post-checkout", &opt);
}
strvec_clear(&child_env);
@ -1148,14 +1148,14 @@ static void validate_no_submodules(const struct worktree *wt)
struct strbuf path = STRBUF_INIT;
int i, found_submodules = 0;
if (is_directory(worktree_git_path(wt, "modules"))) {
if (is_directory(worktree_git_path(the_repository, wt, "modules"))) {
/*
* There could be false positives, e.g. the "modules"
* directory exists but is empty. But it's a rare case and
* this simpler check is probably good enough for now.
*/
found_submodules = 1;
} else if (read_index_from(&istate, worktree_git_path(wt, "index"),
} else if (read_index_from(&istate, worktree_git_path(the_repository, wt, "index"),
get_worktree_git_dir(wt)) > 0) {
for (i = 0; i < istate.cache_nr; i++) {
struct cache_entry *ce = istate.cache[i];

2
commit.c
View file

@ -1960,5 +1960,5 @@ int run_commit_hook(int editor_is_used, const char *index_file,
va_end(args);
opt.invoked_hook = invoked_hook;
return run_hooks_opt(name, &opt);
return run_hooks_opt(the_repository, name, &opt);
}

2
compat/fsmonitor/fsm-ipc-darwin.c
View file

@ -1,3 +1,5 @@
#define USE_THE_REPOSITORY_VARIABLE
#include "git-compat-util.h"
#include "config.h"
#include "gettext.h"

1
compat/precompose_utf8.c
View file

@ -4,6 +4,7 @@
*/
#define PRECOMPOSE_UNICODE_C
#define USE_THE_REPOSITORY_VARIABLE
#include "git-compat-util.h"
#include "config.h"

225
config.c
View file

@ -6,8 +6,6 @@
*
*/
#define USE_THE_REPOSITORY_VARIABLE
#include "git-compat-util.h"
#include "abspath.h"
#include "advice.h"
@ -300,13 +298,14 @@ static int include_by_gitdir(const struct key_value_info *kvi,
return ret;
}
static int include_by_branch(const char *cond, size_t cond_len)
static int include_by_branch(struct config_include_data *data,
const char *cond, size_t cond_len)
{
int flags;
int ret;
struct strbuf pattern = STRBUF_INIT;
const char *refname = !the_repository->gitdir ?
NULL : refs_resolve_ref_unsafe(get_main_ref_store(the_repository),
const char *refname = (!data->repo || !data->repo->gitdir) ?
NULL : refs_resolve_ref_unsafe(get_main_ref_store(data->repo),
"HEAD", 0, NULL, &flags);
const char *shortname;
@ -406,7 +405,7 @@ static int include_condition_is_true(const struct key_value_info *kvi,
else if (skip_prefix_mem(cond, cond_len, "gitdir/i:", &cond, &cond_len))
return include_by_gitdir(kvi, opts, cond, cond_len, 1);
else if (skip_prefix_mem(cond, cond_len, "onbranch:", &cond, &cond_len))
return include_by_branch(cond, cond_len);
return include_by_branch(inc, cond, cond_len);
else if (skip_prefix_mem(cond, cond_len, "hasconfig:remote.*.url:", &cond,
&cond_len))
return include_by_remote_url(inc, cond, cond_len);
@ -2565,7 +2564,7 @@ static void git_config_check_init(struct repository *repo)
repo_read_config(repo);
}
static void repo_config_clear(struct repository *repo)
void repo_config_clear(struct repository *repo)
{
if (!repo->config || !repo->config->hash_initialized)
return;
@ -2612,7 +2611,7 @@ int repo_config_get_string(struct repository *repo,
git_config_check_init(repo);
ret = git_configset_get_string(repo->config, key, dest);
if (ret < 0)
git_die_config(key, NULL);
git_die_config(repo, key, NULL);
return ret;
}
@ -2623,7 +2622,7 @@ int repo_config_get_string_tmp(struct repository *repo,
git_config_check_init(repo);
ret = git_configset_get_string_tmp(repo->config, key, dest);
if (ret < 0)
git_die_config(key, NULL);
git_die_config(repo, key, NULL);
return ret;
}
@ -2669,7 +2668,7 @@ int repo_config_get_pathname(struct repository *repo,
git_config_check_init(repo);
ret = git_configset_get_pathname(repo->config, key, dest);
if (ret < 0)
git_die_config(key, NULL);
git_die_config(repo, key, NULL);
return ret;
}
@ -2695,98 +2694,27 @@ void git_protected_config(config_fn_t fn, void *data)
configset_iter(&protected_config, fn, data);
}
/* Functions used historically to read configuration from 'the_repository' */
void git_config(config_fn_t fn, void *data)
int repo_config_get_expiry(struct repository *r, const char *key, const char **output)
{
repo_config(the_repository, fn, data);
}
void git_config_clear(void)
{
repo_config_clear(the_repository);
}
int git_config_get(const char *key)
{
return repo_config_get(the_repository, key);
}
int git_config_get_value(const char *key, const char **value)
{
return repo_config_get_value(the_repository, key, value);
}
int git_config_get_value_multi(const char *key, const struct string_list **dest)
{
return repo_config_get_value_multi(the_repository, key, dest);
}
int git_config_get_string_multi(const char *key,
const struct string_list **dest)
{
return repo_config_get_string_multi(the_repository, key, dest);
}
int git_config_get_string(const char *key, char **dest)
{
return repo_config_get_string(the_repository, key, dest);
}
int git_config_get_string_tmp(const char *key, const char **dest)
{
return repo_config_get_string_tmp(the_repository, key, dest);
}
int git_config_get_int(const char *key, int *dest)
{
return repo_config_get_int(the_repository, key, dest);
}
int git_config_get_ulong(const char *key, unsigned long *dest)
{
return repo_config_get_ulong(the_repository, key, dest);
}
int git_config_get_bool(const char *key, int *dest)
{
return repo_config_get_bool(the_repository, key, dest);
}
int git_config_get_bool_or_int(const char *key, int *is_bool, int *dest)
{
return repo_config_get_bool_or_int(the_repository, key, is_bool, dest);
}
int git_config_get_maybe_bool(const char *key, int *dest)
{
return repo_config_get_maybe_bool(the_repository, key, dest);
}
int git_config_get_pathname(const char *key, char **dest)
{
return repo_config_get_pathname(the_repository, key, dest);
}
int git_config_get_expiry(const char *key, const char **output)
{
int ret = git_config_get_string(key, (char **)output);
int ret = repo_config_get_string(r, key, (char **)output);
if (ret)
return ret;
if (strcmp(*output, "now")) {
timestamp_t now = approxidate("now");
if (approxidate(*output) >= now)
git_die_config(key, _("Invalid %s: '%s'"), key, *output);
git_die_config(r, key, _("Invalid %s: '%s'"), key, *output);
}
return ret;
}
int git_config_get_expiry_in_days(const char *key, timestamp_t *expiry, timestamp_t now)
int repo_config_get_expiry_in_days(struct repository *r, const char *key,
timestamp_t *expiry, timestamp_t now)
{
const char *expiry_string;
intmax_t days;
timestamp_t when;
if (git_config_get_string_tmp(key, &expiry_string))
if (repo_config_get_string_tmp(r, key, &expiry_string))
return 1; /* no such thing */
if (git_parse_signed(expiry_string, &days, maximum_signed_value_of_type(int))) {
@ -2802,21 +2730,21 @@ int git_config_get_expiry_in_days(const char *key, timestamp_t *expiry, timestam
return -1; /* thing exists but cannot be parsed */
}
int git_config_get_split_index(void)
int repo_config_get_split_index(struct repository *r)
{
int val;
if (!git_config_get_maybe_bool("core.splitindex", &val))
if (!repo_config_get_maybe_bool(r, "core.splitindex", &val))
return val;
return -1; /* default value */
}
int git_config_get_max_percent_split_change(void)
int repo_config_get_max_percent_split_change(struct repository *r)
{
int val = -1;
if (!git_config_get_int("splitindex.maxpercentchange", &val)) {
if (!repo_config_get_int(r, "splitindex.maxpercentchange", &val)) {
if (0 <= val && val <= 100)
return val;
@ -2827,7 +2755,7 @@ int git_config_get_max_percent_split_change(void)
return -1; /* default value */
}
int git_config_get_index_threads(int *dest)
int repo_config_get_index_threads(struct repository *r, int *dest)
{
int is_bool, val;
@ -2837,7 +2765,7 @@ int git_config_get_index_threads(int *dest)
return 0;
}
if (!git_config_get_bool_or_int("index.threads", &is_bool, &val)) {
if (!repo_config_get_bool_or_int(r, "index.threads", &is_bool, &val)) {
if (is_bool)
*dest = val ? 0 : 1;
else
@ -2858,7 +2786,7 @@ void git_die_config_linenr(const char *key, const char *filename, int linenr)
key, filename, linenr);
}
void git_die_config(const char *key, const char *err, ...)
void git_die_config(struct repository *r, const char *key, const char *err, ...)
{
const struct string_list *values;
struct key_value_info *kv_info;
@ -2870,7 +2798,7 @@ void git_die_config(const char *key, const char *err, ...)
error_fn(err, params);
va_end(params);
}
if (git_config_get_value_multi(key, &values))
if (repo_config_get_value_multi(r, key, &values))
BUG("for key '%s' we must have a value to report on", key);
kv_info = values->items[values->nr - 1].util;
git_die_config_linenr(key, kv_info->filename, kv_info->linenr);
@ -3179,21 +3107,21 @@ static void maybe_remove_section(struct config_store_data *store,
*end_offset = store->parsed[store->parsed_nr - 1].end;
}
int git_config_set_in_file_gently(const char *config_filename,
const char *key, const char *comment, const char *value)
int repo_config_set_in_file_gently(struct repository *r, const char *config_filename,
const char *key, const char *comment, const char *value)
{
return git_config_set_multivar_in_file_gently(config_filename, key, value, NULL, comment, 0);
return repo_config_set_multivar_in_file_gently(r, config_filename, key, value, NULL, comment, 0);
}
void git_config_set_in_file(const char *config_filename,
const char *key, const char *value)
void repo_config_set_in_file(struct repository *r, const char *config_filename,
const char *key, const char *value)
{
git_config_set_multivar_in_file(config_filename, key, value, NULL, 0);
repo_config_set_multivar_in_file(r, config_filename, key, value, NULL, 0);
}
int git_config_set_gently(const char *key, const char *value)
int repo_config_set_gently(struct repository *r, const char *key, const char *value)
{
return git_config_set_multivar_gently(key, value, NULL, 0);
return repo_config_set_multivar_gently(r, key, value, NULL, 0);
}
int repo_config_set_worktree_gently(struct repository *r,
@ -3202,17 +3130,17 @@ int repo_config_set_worktree_gently(struct repository *r,
/* Only use worktree-specific config if it is already enabled. */
if (r->repository_format_worktree_config) {
char *file = repo_git_path(r, "config.worktree");
int ret = git_config_set_multivar_in_file_gently(
file, key, value, NULL, NULL, 0);
int ret = repo_config_set_multivar_in_file_gently(
r, file, key, value, NULL, NULL, 0);
free(file);
return ret;
}
return repo_config_set_multivar_gently(r, key, value, NULL, 0);
}
void git_config_set(const char *key, const char *value)
void repo_config_set(struct repository *r, const char *key, const char *value)
{
git_config_set_multivar(key, value, NULL, 0);
repo_config_set_multivar(r, key, value, NULL, 0);
trace2_cmd_set_config(key, value);
}
@ -3294,11 +3222,12 @@ static void validate_comment_string(const char *comment)
* - the config file is removed and the lock file rename()d to it.
*
*/
int git_config_set_multivar_in_file_gently(const char *config_filename,
const char *key, const char *value,
const char *value_pattern,
const char *comment,
unsigned flags)
int repo_config_set_multivar_in_file_gently(struct repository *r,
const char *config_filename,
const char *key, const char *value,
const char *value_pattern,
const char *comment,
unsigned flags)
{
int fd = -1, in_fd = -1;
int ret;
@ -3318,7 +3247,7 @@ int git_config_set_multivar_in_file_gently(const char *config_filename,
store.multi_replace = (flags & CONFIG_FLAGS_MULTI_REPLACE) != 0;
if (!config_filename)
config_filename = filename_buf = git_pathdup("config");
config_filename = filename_buf = repo_git_path(r, "config");
/*
* The lock serves a purpose in addition to locking: the new
@ -3527,7 +3456,7 @@ int git_config_set_multivar_in_file_gently(const char *config_filename,
ret = 0;
/* Invalidate the config cache */
git_config_clear();
repo_config_clear(r);
out_free:
rollback_lock_file(&lock);
@ -3544,12 +3473,13 @@ int git_config_set_multivar_in_file_gently(const char *config_filename,
goto out_free;
}
void git_config_set_multivar_in_file(const char *config_filename,
const char *key, const char *value,
const char *value_pattern, unsigned flags)
void repo_config_set_multivar_in_file(struct repository *r,
const char *config_filename,
const char *key, const char *value,
const char *value_pattern, unsigned flags)
{
if (!git_config_set_multivar_in_file_gently(config_filename, key, value,
value_pattern, NULL, flags))
if (!repo_config_set_multivar_in_file_gently(r, config_filename, key, value,
value_pattern, NULL, flags))
return;
if (value)
die(_("could not set '%s' to '%s'"), key, value);
@ -3557,32 +3487,27 @@ void git_config_set_multivar_in_file(const char *config_filename,
die(_("could not unset '%s'"), key);
}
int git_config_set_multivar_gently(const char *key, const char *value,
const char *value_pattern, unsigned flags)
{
return repo_config_set_multivar_gently(the_repository, key, value,
value_pattern, flags);
}
int repo_config_set_multivar_gently(struct repository *r, const char *key,
const char *value,
const char *value_pattern, unsigned flags)
{
char *file = repo_git_path(r, "config");
int res = git_config_set_multivar_in_file_gently(file,
key, value,
value_pattern,
NULL, flags);
int res = repo_config_set_multivar_in_file_gently(r, file,
key, value,
value_pattern,
NULL, flags);
free(file);
return res;
}
void git_config_set_multivar(const char *key, const char *value,
const char *value_pattern, unsigned flags)
void repo_config_set_multivar(struct repository *r,
const char *key, const char *value,
const char *value_pattern, unsigned flags)
{
git_config_set_multivar_in_file(git_path("config"),
key, value, value_pattern,
flags);
char *file = repo_git_path(r, "config");
repo_config_set_multivar_in_file(r, file, key, value,
value_pattern, flags);
free(file);
}
static size_t section_name_match (const char *buf, const char *name)
@ -3644,9 +3569,11 @@ static int section_name_is_ok(const char *name)
#define GIT_CONFIG_MAX_LINE_LEN (512 * 1024)
/* if new_name == NULL, the section is removed instead */
static int git_config_copy_or_rename_section_in_file(const char *config_filename,
const char *old_name,
const char *new_name, int copy)
static int repo_config_copy_or_rename_section_in_file(
struct repository *r,
const char *config_filename,
const char *old_name,
const char *new_name, int copy)
{
int ret = 0, remove = 0;
char *filename_buf = NULL;
@ -3667,7 +3594,7 @@ static int git_config_copy_or_rename_section_in_file(const char *config_filename
}
if (!config_filename)
config_filename = filename_buf = git_pathdup("config");
config_filename = filename_buf = repo_git_path(r, "config");
out_fd = hold_lock_file_for_update(&lock, config_filename, 0);
if (out_fd < 0) {
@ -3810,28 +3737,28 @@ static int git_config_copy_or_rename_section_in_file(const char *config_filename
return ret;
}
int git_config_rename_section_in_file(const char *config_filename,
const char *old_name, const char *new_name)
int repo_config_rename_section_in_file(struct repository *r, const char *config_filename,
const char *old_name, const char *new_name)
{
return git_config_copy_or_rename_section_in_file(config_filename,
return repo_config_copy_or_rename_section_in_file(r, config_filename,
old_name, new_name, 0);
}
int git_config_rename_section(const char *old_name, const char *new_name)
int repo_config_rename_section(struct repository *r, const char *old_name, const char *new_name)
{
return git_config_rename_section_in_file(NULL, old_name, new_name);
return repo_config_rename_section_in_file(r, NULL, old_name, new_name);
}
int git_config_copy_section_in_file(const char *config_filename,
const char *old_name, const char *new_name)
int repo_config_copy_section_in_file(struct repository *r, const char *config_filename,
const char *old_name, const char *new_name)
{
return git_config_copy_or_rename_section_in_file(config_filename,
return repo_config_copy_or_rename_section_in_file(r, config_filename,
old_name, new_name, 1);
}
int git_config_copy_section(const char *old_name, const char *new_name)
int repo_config_copy_section(struct repository *r, const char *old_name, const char *new_name)
{
return git_config_copy_section_in_file(NULL, old_name, new_name);
return repo_config_copy_section_in_file(r, NULL, old_name, new_name);
}
/*

285
config.h
View file

@ -26,7 +26,7 @@ struct object_id;
/* git_config_parse_key() returns these negated: */
#define CONFIG_INVALID_KEY 1
#define CONFIG_NO_SECTION_OR_NAME 2
/* git_config_set_gently(), git_config_set_multivar_gently() return the above or these: */
/* repo_config_set_gently(), repo_config_set_multivar_gently() return the above or these: */
#define CONFIG_NO_LOCK -1
#define CONFIG_INVALID_FILE 3
#define CONFIG_NO_WRITE 4
@ -170,9 +170,9 @@ int git_default_config(const char *, const char *,
/**
* Read a specific file in git-config format.
* This function takes the same callback and data parameters as `git_config`.
* This function takes the same callback and data parameters as `repo_config`.
*
* Unlike git_config(), this function does not respect includes.
* Unlike repo_config(), this function does not respect includes.
*/
int git_config_from_file(config_fn_t fn, const char *, void *);
@ -198,9 +198,9 @@ void read_very_early_config(config_fn_t cb, void *data);
/**
* Most programs will simply want to look up variables in all config files
* that Git knows about, using the normal precedence rules. To do this,
* call `git_config` with a callback function and void data pointer.
* call `repo_config` with a callback function and void data pointer.
*
* `git_config` will read all config sources in order of increasing
* `repo_config` will read all config sources in order of increasing
* priority. Thus a callback should typically overwrite previously-seen
* entries with new ones (e.g., if both the user-wide `~/.gitconfig` and
* repo-specific `.git/config` contain `color.ui`, the config machinery
@ -210,11 +210,11 @@ void read_very_early_config(config_fn_t cb, void *data);
*
* Unlike git_config_from_file(), this function respects includes.
*/
void git_config(config_fn_t fn, void *);
void repo_config(struct repository *r, config_fn_t fn, void *);
/**
* Lets the caller examine config while adjusting some of the default
* behavior of `git_config`. It should almost never be used by "regular"
* behavior of `repo_config`. It should almost never be used by "regular"
* Git code that is looking up configuration variables.
* It is intended for advanced callers like `git-config`, which are
* intentionally tweaking the normal config-lookup process.
@ -223,12 +223,12 @@ void git_config(config_fn_t fn, void *);
* - `config_source`
* If this parameter is non-NULL, it specifies the source to parse for
* configuration, rather than looking in the usual files. See `struct
* git_config_source` in `config.h` for details. Regular `git_config` defaults
* git_config_source` in `config.h` for details. Regular `repo_config` defaults
* to `NULL`.
*
* - `opts`
* Specify options to adjust the behavior of parsing config files. See `struct
* config_options` in `config.h` for details. As an example: regular `git_config`
* config_options` in `config.h` for details. As an example: regular `repo_config`
* sets `opts.respect_includes` to `1` by default.
*/
int config_with_options(config_fn_t fn, void *,
@ -297,15 +297,16 @@ int git_config_pathname(char **, const char *, const char *);
int git_config_expiry_date(timestamp_t *, const char *, const char *);
int git_config_color(char *, const char *, const char *);
int git_config_set_in_file_gently(const char *, const char *, const char *, const char *);
int repo_config_set_in_file_gently(struct repository *r, const char *config_filename,
const char *key, const char *comment, const char *value);
/**
* write config values to a specific config file, takes a key/value pair as
* parameter.
*/
void git_config_set_in_file(const char *, const char *, const char *);
void repo_config_set_in_file(struct repository *, const char *, const char *, const char *);
int git_config_set_gently(const char *, const char *);
int repo_config_set_gently(struct repository *r, const char *, const char *);
/**
* Write a config value that should apply to the current worktree. If
@ -317,13 +318,13 @@ int repo_config_set_worktree_gently(struct repository *, const char *, const cha
/**
* write config values to `.git/config`, takes a key/value pair as parameter.
*/
void git_config_set(const char *, const char *);
void repo_config_set(struct repository *, const char *, const char *);
int git_config_parse_key(const char *, char **, size_t *);
/*
* The following macros specify flag bits that alter the behavior
* of the git_config_set_multivar*() methods.
* of the repo_config_set_multivar*() methods.
*/
/*
@ -340,10 +341,9 @@ int git_config_parse_key(const char *, char **, size_t *);
*/
#define CONFIG_FLAGS_FIXED_VALUE (1 << 1)
int git_config_set_multivar_gently(const char *, const char *, const char *, unsigned);
void git_config_set_multivar(const char *, const char *, const char *, unsigned);
int repo_config_set_multivar_gently(struct repository *, const char *, const char *, const char *, unsigned);
int git_config_set_multivar_in_file_gently(const char *, const char *, const char *, const char *, const char *, unsigned);
void repo_config_set_multivar(struct repository *r, const char *, const char *, const char *, unsigned);
int repo_config_set_multivar_in_file_gently(struct repository *, const char *, const char *, const char *, const char *, const char *, unsigned);
char *git_config_prepare_comment_string(const char *);
@ -367,11 +367,12 @@ char *git_config_prepare_comment_string(const char *);
*
* It returns 0 on success.
*/
void git_config_set_multivar_in_file(const char *config_filename,
const char *key,
const char *value,
const char *value_pattern,
unsigned flags);
void repo_config_set_multivar_in_file(struct repository *r,
const char *config_filename,
const char *key,
const char *value,
const char *value_pattern,
unsigned flags);
/**
* rename or remove sections in the config file
@ -379,11 +380,11 @@ void git_config_set_multivar_in_file(const char *config_filename,
* If NULL is passed through `new_name` parameter,
* the section will be removed from the config file.
*/
int git_config_rename_section(const char *, const char *);
int repo_config_rename_section(struct repository *, const char *, const char *);
int git_config_rename_section_in_file(const char *, const char *, const char *);
int git_config_copy_section(const char *, const char *);
int git_config_copy_section_in_file(const char *, const char *, const char *);
int repo_config_rename_section_in_file(struct repository *, const char *, const char *, const char *);
int repo_config_copy_section(struct repository *, const char *, const char *);
int repo_config_copy_section_in_file(struct repository *, const char *, const char *, const char *);
int git_config_system(void);
int config_error_nonbool(const char *);
#if defined(__GNUC__)
@ -550,39 +551,11 @@ int git_configset_get_bool_or_int(struct config_set *cs, const char *key, int *i
int git_configset_get_maybe_bool(struct config_set *cs, const char *key, int *dest);
int git_configset_get_pathname(struct config_set *cs, const char *key, char **dest);
/* Functions for reading a repository's config */
struct repository;
void repo_config(struct repository *repo, config_fn_t fn, void *data);
/**
* Run only the discover part of the repo_config_get_*() functions
* below, in addition to 1 if not found, returns negative values on
* error (e.g. if the key itself is invalid).
*/
RESULT_MUST_BE_USED
int repo_config_get(struct repository *repo, const char *key);
int repo_config_get_value(struct repository *repo,
const char *key, const char **value);
RESULT_MUST_BE_USED
int repo_config_get_value_multi(struct repository *repo, const char *key,
const struct string_list **dest);
RESULT_MUST_BE_USED
int repo_config_get_string_multi(struct repository *repo, const char *key,
const struct string_list **dest);
int repo_config_get_string(struct repository *repo,
const char *key, char **dest);
int repo_config_get_string_tmp(struct repository *repo,
const char *key, const char **dest);
int repo_config_get_int(struct repository *repo,
const char *key, int *dest);
int repo_config_get_ulong(struct repository *repo,
const char *key, unsigned long *dest);
int repo_config_get_bool(struct repository *repo,
const char *key, int *dest);
int repo_config_get_bool_or_int(struct repository *repo,
const char *key, int *is_bool, int *dest);
int repo_config_get_maybe_bool(struct repository *repo,
const char *key, int *dest);
int repo_config_get_pathname(struct repository *repo,
const char *key, char **dest);
@ -598,17 +571,17 @@ void git_protected_config(config_fn_t fn, void *data);
* -------------------------------
*
* For programs wanting to query for specific variables in a non-callback
* manner, the config API provides two functions `git_config_get_value`
* and `git_config_get_value_multi`. They both read values from an internal
* manner, the config API provides two functions `repo_config_get_value`
* and `repo_config_get_value_multi`. They both read values from an internal
* cache generated previously from reading the config files.
*
* For those git_config_get*() functions that aren't documented,
* For those repo_config_get*() functions that aren't documented,
* consult the corresponding repo_config_get*() function's
* documentation.
*/
RESULT_MUST_BE_USED
int git_config_get(const char *key);
int repo_config_get(struct repository *r, const char *key);
/**
* Finds the highest-priority value for the configuration variable `key`,
@ -617,7 +590,7 @@ int git_config_get(const char *key);
* `value`. The caller should not free or modify `value`, as it is owned
* by the cache.
*/
int git_config_get_value(const char *key, const char **value);
int repo_config_get_value(struct repository *r, const char *key, const char **value);
/**
* Finds and returns the value list, sorted in order of increasing priority
@ -628,16 +601,16 @@ int git_config_get_value(const char *key, const char **value);
* owned by the cache.
*/
RESULT_MUST_BE_USED
int git_config_get_value_multi(const char *key,
const struct string_list **dest);
RESULT_MUST_BE_USED
int git_config_get_string_multi(const char *key,
int repo_config_get_value_multi(struct repository *r, const char *key,
const struct string_list **dest);
RESULT_MUST_BE_USED
int repo_config_get_string_multi(struct repository *r, const char *key,
const struct string_list **dest);
/**
* Resets and invalidates the config cache.
*/
void git_config_clear(void);
void repo_config_clear(struct repository *repo);
/**
* Allocates and copies the retrieved string into the `dest` parameter for
@ -645,14 +618,15 @@ void git_config_clear(void);
* error message and returns -1. When the configuration variable `key` is
* not found, returns 1 without touching `dest`.
*/
int git_config_get_string(const char *key, char **dest);
int repo_config_get_string(struct repository *r, const char *key, char **dest);
/**
* Similar to `git_config_get_string`, but does not allocate any new
* Similar to `repo_config_get_string`, but does not allocate any new
* memory; on success `dest` will point to memory owned by the config
* machinery, which could be invalidated if it is discarded and reloaded.
*/
int git_config_get_string_tmp(const char *key, const char **dest);
int repo_config_get_string_tmp(struct repository *r,
const char *key, const char **dest);
/**
* Finds and parses the value to an integer for the configuration variable
@ -660,12 +634,13 @@ int git_config_get_string_tmp(const char *key, const char **dest);
* `dest` and returns 0. When the configuration variable `key` is not found,
* returns 1 without touching `dest`.
*/
int git_config_get_int(const char *key, int *dest);
int repo_config_get_int(struct repository *r, const char *key, int *dest);
/**
* Similar to `git_config_get_int` but for unsigned longs.
* Similar to `repo_config_get_int` but for unsigned longs.
*/
int git_config_get_ulong(const char *key, unsigned long *dest);
int repo_config_get_ulong(struct repository *r,
const char *key, unsigned long *dest);
/**
* Finds and parses the value into a boolean value, for the configuration
@ -676,47 +651,45 @@ int git_config_get_ulong(const char *key, unsigned long *dest);
* configuration variable `key` is not found, returns 1 without touching
* `dest`.
*/
int git_config_get_bool(const char *key, int *dest);
int repo_config_get_bool(struct repository *r, const char *key, int *dest);
/**
* Similar to `git_config_get_bool`, except that integers are copied as-is,
* Similar to `repo_config_get_bool`, except that integers are copied as-is,
* and `is_bool` flag is unset.
*/
int git_config_get_bool_or_int(const char *key, int *is_bool, int *dest);
int repo_config_get_bool_or_int(struct repository *r, const char *key,
int *is_bool, int *dest);
/**
* Similar to `git_config_get_bool`, except that it returns -1 on error
* Similar to `repo_config_get_bool`, except that it returns -1 on error
* rather than dying.
*/
int git_config_get_maybe_bool(const char *key, int *dest);
int repo_config_get_maybe_bool(struct repository *r,
const char *key, int *dest);
/**
* Similar to `git_config_get_string`, but expands `~` or `~user` into
* the user's home directory when found at the beginning of the path.
*/
int git_config_get_pathname(const char *key, char **dest);
int git_config_get_index_threads(int *dest);
int git_config_get_split_index(void);
int git_config_get_max_percent_split_change(void);
int repo_config_get_index_threads(struct repository *r, int *dest);
int repo_config_get_split_index(struct repository *r);
int repo_config_get_max_percent_split_change(struct repository *r);
/* This dies if the configured or default date is in the future */
int git_config_get_expiry(const char *key, const char **output);
int repo_config_get_expiry(struct repository *r, const char *key, const char **output);
/* parse either "this many days" integer, or "5.days.ago" approxidate */
int git_config_get_expiry_in_days(const char *key, timestamp_t *, timestamp_t now);
int repo_config_get_expiry_in_days(struct repository *r, const char *key,
timestamp_t *, timestamp_t now);
/**
* First prints the error message specified by the caller in `err` and then
* dies printing the line number and the file name of the highest priority
* value for the configuration variable `key`.
*/
NORETURN void git_die_config(const char *key, const char *err, ...) __attribute__((format(printf, 2, 3)));
NORETURN void git_die_config(struct repository *r, const char *key, const char *err, ...)
__attribute__((format(printf, 3, 4)));
/**
* Helper function which formats the die error message according to the
* parameters entered. Used by `git_die_config()`. It can be used by callers
* handling `git_config_get_value_multi()` to print the correct error message
* handling `repo_config_get_value_multi()` to print the correct error message
* for the desired value.
*/
NORETURN void git_die_config_linenr(const char *key, const char *filename, int linenr);
@ -725,4 +698,140 @@ NORETURN void git_die_config_linenr(const char *key, const char *filename, int l
lookup_config(mapping, ARRAY_SIZE(mapping), var)
int lookup_config(const char **mapping, int nr_mapping, const char *var);
# ifdef USE_THE_REPOSITORY_VARIABLE
static inline void git_config(config_fn_t fn, void *data)
{
repo_config(the_repository, fn, data);
}
static inline void git_config_clear(void)
{
repo_config_clear(the_repository);
}
static inline int git_config_get(const char *key)
{
return repo_config_get(the_repository, key);
}
static inline int git_config_get_value(const char *key, const char **value)
{
return repo_config_get_value(the_repository, key, value);
}
static inline int git_config_get_value_multi(const char *key, const struct string_list **dest)
{
return repo_config_get_value_multi(the_repository, key, dest);
}
static inline int git_config_get_string_multi(const char *key,
const struct string_list **dest)
{
return repo_config_get_string_multi(the_repository, key, dest);
}
static inline int git_config_get_string(const char *key, char **dest)
{
return repo_config_get_string(the_repository, key, dest);
}
static inline int git_config_get_string_tmp(const char *key, const char **dest)
{
return repo_config_get_string_tmp(the_repository, key, dest);
}
static inline int git_config_get_int(const char *key, int *dest)
{
return repo_config_get_int(the_repository, key, dest);
}
static inline int git_config_get_ulong(const char *key, unsigned long *dest)
{
return repo_config_get_ulong(the_repository, key, dest);
}
static inline int git_config_get_bool(const char *key, int *dest)
{
return repo_config_get_bool(the_repository, key, dest);
}
static inline int git_config_get_bool_or_int(const char *key, int *is_bool, int *dest)
{
return repo_config_get_bool_or_int(the_repository, key, is_bool, dest);
}
static inline int git_config_get_maybe_bool(const char *key, int *dest)
{
return repo_config_get_maybe_bool(the_repository, key, dest);
}
static inline int git_config_get_pathname(const char *key, char **dest)
{
return repo_config_get_pathname(the_repository, key, dest);
}
static inline void git_config_set_in_file(const char *config_filename,
const char *key, const char *value)
{
repo_config_set_in_file(the_repository, config_filename, key, value);
}
static inline int git_config_set_gently(const char *key, const char *value)
{
return repo_config_set_gently(the_repository, key, value);
}
static inline void git_config_set(const char *key, const char *value)
{
repo_config_set(the_repository, key, value);
}
static inline int git_config_set_in_file_gently(
const char *config_filename,
const char *key,
const char *comment,
const char *value)
{
return repo_config_set_in_file_gently(the_repository, config_filename,
key, comment, value);
}
static inline int git_config_set_multivar_in_file_gently(
const char *config_filename,
const char *key, const char *value,
const char *value_pattern,
const char *comment,
unsigned flags)
{
return repo_config_set_multivar_in_file_gently(the_repository, config_filename,
key, value, value_pattern,
comment, flags);
}
static inline void git_config_set_multivar_in_file(
const char *config_filename,
const char *key,
const char *value,
const char *value_pattern,
unsigned flags)
{
repo_config_set_multivar_in_file(the_repository, config_filename,
key, value, value_pattern, flags);
}
static inline int git_config_set_multivar_gently(const char *key, const char *value,
const char *value_pattern, unsigned flags)
{
return repo_config_set_multivar_gently(the_repository, key, value,
value_pattern, flags);
}
static inline void git_config_set_multivar(const char *key, const char *value,
const char *value_pattern, unsigned flags)
{
repo_config_set_multivar(the_repository, key, value,
value_pattern, flags);
}
# endif /* USE_THE_REPOSITORY_VARIABLE */
#endif /* CONFIG_H */

2
connect.c
View file

@ -1,3 +1,5 @@
#define USE_THE_REPOSITORY_VARIABLE
#include "git-compat-util.h"
#include "config.h"
#include "environment.h"

2
credential.c
View file

@ -1,3 +1,5 @@
#define USE_THE_REPOSITORY_VARIABLE
#include "git-compat-util.h"
#include "abspath.h"
#include "config.h"

2
daemon.c
View file

@ -1,3 +1,5 @@
#define USE_THE_REPOSITORY_VARIABLE
#include "git-compat-util.h"
#include "abspath.h"
#include "config.h"

15
editor.c
View file

@ -1,3 +1,5 @@
#define USE_THE_REPOSITORY_VARIABLE
#include "git-compat-util.h"
#include "abspath.h"
#include "advice.h"
@ -133,14 +135,17 @@ int launch_sequence_editor(const char *path, struct strbuf *buffer,
return launch_specified_editor(git_sequence_editor(), path, buffer, env);
}
int strbuf_edit_interactively(struct strbuf *buffer, const char *path,
int strbuf_edit_interactively(struct repository *r,
struct strbuf *buffer, const char *path,
const char *const *env)
{
char *path2 = NULL;
struct strbuf sb = STRBUF_INIT;
int fd, res = 0;
if (!is_absolute_path(path))
path = path2 = xstrdup(git_path("%s", path));
if (!is_absolute_path(path)) {
strbuf_repo_git_path(&sb, r, "%s", path);
path = sb.buf;
}
fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0666);
if (fd < 0)
@ -157,6 +162,6 @@ int strbuf_edit_interactively(struct strbuf *buffer, const char *path,
unlink(path);
}
free(path2);
strbuf_release(&sb);
return res;
}

5
editor.h
View file

@ -1,6 +1,7 @@
#ifndef EDITOR_H
#define EDITOR_H
struct repository;
struct strbuf;
const char *git_editor(void);
@ -28,7 +29,7 @@ int launch_sequence_editor(const char *path, struct strbuf *buffer,
*
* If `path` is relative, it refers to a file in the `.git` directory.
*/
int strbuf_edit_interactively(struct strbuf *buffer, const char *path,
const char *const *env);
int strbuf_edit_interactively(struct repository *r, struct strbuf *buffer,
const char *path, const char *const *env);
#endif

2
fsmonitor.c
View file

@ -1,3 +1,5 @@
#define USE_THE_REPOSITORY_VARIABLE
#include "git-compat-util.h"
#include "config.h"
#include "dir.h"

2
gpg-interface.c
View file

@ -1,3 +1,5 @@
#define USE_THE_REPOSITORY_VARIABLE
#include "git-compat-util.h"
#include "commit.h"
#include "config.h"

2
graph.c
View file

@ -1,3 +1,5 @@
#define USE_THE_REPOSITORY_VARIABLE
#include "git-compat-util.h"
#include "gettext.h"
#include "config.h"

21
hook.c
View file

@ -10,14 +10,14 @@
#include "environment.h"
#include "setup.h"
const char *find_hook(const char *name)
const char *find_hook(struct repository *r, const char *name)
{
static struct strbuf path = STRBUF_INIT;
int found_hook;
strbuf_reset(&path);
strbuf_git_path(&path, "hooks/%s", name);
strbuf_repo_git_path(&path, r, "hooks/%s", name);
found_hook = access(path.buf, X_OK) >= 0;
#ifdef STRIP_EXTENSION
if (!found_hook) {
@ -48,9 +48,9 @@ const char *find_hook(const char *name)
return path.buf;
}
int hook_exists(const char *name)
int hook_exists(struct repository *r, const char *name)
{
return !!find_hook(name);
return !!find_hook(r, name);
}
static int pick_next_hook(struct child_process *cp,
@ -121,7 +121,8 @@ static void run_hooks_opt_clear(struct run_hooks_opt *options)
strvec_clear(&options->args);
}
int run_hooks_opt(const char *hook_name, struct run_hooks_opt *options)
int run_hooks_opt(struct repository *r, const char *hook_name,
struct run_hooks_opt *options)
{
struct strbuf abs_path = STRBUF_INIT;
struct hook_cb_data cb_data = {
@ -129,7 +130,7 @@ int run_hooks_opt(const char *hook_name, struct run_hooks_opt *options)
.hook_name = hook_name,
.options = options,
};
const char *const hook_path = find_hook(hook_name);
const char *const hook_path = find_hook(r, hook_name);
int ret = 0;
const struct run_process_parallel_opts opts = {
.tr2_category = "hook",
@ -173,14 +174,14 @@ int run_hooks_opt(const char *hook_name, struct run_hooks_opt *options)
return ret;
}
int run_hooks(const char *hook_name)
int run_hooks(struct repository *r, const char *hook_name)
{
struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT;
return run_hooks_opt(hook_name, &opt);
return run_hooks_opt(r, hook_name, &opt);
}
int run_hooks_l(const char *hook_name, ...)
int run_hooks_l(struct repository *r, const char *hook_name, ...)
{
struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT;
va_list ap;
@ -191,5 +192,5 @@ int run_hooks_l(const char *hook_name, ...)
strvec_push(&opt.args, arg);
va_end(ap);
return run_hooks_opt(hook_name, &opt);
return run_hooks_opt(r, hook_name, &opt);
}

13
hook.h
View file

@ -2,6 +2,8 @@
#define HOOK_H
#include "strvec.h"
struct repository;
struct run_hooks_opt
{
/* Environment vars to be set for each hook */
@ -55,12 +57,12 @@ struct hook_cb_data {
* or disabled. Note that this points to static storage that will be
* overwritten by further calls to find_hook and run_hook_*.
*/
const char *find_hook(const char *name);
const char *find_hook(struct repository *r, const char *name);
/**
* A boolean version of find_hook()
*/
int hook_exists(const char *hookname);
int hook_exists(struct repository *r, const char *hookname);
/**
* Takes a `hook_name`, resolves it to a path with find_hook(), and
@ -70,13 +72,14 @@ int hook_exists(const char *hookname);
* Returns the status code of the run hook, or a negative value on
* error().
*/
int run_hooks_opt(const char *hook_name, struct run_hooks_opt *options);
int run_hooks_opt(struct repository *r, const char *hook_name,
struct run_hooks_opt *options);
/**
* A wrapper for run_hooks_opt() which provides a dummy "struct
* run_hooks_opt" initialized with "RUN_HOOKS_OPT_INIT".
*/
int run_hooks(const char *hook_name);
int run_hooks(struct repository *r, const char *hook_name);
/**
* Like run_hooks(), a wrapper for run_hooks_opt().
@ -87,5 +90,5 @@ int run_hooks(const char *hook_name);
* hook. This function behaves like the old run_hook_le() API.
*/
LAST_ARG_MUST_BE_NULL
int run_hooks_l(const char *hook_name, ...);
int run_hooks_l(struct repository *r, const char *hook_name, ...);
#endif

2
imap-send.c
View file

@ -21,6 +21,8 @@
* along with this program; if not, see <https://www.gnu.org/licenses/>.
*/
#define USE_THE_REPOSITORY_VARIABLE
#include "git-compat-util.h"
#include "config.h"
#include "credential.h"

2
mailinfo.c
View file

@ -1,3 +1,5 @@
#define USE_THE_REPOSITORY_VARIABLE
#include "git-compat-util.h"
#include "config.h"
#include "gettext.h"

2
merge-ll.c
View file

@ -4,6 +4,8 @@
* Copyright (c) 2007 Junio C Hamano
*/
#define USE_THE_REPOSITORY_VARIABLE
#include "git-compat-util.h"
#include "config.h"
#include "convert.h"

2
parallel-checkout.c
View file

@ -1,3 +1,5 @@
#define USE_THE_REPOSITORY_VARIABLE
#include "git-compat-util.h"
#include "config.h"
#include "entry.h"

97
path.c
View file

@ -2,8 +2,6 @@
* Utilities for paths and pathnames
*/
#define USE_THE_REPOSITORY_VARIABLE
#include "git-compat-util.h"
#include "abspath.h"
#include "environment.h"
@ -30,7 +28,7 @@ static int get_st_mode_bits(const char *path, int *mode)
return 0;
}
static struct strbuf *get_pathname(void)
struct strbuf *get_pathname(void)
{
static struct strbuf pathname_array[4] = {
STRBUF_INIT, STRBUF_INIT, STRBUF_INIT, STRBUF_INIT
@ -365,15 +363,15 @@ static void update_common_dir(struct strbuf *buf, int git_dir_len,
strbuf_addstr(buf, LOCK_SUFFIX);
}
void report_linked_checkout_garbage(void)
void report_linked_checkout_garbage(struct repository *r)
{
struct strbuf sb = STRBUF_INIT;
const struct common_dir *p;
int len;
if (!the_repository->different_commondir)
if (!r->different_commondir)
return;
strbuf_addf(&sb, "%s/", get_git_dir());
strbuf_addf(&sb, "%s/", r->gitdir);
len = sb.len;
for (p = common_list; p->path; p++) {
const char *path = p->path;
@ -417,9 +415,9 @@ static void strbuf_worktree_gitdir(struct strbuf *buf,
strbuf_git_common_path(buf, repo, "worktrees/%s", wt->id);
}
static void do_git_path(const struct repository *repo,
const struct worktree *wt, struct strbuf *buf,
const char *fmt, va_list args)
void repo_git_pathv(const struct repository *repo,
const struct worktree *wt, struct strbuf *buf,
const char *fmt, va_list args)
{
int gitdir_len;
strbuf_worktree_gitdir(buf, repo, wt);
@ -438,7 +436,7 @@ char *repo_git_path(const struct repository *repo,
struct strbuf path = STRBUF_INIT;
va_list args;
va_start(args, fmt);
do_git_path(repo, NULL, &path, fmt, args);
repo_git_pathv(repo, NULL, &path, fmt, args);
va_end(args);
return strbuf_detach(&path, NULL);
}
@ -449,48 +447,10 @@ void strbuf_repo_git_path(struct strbuf *sb,
{
va_list args;
va_start(args, fmt);
do_git_path(repo, NULL, sb, fmt, args);
repo_git_pathv(repo, NULL, sb, fmt, args);
va_end(args);
}
char *git_path_buf(struct strbuf *buf, const char *fmt, ...)
{
va_list args;
strbuf_reset(buf);
va_start(args, fmt);
do_git_path(the_repository, NULL, buf, fmt, args);
va_end(args);
return buf->buf;
}
void strbuf_git_path(struct strbuf *sb, const char *fmt, ...)
{
va_list args;
va_start(args, fmt);
do_git_path(the_repository, NULL, sb, fmt, args);
va_end(args);
}
const char *git_path(const char *fmt, ...)
{
struct strbuf *pathname = get_pathname();
va_list args;
va_start(args, fmt);
do_git_path(the_repository, NULL, pathname, fmt, args);
va_end(args);
return pathname->buf;
}
char *git_pathdup(const char *fmt, ...)
{
struct strbuf path = STRBUF_INIT;
va_list args;
va_start(args, fmt);
do_git_path(the_repository, NULL, &path, fmt, args);
va_end(args);
return strbuf_detach(&path, NULL);
}
char *mkpathdup(const char *fmt, ...)
{
struct strbuf sb = STRBUF_INIT;
@ -512,12 +472,17 @@ const char *mkpath(const char *fmt, ...)
return cleanup_path(pathname->buf);
}
const char *worktree_git_path(const struct worktree *wt, const char *fmt, ...)
const char *worktree_git_path(struct repository *r,
const struct worktree *wt, const char *fmt, ...)
{
struct strbuf *pathname = get_pathname();
va_list args;
if (wt && wt->repo != r)
BUG("worktree not connected to expected repository");
va_start(args, fmt);
do_git_path(the_repository, wt, pathname, fmt, args);
repo_git_pathv(r, wt, pathname, fmt, args);
va_end(args);
return pathname->buf;
}
@ -617,26 +582,16 @@ int strbuf_git_path_submodule(struct strbuf *buf, const char *path,
return err;
}
static void do_git_common_path(const struct repository *repo,
struct strbuf *buf,
const char *fmt,
va_list args)
void repo_common_pathv(const struct repository *repo,
struct strbuf *sb,
const char *fmt,
va_list args)
{
strbuf_addstr(buf, repo->commondir);
if (buf->len && !is_dir_sep(buf->buf[buf->len - 1]))
strbuf_addch(buf, '/');
strbuf_vaddf(buf, fmt, args);
strbuf_cleanup_path(buf);
}
const char *git_common_path(const char *fmt, ...)
{
struct strbuf *pathname = get_pathname();
va_list args;
va_start(args, fmt);
do_git_common_path(the_repository, pathname, fmt, args);
va_end(args);
return pathname->buf;
strbuf_addstr(sb, repo->commondir);
if (sb->len && !is_dir_sep(sb->buf[sb->len - 1]))
strbuf_addch(sb, '/');
strbuf_vaddf(sb, fmt, args);
strbuf_cleanup_path(sb);
}
void strbuf_git_common_path(struct strbuf *sb,
@ -645,7 +600,7 @@ void strbuf_git_common_path(struct strbuf *sb,
{
va_list args;
va_start(args, fmt);
do_git_common_path(repo, sb, fmt, args);
repo_common_pathv(repo, sb, fmt, args);
va_end(args);
}

170
path.h
View file

@ -25,7 +25,7 @@ char *mkpathdup(const char *fmt, ...)
__attribute__((format (printf, 1, 2)));
/*
* The `git_common_path` family of functions will construct a path into a
* The `strbuf_git_common_path` family of functions will construct a path into a
* repository's common git directory, which is shared by all worktrees.
*/
@ -37,17 +37,13 @@ void strbuf_git_common_path(struct strbuf *sb,
const struct repository *repo,
const char *fmt, ...)
__attribute__((format (printf, 3, 4)));
void repo_common_pathv(const struct repository *repo,
struct strbuf *buf,
const char *fmt,
va_list args);
/*
* Return a statically allocated path into the main repository's
* (the_repository) common git directory.
*/
const char *git_common_path(const char *fmt, ...)
__attribute__((format (printf, 1, 2)));
/*
* The `git_path` family of functions will construct a path into a repository's
* The `repo_git_path` family of functions will construct a path into a repository's
* git directory.
*
* These functions will perform adjustments to the resultant path to account
@ -66,6 +62,14 @@ char *repo_git_path(const struct repository *repo,
const char *fmt, ...)
__attribute__((format (printf, 2, 3)));
/*
* Print a path into the git directory of repository `repo` into the provided
* buffer.
*/
void repo_git_pathv(const struct repository *repo,
const struct worktree *wt, struct strbuf *buf,
const char *fmt, va_list args);
/*
* Construct a path into the git directory of repository `repo` and append it
* to the provided buffer `sb`.
@ -76,40 +80,14 @@ void strbuf_repo_git_path(struct strbuf *sb,
__attribute__((format (printf, 3, 4)));
/*
* Return a statically allocated path into the main repository's
* (the_repository) git directory.
* Similar to repo_git_path() but can produce paths for a specified
* worktree instead of current one. When no worktree is given, then the path is
* computed relative to main worktree of the given repository.
*/
const char *git_path(const char *fmt, ...)
__attribute__((format (printf, 1, 2)));
/*
* Similar to git_path() but can produce paths for a specified
* worktree instead of current one
*/
const char *worktree_git_path(const struct worktree *wt,
const char *worktree_git_path(struct repository *r,
const struct worktree *wt,
const char *fmt, ...)
__attribute__((format (printf, 2, 3)));
/*
* Return a path into the main repository's (the_repository) git directory.
*/
char *git_pathdup(const char *fmt, ...)
__attribute__((format (printf, 1, 2)));
/*
* Construct a path into the main repository's (the_repository) git directory
* and place it in the provided buffer `buf`, the contents of the buffer will
* be overridden.
*/
char *git_path_buf(struct strbuf *buf, const char *fmt, ...)
__attribute__((format (printf, 2, 3)));
/*
* Construct a path into the main repository's (the_repository) git directory
* and append it to the provided buffer `sb`.
*/
void strbuf_git_path(struct strbuf *sb, const char *fmt, ...)
__attribute__((format (printf, 2, 3)));
__attribute__((format (printf, 3, 4)));
/*
* Return a path into the worktree of repository `repo`.
@ -147,24 +125,15 @@ int strbuf_git_path_submodule(struct strbuf *sb, const char *path,
const char *fmt, ...)
__attribute__((format (printf, 3, 4)));
void report_linked_checkout_garbage(void);
void report_linked_checkout_garbage(struct repository *r);
/*
* You can define a static memoized git path like:
*
* static GIT_PATH_FUNC(git_path_foo, "FOO")
* static REPO_GIT_PATH_FUNC(git_path_foo, "FOO")
*
* or use one of the global ones below.
*/
#define GIT_PATH_FUNC(func, filename) \
const char *func(void) \
{ \
static char *ret; \
if (!ret) \
ret = git_pathdup(filename); \
return ret; \
}
#define REPO_GIT_PATH_FUNC(var, filename) \
const char *git_path_##var(struct repository *r) \
{ \
@ -248,4 +217,99 @@ char *xdg_cache_home(const char *filename);
*/
void safe_create_dir(const char *dir, int share);
/*
* Do not use this function. It is only exported to other subsystems until we
* can get rid of the below block of functions that implicitly rely on
* `the_repository`.
*/
struct strbuf *get_pathname(void);
# ifdef USE_THE_REPOSITORY_VARIABLE
# include "strbuf.h"
# include "repository.h"
/*
* Return a statically allocated path into the main repository's
* (the_repository) common git directory.
*/
__attribute__((format (printf, 1, 2)))
static inline const char *git_common_path(const char *fmt, ...)
{
struct strbuf *pathname = get_pathname();
va_list args;
va_start(args, fmt);
repo_common_pathv(the_repository, pathname, fmt, args);
va_end(args);
return pathname->buf;
}
/*
* Construct a path into the main repository's (the_repository) git directory
* and place it in the provided buffer `buf`, the contents of the buffer will
* be overridden.
*/
__attribute__((format (printf, 2, 3)))
static inline char *git_path_buf(struct strbuf *buf, const char *fmt, ...)
{
va_list args;
strbuf_reset(buf);
va_start(args, fmt);
repo_git_pathv(the_repository, NULL, buf, fmt, args);
va_end(args);
return buf->buf;
}
/*
* Construct a path into the main repository's (the_repository) git directory
* and append it to the provided buffer `sb`.
*/
__attribute__((format (printf, 2, 3)))
static inline void strbuf_git_path(struct strbuf *sb, const char *fmt, ...)
{
va_list args;
va_start(args, fmt);
repo_git_pathv(the_repository, NULL, sb, fmt, args);
va_end(args);
}
/*
* Return a statically allocated path into the main repository's
* (the_repository) git directory.
*/
__attribute__((format (printf, 1, 2)))
static inline const char *git_path(const char *fmt, ...)
{
struct strbuf *pathname = get_pathname();
va_list args;
va_start(args, fmt);
repo_git_pathv(the_repository, NULL, pathname, fmt, args);
va_end(args);
return pathname->buf;
}
#define GIT_PATH_FUNC(func, filename) \
const char *func(void) \
{ \
static char *ret; \
if (!ret) \
ret = git_pathdup(filename); \
return ret; \
}
/*
* Return a path into the main repository's (the_repository) git directory.
*/
__attribute__((format (printf, 1, 2)))
static inline char *git_pathdup(const char *fmt, ...)
{
struct strbuf path = STRBUF_INIT;
va_list args;
va_start(args, fmt);
repo_git_pathv(the_repository, NULL, &path, fmt, args);
va_end(args);
return strbuf_detach(&path, NULL);
}
# endif /* USE_THE_REPOSITORY_VARIABLE */
#endif /* PATH_H */

2
protocol.c
View file

@ -1,3 +1,5 @@
#define USE_THE_REPOSITORY_VARIABLE
#include "git-compat-util.h"
#include "config.h"
#include "environment.h"

22
read-cache.c
View file

@ -1945,7 +1945,7 @@ static void tweak_untracked_cache(struct index_state *istate)
static void tweak_split_index(struct index_state *istate)
{
switch (git_config_get_split_index()) {
switch (repo_config_get_split_index(the_repository)) {
case -1: /* unset: do nothing */
break;
case 0: /* false */
@ -2267,7 +2267,7 @@ int do_read_index(struct index_state *istate, const char *path, int must_exist)
src_offset = sizeof(*hdr);
if (git_config_get_index_threads(&nr_threads))
if (repo_config_get_index_threads(the_repository, &nr_threads))
nr_threads = 1;
/* TODO: does creating more threads than cores help? */
@ -2787,7 +2787,7 @@ static int record_eoie(void)
* used for threading is written by default if the user
* explicitly requested threaded index reads.
*/
return !git_config_get_index_threads(&val) && val != 1;
return !repo_config_get_index_threads(the_repository, &val) && val != 1;
}
static int record_ieot(void)
@ -2802,7 +2802,7 @@ static int record_ieot(void)
* written by default if the user explicitly requested
* threaded index reads.
*/
return !git_config_get_index_threads(&val) && val != 1;
return !repo_config_get_index_threads(the_repository, &val) && val != 1;
}
enum write_extensions {
@ -2876,7 +2876,7 @@ static int do_write_index(struct index_state *istate, struct tempfile *tempfile,
hashwrite(f, &hdr, sizeof(hdr));
if (!HAVE_THREADS || git_config_get_index_threads(&nr_threads))
if (!HAVE_THREADS || repo_config_get_index_threads(the_repository, &nr_threads))
nr_threads = 1;
if (nr_threads != 1 && record_ieot()) {
@ -3175,9 +3175,9 @@ static int do_write_locked_index(struct index_state *istate,
else
ret = close_lock_file_gently(lock);
run_hooks_l("post-index-change",
istate->updated_workdir ? "1" : "0",
istate->updated_skipworktree ? "1" : "0", NULL);
run_hooks_l(the_repository, "post-index-change",
istate->updated_workdir ? "1" : "0",
istate->updated_skipworktree ? "1" : "0", NULL);
istate->updated_workdir = 0;
istate->updated_skipworktree = 0;
@ -3203,8 +3203,8 @@ static unsigned long get_shared_index_expire_date(void)
static int shared_index_expire_date_prepared;
if (!shared_index_expire_date_prepared) {
git_config_get_expiry("splitindex.sharedindexexpire",
&shared_index_expire);
repo_config_get_expiry(the_repository, "splitindex.sharedindexexpire",
&shared_index_expire);
shared_index_expire_date = approxidate(shared_index_expire);
shared_index_expire_date_prepared = 1;
}
@ -3294,7 +3294,7 @@ static const int default_max_percent_split_change = 20;
static int too_many_not_shared_entries(struct index_state *istate)
{
int i, not_shared = 0;
int max_split = git_config_get_max_percent_split_change();
int max_split = repo_config_get_max_percent_split_change(the_repository);
switch (max_split) {
case -1:

4
refs.c
View file

@ -2,6 +2,8 @@
* The backend-independent part of the reference module.
*/
#define USE_THE_REPOSITORY_VARIABLE
#include "git-compat-util.h"
#include "advice.h"
#include "config.h"
@ -2137,7 +2139,7 @@ static int run_transaction_hook(struct ref_transaction *transaction,
const char *hook;
int ret = 0, i;
hook = find_hook("reference-transaction");
hook = find_hook(transaction->ref_store->repo, "reference-transaction");
if (!hook)
return ret;

2
refs/packed-backend.c
View file

@ -1,3 +1,5 @@
#define USE_THE_REPOSITORY_VARIABLE
#include "../git-compat-util.h"
#include "../config.h"
#include "../dir.h"

2
refs/reftable-backend.c
View file

@ -1,3 +1,5 @@
#define USE_THE_REPOSITORY_VARIABLE
#include "../git-compat-util.h"
#include "../abspath.h"
#include "../chdir-notify.h"

6
rerere.c
View file

@ -1208,8 +1208,10 @@ void rerere_gc(struct repository *r, struct string_list *rr)
if (setup_rerere(r, rr, 0) < 0)
return;
git_config_get_expiry_in_days("gc.rerereresolved", &cutoff_resolve, now);
git_config_get_expiry_in_days("gc.rerereunresolved", &cutoff_noresolve, now);
repo_config_get_expiry_in_days(the_repository, "gc.rerereresolved",
&cutoff_resolve, now);
repo_config_get_expiry_in_days(the_repository, "gc.rerereunresolved",
&cutoff_noresolve, now);
git_config(git_default_config, NULL);
dir = opendir(git_path("rr-cache"));
if (!dir)

2
reset.c
View file

@ -79,7 +79,7 @@ static int update_refs(const struct reset_head_opts *opts,
reflog_head);
}
if (!ret && run_hook)
run_hooks_l("post-checkout",
run_hooks_l(the_repository, "post-checkout",
oid_to_hex(head ? head : null_oid()),
oid_to_hex(oid), "1", NULL);
strbuf_release(&msg);

2
revision.c
View file

@ -1872,7 +1872,7 @@ void add_index_objects_to_pending(struct rev_info *revs, unsigned int flags)
continue; /* current index already taken care of */
if (read_index_from(&istate,
worktree_git_path(wt, "index"),
worktree_git_path(the_repository, wt, "index"),
get_worktree_git_dir(wt)) > 0)
do_add_index_objects_to_pending(revs, &istate, flags);
discard_index(&istate);

6
sequencer.c
View file

@ -1317,7 +1317,7 @@ static int run_rewrite_hook(const struct object_id *oldoid,
struct child_process proc = CHILD_PROCESS_INIT;
int code;
struct strbuf sb = STRBUF_INIT;
const char *hook_path = find_hook("post-rewrite");
const char *hook_path = find_hook(the_repository, "post-rewrite");
if (!hook_path)
return 0;
@ -1615,7 +1615,7 @@ static int try_to_commit(struct repository *r,
}
}
if (hook_exists("prepare-commit-msg")) {
if (hook_exists(r, "prepare-commit-msg")) {
res = run_prepare_commit_msg_hook(r, msg, hook_commit);
if (res)
goto out;
@ -5150,7 +5150,7 @@ static int pick_commits(struct repository *r,
hook_opt.path_to_stdin = rebase_path_rewritten_list();
strvec_push(&hook_opt.args, "rebase");
run_hooks_opt("post-rewrite", &hook_opt);
run_hooks_opt(r, "post-rewrite", &hook_opt);
}
apply_autostash(rebase_path_autostash());

2
sideband.c
View file

@ -1,3 +1,5 @@
#define USE_THE_REPOSITORY_VARIABLE
#include "git-compat-util.h"
#include "color.h"
#include "config.h"

2
submodule.c
View file

@ -159,7 +159,7 @@ int remove_path_from_gitmodules(const char *path)
}
strbuf_addstr(&sect, "submodule.");
strbuf_addstr(&sect, submodule->name);
if (git_config_rename_section_in_file(GITMODULES_FILE, sect.buf, NULL) < 0) {
if (repo_config_rename_section_in_file(the_repository, 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(&sect);

2
t/helper/test-advise.c
View file

@ -1,3 +1,5 @@
#define USE_THE_REPOSITORY_VARIABLE
#include "test-tool.h"
#include "advice.h"
#include "config.h"

2
t/helper/test-config.c
View file

@ -1,3 +1,5 @@
#define USE_THE_REPOSITORY_VARIABLE
#include "test-tool.h"
#include "config.h"
#include "setup.h"

2
t/helper/test-userdiff.c
View file

@ -1,3 +1,5 @@
#define USE_THE_REPOSITORY_VARIABLE
#include "test-tool.h"
#include "setup.h"
#include "userdiff.h"

2
trailer.c
View file

@ -1,3 +1,5 @@
#define USE_THE_REPOSITORY_VARIABLE
#include "git-compat-util.h"
#include "config.h"
#include "environment.h"

2
transport.c
View file

@ -1273,7 +1273,7 @@ static int run_pre_push_hook(struct transport *transport,
struct ref *r;
struct child_process proc = CHILD_PROCESS_INIT;
struct strbuf buf;
const char *hook_path = find_hook("pre-push");
const char *hook_path = find_hook(the_repository, "pre-push");
if (!hook_path)
return 0;

2
versioncmp.c
View file

@ -1,3 +1,5 @@
#define USE_THE_REPOSITORY_VARIABLE
#include "git-compat-util.h"
#include "config.h"
#include "strbuf.h"

2
worktree.c
View file

@ -252,7 +252,7 @@ const char *worktree_lock_reason(struct worktree *wt)
if (!wt->lock_reason_valid) {
struct strbuf path = STRBUF_INIT;
strbuf_addstr(&path, worktree_git_path(wt, "locked"));
strbuf_addstr(&path, worktree_git_path(the_repository, wt, "locked"));
if (file_exists(path.buf)) {
struct strbuf lock_reason = STRBUF_INIT;
if (strbuf_read_file(&lock_reason, path.buf, 0) < 0)

14
wt-status.c
View file

@ -1618,7 +1618,7 @@ static char *get_branch(const struct worktree *wt, const char *path)
struct object_id oid;
const char *branch_name;
if (strbuf_read_file(&sb, worktree_git_path(wt, "%s", path), 0) <= 0)
if (strbuf_read_file(&sb, worktree_git_path(the_repository, wt, "%s", path), 0) <= 0)
goto got_nothing;
while (sb.len && sb.buf[sb.len - 1] == '\n')
@ -1716,18 +1716,18 @@ int wt_status_check_rebase(const struct worktree *wt,
{
struct stat st;
if (!stat(worktree_git_path(wt, "rebase-apply"), &st)) {
if (!stat(worktree_git_path(wt, "rebase-apply/applying"), &st)) {
if (!stat(worktree_git_path(the_repository, wt, "rebase-apply"), &st)) {
if (!stat(worktree_git_path(the_repository, wt, "rebase-apply/applying"), &st)) {
state->am_in_progress = 1;
if (!stat(worktree_git_path(wt, "rebase-apply/patch"), &st) && !st.st_size)
if (!stat(worktree_git_path(the_repository, wt, "rebase-apply/patch"), &st) && !st.st_size)
state->am_empty_patch = 1;
} else {
state->rebase_in_progress = 1;
state->branch = get_branch(wt, "rebase-apply/head-name");
state->onto = get_branch(wt, "rebase-apply/onto");
}
} else if (!stat(worktree_git_path(wt, "rebase-merge"), &st)) {
if (!stat(worktree_git_path(wt, "rebase-merge/interactive"), &st))
} else if (!stat(worktree_git_path(the_repository, wt, "rebase-merge"), &st)) {
if (!stat(worktree_git_path(the_repository, wt, "rebase-merge/interactive"), &st))
state->rebase_interactive_in_progress = 1;
else
state->rebase_in_progress = 1;
@ -1743,7 +1743,7 @@ int wt_status_check_bisect(const struct worktree *wt,
{
struct stat st;
if (!stat(worktree_git_path(wt, "BISECT_LOG"), &st)) {
if (!stat(worktree_git_path(the_repository, wt, "BISECT_LOG"), &st)) {
state->bisect_in_progress = 1;
state->bisecting_from = get_branch(wt, "BISECT_START");
return 1;