Browse Source
Introduce a "repository" object to eventually make it easier to work in multiple repositories (the primary focus is to work with the superproject and its submodules) in a single process. * bw/repo-object: ls-files: use repository object repository: enable initialization of submodules submodule: convert is_submodule_initialized to work on a repository submodule: add repo_read_gitmodules submodule-config: store the_submodule_cache in the_repository repository: add index_state to struct repo config: read config from a repository object path: add repo_worktree_path and strbuf_repo_worktree_path path: add repo_git_path and strbuf_repo_git_path path: worktree_git_path() should not use file relocation path: convert do_git_path to take a 'struct repository' path: convert strbuf_git_common_path to take a 'struct repository' path: always pass in commondir to update_common_dir path: create path.h environment: store worktree in the_repository environment: place key repository state in the_repository repository: introduce the repository object environment: remove namespace_len variable setup: add comment indicating a hack setup: don't perform lazy initialization of repository statemaint
Junio C Hamano
8 years ago
20 changed files with 972 additions and 373 deletions
@ -0,0 +1,82 @@
@@ -0,0 +1,82 @@
|
||||
#ifndef PATH_H |
||||
#define PATH_H |
||||
|
||||
struct repository; |
||||
|
||||
/* |
||||
* Return a statically allocated filename, either generically (mkpath), in |
||||
* the repository directory (git_path), or in a submodule's repository |
||||
* directory (git_path_submodule). In all cases, note that the result |
||||
* may be overwritten by another call to _any_ of the functions. Consider |
||||
* using the safer "dup" or "strbuf" formats below (in some cases, the |
||||
* unsafe versions have already been removed). |
||||
*/ |
||||
extern const char *mkpath(const char *fmt, ...) __attribute__((format (printf, 1, 2))); |
||||
extern const char *git_path(const char *fmt, ...) __attribute__((format (printf, 1, 2))); |
||||
extern const char *git_common_path(const char *fmt, ...) __attribute__((format (printf, 1, 2))); |
||||
|
||||
extern char *mksnpath(char *buf, size_t n, const char *fmt, ...) |
||||
__attribute__((format (printf, 3, 4))); |
||||
extern void strbuf_git_path(struct strbuf *sb, const char *fmt, ...) |
||||
__attribute__((format (printf, 2, 3))); |
||||
extern void strbuf_git_common_path(struct strbuf *sb, |
||||
const struct repository *repo, |
||||
const char *fmt, ...) |
||||
__attribute__((format (printf, 3, 4))); |
||||
extern char *git_path_buf(struct strbuf *buf, const char *fmt, ...) |
||||
__attribute__((format (printf, 2, 3))); |
||||
extern int strbuf_git_path_submodule(struct strbuf *sb, const char *path, |
||||
const char *fmt, ...) |
||||
__attribute__((format (printf, 3, 4))); |
||||
extern char *git_pathdup(const char *fmt, ...) |
||||
__attribute__((format (printf, 1, 2))); |
||||
extern char *mkpathdup(const char *fmt, ...) |
||||
__attribute__((format (printf, 1, 2))); |
||||
extern char *git_pathdup_submodule(const char *path, const char *fmt, ...) |
||||
__attribute__((format (printf, 2, 3))); |
||||
|
||||
extern char *repo_git_path(const struct repository *repo, |
||||
const char *fmt, ...) |
||||
__attribute__((format (printf, 2, 3))); |
||||
extern void strbuf_repo_git_path(struct strbuf *sb, |
||||
const struct repository *repo, |
||||
const char *fmt, ...) |
||||
__attribute__((format (printf, 3, 4))); |
||||
|
||||
extern char *repo_worktree_path(const struct repository *repo, |
||||
const char *fmt, ...) |
||||
__attribute__((format (printf, 2, 3))); |
||||
extern void strbuf_repo_worktree_path(struct strbuf *sb, |
||||
const struct repository *repo, |
||||
const char *fmt, ...) |
||||
__attribute__((format (printf, 3, 4))); |
||||
|
||||
extern void report_linked_checkout_garbage(void); |
||||
|
||||
/* |
||||
* You can define a static memoized git path like: |
||||
* |
||||
* static 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; \ |
||||
} |
||||
|
||||
const char *git_path_cherry_pick_head(void); |
||||
const char *git_path_revert_head(void); |
||||
const char *git_path_squash_msg(void); |
||||
const char *git_path_merge_msg(void); |
||||
const char *git_path_merge_rr(void); |
||||
const char *git_path_merge_mode(void); |
||||
const char *git_path_merge_head(void); |
||||
const char *git_path_fetch_head(void); |
||||
const char *git_path_shallow(void); |
||||
|
||||
#endif /* PATH_H */ |
||||
@ -0,0 +1,242 @@
@@ -0,0 +1,242 @@
|
||||
#include "cache.h" |
||||
#include "repository.h" |
||||
#include "config.h" |
||||
#include "submodule-config.h" |
||||
|
||||
/* The main repository */ |
||||
static struct repository the_repo; |
||||
struct repository *the_repository = &the_repo; |
||||
|
||||
static char *git_path_from_env(const char *envvar, const char *git_dir, |
||||
const char *path, int fromenv) |
||||
{ |
||||
if (fromenv) { |
||||
const char *value = getenv(envvar); |
||||
if (value) |
||||
return xstrdup(value); |
||||
} |
||||
|
||||
return xstrfmt("%s/%s", git_dir, path); |
||||
} |
||||
|
||||
static int find_common_dir(struct strbuf *sb, const char *gitdir, int fromenv) |
||||
{ |
||||
if (fromenv) { |
||||
const char *value = getenv(GIT_COMMON_DIR_ENVIRONMENT); |
||||
if (value) { |
||||
strbuf_addstr(sb, value); |
||||
return 1; |
||||
} |
||||
} |
||||
|
||||
return get_common_dir_noenv(sb, gitdir); |
||||
} |
||||
|
||||
static void repo_setup_env(struct repository *repo) |
||||
{ |
||||
struct strbuf sb = STRBUF_INIT; |
||||
|
||||
repo->different_commondir = find_common_dir(&sb, repo->gitdir, |
||||
!repo->ignore_env); |
||||
repo->commondir = strbuf_detach(&sb, NULL); |
||||
repo->objectdir = git_path_from_env(DB_ENVIRONMENT, repo->commondir, |
||||
"objects", !repo->ignore_env); |
||||
repo->graft_file = git_path_from_env(GRAFT_ENVIRONMENT, repo->commondir, |
||||
"info/grafts", !repo->ignore_env); |
||||
repo->index_file = git_path_from_env(INDEX_ENVIRONMENT, repo->gitdir, |
||||
"index", !repo->ignore_env); |
||||
} |
||||
|
||||
void repo_set_gitdir(struct repository *repo, const char *path) |
||||
{ |
||||
const char *gitfile = read_gitfile(path); |
||||
|
||||
/* |
||||
* NEEDSWORK: Eventually we want to be able to free gitdir and the rest |
||||
* of the environment before reinitializing it again, but we have some |
||||
* crazy code paths where we try to set gitdir with the current gitdir |
||||
* and we don't want to free gitdir before copying the passed in value. |
||||
*/ |
||||
repo->gitdir = xstrdup(gitfile ? gitfile : path); |
||||
|
||||
repo_setup_env(repo); |
||||
} |
||||
|
||||
/* |
||||
* Attempt to resolve and set the provided 'gitdir' for repository 'repo'. |
||||
* Return 0 upon success and a non-zero value upon failure. |
||||
*/ |
||||
static int repo_init_gitdir(struct repository *repo, const char *gitdir) |
||||
{ |
||||
int ret = 0; |
||||
int error = 0; |
||||
char *abspath = NULL; |
||||
const char *resolved_gitdir; |
||||
|
||||
abspath = real_pathdup(gitdir, 0); |
||||
if (!abspath) { |
||||
ret = -1; |
||||
goto out; |
||||
} |
||||
|
||||
/* 'gitdir' must reference the gitdir directly */ |
||||
resolved_gitdir = resolve_gitdir_gently(abspath, &error); |
||||
if (!resolved_gitdir) { |
||||
ret = -1; |
||||
goto out; |
||||
} |
||||
|
||||
repo_set_gitdir(repo, resolved_gitdir); |
||||
|
||||
out: |
||||
free(abspath); |
||||
return ret; |
||||
} |
||||
|
||||
void repo_set_worktree(struct repository *repo, const char *path) |
||||
{ |
||||
repo->worktree = real_pathdup(path, 1); |
||||
} |
||||
|
||||
static int read_and_verify_repository_format(struct repository_format *format, |
||||
const char *commondir) |
||||
{ |
||||
int ret = 0; |
||||
struct strbuf sb = STRBUF_INIT; |
||||
|
||||
strbuf_addf(&sb, "%s/config", commondir); |
||||
read_repository_format(format, sb.buf); |
||||
strbuf_reset(&sb); |
||||
|
||||
if (verify_repository_format(format, &sb) < 0) { |
||||
warning("%s", sb.buf); |
||||
ret = -1; |
||||
} |
||||
|
||||
strbuf_release(&sb); |
||||
return ret; |
||||
} |
||||
|
||||
/* |
||||
* Initialize 'repo' based on the provided 'gitdir'. |
||||
* Return 0 upon success and a non-zero value upon failure. |
||||
*/ |
||||
int repo_init(struct repository *repo, const char *gitdir, const char *worktree) |
||||
{ |
||||
struct repository_format format; |
||||
memset(repo, 0, sizeof(*repo)); |
||||
|
||||
repo->ignore_env = 1; |
||||
|
||||
if (repo_init_gitdir(repo, gitdir)) |
||||
goto error; |
||||
|
||||
if (read_and_verify_repository_format(&format, repo->commondir)) |
||||
goto error; |
||||
|
||||
if (worktree) |
||||
repo_set_worktree(repo, worktree); |
||||
|
||||
return 0; |
||||
|
||||
error: |
||||
repo_clear(repo); |
||||
return -1; |
||||
} |
||||
|
||||
/* |
||||
* Initialize 'submodule' as the submodule given by 'path' in parent repository |
||||
* 'superproject'. |
||||
* Return 0 upon success and a non-zero value upon failure. |
||||
*/ |
||||
int repo_submodule_init(struct repository *submodule, |
||||
struct repository *superproject, |
||||
const char *path) |
||||
{ |
||||
const struct submodule *sub; |
||||
struct strbuf gitdir = STRBUF_INIT; |
||||
struct strbuf worktree = STRBUF_INIT; |
||||
int ret = 0; |
||||
|
||||
sub = submodule_from_cache(superproject, null_sha1, path); |
||||
if (!sub) { |
||||
ret = -1; |
||||
goto out; |
||||
} |
||||
|
||||
strbuf_repo_worktree_path(&gitdir, superproject, "%s/.git", path); |
||||
strbuf_repo_worktree_path(&worktree, superproject, "%s", path); |
||||
|
||||
if (repo_init(submodule, gitdir.buf, worktree.buf)) { |
||||
/* |
||||
* If initilization fails then it may be due to the submodule |
||||
* not being populated in the superproject's worktree. Instead |
||||
* we can try to initilize the submodule by finding it's gitdir |
||||
* in the superproject's 'modules' directory. In this case the |
||||
* submodule would not have a worktree. |
||||
*/ |
||||
strbuf_reset(&gitdir); |
||||
strbuf_repo_git_path(&gitdir, superproject, |
||||
"modules/%s", sub->name); |
||||
|
||||
if (repo_init(submodule, gitdir.buf, NULL)) { |
||||
ret = -1; |
||||
goto out; |
||||
} |
||||
} |
||||
|
||||
submodule->submodule_prefix = xstrfmt("%s%s/", |
||||
superproject->submodule_prefix ? |
||||
superproject->submodule_prefix : |
||||
"", path); |
||||
|
||||
out: |
||||
strbuf_release(&gitdir); |
||||
strbuf_release(&worktree); |
||||
return ret; |
||||
} |
||||
|
||||
void repo_clear(struct repository *repo) |
||||
{ |
||||
free(repo->gitdir); |
||||
repo->gitdir = NULL; |
||||
free(repo->commondir); |
||||
repo->commondir = NULL; |
||||
free(repo->objectdir); |
||||
repo->objectdir = NULL; |
||||
free(repo->graft_file); |
||||
repo->graft_file = NULL; |
||||
free(repo->index_file); |
||||
repo->index_file = NULL; |
||||
free(repo->worktree); |
||||
repo->worktree = NULL; |
||||
free(repo->submodule_prefix); |
||||
repo->submodule_prefix = NULL; |
||||
|
||||
if (repo->config) { |
||||
git_configset_clear(repo->config); |
||||
free(repo->config); |
||||
repo->config = NULL; |
||||
} |
||||
|
||||
if (repo->submodule_cache) { |
||||
submodule_cache_free(repo->submodule_cache); |
||||
repo->submodule_cache = NULL; |
||||
} |
||||
|
||||
if (repo->index) { |
||||
discard_index(repo->index); |
||||
free(repo->index); |
||||
repo->index = NULL; |
||||
} |
||||
} |
||||
|
||||
int repo_read_index(struct repository *repo) |
||||
{ |
||||
if (!repo->index) |
||||
repo->index = xcalloc(1, sizeof(*repo->index)); |
||||
else |
||||
discard_index(repo->index); |
||||
|
||||
return read_index_from(repo->index, repo->index_file); |
||||
} |
||||
@ -0,0 +1,97 @@
@@ -0,0 +1,97 @@
|
||||
#ifndef REPOSITORY_H |
||||
#define REPOSITORY_H |
||||
|
||||
struct config_set; |
||||
struct index_state; |
||||
struct submodule_cache; |
||||
|
||||
struct repository { |
||||
/* Environment */ |
||||
/* |
||||
* Path to the git directory. |
||||
* Cannot be NULL after initialization. |
||||
*/ |
||||
char *gitdir; |
||||
|
||||
/* |
||||
* Path to the common git directory. |
||||
* Cannot be NULL after initialization. |
||||
*/ |
||||
char *commondir; |
||||
|
||||
/* |
||||
* Path to the repository's object store. |
||||
* Cannot be NULL after initialization. |
||||
*/ |
||||
char *objectdir; |
||||
|
||||
/* |
||||
* Path to the repository's graft file. |
||||
* Cannot be NULL after initialization. |
||||
*/ |
||||
char *graft_file; |
||||
|
||||
/* |
||||
* Path to the current worktree's index file. |
||||
* Cannot be NULL after initialization. |
||||
*/ |
||||
char *index_file; |
||||
|
||||
/* |
||||
* Path to the working directory. |
||||
* A NULL value indicates that there is no working directory. |
||||
*/ |
||||
char *worktree; |
||||
|
||||
/* |
||||
* Path from the root of the top-level superproject down to this |
||||
* repository. This is only non-NULL if the repository is initialized |
||||
* as a submodule of another repository. |
||||
*/ |
||||
char *submodule_prefix; |
||||
|
||||
/* Subsystems */ |
||||
/* |
||||
* Repository's config which contains key-value pairs from the usual |
||||
* set of config files (i.e. repo specific .git/config, user wide |
||||
* ~/.gitconfig, XDG config file and the global /etc/gitconfig) |
||||
*/ |
||||
struct config_set *config; |
||||
|
||||
/* Repository's submodule config as defined by '.gitmodules' */ |
||||
struct submodule_cache *submodule_cache; |
||||
|
||||
/* |
||||
* Repository's in-memory index. |
||||
* 'repo_read_index()' can be used to populate 'index'. |
||||
*/ |
||||
struct index_state *index; |
||||
|
||||
/* Configurations */ |
||||
/* |
||||
* Bit used during initialization to indicate if repository state (like |
||||
* the location of the 'objectdir') should be read from the |
||||
* environment. By default this bit will be set at the begining of |
||||
* 'repo_init()' so that all repositories will ignore the environment. |
||||
* The exception to this is 'the_repository', which doesn't go through |
||||
* the normal 'repo_init()' process. |
||||
*/ |
||||
unsigned ignore_env:1; |
||||
|
||||
/* Indicate if a repository has a different 'commondir' from 'gitdir' */ |
||||
unsigned different_commondir:1; |
||||
}; |
||||
|
||||
extern struct repository *the_repository; |
||||
|
||||
extern void repo_set_gitdir(struct repository *repo, const char *path); |
||||
extern void repo_set_worktree(struct repository *repo, const char *path); |
||||
extern int repo_init(struct repository *repo, const char *gitdir, const char *worktree); |
||||
extern int repo_submodule_init(struct repository *submodule, |
||||
struct repository *superproject, |
||||
const char *path); |
||||
extern void repo_clear(struct repository *repo); |
||||
|
||||
extern int repo_read_index(struct repository *repo); |
||||
|
||||
#endif /* REPOSITORY_H */ |
||||
Loading…
Reference in new issue