rugged 1.3.1 → 1.9.0

data/vendor/libgit2/src/libgit2/CMakeLists.txt

@@ -0,0 +1,140 @@
+# libgit2: the shared library: this CMakeLists.txt compiles the core
+# git library functionality.
+
+add_library(libgit2 OBJECT)
+
+include(PkgBuildConfig)
+include(CMakePackageConfigHelpers)
+
+set(LIBGIT2_INCLUDES
+	"${PROJECT_BINARY_DIR}/src/util"
+	"${PROJECT_BINARY_DIR}/include"
+	"${PROJECT_SOURCE_DIR}/src/libgit2"
+	"${PROJECT_SOURCE_DIR}/src/util"
+	"${PROJECT_SOURCE_DIR}/include")
+
+# Collect sourcefiles
+file(GLOB SRC_H
+	"${PROJECT_SOURCE_DIR}/include/git2.h"
+	"${PROJECT_SOURCE_DIR}/include/git2/*.h"
+	"${PROJECT_SOURCE_DIR}/include/git2/sys/*.h")
+list(SORT SRC_H)
+target_sources(libgit2 PRIVATE ${SRC_H})
+
+file(GLOB SRC_GIT2 *.c *.h
+	streams/*.c streams/*.h
+	transports/*.c transports/*.h)
+list(SORT SRC_GIT2)
+target_sources(libgit2 PRIVATE ${SRC_GIT2})
+
+if(WIN32 AND NOT CYGWIN)
+	# Add resource information on Windows
+	set(SRC_RC "git2.rc")
+endif()
+
+if(APPLE)
+	# The old Secure Transport API has been deprecated in macOS 10.15.
+	set_source_files_properties(streams/stransport.c PROPERTIES COMPILE_FLAGS -Wno-deprecated)
+endif()
+
+ide_split_sources(libgit2)
+list(APPEND LIBGIT2_OBJECTS $<TARGET_OBJECTS:util> $<TARGET_OBJECTS:libgit2> ${LIBGIT2_DEPENDENCY_OBJECTS})
+list(APPEND LIBGIT2_INCLUDES ${LIBGIT2_DEPENDENCY_INCLUDES})
+
+target_include_directories(libgit2 PRIVATE ${LIBGIT2_INCLUDES} ${LIBGIT2_DEPENDENCY_INCLUDES} PUBLIC ${PROJECT_SOURCE_DIR}/include)
+target_include_directories(libgit2 SYSTEM PRIVATE ${LIBGIT2_SYSTEM_INCLUDES})
+
+set(LIBGIT2_INCLUDES ${LIBGIT2_INCLUDES} PARENT_SCOPE)
+set(LIBGIT2_OBJECTS ${LIBGIT2_OBJECTS} PARENT_SCOPE)
+set(LIBGIT2_DEPENDENCY_INCLUDES ${LIBGIT2_DEPENDENCY_INCLUDES} PARENT_SCOPE)
+set(LIBGIT2_DEPENDENCY_OBJECTS ${LIBGIT2_DEPENDENCY_OBJECTS} PARENT_SCOPE)
+set(LIBGIT2_SYSTEM_INCLUDES ${LIBGIT2_SYSTEM_INCLUDES} PARENT_SCOPE)
+set(LIBGIT2_SYSTEM_LIBS ${LIBGIT2_SYSTEM_LIBS} PARENT_SCOPE)
+
+#
+# Compile and link libgit2
+#
+
+add_library(libgit2package ${SRC_RC} ${LIBGIT2_OBJECTS})
+target_link_libraries(libgit2package ${LIBGIT2_SYSTEM_LIBS})
+target_include_directories(libgit2package SYSTEM PRIVATE ${LIBGIT2_INCLUDES})
+target_include_directories(libgit2package INTERFACE $<INSTALL_INTERFACE:./include/git2>)
+
+set_target_properties(libgit2package PROPERTIES C_STANDARD 90)
+set_target_properties(libgit2package PROPERTIES C_EXTENSIONS OFF)
+set_target_properties(libgit2package PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR})
+set_target_properties(libgit2package PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR})
+set_target_properties(libgit2package PROPERTIES ARCHIVE_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR})
+
+ide_split_sources(libgit2package)
+
+if(SONAME)
+	set_target_properties(libgit2package PROPERTIES VERSION ${libgit2_VERSION})
+	set_target_properties(libgit2package PROPERTIES SOVERSION "${libgit2_VERSION_MAJOR}.${libgit2_VERSION_MINOR}")
+	if(LIBGIT2_FILENAME)
+		target_compile_definitions(libgit2package PRIVATE LIBGIT2_FILENAME=\"${LIBGIT2_FILENAME}\")
+		set_target_properties(libgit2package PROPERTIES OUTPUT_NAME ${LIBGIT2_FILENAME})
+	elseif(DEFINED LIBGIT2_PREFIX)
+		set_target_properties(libgit2package PROPERTIES PREFIX "${LIBGIT2_PREFIX}")
+	endif()
+endif()
+
+pkg_build_config(NAME "lib${LIBGIT2_FILENAME}"
+	VERSION ${libgit2_VERSION}
+	DESCRIPTION "The git library, take 2"
+	LIBS_SELF ${LIBGIT2_FILENAME}
+	PRIVATE_LIBS ${LIBGIT2_PC_LIBS}
+	REQUIRES ${LIBGIT2_PC_REQUIRES})
+
+if(MSVC_IDE)
+	# Precompiled headers
+	set_target_properties(libgit2package PROPERTIES COMPILE_FLAGS "/Yuprecompiled.h /FIprecompiled.h")
+	set_source_files_properties(win32/precompiled.c COMPILE_FLAGS "/Ycprecompiled.h")
+endif()
+
+# support experimental features and functionality
+
+configure_file(experimental.h.in "${PROJECT_BINARY_DIR}/include/git2/experimental.h")
+
+# translate filenames in the git2.h so that they match the install directory
+# (allows for side-by-side installs of libgit2 and libgit2-experimental.)
+
+FILE(READ "${PROJECT_SOURCE_DIR}/include/git2.h" LIBGIT2_INCLUDE)
+STRING(REGEX REPLACE "#include \"git2\/" "#include \"${LIBGIT2_FILENAME}/" LIBGIT2_INCLUDE "${LIBGIT2_INCLUDE}")
+FILE(WRITE "${PROJECT_BINARY_DIR}/include/${LIBGIT2_FILENAME}.h" ${LIBGIT2_INCLUDE})
+
+# cmake package targets
+
+set(LIBGIT2_TARGETS_EXPORT_NAME "${PROJECT_NAME}Targets")
+
+write_basic_package_version_file(
+	"${PROJECT_BINARY_DIR}/cmake/${PROJECT_NAME}ConfigVersion.cmake"
+	VERSION ${PROJECT_VERSION}
+	COMPATIBILITY SameMajorVersion)
+
+configure_file(config.cmake.in
+	"${PROJECT_BINARY_DIR}/cmake/${PROJECT_NAME}Config.cmake"
+	@ONLY)
+
+install(FILES
+	"${PROJECT_BINARY_DIR}/cmake/${PROJECT_NAME}Config.cmake"
+	"${PROJECT_BINARY_DIR}/cmake/${PROJECT_NAME}ConfigVersion.cmake"
+	DESTINATION "lib/cmake/${PROJECT_NAME}")
+install(
+	EXPORT ${LIBGIT2_TARGETS_EXPORT_NAME}
+	NAMESPACE "${PROJECT_NAME}::"
+	DESTINATION "lib/cmake/${PROJECT_NAME}")
+
+# Install
+
+install(TARGETS libgit2package
+	EXPORT ${LIBGIT2_TARGETS_EXPORT_NAME}
+	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
+install(DIRECTORY ${PROJECT_SOURCE_DIR}/include/git2/
+        DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/${LIBGIT2_FILENAME}")
+install(FILES ${PROJECT_BINARY_DIR}/include/git2/experimental.h
+        DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/${LIBGIT2_FILENAME}")
+install(FILES "${PROJECT_BINARY_DIR}/include/${LIBGIT2_FILENAME}.h"
+        DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})

data/vendor/libgit2/src/{annotated_commit.c → libgit2/annotated_commit.c}

@@ -39,8 +39,8 @@ static int annotated_commit_init(
 	if ((error = git_commit_dup(&annotated_commit->commit, commit)) < 0)
 		goto done;
 
-	git_oid_fmt(annotated_commit->id_str, git_commit_id(commit));
-	annotated_commit->id_str[GIT_OID_HEXSZ] = '\0';
+	git_oid_tostr(annotated_commit->id_str, GIT_OID_MAX_HEXSIZE + 1,
+		git_commit_id(commit));
 
 	if (!description)
 		description = annotated_commit->id_str;

data/vendor/libgit2/src/{annotated_commit.h → libgit2/annotated_commit.h}

@@ -15,7 +15,7 @@
 
 typedef enum {
 	GIT_ANNOTATED_COMMIT_REAL = 1,
-	GIT_ANNOTATED_COMMIT_VIRTUAL = 2,
+	GIT_ANNOTATED_COMMIT_VIRTUAL = 2
 } git_annotated_commit_t;
 
 /**
@@ -41,7 +41,7 @@ struct git_annotated_commit {
 	const char *ref_name;
 	const char *remote_url;
 
-	char id_str[GIT_OID_HEXSZ+1];
+	char id_str[GIT_OID_MAX_HEXSIZE + 1];
 };
 
 extern int git_annotated_commit_from_head(git_annotated_commit **out,

data/vendor/libgit2/src/{apply.c → libgit2/apply.c}

@@ -19,6 +19,8 @@
 #include "zstream.h"
 #include "reader.h"
 #include "index.h"
+#include "repository.h"
+#include "hashmap_str.h"
 #include "apply.h"
 
 typedef struct {
@@ -95,7 +97,7 @@ static void patch_image_free(patch_image *image)
 		return;
 
 	git_pool_clear(&image->pool);
-	git_vector_free(&image->lines);
+	git_vector_dispose(&image->lines);
 }
 
 static bool match_hunk(
@@ -265,7 +267,7 @@ done:
 }
 
 static int apply_hunks(
-	git_buf *out,
+	git_str *out,
 	const char *source,
 	size_t source_len,
 	git_patch *patch,
@@ -286,7 +288,7 @@ static int apply_hunks(
 	}
 
 	git_vector_foreach(&image.lines, i, line)
-		git_buf_put(out, line->content, line->content_len);
+		git_str_put(out, line->content, line->content_len);
 
 done:
 	patch_image_free(&image);
@@ -295,24 +297,24 @@ done:
 }
 
 static int apply_binary_delta(
-	git_buf *out,
+	git_str *out,
 	const char *source,
 	size_t source_len,
 	git_diff_binary_file *binary_file)
 {
-	git_buf inflated = GIT_BUF_INIT;
+	git_str inflated = GIT_STR_INIT;
 	int error = 0;
 
 	/* no diff means identical contents */
 	if (binary_file->datalen == 0)
-		return git_buf_put(out, source, source_len);
+		return git_str_put(out, source, source_len);
 
 	error = git_zstream_inflatebuf(&inflated,
 		binary_file->data, binary_file->datalen);
 
 	if (!error && inflated.size != binary_file->inflatedlen) {
 		error = apply_err("inflated delta does not match expected length");
-		git_buf_dispose(out);
+		git_str_dispose(out);
 	}
 
 	if (error < 0)
@@ -330,7 +332,7 @@ static int apply_binary_delta(
 		out->asize = data_len;
 	}
 	else if (binary_file->type == GIT_DIFF_BINARY_LITERAL) {
-		git_buf_swap(out, &inflated);
+		git_str_swap(out, &inflated);
 	}
 	else {
 		error = apply_err("unknown binary delta type");
@@ -338,17 +340,17 @@ static int apply_binary_delta(
 	}
 
 done:
-	git_buf_dispose(&inflated);
+	git_str_dispose(&inflated);
 	return error;
 }
 
 static int apply_binary(
-	git_buf *out,
+	git_str *out,
 	const char *source,
 	size_t source_len,
 	git_patch *patch)
 {
-	git_buf reverse = GIT_BUF_INIT;
+	git_str reverse = GIT_STR_INIT;
 	int error = 0;
 
 	if (!patch->binary.contains_data) {
@@ -378,14 +380,14 @@ static int apply_binary(
 
 done:
 	if (error < 0)
-		git_buf_dispose(out);
+		git_str_dispose(out);
 
-	git_buf_dispose(&reverse);
+	git_str_dispose(&reverse);
 	return error;
 }
 
 int git_apply__patch(
-	git_buf *contents_out,
+	git_str *contents_out,
 	char **filename_out,
 	unsigned int *mode_out,
 	const char *source,
@@ -423,13 +425,13 @@ int git_apply__patch(
 	else if (patch->hunks.size)
 		error = apply_hunks(contents_out, source, source_len, patch, &ctx);
 	else
-		error = git_buf_put(contents_out, source, source_len);
+		error = git_str_put(contents_out, source, source_len);
 
 	if (error)
 		goto done;
 
 	if (patch->delta->status == GIT_DELTA_DELETED &&
-		git_buf_len(contents_out) > 0) {
+		git_str_len(contents_out) > 0) {
 		error = apply_err("removal patch leaves file contents");
 		goto done;
 	}
@@ -451,12 +453,12 @@ static int apply_one(
 	git_reader *postimage_reader,
 	git_index *postimage,
 	git_diff *diff,
-	git_strmap *removed_paths,
+	git_hashset_str *removed_paths,
 	size_t i,
 	const git_apply_options *opts)
 {
 	git_patch *patch = NULL;
-	git_buf pre_contents = GIT_BUF_INIT, post_contents = GIT_BUF_INIT;
+	git_str pre_contents = GIT_STR_INIT, post_contents = GIT_STR_INIT;
 	const git_diff_delta *delta;
 	char *filename = NULL;
 	unsigned int mode;
@@ -488,7 +490,7 @@ static int apply_one(
 	 */
 	if (delta->status != GIT_DELTA_RENAMED &&
 	    delta->status != GIT_DELTA_ADDED) {
-		if (git_strmap_exists(removed_paths, delta->old_file.path)) {
+		if (git_hashset_str_contains(removed_paths, delta->old_file.path)) {
 			error = apply_err("path '%s' has been renamed or deleted", delta->old_file.path);
 			goto done;
 		}
@@ -572,15 +574,15 @@ static int apply_one(
 
 	if (delta->status == GIT_DELTA_RENAMED ||
 	    delta->status == GIT_DELTA_DELETED)
-		error = git_strmap_set(removed_paths, delta->old_file.path, (char *) delta->old_file.path);
+		error = git_hashset_str_add(removed_paths, delta->old_file.path);
 
 	if (delta->status == GIT_DELTA_RENAMED ||
 	    delta->status == GIT_DELTA_ADDED)
-		git_strmap_delete(removed_paths, delta->new_file.path);
+		git_hashset_str_remove(removed_paths, delta->new_file.path);
 
 done:
-	git_buf_dispose(&pre_contents);
-	git_buf_dispose(&post_contents);
+	git_str_dispose(&pre_contents);
+	git_str_dispose(&post_contents);
 	git__free(filename);
 	git_patch_free(patch);
 
@@ -596,20 +598,17 @@ static int apply_deltas(
 	git_diff *diff,
 	const git_apply_options *opts)
 {
-	git_strmap *removed_paths;
+	git_hashset_str removed_paths = GIT_HASHSET_INIT;
 	size_t i;
 	int error = 0;
 
-	if (git_strmap_new(&removed_paths) < 0)
-		return -1;
-
 	for (i = 0; i < git_diff_num_deltas(diff); i++) {
-		if ((error = apply_one(repo, pre_reader, preimage, post_reader, postimage, diff, removed_paths, i, opts)) < 0)
+		if ((error = apply_one(repo, pre_reader, preimage, post_reader, postimage, diff, &removed_paths, i, opts)) < 0)
 			goto done;
 	}
 
 done:
-	git_strmap_free(removed_paths);
+	git_hashset_str_dispose(&removed_paths);
 	return error;
 }
 
@@ -644,7 +643,7 @@ int git_apply_to_tree(
 	 * put the current tree into the postimage as-is - the diff will
 	 * replace any entries contained therein
 	 */
-	if ((error = git_index_new(&postimage)) < 0 ||
+	if ((error = git_index__new(&postimage, repo->oid_type)) < 0 ||
 		(error = git_index_read_tree(postimage, preimage)) < 0 ||
 		(error = git_reader_for_index(&post_reader, repo, postimage)) < 0)
 		goto done;
@@ -714,7 +713,6 @@ static int git_apply__to_workdir(
 			goto done;
 	}
 
-	checkout_opts.checkout_strategy |= GIT_CHECKOUT_SAFE;
 	checkout_opts.checkout_strategy |= GIT_CHECKOUT_DISABLE_PATHSPEC_MATCH;
 	checkout_opts.checkout_strategy |= GIT_CHECKOUT_DONT_WRITE_INDEX;
 
@@ -729,7 +727,7 @@ static int git_apply__to_workdir(
 	error = git_checkout_index(repo, postimage, &checkout_opts);
 
 done:
-	git_vector_free(&paths);
+	git_vector_dispose(&paths);
 	return error;
 }
 
@@ -851,8 +849,8 @@ int git_apply(
 	 * having the full repo index, so we will limit our checkout
 	 * to only write these files that were affected by the diff.
 	 */
-	if ((error = git_index_new(&preimage)) < 0 ||
-	    (error = git_index_new(&postimage)) < 0 ||
+	if ((error = git_index__new(&preimage, repo->oid_type)) < 0 ||
+	    (error = git_index__new(&postimage, repo->oid_type)) < 0 ||
 	    (error = git_reader_for_index(&post_reader, repo, postimage)) < 0)
 		goto done;
 

data/vendor/libgit2/src/{apply.h → libgit2/apply.h}

@@ -11,10 +11,10 @@
 
 #include "git2/patch.h"
 #include "git2/apply.h"
-#include "buffer.h"
+#include "str.h"
 
 extern int git_apply__patch(
-	git_buf *out,
+	git_str *out,
 	char **filename,
 	unsigned int *mode,
 	const char *source,

data/vendor/libgit2/src/{attr.c → libgit2/attr.c}

@@ -13,6 +13,7 @@
 #include "attr_file.h"
 #include "ignore.h"
 #include "git2/oid.h"
+#include "hashmap_str.h"
 #include <ctype.h>
 
 const char *git_attr__true  = "[internal]__TRUE__";
@@ -254,7 +255,7 @@ int git_attr_foreach_ext(
 	git_attr_file *file;
 	git_attr_rule *rule;
 	git_attr_assignment *assign;
-	git_strmap *seen = NULL;
+	git_hashset_str seen = GIT_HASHSET_INIT;
 	git_dir_flag dir_flag = GIT_DIR_FLAG_UNKNOWN;
 
 	GIT_ASSERT_ARG(repo);
@@ -267,8 +268,7 @@ int git_attr_foreach_ext(
 	if (git_attr_path__init(&path, pathname, git_repository_workdir(repo), dir_flag) < 0)
 		return -1;
 
-	if ((error = collect_attr_files(repo, NULL, opts, pathname, &files)) < 0 ||
-	    (error = git_strmap_new(&seen)) < 0)
+	if ((error = collect_attr_files(repo, NULL, opts, pathname, &files)) < 0)
 		goto cleanup;
 
 	git_vector_foreach(&files, i, file) {
@@ -277,10 +277,10 @@ int git_attr_foreach_ext(
 
 			git_vector_foreach(&rule->assigns, k, assign) {
 				/* skip if higher priority assignment was already seen */
-				if (git_strmap_exists(seen, assign->name))
+				if (git_hashset_str_contains(&seen, assign->name))
 					continue;
 
-				if ((error = git_strmap_set(seen, assign->name, assign)) < 0)
+				if ((error = git_hashset_str_add(&seen, assign->name)) < 0)
 					goto cleanup;
 
 				error = callback(assign->name, assign->value, payload);
@@ -293,7 +293,7 @@ int git_attr_foreach_ext(
 	}
 
 cleanup:
-	git_strmap_free(seen);
+	git_hashset_str_dispose(&seen);
 	release_attr_files(&files);
 	git_attr_path__free(&path);
 
@@ -338,7 +338,7 @@ GIT_INLINE(int) preload_attr_file(
 }
 
 static int system_attr_file(
-	git_buf *out,
+	git_str *out,
 	git_attr_session *attr_session)
 {
 	int error;
@@ -366,11 +366,11 @@ static int system_attr_file(
 	if (attr_session->sysdir.size == 0)
 		return GIT_ENOTFOUND;
 
-	/* We can safely provide a git_buf with no allocation (asize == 0) to
-	 * a consumer. This allows them to treat this as a regular `git_buf`,
-	 * but their call to `git_buf_dispose` will not attempt to free it.
+	/* We can safely provide a git_str with no allocation (asize == 0) to
+	 * a consumer. This allows them to treat this as a regular `git_str`,
+	 * but their call to `git_str_dispose` will not attempt to free it.
 	 */
-	git_buf_attach_notowned(
+	git_str_attach_notowned(
 		out, attr_session->sysdir.ptr, attr_session->sysdir.size);
 	return 0;
 }
@@ -380,10 +380,12 @@ static int attr_setup(
 	git_attr_session *attr_session,
 	git_attr_options *opts)
 {
-	git_buf system = GIT_BUF_INIT, info = GIT_BUF_INIT;
+	git_str system = GIT_STR_INIT, info = GIT_STR_INIT;
 	git_attr_file_source index_source = { GIT_ATTR_FILE_SOURCE_INDEX, NULL, GIT_ATTR_FILE, NULL };
 	git_attr_file_source head_source = { GIT_ATTR_FILE_SOURCE_HEAD, NULL, GIT_ATTR_FILE, NULL };
 	git_attr_file_source commit_source = { GIT_ATTR_FILE_SOURCE_COMMIT, NULL, GIT_ATTR_FILE, NULL };
+	git_attr_cache *attrcache;
+	const char *attr_cfg_file = NULL;
 	git_index *idx = NULL;
 	const char *workdir;
 	int error = 0;
@@ -407,11 +409,13 @@ static int attr_setup(
 		error = 0;
 	}
 
-	if ((error = preload_attr_file(repo, attr_session, NULL,
-	                               git_repository_attr_cache(repo)->cfg_attr_file)) < 0)
+	if ((attrcache = git_repository_attr_cache(repo)) != NULL)
+		attr_cfg_file = git_attr_cache_attributesfile(attrcache);
+
+	if ((error = preload_attr_file(repo, attr_session, NULL, attr_cfg_file)) < 0)
 		goto out;
 
-	if ((error = git_repository_item_path(&info, repo, GIT_REPOSITORY_ITEM_INFO)) < 0 ||
+	if ((error = git_repository__item_path(&info, repo, GIT_REPOSITORY_ITEM_INFO)) < 0 ||
 	    (error = preload_attr_file(repo, attr_session, info.ptr, GIT_ATTR_FILE_INREPO)) < 0) {
 		if (error != GIT_ENOTFOUND)
 			goto out;
@@ -424,9 +428,13 @@ static int attr_setup(
 			goto out;
 
 	if ((error = git_repository_index__weakptr(&idx, repo)) < 0 ||
-	    (error = preload_attr_source(repo, attr_session, &index_source)) < 0)
+	    (error = preload_attr_source(repo, attr_session, &index_source)) < 0) {
+		if (error != GIT_ENOTFOUND)
 			goto out;
 
+		error = 0;
+	}
+
 	if ((opts && (opts->flags & GIT_ATTR_CHECK_INCLUDE_HEAD) != 0) &&
 	    (error = preload_attr_source(repo, attr_session, &head_source)) < 0)
 		goto out;
@@ -447,8 +455,8 @@ static int attr_setup(
 		attr_session->init_setup = 1;
 
 out:
-	git_buf_dispose(&system);
-	git_buf_dispose(&info);
+	git_str_dispose(&system);
+	git_str_dispose(&info);
 
 	return error;
 }
@@ -460,6 +468,7 @@ int git_attr_add_macro(
 {
 	int error;
 	git_attr_rule *macro = NULL;
+	git_attr_cache *attrcache;
 	git_pool *pool;
 
 	GIT_ASSERT_ARG(repo);
@@ -471,7 +480,8 @@ int git_attr_add_macro(
 	macro = git__calloc(1, sizeof(git_attr_rule));
 	GIT_ERROR_CHECK_ALLOC(macro);
 
-	pool = &git_repository_attr_cache(repo)->pool;
+	attrcache = git_repository_attr_cache(repo);
+	pool = git_attr_cache_pool(attrcache);
 
 	macro->match.pattern = git_pool_strdup(pool, name);
 	GIT_ERROR_CHECK_ALLOC(macro->match.pattern);
@@ -614,7 +624,7 @@ static void release_attr_files(git_vector *files)
 		git_attr_file__free(file);
 		files->contents[i] = NULL;
 	}
-	git_vector_free(files);
+	git_vector_dispose(files);
 }
 
 static int collect_attr_files(
@@ -625,11 +635,13 @@ static int collect_attr_files(
 	git_vector *files)
 {
 	int error = 0;
-	git_buf dir = GIT_BUF_INIT, attrfile = GIT_BUF_INIT;
+	git_str dir = GIT_STR_INIT, attrfile = GIT_STR_INIT;
 	const char *workdir = git_repository_workdir(repo);
+	git_attr_cache *attrcache;
+	const char *attr_cfg_file = NULL;
 	attr_walk_up_info info = { NULL };
 
-	GIT_ASSERT(!git_path_is_absolute(path));
+	GIT_ASSERT(!git_fs_path_is_absolute(path));
 
 	if ((error = attr_setup(repo, attr_session, opts)) < 0)
 		return error;
@@ -637,23 +649,23 @@ static int collect_attr_files(
 	/* Resolve path in a non-bare repo */
 	if (workdir != NULL) {
 		if (!(error = git_repository_workdir_path(&dir, repo, path)))
-			error = git_path_find_dir(&dir);
+			error = git_fs_path_find_dir(&dir);
 	}
 	else {
-		error = git_path_dirname_r(&dir, path);
+		error = git_fs_path_dirname_r(&dir, path);
 	}
 
 	if (error < 0)
 		goto cleanup;
 
-	/* in precendence order highest to lowest:
+	/* in precedence order highest to lowest:
 	 * - $GIT_DIR/info/attributes
 	 * - path components with .gitattributes
 	 * - config core.attributesfile
 	 * - $GIT_PREFIX/etc/gitattributes
 	 */
 
-	if ((error = git_repository_item_path(&attrfile, repo, GIT_REPOSITORY_ITEM_INFO)) < 0 ||
+	if ((error = git_repository__item_path(&attrfile, repo, GIT_REPOSITORY_ITEM_INFO)) < 0 ||
 	    (error = push_attr_file(repo, attr_session, files, attrfile.ptr, GIT_ATTR_FILE_INREPO)) < 0) {
 		if (error != GIT_ENOTFOUND)
 			goto cleanup;
@@ -670,13 +682,18 @@ static int collect_attr_files(
 	if (!strcmp(dir.ptr, "."))
 		error = push_one_attr(&info, "");
 	else
-		error = git_path_walk_up(&dir, workdir, push_one_attr, &info);
+		error = git_fs_path_walk_up(&dir, workdir, push_one_attr, &info);
 
 	if (error < 0)
 		goto cleanup;
 
-	if (git_repository_attr_cache(repo)->cfg_attr_file != NULL) {
-		error = push_attr_file(repo, attr_session, files, NULL, git_repository_attr_cache(repo)->cfg_attr_file);
+	if ((attrcache = git_repository_attr_cache(repo)) != NULL)
+		attr_cfg_file = git_attr_cache_attributesfile(attrcache);
+
+
+	if (attr_cfg_file) {
+		error = push_attr_file(repo, attr_session, files, NULL, attr_cfg_file);
+
 		if (error < 0)
 			goto cleanup;
 	}
@@ -693,8 +710,8 @@ static int collect_attr_files(
  cleanup:
 	if (error < 0)
 		release_attr_files(files);
-	git_buf_dispose(&attrfile);
-	git_buf_dispose(&dir);
+	git_str_dispose(&attrfile);
+	git_str_dispose(&dir);
 
 	return error;
 }