Skip to content

G
git2
Commit 1744fafe by Russell Belfer
Options

Move path related functions from fileops to path 

This takes all of the functions that look up simple data about
paths (such as `git_futils_isdir`) and moves them over to path.h
(becoming `git_path_isdir`).  This leaves fileops.h just with
functions that actually manipulate the filesystem or look at
the file contents in some way.

As part of this, the dir.h header which is really just for win32
support was moved into win32 (with some minor changes).
parent d1317f1b
Showing with 403 additions and 339 deletions
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:
......
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;
}
......
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)
......
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;
}
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
......
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 */
......
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;
......
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;
}
......
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;
}
......
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;
}
......
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");
......
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;
}
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
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);
......
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);
......
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);
......
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);
......
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));
}
......
src/dir.h → 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__ */
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));
......
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));
......
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));
}
......
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
......
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;
}
......
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);
......
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)
......
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)
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment