summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/attr.c4
-rw-r--r--src/attr_file.c2
-rw-r--r--src/filebuf.c6
-rw-r--r--src/fileops.c181
-rw-r--r--src/fileops.h61
-rw-r--r--src/ignore.c2
-rw-r--r--src/index.c4
-rw-r--r--src/odb.c2
-rw-r--r--src/odb_loose.c12
-rw-r--r--src/odb_pack.c4
-rw-r--r--src/pack.c2
-rw-r--r--src/path.c175
-rw-r--r--src/path.h149
-rw-r--r--src/reflog.c6
-rw-r--r--src/refs.c22
-rw-r--r--src/repository.c16
-rw-r--r--src/status.c14
-rw-r--r--src/tree.c2
-rw-r--r--src/win32/dir.h (renamed from src/dir.h)8
-rw-r--r--tests-clay/config/stress.c2
-rw-r--r--tests-clay/core/dirent.c12
-rw-r--r--tests-clay/core/filebuf.c2
-rw-r--r--tests/t00-core.c14
-rw-r--r--tests/t03-objwrite.c4
-rw-r--r--tests/t10-refs.c20
-rw-r--r--tests/t12-repo.c2
-rw-r--r--tests/test_helpers.c14
27 files changed, 403 insertions, 339 deletions
diff --git a/src/attr.c b/src/attr.c
index dc42379ff..984b04ff1 100644
--- a/src/attr.c
+++ b/src/attr.c
@@ -230,7 +230,7 @@ int git_attr_cache__push_file(
/* either get attr_file from cache or read from disk */
file = git_hashtable_lookup(cache->files, filename);
- if (file == NULL && git_futils_exists(filename) == GIT_SUCCESS) {
+ if (file == NULL && git_path_exists(filename) == GIT_SUCCESS) {
error = (*loader)(repo, filename, &file);
add_to_cache = (error == GIT_SUCCESS);
}
@@ -279,7 +279,7 @@ static int collect_attr_files(
if ((error = git_vector_init(files, 4, NULL)) < GIT_SUCCESS)
goto cleanup;
- if ((error = git_futils_dir_for_path(&dir, path, workdir)) < GIT_SUCCESS)
+ if ((error = git_path_find_dir(&dir, path, workdir)) < GIT_SUCCESS)
goto cleanup;
/* in precendence order highest to lowest:
diff --git a/src/attr_file.c b/src/attr_file.c
index 5ea07c984..b38b35f01 100644
--- a/src/attr_file.c
+++ b/src/attr_file.c
@@ -223,7 +223,7 @@ int git_attr_path__init(
info->basename++;
if (!info->basename || !*info->basename)
info->basename = path;
- info->is_dir = (git_futils_isdir(path) == GIT_SUCCESS);
+ info->is_dir = (git_path_isdir(path) == GIT_SUCCESS);
return GIT_SUCCESS;
}
diff --git a/src/filebuf.c b/src/filebuf.c
index aa47d5eb0..447d8a089 100644
--- a/src/filebuf.c
+++ b/src/filebuf.c
@@ -16,7 +16,7 @@ static const size_t WRITE_BUFFER_SIZE = (4096 * 2);
static int lock_file(git_filebuf *file, int flags)
{
- if (git_futils_exists(file->path_lock) == 0) {
+ if (git_path_exists(file->path_lock) == 0) {
if (flags & GIT_FILEBUF_FORCE)
p_unlink(file->path_lock);
else
@@ -34,7 +34,7 @@ static int lock_file(git_filebuf *file, int flags)
if (file->fd < 0)
return git__throw(GIT_EOSERR, "Failed to create lock");
- if ((flags & GIT_FILEBUF_APPEND) && git_futils_exists(file->path_original) == 0) {
+ if ((flags & GIT_FILEBUF_APPEND) && git_path_exists(file->path_original) == 0) {
git_file source;
char buffer[2048];
size_t read_bytes;
@@ -60,7 +60,7 @@ void git_filebuf_cleanup(git_filebuf *file)
if (file->fd >= 0)
p_close(file->fd);
- if (file->fd >= 0 && file->path_lock && git_futils_exists(file->path_lock) == GIT_SUCCESS)
+ if (file->fd >= 0 && file->path_lock && git_path_exists(file->path_lock) == GIT_SUCCESS)
p_unlink(file->path_lock);
if (file->digest)
diff --git a/src/fileops.c b/src/fileops.c
index 3412a47e2..e2a6adf0b 100644
--- a/src/fileops.c
+++ b/src/fileops.c
@@ -23,7 +23,7 @@ int git_futils_mkpath2file(const char *file_path, const mode_t mode)
}
/* Does the containing folder exist? */
- if (git_futils_isdir(target_folder.ptr) != GIT_SUCCESS)
+ if (git_path_isdir(target_folder.ptr) != GIT_SUCCESS)
/* Let's create the tree structure */
error = git_futils_mkdir_r(target_folder.ptr, NULL, mode);
@@ -70,47 +70,6 @@ int git_futils_creat_locked_withpath(const char *path, const mode_t dirmode, con
return git_futils_creat_locked(path, mode);
}
-int git_futils_isdir(const char *path)
-{
-#ifdef GIT_WIN32
- DWORD attr = GetFileAttributes(path);
- if (attr == INVALID_FILE_ATTRIBUTES)
- return GIT_ERROR;
-
- return (attr & FILE_ATTRIBUTE_DIRECTORY) ? GIT_SUCCESS : GIT_ERROR;
-
-#else
- struct stat st;
- if (p_stat(path, &st) < GIT_SUCCESS)
- return GIT_ERROR;
-
- return S_ISDIR(st.st_mode) ? GIT_SUCCESS : GIT_ERROR;
-#endif
-}
-
-int git_futils_isfile(const char *path)
-{
- struct stat st;
- int stat_error;
-
- assert(path);
- stat_error = p_stat(path, &st);
-
- if (stat_error < GIT_SUCCESS)
- return -1;
-
- if (!S_ISREG(st.st_mode))
- return -1;
-
- return 0;
-}
-
-int git_futils_exists(const char *path)
-{
- assert(path);
- return p_access(path, F_OK);
-}
-
git_off_t git_futils_filesize(git_file fd)
{
struct stat sb;
@@ -219,54 +178,6 @@ void git_futils_mmap_free(git_map *out)
p_munmap(out);
}
-/* Taken from git.git */
-GIT_INLINE(int) is_dot_or_dotdot(const char *name)
-{
- return (name[0] == '.' &&
- (name[1] == '\0' ||
- (name[1] == '.' && name[2] == '\0')));
-}
-
-int git_futils_direach(
- git_buf *path,
- int (*fn)(void *, git_buf *),
- void *arg)
-{
- ssize_t wd_len;
- DIR *dir;
- struct dirent *de;
-
- if (git_path_to_dir(path) < GIT_SUCCESS)
- return git_buf_lasterror(path);
-
- wd_len = path->size;
- dir = opendir(path->ptr);
- if (!dir)
- return git__throw(GIT_EOSERR, "Failed to process `%s` tree structure. An error occured while opening the directory", path->ptr);
-
- while ((de = readdir(dir)) != NULL) {
- int result;
-
- if (is_dot_or_dotdot(de->d_name))
- continue;
-
- if (git_buf_puts(path, de->d_name) < GIT_SUCCESS)
- return git_buf_lasterror(path);
-
- result = fn(arg, path);
-
- git_buf_truncate(path, wd_len); /* restore path */
-
- if (result != GIT_SUCCESS) {
- closedir(dir);
- return result; /* The callee is reponsible for setting the correct error message */
- }
- }
-
- closedir(dir);
- return GIT_SUCCESS;
-}
-
int git_futils_mkdir_r(const char *path, const char *base, const mode_t mode)
{
int error, root_path_offset;
@@ -291,7 +202,7 @@ int git_futils_mkdir_r(const char *path, const char *base, const mode_t mode)
pp += root_path_offset; /* On Windows, will skip the drive name (eg. C: or D:) */
while (error == GIT_SUCCESS && (sp = strchr(pp, '/')) != NULL) {
- if (sp != pp && git_futils_isdir(make_path.ptr) < GIT_SUCCESS) {
+ if (sp != pp && git_path_isdir(make_path.ptr) < GIT_SUCCESS) {
*sp = 0;
error = p_mkdir(make_path.ptr, mode);
@@ -324,8 +235,8 @@ static int _rmdir_recurs_foreach(void *opaque, git_buf *path)
int error = GIT_SUCCESS;
int force = *(int *)opaque;
- if (git_futils_isdir(path->ptr) == GIT_SUCCESS) {
- error = git_futils_direach(path, _rmdir_recurs_foreach, opaque);
+ if (git_path_isdir(path->ptr) == GIT_SUCCESS) {
+ error = git_path_direach(path, _rmdir_recurs_foreach, opaque);
if (error < GIT_SUCCESS)
return git__rethrow(error, "Failed to remove directory `%s`", path->ptr);
return p_rmdir(path->ptr);
@@ -349,60 +260,6 @@ int git_futils_rmdir_r(const char *path, int force)
return error;
}
-int git_futils_cmp_path(const char *name1, int len1, int isdir1,
- const char *name2, int len2, int isdir2)
-{
- int len = len1 < len2 ? len1 : len2;
- int cmp;
-
- cmp = memcmp(name1, name2, len);
- if (cmp)
- return cmp;
- if (len1 < len2)
- return ((!isdir1 && !isdir2) ? -1 :
- (isdir1 ? '/' - name2[len1] : name2[len1] - '/'));
- if (len1 > len2)
- return ((!isdir1 && !isdir2) ? 1 :
- (isdir2 ? name1[len2] - '/' : '/' - name1[len2]));
- return 0;
-}
-
-static int _check_dir_contents(
- git_buf *dir,
- const char *sub,
- int append_on_success,
- int (*predicate)(const char *))
-{
- int error = GIT_SUCCESS;
- size_t dir_size = dir->size;
- size_t sub_size = strlen(sub);
-
- /* leave base valid even if we could not make space for subdir */
- if ((error = git_buf_try_grow(dir, dir_size + sub_size + 2)) < GIT_SUCCESS)
- return error;
-
- /* save excursion */
- git_buf_joinpath(dir, dir->ptr, sub);
-
- error = (*predicate)(dir->ptr);
-
- /* restore excursion */
- if (!append_on_success || error != GIT_SUCCESS)
- git_buf_truncate(dir, dir_size);
-
- return error;
-}
-
-int git_futils_contains_dir(git_buf *base, const char *subdir, int append_if_exists)
-{
- return _check_dir_contents(base, subdir, append_if_exists, &git_futils_isdir);
-}
-
-int git_futils_contains_file(git_buf *base, const char *file, int append_if_exists)
-{
- return _check_dir_contents(base, file, append_if_exists, &git_futils_isfile);
-}
-
int git_futils_find_global_file(git_buf *path, const char *filename)
{
int error;
@@ -420,7 +277,7 @@ int git_futils_find_global_file(git_buf *path, const char *filename)
if ((error = git_buf_joinpath(path, home, filename)) < GIT_SUCCESS)
return error;
- if (git_futils_exists(path->ptr) < GIT_SUCCESS) {
+ if (git_path_exists(path->ptr) < GIT_SUCCESS) {
git_buf_clear(path);
return GIT_ENOTFOUND;
}
@@ -522,7 +379,7 @@ int git_futils_find_system_file(git_buf *path, const char *filename)
if (git_buf_joinpath(path, "/etc", filename) < GIT_SUCCESS)
return git_buf_lasterror(path);
- if (git_futils_exists(path->ptr) == GIT_SUCCESS)
+ if (git_path_exists(path->ptr) == GIT_SUCCESS)
return GIT_SUCCESS;
git_buf_clear(path);
@@ -533,29 +390,3 @@ int git_futils_find_system_file(git_buf *path, const char *filename)
return GIT_ENOTFOUND;
#endif
}
-
-int git_futils_dir_for_path(git_buf *dir, const char *path, const char *base)
-{
- int error = GIT_SUCCESS;
-
- if (base != NULL && git_path_root(path) < 0)
- error = git_buf_joinpath(dir, base, path);
- else
- error = git_buf_sets(dir, path);
-
- if (error == GIT_SUCCESS) {
- char buf[GIT_PATH_MAX];
- if (p_realpath(dir->ptr, buf) != NULL)
- error = git_buf_sets(dir, buf);
- }
-
- /* call dirname if this is not a directory */
- if (error == GIT_SUCCESS && git_futils_isdir(dir->ptr) != GIT_SUCCESS)
- if (git_path_dirname_r(dir, dir->ptr) < GIT_SUCCESS)
- error = git_buf_lasterror(dir);
-
- if (error == GIT_SUCCESS)
- error = git_path_to_dir(dir);
-
- return error;
-}
diff --git a/src/fileops.h b/src/fileops.h
index 91903a731..1ded0d3b1 100644
--- a/src/fileops.h
+++ b/src/fileops.h
@@ -9,7 +9,6 @@
#include "common.h"
#include "map.h"
-#include "dir.h"
#include "posix.h"
#include "path.h"
@@ -41,11 +40,6 @@ extern void git_futils_fbuffer_rtrim(git_fbuffer *obj);
*/
/**
- * Check if a file exists and can be accessed.
- */
-extern int git_futils_exists(const char *path);
-
-/**
* Create and open a file, while also
* creating all the folders in its path
*/
@@ -63,32 +57,6 @@ extern int git_futils_creat_locked(const char *path, const mode_t mode);
extern int git_futils_creat_locked_withpath(const char *path, const mode_t dirmode, const mode_t mode);
/**
- * Check if the given path points to a directory
- */
-extern int git_futils_isdir(const char *path);
-
-/**
- * Check if the given path points to a regular file
- */
-extern int git_futils_isfile(const char *path);
-
-/**
- * Check if the given path contains the given subdirectory.
- *
- * If `append_if_exists` is true, then the subdir will be appended to the
- * parent path if it does exists.
- */
-extern int git_futils_contains_dir(git_buf *parent, const char *subdir, int append_if_exists);
-
-/**
- * Check if the given path contains the given file
- *
- * If `append_if_exists` is true, then the filename will be appended to the
- * parent path if it does exists.
- */
-extern int git_futils_contains_file(git_buf *parent, const char *file, int append_if_exists);
-
-/**
* Create a path recursively
*/
extern int git_futils_mkdir_r(const char *path, const char *base, const mode_t mode);
@@ -99,17 +67,10 @@ extern int git_futils_mkdir_r(const char *path, const char *base, const mode_t m
*/
extern int git_futils_mkpath2file(const char *path, const mode_t mode);
-extern int git_futils_rmdir_r(const char *path, int force);
-
/**
- * Get the directory for a path.
- *
- * If the path is a directory, this does nothing (save append a '/' as
- * needed). If path is a normal file, this gets the directory containing
- * it. If the path does not exist, then this treats it a filename and
- * returns the dirname of it.
+ * Remove path and any files and directories beneath it.
*/
-extern int git_futils_dir_for_path(git_buf *dir, const char *path, const char *base);
+extern int git_futils_rmdir_r(const char *path, int force);
/**
* Create and open a temporary file with a `_git2_` suffix.
@@ -158,24 +119,6 @@ extern int git_futils_mmap_ro(
extern void git_futils_mmap_free(git_map *map);
/**
- * Walk each directory entry, except '.' and '..', calling fn(state).
- *
- * @param pathbuf buffer the function reads the initial directory
- * path from, and updates with each successive entry's name.
- * @param fn function to invoke with each entry. The first arg is
- * the input state and the second arg is pathbuf. The function
- * may modify the pathbuf, but only by appending new text.
- * @param state to pass to fn as the first arg.
- */
-extern int git_futils_direach(
- git_buf *pathbuf,
- int (*fn)(void *, git_buf *),
- void *state);
-
-extern int git_futils_cmp_path(const char *name1, int len1, int isdir1,
- const char *name2, int len2, int isdir2);
-
-/**
* Find a "global" file (i.e. one in a user's home directory).
*
* @param pathbuf buffer to write the full path into
diff --git a/src/ignore.c b/src/ignore.c
index 1040574d7..8e0b8a0ff 100644
--- a/src/ignore.c
+++ b/src/ignore.c
@@ -88,7 +88,7 @@ int git_ignore__for_path(git_repository *repo, const char *path, git_vector *sta
if ((error = git_attr_cache__init(repo)) < GIT_SUCCESS)
goto cleanup;
- if ((error = git_futils_dir_for_path(&dir, path, workdir)) < GIT_SUCCESS)
+ if ((error = git_path_find_dir(&dir, path, workdir)) < GIT_SUCCESS)
goto cleanup;
/* insert internals */
diff --git a/src/index.c b/src/index.c
index 9e88012bb..66e7a81da 100644
--- a/src/index.c
+++ b/src/index.c
@@ -150,7 +150,7 @@ int git_index_open(git_index **index_out, const char *index_path)
git_vector_init(&index->entries, 32, index_cmp);
/* Check if index file is stored on disk already */
- if (git_futils_exists(index->index_file_path) == 0)
+ if (git_path_exists(index->index_file_path) == 0)
index->on_disk = 1;
*index_out = index;
@@ -221,7 +221,7 @@ int git_index_read(git_index *index)
assert(index->index_file_path);
- if (!index->on_disk || git_futils_exists(index->index_file_path) < 0) {
+ if (!index->on_disk || git_path_exists(index->index_file_path) < 0) {
git_index_clear(index);
index->on_disk = 0;
return GIT_SUCCESS;
diff --git a/src/odb.c b/src/odb.c
index b52f87078..8905c2237 100644
--- a/src/odb.c
+++ b/src/odb.c
@@ -354,7 +354,7 @@ static int load_alternates(git_odb *odb, const char *objects_dir)
if (error < GIT_SUCCESS)
return error;
- if (git_futils_exists(alternates_path.ptr) < GIT_SUCCESS) {
+ if (git_path_exists(alternates_path.ptr) < GIT_SUCCESS) {
git_buf_free(&alternates_path);
return GIT_SUCCESS;
}
diff --git a/src/odb_loose.c b/src/odb_loose.c
index f177af86c..d958fce9f 100644
--- a/src/odb_loose.c
+++ b/src/odb_loose.c
@@ -466,7 +466,7 @@ static int locate_object(
int error = object_file_name(object_location, backend->objects_dir, oid);
if (error == GIT_SUCCESS)
- error = git_futils_exists(git_buf_cstr(object_location));
+ error = git_path_exists(git_buf_cstr(object_location));
return error;
}
@@ -480,7 +480,7 @@ static int fn_locate_object_short_oid(void *state, git_buf *pathbuf) {
return GIT_SUCCESS;
}
- if (!git_futils_exists(pathbuf->ptr) && git_futils_isdir(pathbuf->ptr)) {
+ if (!git_path_exists(pathbuf->ptr) && git_path_isdir(pathbuf->ptr)) {
/* We are already in the directory matching the 2 first hex characters,
* compare the first ncmp characters of the oids */
if (!memcmp(sstate->short_oid + 2,
@@ -533,8 +533,8 @@ static int locate_object_short_oid(
return git__rethrow(error, "Failed to locate object from short oid");
/* Check that directory exists */
- if (git_futils_exists(object_location->ptr) ||
- git_futils_isdir(object_location->ptr))
+ if (git_path_exists(object_location->ptr) ||
+ git_path_isdir(object_location->ptr))
return git__throw(GIT_ENOTFOUND, "Failed to locate object from short oid. Object not found");
state.dir_len = object_location->size;
@@ -542,7 +542,7 @@ static int locate_object_short_oid(
state.found = 0;
/* Explore directory to find a unique object matching short_oid */
- error = git_futils_direach(object_location, fn_locate_object_short_oid, &state);
+ error = git_path_direach(object_location, fn_locate_object_short_oid, &state);
if (error)
return git__rethrow(error, "Failed to locate object from short oid");
@@ -716,7 +716,7 @@ static int loose_backend__stream_fwrite(git_oid *oid, git_odb_stream *_stream)
* is what git does and allows us to sidestep the fact that
* we're not allowed to overwrite a read-only file on Windows.
*/
- if (git_futils_exists(final_path.ptr) == GIT_SUCCESS) {
+ if (git_path_exists(final_path.ptr) == GIT_SUCCESS) {
git_filebuf_cleanup(&stream->fbuf);
goto cleanup;
}
diff --git a/src/odb_pack.c b/src/odb_pack.c
index 757d6277e..81168bfa6 100644
--- a/src/odb_pack.c
+++ b/src/odb_pack.c
@@ -254,7 +254,7 @@ static int packfile_refresh_all(struct pack_backend *backend)
git_buf_sets(&path, backend->pack_folder);
/* reload all packs */
- error = git_futils_direach(&path, packfile_load__cb, (void *)backend);
+ error = git_path_direach(&path, packfile_load__cb, (void *)backend);
git_buf_free(&path);
if (error < GIT_SUCCESS)
@@ -469,7 +469,7 @@ int git_odb_backend_pack(git_odb_backend **backend_out, const char *objects_dir)
if (error < GIT_SUCCESS)
goto cleanup;
- if (git_futils_isdir(git_buf_cstr(&path)) == GIT_SUCCESS) {
+ if (git_path_isdir(git_buf_cstr(&path)) == GIT_SUCCESS) {
backend->pack_folder = git_buf_detach(&path);
backend->pack_folder_mtime = 0;
}
diff --git a/src/pack.c b/src/pack.c
index 1510ded0c..cf64983ca 100644
--- a/src/pack.c
+++ b/src/pack.c
@@ -600,7 +600,7 @@ int git_packfile_check(struct git_pack_file **pack_out, const char *path)
memcpy(p->pack_name, path, path_len);
strcpy(p->pack_name + path_len, ".keep");
- if (git_futils_exists(p->pack_name) == GIT_SUCCESS)
+ if (git_path_exists(p->pack_name) == GIT_SUCCESS)
p->pack_keep = 1;
strcpy(p->pack_name + path_len, ".pack");
diff --git a/src/path.c b/src/path.c
index 03ebfe090..5319ca6a5 100644
--- a/src/path.c
+++ b/src/path.c
@@ -7,7 +7,11 @@
#include "common.h"
#include "path.h"
#include "posix.h"
-
+#ifdef GIT_WIN32
+#include "win32/dir.h"
+#else
+#include <dirent.h>
+#endif
#include <stdarg.h>
#include <stdio.h>
#include <ctype.h>
@@ -349,3 +353,172 @@ int git_path_walk_up(
return error;
}
+
+int git_path_exists(const char *path)
+{
+ assert(path);
+ return p_access(path, F_OK);
+}
+
+int git_path_isdir(const char *path)
+{
+#ifdef GIT_WIN32
+ DWORD attr = GetFileAttributes(path);
+ if (attr == INVALID_FILE_ATTRIBUTES)
+ return GIT_ERROR;
+
+ return (attr & FILE_ATTRIBUTE_DIRECTORY) ? GIT_SUCCESS : GIT_ERROR;
+
+#else
+ struct stat st;
+ if (p_stat(path, &st) < GIT_SUCCESS)
+ return GIT_ERROR;
+
+ return S_ISDIR(st.st_mode) ? GIT_SUCCESS : GIT_ERROR;
+#endif
+}
+
+int git_path_isfile(const char *path)
+{
+ struct stat st;
+ int stat_error;
+
+ assert(path);
+ stat_error = p_stat(path, &st);
+
+ if (stat_error < GIT_SUCCESS)
+ return -1;
+
+ if (!S_ISREG(st.st_mode))
+ return -1;
+
+ return 0;
+}
+
+static int _check_dir_contents(
+ git_buf *dir,
+ const char *sub,
+ int append_on_success,
+ int (*predicate)(const char *))
+{
+ int error = GIT_SUCCESS;
+ size_t dir_size = dir->size;
+ size_t sub_size = strlen(sub);
+
+ /* leave base valid even if we could not make space for subdir */
+ if ((error = git_buf_try_grow(dir, dir_size + sub_size + 2)) < GIT_SUCCESS)
+ return error;
+
+ /* save excursion */
+ git_buf_joinpath(dir, dir->ptr, sub);
+
+ error = (*predicate)(dir->ptr);
+
+ /* restore excursion */
+ if (!append_on_success || error != GIT_SUCCESS)
+ git_buf_truncate(dir, dir_size);
+
+ return error;
+}
+
+int git_path_contains_dir(git_buf *base, const char *subdir, int append_if_exists)
+{
+ return _check_dir_contents(base, subdir, append_if_exists, &git_path_isdir);
+}
+
+int git_path_contains_file(git_buf *base, const char *file, int append_if_exists)
+{
+ return _check_dir_contents(base, file, append_if_exists, &git_path_isfile);
+}
+
+int git_path_find_dir(git_buf *dir, const char *path, const char *base)
+{
+ int error = GIT_SUCCESS;
+
+ if (base != NULL && git_path_root(path) < 0)
+ error = git_buf_joinpath(dir, base, path);
+ else
+ error = git_buf_sets(dir, path);
+
+ if (error == GIT_SUCCESS) {
+ char buf[GIT_PATH_MAX];
+ if (p_realpath(dir->ptr, buf) != NULL)
+ error = git_buf_sets(dir, buf);
+ }
+
+ /* call dirname if this is not a directory */
+ if (error == GIT_SUCCESS && git_path_isdir(dir->ptr) != GIT_SUCCESS)
+ if (git_path_dirname_r(dir, dir->ptr) < GIT_SUCCESS)
+ error = git_buf_lasterror(dir);
+
+ if (error == GIT_SUCCESS)
+ error = git_path_to_dir(dir);
+
+ return error;
+}
+
+int git_path_cmp(const char *name1, int len1, int isdir1,
+ const char *name2, int len2, int isdir2)
+{
+ int len = len1 < len2 ? len1 : len2;
+ int cmp;
+
+ cmp = memcmp(name1, name2, len);
+ if (cmp)
+ return cmp;
+ if (len1 < len2)
+ return ((!isdir1 && !isdir2) ? -1 :
+ (isdir1 ? '/' - name2[len1] : name2[len1] - '/'));
+ if (len1 > len2)
+ return ((!isdir1 && !isdir2) ? 1 :
+ (isdir2 ? name1[len2] - '/' : '/' - name1[len2]));
+ return 0;
+}
+
+/* Taken from git.git */
+GIT_INLINE(int) is_dot_or_dotdot(const char *name)
+{
+ return (name[0] == '.' &&
+ (name[1] == '\0' ||
+ (name[1] == '.' && name[2] == '\0')));
+}
+
+int git_path_direach(
+ git_buf *path,
+ int (*fn)(void *, git_buf *),
+ void *arg)
+{
+ ssize_t wd_len;
+ DIR *dir;
+ struct dirent *de;
+
+ if (git_path_to_dir(path) < GIT_SUCCESS)
+ return git_buf_lasterror(path);
+
+ wd_len = path->size;
+ dir = opendir(path->ptr);
+ if (!dir)
+ return git__throw(GIT_EOSERR, "Failed to process `%s` tree structure. An error occured while opening the directory", path->ptr);
+
+ while ((de = readdir(dir)) != NULL) {
+ int result;
+
+ if (is_dot_or_dotdot(de->d_name))
+ continue;
+
+ if (git_buf_puts(path, de->d_name) < GIT_SUCCESS)
+ return git_buf_lasterror(path);
+
+ result = fn(arg, path);
+
+ git_buf_truncate(path, wd_len); /* restore path */
+
+ if (result != GIT_SUCCESS) {
+ closedir(dir);
+ return result; /* The callee is reponsible for setting the correct error message */
+ }
+ }
+
+ closedir(dir);
+ return GIT_SUCCESS;
+}
diff --git a/src/path.h b/src/path.h
index e59c19ad9..ee3607ce9 100644
--- a/src/path.h
+++ b/src/path.h
@@ -10,6 +10,13 @@
#include "common.h"
#include "buffer.h"
+/**
+ * Path manipulation utils
+ *
+ * These are path utilities that munge paths without actually
+ * looking at the real filesystem.
+ */
+
/*
* The dirname() function shall take a pointer to a character string
* that contains a pathname, and return a pointer to a string that is a
@@ -52,15 +59,30 @@ extern int git_path_basename_r(git_buf *buffer, const char *path);
extern const char *git_path_topdir(const char *path);
+/**
+ * Find offset to root of path if path has one.
+ *
+ * This will return a number >= 0 which is the offset to the start of the
+ * path, if the path is rooted (i.e. "/rooted/path" returns 0 and
+ * "c:/windows/rooted/path" returns 2). If the path is not rooted, this
+ * returns < 0.
+ */
extern int git_path_root(const char *path);
-extern int git_path_prettify(git_buf *path_out, const char *path, const char *base);
-extern int git_path_prettify_dir(git_buf *path_out, const char *path, const char *base);
-
+/**
+ * Ensure path has a trailing '/'.
+ */
extern int git_path_to_dir(git_buf *path);
+
+/**
+ * Ensure string has a trailing '/' if there is space for it.
+ */
extern void git_path_string_to_dir(char* path, size_t size);
#ifdef GIT_WIN32
+/**
+ * Convert backslashes in path to forward slashes.
+ */
GIT_INLINE(void) git_path_mkposix(char *path)
{
while (*path) {
@@ -75,20 +97,123 @@ GIT_INLINE(void) git_path_mkposix(char *path)
#endif
extern int git__percent_decode(git_buf *decoded_out, const char *input);
+
+/**
+ * Extract path from file:// URL.
+ */
extern int git_path_fromurl(git_buf *local_path_out, const char *file_url);
+
+/**
+ * Path filesystem utils
+ *
+ * These are path utilities that actually access the filesystem.
+ */
+
+/**
+ * Check if a file exists and can be accessed.
+ * @return GIT_SUCCESS if file exists, < 0 otherwise.
+ */
+extern int git_path_exists(const char *path);
+
+/**
+ * Check if the given path points to a directory.
+ * @return GIT_SUCCESS if it is a directory, < 0 otherwise.
+ */
+extern int git_path_isdir(const char *path);
+
/**
- * Invoke callback directory by directory up the path until the ceiling
- * is reached (inclusive of a final call at the root_path).
+ * Check if the given path points to a regular file.
+ * @return GIT_SUCCESS if it is a regular file, < 0 otherwise.
+ */
+extern int git_path_isfile(const char *path);
+
+/**
+ * Check if the given path contains the given subdirectory.
+ *
+ * @param parent Directory path that might contain subdir
+ * @param subdir Subdirectory name to look for in parent
+ * @param append_if_exists If true, then subdir will be appended to the parent path if it does exist
+ * @return GIT_SUCCESS if subdirectory exists, < 0 otherwise.
+ */
+extern int git_path_contains_dir(git_buf *parent, const char *subdir, int append_if_exists);
+
+/**
+ * Check if the given path contains the given file.
+ *
+ * @param dir Directory path that might contain file
+ * @param file File name to look for in parent
+ * @param append_if_exists If true, then file will be appended to the path if it does exist
+ * @return GIT_SUCCESS if file exists, < 0 otherwise.
+ */
+extern int git_path_contains_file(git_buf *dir, const char *file, int append_if_exists);
+
+/**
+ * Clean up path, prepending base if it is not already rooted.
+ */
+extern int git_path_prettify(git_buf *path_out, const char *path, const char *base);
+
+/**
+ * Clean up path, prepending base if it is not already rooted and
+ * appending a slash.
+ */
+extern int git_path_prettify_dir(git_buf *path_out, const char *path, const char *base);
+
+/**
+ * Get a directory from a path.
+ *
+ * If path is a directory, this acts like `git_path_prettify_dir`
+ * (cleaning up path and appending a '/'). If path is a normal file,
+ * this prettifies it, then removed the filename a la dirname and
+ * appends the trailing '/'. If the path does not exist, it is
+ * treated like a regular filename.
+ */
+extern int git_path_find_dir(git_buf *dir, const char *path, const char *base);
+
+/**
+ * Walk each directory entry, except '.' and '..', calling fn(state).
+ *
+ * @param pathbuf buffer the function reads the initial directory
+ * path from, and updates with each successive entry's name.
+ * @param fn function to invoke with each entry. The first arg is
+ * the input state and the second arg is pathbuf. The function
+ * may modify the pathbuf, but only by appending new text.
+ * @param state to pass to fn as the first arg.
+ */
+extern int git_path_direach(
+ git_buf *pathbuf,
+ int (*fn)(void *, git_buf *),
+ void *state);
+
+/**
+ * Sort function to order two paths.
+ */
+extern int git_path_cmp(
+ const char *name1, int len1, int isdir1,
+ const char *name2, int len2, int isdir2);
+
+/**
+ * Invoke callback up path directory by directory until the ceiling is
+ * reached (inclusive of a final call at the root_path).
+ *
+ * Returning anything other than GIT_SUCCESS from the callback function
+ * will stop the iteration and propogate the error to the caller.
*
- * If the ceiling is NULL, this will walk all the way up to the root.
- * If the ceiling is not a prefix of the path, the callback will be
- * invoked a single time on the verbatim input path. Returning anything
- * other than GIT_SUCCESS from the callback function will stop the
- * iteration and propogate the error to the caller.
+ * @param pathbuf Buffer the function reads the directory from and
+ * and updates with each successive name.
+ * @param ceiling Prefix of path at which to stop walking up. If NULL,
+ * this will walk all the way up to the root. If not a prefix of
+ * pathbuf, the callback will be invoked a single time on the
+ * original input path.
+ * @param fn Function to invoke on each path. The first arg is the
+ * input satte and the second arg is the pathbuf. The function
+ * should not modify the pathbuf.
+ * @param state Passed to fn as the first ath.
*/
extern int git_path_walk_up(
- git_buf *path, const char *ceiling,
- int (*cb)(void *data, git_buf *), void *data);
+ git_buf *pathbuf,
+ const char *ceiling,
+ int (*fn)(void *state, git_buf *),
+ void *state);
#endif
diff --git a/src/reflog.c b/src/reflog.c
index a327975d6..970e7c2de 100644
--- a/src/reflog.c
+++ b/src/reflog.c
@@ -246,12 +246,12 @@ int git_reflog_write(git_reference *ref, const git_oid *oid_old,
if (error < GIT_SUCCESS)
goto cleanup;
- if (git_futils_exists(log_path.ptr)) {
+ if (git_path_exists(log_path.ptr)) {
error = git_futils_mkpath2file(log_path.ptr, GIT_REFLOG_DIR_MODE);
if (error < GIT_SUCCESS)
git__rethrow(error,
"Failed to write reflog. Cannot create reflog directory");
- } else if (git_futils_isfile(log_path.ptr)) {
+ } else if (git_path_isfile(log_path.ptr)) {
error = git__throw(GIT_ERROR,
"Failed to write reflog. `%s` is directory", log_path.ptr);
} else if (oid_old == NULL) {
@@ -302,7 +302,7 @@ int git_reflog_delete(git_reference *ref)
error = git_buf_join_n(&path, '/', 3,
ref->owner->path_repository, GIT_REFLOG_DIR, ref->name);
- if (error == GIT_SUCCESS && git_futils_exists(path.ptr) == 0)
+ if (error == GIT_SUCCESS && git_path_exists(path.ptr) == 0)
error = p_unlink(path.ptr);
git_buf_free(&path);
diff --git a/src/refs.c b/src/refs.c
index 2842adab1..340841cc6 100644
--- a/src/refs.c
+++ b/src/refs.c
@@ -525,8 +525,8 @@ static int _dirent_loose_listall(void *_data, git_buf *full_path)
struct dirent_list_data *data = (struct dirent_list_data *)_data;
const char *file_path = full_path->ptr + data->repo_path_len;
- if (git_futils_isdir(full_path->ptr) == GIT_SUCCESS)
- return git_futils_direach(full_path, _dirent_loose_listall, _data);
+ if (git_path_isdir(full_path->ptr) == GIT_SUCCESS)
+ return git_path_direach(full_path, _dirent_loose_listall, _data);
/* do not add twice a reference that exists already in the packfile */
if ((data->list_flags & GIT_REF_PACKED) != 0 &&
@@ -549,8 +549,8 @@ static int _dirent_loose_load(void *data, git_buf *full_path)
const char *file_path;
int error;
- if (git_futils_isdir(full_path->ptr) == GIT_SUCCESS)
- return git_futils_direach(full_path, _dirent_loose_load, repository);
+ if (git_path_isdir(full_path->ptr) == GIT_SUCCESS)
+ return git_path_direach(full_path, _dirent_loose_load, repository);
file_path = full_path->ptr + strlen(repository->path_repository);
error = loose_lookup_to_packfile(&ref, repository, file_path);
@@ -596,7 +596,7 @@ static int packed_loadloose(git_repository *repository)
* This will overwrite any old packed entries with their
* updated loose versions
*/
- error = git_futils_direach(&refs_path, _dirent_loose_load, repository);
+ error = git_path_direach(&refs_path, _dirent_loose_load, repository);
git_buf_free(&refs_path);
return error;
}
@@ -719,7 +719,7 @@ static int packed_remove_loose(git_repository *repo, git_vector *packing_list)
an_error = git_buf_joinpath(&full_path, repo->path_repository, ref->name);
if (an_error == GIT_SUCCESS &&
- git_futils_exists(full_path.ptr) == GIT_SUCCESS &&
+ git_path_exists(full_path.ptr) == GIT_SUCCESS &&
p_unlink(full_path.ptr) < GIT_SUCCESS)
an_error = GIT_EOSERR;
@@ -902,7 +902,7 @@ static int reference_exists(int *exists, git_repository *repo, const char *ref_n
if (error < GIT_SUCCESS)
return git__rethrow(error, "Cannot resolve if a reference exists");
- if (git_futils_isfile(ref_path.ptr) == GIT_SUCCESS ||
+ if (git_path_isfile(ref_path.ptr) == GIT_SUCCESS ||
git_hashtable_lookup(repo->references.packfile, ref_path.ptr) != NULL) {
*exists = 1;
} else {
@@ -1352,8 +1352,8 @@ int git_reference_rename(git_reference *ref, const char *new_name, int force)
if ((error = reference_delete(ref)) < GIT_SUCCESS)
goto cleanup;
- if (git_futils_exists(aux_path.ptr) == GIT_SUCCESS) {
- if (git_futils_isdir(aux_path.ptr) == GIT_SUCCESS) {
+ if (git_path_exists(aux_path.ptr) == GIT_SUCCESS) {
+ if (git_path_isdir(aux_path.ptr) == GIT_SUCCESS) {
if ((error = git_futils_rmdir_r(aux_path.ptr, 0)) < GIT_SUCCESS)
goto rollback;
} else goto rollback;
@@ -1398,7 +1398,7 @@ int git_reference_rename(git_reference *ref, const char *new_name, int force)
if (error < GIT_SUCCESS)
goto cleanup;
- if (git_futils_exists(aux_path.ptr) == GIT_SUCCESS)
+ if (git_path_exists(aux_path.ptr) == GIT_SUCCESS)
error = git_reflog_rename(ref, new_name);
/*
@@ -1536,7 +1536,7 @@ int git_reference_foreach(
repo->path_repository, GIT_REFS_DIR)) < GIT_SUCCESS)
return git__rethrow(error, "Failed to alloc space for references");
- error = git_futils_direach(&refs_path, _dirent_loose_listall, &data);
+ error = git_path_direach(&refs_path, _dirent_loose_listall, &data);
git_buf_free(&refs_path);
diff --git a/src/repository.c b/src/repository.c
index 67bfcc916..97d70c437 100644
--- a/src/repository.c
+++ b/src/repository.c
@@ -79,14 +79,14 @@ void git_repository_free(git_repository *repo)
static int quickcheck_repository_dir(git_buf *repository_path)
{
/* Check OBJECTS_DIR first, since it will generate the longest path name */
- if (git_futils_contains_dir(repository_path, GIT_OBJECTS_DIR, 0) < 0)
+ if (git_path_contains_dir(repository_path, GIT_OBJECTS_DIR, 0) < 0)
return GIT_ERROR;
/* Ensure HEAD file exists */
- if (git_futils_contains_file(repository_path, GIT_HEAD_FILE, 0) < 0)
+ if (git_path_contains_file(repository_path, GIT_HEAD_FILE, 0) < 0)
return GIT_ERROR;
- if (git_futils_contains_dir(repository_path, GIT_REFS_DIR, 0) < 0)
+ if (git_path_contains_dir(repository_path, GIT_REFS_DIR, 0) < 0)
return GIT_ERROR;
return GIT_SUCCESS;
@@ -164,7 +164,7 @@ int git_repository_open(git_repository **repo_out, const char *path)
* of the working dir, by testing if it contains a `.git`
* folder inside of it.
*/
- git_futils_contains_dir(&path_buf, DOT_GIT, 1); /* append on success */
+ git_path_contains_dir(&path_buf, DOT_GIT, 1); /* append on success */
/* ignore error, since it just means `path/.git` doesn't exist */
if (quickcheck_repository_dir(&path_buf) < GIT_SUCCESS) {
@@ -491,7 +491,7 @@ static int read_gitfile(git_buf *path_out, const char *file_path, const char *ba
git_futils_freebuffer(&file);
- if (error == GIT_SUCCESS && git_futils_exists(path_out->ptr) == 0)
+ if (error == GIT_SUCCESS && git_path_exists(path_out->ptr) == 0)
return GIT_SUCCESS;
return git__throw(GIT_EOBJCORRUPTED, "The `.git` file points to a nonexistent path");
@@ -535,7 +535,7 @@ int git_repository_discover(
* If the `.git` file is regular instead of
* a directory, it should contain the path of the actual git repository
*/
- if (git_futils_isfile(normal_path.ptr) == GIT_SUCCESS) {
+ if (git_path_isfile(normal_path.ptr) == GIT_SUCCESS) {
git_buf gitfile_path = GIT_BUF_INIT;
error = read_gitfile(&gitfile_path, normal_path.ptr, bare_path.ptr);
@@ -557,7 +557,7 @@ int git_repository_discover(
/**
* If the `.git` file is a folder, we check inside of it
*/
- if (git_futils_isdir(normal_path.ptr) == GIT_SUCCESS) {
+ if (git_path_isdir(normal_path.ptr) == GIT_SUCCESS) {
error = quickcheck_repository_dir(&normal_path);
if (error == GIT_SUCCESS) {
found_path = &normal_path;
@@ -733,7 +733,7 @@ int git_repository_init(git_repository **repo_out, const char *path, unsigned is
if (error < GIT_SUCCESS)
return error;
- if (git_futils_isdir(repository_path.ptr) == GIT_SUCCESS) {
+ if (git_path_isdir(repository_path.ptr) == GIT_SUCCESS) {
if (quickcheck_repository_dir(&repository_path) == GIT_SUCCESS) {
error = repo_init_reinit(repository_path.ptr, is_bare);
git_buf_free(&repository_path);
diff --git a/src/status.c b/src/status.c
index 3ead15a87..492edf568 100644
--- a/src/status.c
+++ b/src/status.c
@@ -489,7 +489,7 @@ int git_status_foreach(
dirent_st.index_position = 0;
dirent_st.is_dir = 1;
- if (git_futils_isdir(workdir)) {
+ if (git_path_isdir(workdir)) {
error = git__throw(GIT_EINVALIDPATH,
"Failed to determine status of file '%s'. "
"The given path doesn't lead to a folder", workdir);
@@ -592,7 +592,7 @@ int git_status_file(unsigned int *status_flags, git_repository *repo, const char
return git__rethrow(error,
"Failed to determine status of file '%s'", path);
- if (git_futils_isdir(temp_path.ptr) == GIT_SUCCESS) {
+ if (git_path_isdir(temp_path.ptr) == GIT_SUCCESS) {
git_buf_free(&temp_path);
return git__throw(GIT_EINVALIDPATH,
"Failed to determine status of file '%s'. "
@@ -606,7 +606,7 @@ int git_status_file(unsigned int *status_flags, git_repository *repo, const char
}
/* Find file in Workdir */
- if (git_futils_exists(temp_path.ptr) == GIT_SUCCESS) {
+ if (git_path_exists(temp_path.ptr) == GIT_SUCCESS) {
if ((error = status_entry_update_from_workdir(e, temp_path.ptr)) < GIT_SUCCESS)
goto cleanup; /* The callee has already set the error message */
}
@@ -672,8 +672,8 @@ cleanup:
}
/*
- * git_futils_direach is not supposed to return entries in an ordered manner.
- * alphasorted_futils_direach wraps git_futils_direach and invokes the callback
+ * git_path_direach is not supposed to return entries in an ordered manner.
+ * alphasorted_futils_direach wraps git_path_direach and invokes the callback
* function by passing it alphabeticcally sorted paths parameters.
*
*/
@@ -686,7 +686,7 @@ static char *alphasorted_dirent_info_new(const git_buf *path)
git_buf_copy_cstr(di, path->size + 1, path);
- if (git_futils_isdir(path->ptr) == GIT_SUCCESS) {
+ if (git_path_isdir(path->ptr) == GIT_SUCCESS) {
/*
* Append a forward slash to the name to force folders
* to be ordered in a similar way than in a tree
@@ -734,7 +734,7 @@ static int alphasorted_futils_direach(
if (git_vector_init(&entry_names, 16, git__strcmp_cb) < GIT_SUCCESS)
return GIT_ENOMEM;
- error = git_futils_direach(path, alphasorted_dirent_cb, &entry_names);
+ error = git_path_direach(path, alphasorted_dirent_cb, &entry_names);
git_vector_sort(&entry_names);
diff --git a/src/tree.c b/src/tree.c
index 8bc17d975..f21490235 100644
--- a/src/tree.c
+++ b/src/tree.c
@@ -30,7 +30,7 @@ static int entry_sort_cmp(const void *a, const void *b)
const git_tree_entry *entry_a = (const git_tree_entry *)(a);
const git_tree_entry *entry_b = (const git_tree_entry *)(b);
- return git_futils_cmp_path(
+ return git_path_cmp(
entry_a->filename, entry_a->filename_len, entry_is_tree(entry_a),
entry_b->filename, entry_b->filename_len, entry_is_tree(entry_b));
}
diff --git a/src/dir.h b/src/win32/dir.h
index 5d50692e4..b16a3cfeb 100644
--- a/src/dir.h
+++ b/src/win32/dir.h
@@ -9,12 +9,6 @@
#include "common.h"
-#ifndef GIT_WIN32
-# include <dirent.h>
-#endif
-
-#ifdef GIT_WIN32
-
struct git__dirent {
int d_ino;
char d_name[261];
@@ -42,6 +36,4 @@ extern int git__closedir(git__DIR *);
# define closedir git__closedir
# endif
-#endif
-
#endif /* INCLUDE_dir_h__ */
diff --git a/tests-clay/config/stress.c b/tests-clay/config/stress.c
index b48ed399d..3d3729c41 100644
--- a/tests-clay/config/stress.c
+++ b/tests-clay/config/stress.c
@@ -27,7 +27,7 @@ void test_config_stress__dont_break_on_invalid_input(void)
struct git_config_file *file;
git_config *config;
- cl_git_pass(git_futils_exists("git-test-config"));
+ cl_git_pass(git_path_exists("git-test-config"));
cl_git_pass(git_config_file__ondisk(&file, "git-test-config"));
cl_git_pass(git_config_new(&config));
cl_git_pass(git_config_add_file(config, file, 0));
diff --git a/tests-clay/core/dirent.c b/tests-clay/core/dirent.c
index 4f55368ac..c9ab1c103 100644
--- a/tests-clay/core/dirent.c
+++ b/tests-clay/core/dirent.c
@@ -115,7 +115,7 @@ void test_core_dirent__dont_traverse_dot(void)
cl_set_cleanup(&dirent_cleanup__cb, &dot);
setup(&dot);
- cl_git_pass(git_futils_direach(&dot.path,
+ cl_git_pass(git_path_direach(&dot.path,
one_entry,
&dot));
@@ -141,7 +141,7 @@ void test_core_dirent__traverse_subfolder(void)
cl_set_cleanup(&dirent_cleanup__cb, &sub);
setup(&sub);
- cl_git_pass(git_futils_direach(&sub.path,
+ cl_git_pass(git_path_direach(&sub.path,
one_entry,
&sub));
@@ -161,7 +161,7 @@ void test_core_dirent__traverse_slash_terminated_folder(void)
cl_set_cleanup(&dirent_cleanup__cb, &sub_slash);
setup(&sub_slash);
- cl_git_pass(git_futils_direach(&sub_slash.path,
+ cl_git_pass(git_path_direach(&sub_slash.path,
one_entry,
&sub_slash));
@@ -184,14 +184,14 @@ void test_core_dirent__dont_traverse_empty_folders(void)
cl_set_cleanup(&dirent_cleanup__cb, &empty);
setup(&empty);
- cl_git_pass(git_futils_direach(&empty.path,
+ cl_git_pass(git_path_direach(&empty.path,
one_entry,
&empty));
check_counts(&empty);
/* make sure callback not called */
- cl_git_pass(git_futils_direach(&empty.path,
+ cl_git_pass(git_path_direach(&empty.path,
dont_call_me,
&empty));
}
@@ -216,7 +216,7 @@ void test_core_dirent__traverse_weird_filenames(void)
cl_set_cleanup(&dirent_cleanup__cb, &odd);
setup(&odd);
- cl_git_pass(git_futils_direach(&odd.path,
+ cl_git_pass(git_path_direach(&odd.path,
one_entry,
&odd));
diff --git a/tests-clay/core/filebuf.c b/tests-clay/core/filebuf.c
index 5b233fe8e..6a87902fe 100644
--- a/tests-clay/core/filebuf.c
+++ b/tests-clay/core/filebuf.c
@@ -14,7 +14,7 @@ void test_core_filebuf__0(void)
cl_must_pass(p_close(fd));
cl_git_fail(git_filebuf_open(&file, test, 0));
- cl_git_pass(git_futils_exists(testlock));
+ cl_git_pass(git_path_exists(testlock));
cl_must_pass(p_unlink(testlock));
}
diff --git a/tests/t00-core.c b/tests/t00-core.c
index 708a889de..58f048af6 100644
--- a/tests/t00-core.c
+++ b/tests/t00-core.c
@@ -362,7 +362,7 @@ static walk_data dot = {
BEGIN_TEST(dirent0, "make sure that the '.' folder is not traversed")
must_pass(setup(&dot));
- must_pass(git_futils_direach(&dot.path,
+ must_pass(git_path_direach(&dot.path,
one_entry,
&dot));
@@ -387,7 +387,7 @@ BEGIN_TEST(dirent1, "traverse a subfolder")
must_pass(setup(&sub));
- must_pass(git_futils_direach(&sub.path,
+ must_pass(git_path_direach(&sub.path,
one_entry,
&sub));
@@ -406,7 +406,7 @@ BEGIN_TEST(dirent2, "traverse a slash-terminated subfolder")
must_pass(setup(&sub_slash));
- must_pass(git_futils_direach(&sub_slash.path,
+ must_pass(git_path_direach(&sub_slash.path,
one_entry,
&sub_slash));
@@ -435,14 +435,14 @@ BEGIN_TEST(dirent3, "make sure that empty folders are not traversed")
must_pass(setup(&empty));
- must_pass(git_futils_direach(&empty.path,
+ must_pass(git_path_direach(&empty.path,
one_entry,
&empty));
must_pass(check_counts(&empty));
/* make sure callback not called */
- must_pass(git_futils_direach(&empty.path,
+ must_pass(git_path_direach(&empty.path,
dont_call_me,
&empty));
@@ -467,7 +467,7 @@ BEGIN_TEST(dirent4, "make sure that strange looking filenames ('..c') are traver
must_pass(setup(&odd));
- must_pass(git_futils_direach(&odd.path,
+ must_pass(git_path_direach(&odd.path,
one_entry,
&odd));
@@ -485,7 +485,7 @@ BEGIN_TEST(filebuf0, "make sure git_filebuf_open doesn't delete an existing lock
must_pass(fd);
must_pass(p_close(fd));
must_fail(git_filebuf_open(&file, test, 0));
- must_pass(git_futils_exists(testlock));
+ must_pass(git_path_exists(testlock));
must_pass(p_unlink(testlock));
END_TEST
diff --git a/tests/t03-objwrite.c b/tests/t03-objwrite.c
index 1fc0cac5e..1650b8060 100644
--- a/tests/t03-objwrite.c
+++ b/tests/t03-objwrite.c
@@ -44,9 +44,9 @@ static int make_odb_dir(void)
static int check_object_files(object_data *d)
{
- if (git_futils_exists(d->dir) < 0)
+ if (git_path_exists(d->dir) < 0)
return -1;
- if (git_futils_exists(d->file) < 0)
+ if (git_path_exists(d->file) < 0)
return -1;
return 0;
}
diff --git a/tests/t10-refs.c b/tests/t10-refs.c
index e8c7b7e00..63d1cb7d1 100644
--- a/tests/t10-refs.c
+++ b/tests/t10-refs.c
@@ -530,7 +530,7 @@ BEGIN_TEST(pack1, "create a packfile from all the loose rn a repo")
/* Ensure the packed-refs file exists */
must_pass(git_buf_joinpath(&temp_path, repo->path_repository, GIT_PACKEDREFS_FILE));
- must_pass(git_futils_exists(temp_path.ptr));
+ must_pass(git_path_exists(temp_path.ptr));
/* Ensure the known ref can still be looked up but is now packed */
must_pass(git_reference_lookup(&reference, repo, loose_tag_ref_name));
@@ -539,7 +539,7 @@ BEGIN_TEST(pack1, "create a packfile from all the loose rn a repo")
/* Ensure the known ref has been removed from the loose folder structure */
must_pass(git_buf_joinpath(&temp_path, repo->path_repository, loose_tag_ref_name));
- must_pass(!git_futils_exists(temp_path.ptr));
+ must_pass(!git_path_exists(temp_path.ptr));
close_temp_repo(repo);
@@ -557,7 +557,7 @@ BEGIN_TEST(rename0, "rename a loose reference")
/* Ensure the ref doesn't exist on the file system */
must_pass(git_buf_joinpath(&temp_path, repo->path_repository, new_name));
- must_pass(!git_futils_exists(temp_path.ptr));
+ must_pass(!git_path_exists(temp_path.ptr));
/* Retrieval of the reference to rename */
must_pass(git_reference_lookup(&looked_up_ref, repo, loose_tag_ref_name));
@@ -582,7 +582,7 @@ BEGIN_TEST(rename0, "rename a loose reference")
/* ...and the ref can be found in the file system */
must_pass(git_buf_joinpath(&temp_path, repo->path_repository, new_name));
- must_pass(git_futils_exists(temp_path.ptr));
+ must_pass(git_path_exists(temp_path.ptr));
close_temp_repo(repo);
@@ -601,7 +601,7 @@ BEGIN_TEST(rename1, "rename a packed reference (should make it loose)")
/* Ensure the ref doesn't exist on the file system */
must_pass(git_buf_joinpath(&temp_path, repo->path_repository, packed_head_name));
- must_pass(!git_futils_exists(temp_path.ptr));
+ must_pass(!git_path_exists(temp_path.ptr));
/* The reference can however be looked-up... */
must_pass(git_reference_lookup(&looked_up_ref, repo, packed_head_name));
@@ -626,7 +626,7 @@ BEGIN_TEST(rename1, "rename a packed reference (should make it loose)")
/* ...and the ref now happily lives in the file system */
must_pass(git_buf_joinpath(&temp_path, repo->path_repository, brand_new_name));
- must_pass(git_futils_exists(temp_path.ptr));
+ must_pass(git_path_exists(temp_path.ptr));
close_temp_repo(repo);
@@ -645,7 +645,7 @@ BEGIN_TEST(rename2, "renaming a packed reference does not pack another reference
/* Ensure the other reference exists on the file system */
must_pass(git_buf_joinpath(&temp_path, repo->path_repository, packed_test_head_name));
- must_pass(git_futils_exists(temp_path.ptr));
+ must_pass(git_path_exists(temp_path.ptr));
/* Lookup the other reference */
must_pass(git_reference_lookup(&another_looked_up_ref, repo, packed_test_head_name));
@@ -670,7 +670,7 @@ BEGIN_TEST(rename2, "renaming a packed reference does not pack another reference
must_be_true(git_reference_is_packed(another_looked_up_ref) == 0);
/* Ensure the other ref still exists on the file system */
- must_pass(git_futils_exists(temp_path.ptr));
+ must_pass(git_path_exists(temp_path.ptr));
close_temp_repo(repo);
@@ -899,7 +899,7 @@ BEGIN_TEST(delete0, "deleting a ref which is both packed and loose should remove
/* Ensure the loose reference exists on the file system */
must_pass(git_buf_joinpath(&temp_path, repo->path_repository, packed_test_head_name));
- must_pass(git_futils_exists(temp_path.ptr));
+ must_pass(git_path_exists(temp_path.ptr));
/* Lookup the reference */
must_pass(git_reference_lookup(&looked_up_ref, repo, packed_test_head_name));
@@ -914,7 +914,7 @@ BEGIN_TEST(delete0, "deleting a ref which is both packed and loose should remove
must_fail(git_reference_lookup(&another_looked_up_ref, repo, packed_test_head_name));
/* Ensure the loose reference doesn't exist any longer on the file system */
- must_pass(!git_futils_exists(temp_path.ptr));
+ must_pass(!git_path_exists(temp_path.ptr));
close_temp_repo(repo);
diff --git a/tests/t12-repo.c b/tests/t12-repo.c
index 0b245656c..6a080ecb3 100644
--- a/tests/t12-repo.c
+++ b/tests/t12-repo.c
@@ -68,7 +68,7 @@ static int write_file(const char *path, const char *content)
int error;
git_file file;
- if (git_futils_exists(path) == GIT_SUCCESS) {
+ if (git_path_exists(path) == GIT_SUCCESS) {
error = p_unlink(path);
if (error < GIT_SUCCESS)
diff --git a/tests/test_helpers.c b/tests/test_helpers.c
index 40b3499bb..42c8031cd 100644
--- a/tests/test_helpers.c
+++ b/tests/test_helpers.c
@@ -238,8 +238,8 @@ static int copy_filesystem_element_recurs(void *_data, git_buf *source)
git_buf_truncate(&data->dst, data->dst_baselen);
git_buf_puts(&data->dst, source->ptr + data->src_baselen);
- if (git_futils_isdir(source->ptr) == GIT_SUCCESS)
- return git_futils_direach(source, copy_filesystem_element_recurs, _data);
+ if (git_path_isdir(source->ptr) == GIT_SUCCESS)
+ return git_path_direach(source, copy_filesystem_element_recurs, _data);
else
return copy_file(source->ptr, data->dst.ptr);
}
@@ -252,8 +252,8 @@ int copydir_recurs(
copydir_data data = { GIT_BUF_INIT, 0, GIT_BUF_INIT, 0 };
/* Source has to exist, Destination hast to _not_ exist */
- if (git_futils_isdir(source_directory_path) != GIT_SUCCESS ||
- git_futils_isdir(destination_directory_path) == GIT_SUCCESS)
+ if (git_path_isdir(source_directory_path) != GIT_SUCCESS ||
+ git_path_isdir(destination_directory_path) == GIT_SUCCESS)
return GIT_EINVALIDPATH;
git_buf_joinpath(&data.src, source_directory_path, "");
@@ -298,8 +298,8 @@ static int remove_placeholders_recurs(void *_data, git_buf *path)
remove_data *data = (remove_data *)_data;
size_t pathlen;
- if (!git_futils_isdir(path->ptr))
- return git_futils_direach(path, remove_placeholders_recurs, data);
+ if (!git_path_isdir(path->ptr))
+ return git_path_direach(path, remove_placeholders_recurs, data);
pathlen = path->size;
@@ -321,7 +321,7 @@ int remove_placeholders(const char *directory_path, const char *filename)
remove_data data;
git_buf buffer = GIT_BUF_INIT;
- if (git_futils_isdir(directory_path))
+ if (git_path_isdir(directory_path))
return GIT_EINVALIDPATH;
if ((error = git_buf_sets(&buffer, directory_path)) < GIT_SUCCESS)
View Lorry Controller Status