rugged 1.1.1 → 1.4.3

data/vendor/libgit2/src/fetch.h

@@ -15,7 +15,7 @@
 
 int git_fetch_negotiate(git_remote *remote, const git_fetch_options *opts);
 
-int git_fetch_download_pack(git_remote *remote, const git_remote_callbacks *callbacks);
+int git_fetch_download_pack(git_remote *remote);
 
 int git_fetch_setup_walk(git_revwalk **out, git_repository *repo);
 

data/vendor/libgit2/src/fetchhead.c

@@ -10,7 +10,7 @@
 #include "git2/types.h"
 #include "git2/oid.h"
 
-#include "buffer.h"
+#include "str.h"
 #include "futils.h"
 #include "filebuf.h"
 #include "refs.h"
@@ -44,7 +44,7 @@ static char *sanitized_remote_url(const char *remote_url)
 	int error;
 
 	if (git_net_url_parse(&url, remote_url) == 0) {
-		git_buf buf = GIT_BUF_INIT;
+		git_str buf = GIT_STR_INIT;
 
 		git__free(url.username);
 		git__free(url.password);
@@ -53,7 +53,7 @@ static char *sanitized_remote_url(const char *remote_url)
 		if ((error = git_net_url_fmt(&buf, &url)) < 0)
 			goto fallback;
 
-		sanitized = git_buf_detach(&buf);
+		sanitized = git_str_detach(&buf);
 	}
 
 fallback:
@@ -73,7 +73,8 @@ int git_fetchhead_ref_create(
 {
 	git_fetchhead_ref *fetchhead_ref;
 
-	assert(out && oid);
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(oid);
 
 	*out = NULL;
 
@@ -108,7 +109,8 @@ static int fetchhead_ref_write(
 	const char *type, *name;
 	int head = 0;
 
-	assert(file && fetchhead_ref);
+	GIT_ASSERT_ARG(file);
+	GIT_ASSERT_ARG(fetchhead_ref);
 
 	git_oid_fmt(oid, &fetchhead_ref->oid);
 	oid[GIT_OID_HEXSZ] = '\0';
@@ -141,21 +143,22 @@ static int fetchhead_ref_write(
 int git_fetchhead_write(git_repository *repo, git_vector *fetchhead_refs)
 {
 	git_filebuf file = GIT_FILEBUF_INIT;
-	git_buf path = GIT_BUF_INIT;
+	git_str path = GIT_STR_INIT;
 	unsigned int i;
 	git_fetchhead_ref *fetchhead_ref;
 
-	assert(repo && fetchhead_refs);
+	GIT_ASSERT_ARG(repo);
+	GIT_ASSERT_ARG(fetchhead_refs);
 
-	if (git_buf_joinpath(&path, repo->gitdir, GIT_FETCH_HEAD_FILE) < 0)
+	if (git_str_joinpath(&path, repo->gitdir, GIT_FETCH_HEAD_FILE) < 0)
 		return -1;
 
 	if (git_filebuf_open(&file, path.ptr, GIT_FILEBUF_APPEND, GIT_REFS_FILE_MODE) < 0) {
-		git_buf_dispose(&path);
+		git_str_dispose(&path);
 		return -1;
 	}
 
-	git_buf_dispose(&path);
+	git_str_dispose(&path);
 
 	git_vector_sort(fetchhead_refs);
 
@@ -168,7 +171,7 @@ int git_fetchhead_write(git_repository *repo, git_vector *fetchhead_refs)
 static int fetchhead_ref_parse(
 	git_oid *oid,
 	unsigned int *is_merge,
-	git_buf *ref_name,
+	git_str *ref_name,
 	const char **remote_url,
 	char *line,
 	size_t line_num)
@@ -256,12 +259,12 @@ static int fetchhead_ref_parse(
 		*remote_url = desc;
 	}
 
-	git_buf_clear(ref_name);
+	git_str_clear(ref_name);
 
 	if (type)
-		git_buf_join(ref_name, '/', type, name);
+		git_str_join(ref_name, '/', type, name);
 	else if(name)
-		git_buf_puts(ref_name, name);
+		git_str_puts(ref_name, name);
 
 	return error;
 }
@@ -270,7 +273,7 @@ int git_repository_fetchhead_foreach(git_repository *repo,
 	git_repository_fetchhead_foreach_cb cb,
 	void *payload)
 {
-	git_buf path = GIT_BUF_INIT, file = GIT_BUF_INIT, name = GIT_BUF_INIT;
+	git_str path = GIT_STR_INIT, file = GIT_STR_INIT, name = GIT_STR_INIT;
 	const char *ref_name;
 	git_oid oid;
 	const char *remote_url;
@@ -279,12 +282,13 @@ int git_repository_fetchhead_foreach(git_repository *repo,
 	size_t line_num = 0;
 	int error = 0;
 
-	assert(repo && cb);
+	GIT_ASSERT_ARG(repo);
+	GIT_ASSERT_ARG(cb);
 
-	if (git_buf_joinpath(&path, repo->gitdir, GIT_FETCH_HEAD_FILE) < 0)
+	if (git_str_joinpath(&path, repo->gitdir, GIT_FETCH_HEAD_FILE) < 0)
 		return -1;
 
-	if ((error = git_futils_readbuffer(&file, git_buf_cstr(&path))) < 0)
+	if ((error = git_futils_readbuffer(&file, git_str_cstr(&path))) < 0)
 		goto done;
 
 	buffer = file.ptr;
@@ -296,8 +300,8 @@ int git_repository_fetchhead_foreach(git_repository *repo,
 				&oid, &is_merge, &name, &remote_url, line, line_num)) < 0)
 			goto done;
 
-		if (git_buf_len(&name) > 0)
-			ref_name = git_buf_cstr(&name);
+		if (git_str_len(&name) > 0)
+			ref_name = git_str_cstr(&name);
 		else
 			ref_name = NULL;
 
@@ -315,9 +319,9 @@ int git_repository_fetchhead_foreach(git_repository *repo,
 	}
 
 done:
-	git_buf_dispose(&file);
-	git_buf_dispose(&path);
-	git_buf_dispose(&name);
+	git_str_dispose(&file);
+	git_str_dispose(&path);
+	git_str_dispose(&name);
 
 	return error;
 }

data/vendor/libgit2/src/filebuf.c

@@ -43,7 +43,7 @@ static int verify_last_error(git_filebuf *file)
 
 static int lock_file(git_filebuf *file, int flags, mode_t mode)
 {
-	if (git_path_exists(file->path_lock) == true) {
+	if (git_fs_path_exists(file->path_lock) == true) {
 		git_error_clear(); /* actual OS error code just confuses */
 		git_error_set(GIT_ERROR_OS,
 			"failed to lock file '%s' for writing", file->path_lock);
@@ -63,7 +63,7 @@ static int lock_file(git_filebuf *file, int flags, mode_t mode)
 
 	file->fd_is_open = true;
 
-	if ((flags & GIT_FILEBUF_APPEND) && git_path_exists(file->path_original) == true) {
+	if ((flags & GIT_FILEBUF_APPEND) && git_fs_path_exists(file->path_original) == true) {
 		git_file source;
 		char buffer[FILEIO_BUFSIZE];
 		ssize_t read_bytes;
@@ -103,7 +103,7 @@ void git_filebuf_cleanup(git_filebuf *file)
 	if (file->fd_is_open && file->fd >= 0)
 		p_close(file->fd);
 
-	if (file->created_lock && !file->did_rename && file->path_lock && git_path_exists(file->path_lock))
+	if (file->created_lock && !file->did_rename && file->path_lock && git_fs_path_exists(file->path_lock))
 		p_unlink(file->path_lock);
 
 	if (file->compute_digest) {
@@ -184,7 +184,7 @@ static int write_deflate(git_filebuf *file, void *source, size_t len)
 
 		} while (zs->avail_out == 0);
 
-		assert(zs->avail_in == 0);
+		GIT_ASSERT(zs->avail_in == 0);
 
 		if (file->compute_digest)
 			git_hash_update(&file->digest, source, len);
@@ -195,21 +195,21 @@ static int write_deflate(git_filebuf *file, void *source, size_t len)
 
 #define MAX_SYMLINK_DEPTH 5
 
-static int resolve_symlink(git_buf *out, const char *path)
+static int resolve_symlink(git_str *out, const char *path)
 {
 	int i, error, root;
 	ssize_t ret;
 	struct stat st;
-	git_buf curpath = GIT_BUF_INIT, target = GIT_BUF_INIT;
+	git_str curpath = GIT_STR_INIT, target = GIT_STR_INIT;
 
-	if ((error = git_buf_grow(&target, GIT_PATH_MAX + 1)) < 0 ||
-	    (error = git_buf_puts(&curpath, path)) < 0)
+	if ((error = git_str_grow(&target, GIT_PATH_MAX + 1)) < 0 ||
+	    (error = git_str_puts(&curpath, path)) < 0)
 		return error;
 
 	for (i = 0; i < MAX_SYMLINK_DEPTH; i++) {
 		error = p_lstat(curpath.ptr, &st);
 		if (error < 0 && errno == ENOENT) {
-			error = git_buf_puts(out, curpath.ptr);
+			error = git_str_puts(out, curpath.ptr);
 			goto cleanup;
 		}
 
@@ -220,7 +220,7 @@ static int resolve_symlink(git_buf *out, const char *path)
 		}
 
 		if (!S_ISLNK(st.st_mode)) {
-			error = git_buf_puts(out, curpath.ptr);
+			error = git_str_puts(out, curpath.ptr);
 			goto cleanup;
 		}
 
@@ -241,20 +241,20 @@ static int resolve_symlink(git_buf *out, const char *path)
 		target.ptr[ret] = '\0';
 		target.size = ret;
 
-		root = git_path_root(target.ptr);
+		root = git_fs_path_root(target.ptr);
 		if (root >= 0) {
-			if ((error = git_buf_sets(&curpath, target.ptr)) < 0)
+			if ((error = git_str_sets(&curpath, target.ptr)) < 0)
 				goto cleanup;
 		} else {
-			git_buf dir = GIT_BUF_INIT;
+			git_str dir = GIT_STR_INIT;
 
-			if ((error = git_path_dirname_r(&dir, curpath.ptr)) < 0)
+			if ((error = git_fs_path_dirname_r(&dir, curpath.ptr)) < 0)
 				goto cleanup;
 
-			git_buf_swap(&curpath, &dir);
-			git_buf_dispose(&dir);
+			git_str_swap(&curpath, &dir);
+			git_str_dispose(&dir);
 
-			if ((error = git_path_apply_relative(&curpath, target.ptr)) < 0)
+			if ((error = git_fs_path_apply_relative(&curpath, target.ptr)) < 0)
 				goto cleanup;
 		}
 	}
@@ -263,8 +263,8 @@ static int resolve_symlink(git_buf *out, const char *path)
 	error = -1;
 
 cleanup:
-	git_buf_dispose(&curpath);
-	git_buf_dispose(&target);
+	git_str_dispose(&curpath);
+	git_str_dispose(&target);
 	return error;
 }
 
@@ -278,10 +278,9 @@ int git_filebuf_open_withsize(git_filebuf *file, const char *path, int flags, mo
 	int compression, error = -1;
 	size_t path_len, alloc_len;
 
-	/* opening an already open buffer is a programming error;
-	 * assert that this never happens instead of returning
-	 * an error code */
-	assert(file && path && file->buffer == NULL);
+	GIT_ASSERT_ARG(file);
+	GIT_ASSERT_ARG(path);
+	GIT_ASSERT(file->buffer == NULL);
 
 	memset(file, 0x0, sizeof(git_filebuf));
 
@@ -306,7 +305,7 @@ int git_filebuf_open_withsize(git_filebuf *file, const char *path, int flags, mo
 	if (flags & GIT_FILEBUF_HASH_CONTENTS) {
 		file->compute_digest = 1;
 
-		if (git_hash_ctx_init(&file->digest) < 0)
+		if (git_hash_ctx_init(&file->digest, GIT_HASH_ALGORITHM_SHA1) < 0)
 			goto cleanup;
 	}
 
@@ -333,13 +332,13 @@ int git_filebuf_open_withsize(git_filebuf *file, const char *path, int flags, mo
 
 	/* If we are writing to a temp file */
 	if (flags & GIT_FILEBUF_TEMPORARY) {
-		git_buf tmp_path = GIT_BUF_INIT;
+		git_str tmp_path = GIT_STR_INIT;
 
 		/* Open the file as temporary for locking */
 		file->fd = git_futils_mktmp(&tmp_path, path, mode);
 
 		if (file->fd < 0) {
-			git_buf_dispose(&tmp_path);
+			git_str_dispose(&tmp_path);
 			goto cleanup;
 		}
 		file->fd_is_open = true;
@@ -347,17 +346,17 @@ int git_filebuf_open_withsize(git_filebuf *file, const char *path, int flags, mo
 
 		/* No original path */
 		file->path_original = NULL;
-		file->path_lock = git_buf_detach(&tmp_path);
+		file->path_lock = git_str_detach(&tmp_path);
 		GIT_ERROR_CHECK_ALLOC(file->path_lock);
 	} else {
-		git_buf resolved_path = GIT_BUF_INIT;
+		git_str resolved_path = GIT_STR_INIT;
 
 		if ((error = resolve_symlink(&resolved_path, path)) < 0)
 			goto cleanup;
 
 		/* Save the original path of the file */
 		path_len = resolved_path.size;
-		file->path_original = git_buf_detach(&resolved_path);
+		file->path_original = git_str_detach(&resolved_path);
 
 		/* create the locking path by appending ".lock" to the original */
 		GIT_ERROR_CHECK_ALLOC_ADD(&alloc_len, path_len, GIT_FILELOCK_EXTLENGTH);
@@ -367,7 +366,7 @@ int git_filebuf_open_withsize(git_filebuf *file, const char *path, int flags, mo
 		memcpy(file->path_lock, file->path_original, path_len);
 		memcpy(file->path_lock + path_len, GIT_FILELOCK_EXTENSION, GIT_FILELOCK_EXTLENGTH);
 
-		if (git_path_isdir(file->path_original)) {
+		if (git_fs_path_isdir(file->path_original)) {
 			git_error_set(GIT_ERROR_FILESYSTEM, "path '%s' is a directory", file->path_original);
 			error = GIT_EDIRECTORY;
 			goto cleanup;
@@ -387,16 +386,18 @@ cleanup:
 	return error;
 }
 
-int git_filebuf_hash(git_oid *oid, git_filebuf *file)
+int git_filebuf_hash(unsigned char *out, git_filebuf *file)
 {
-	assert(oid && file && file->compute_digest);
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(file);
+	GIT_ASSERT_ARG(file->compute_digest);
 
 	flush_buffer(file);
 
 	if (verify_last_error(file) < 0)
 		return -1;
 
-	git_hash_final(oid, &file->digest);
+	git_hash_final(out, &file->digest);
 	git_hash_ctx_cleanup(&file->digest);
 	file->compute_digest = 0;
 
@@ -415,7 +416,8 @@ int git_filebuf_commit_at(git_filebuf *file, const char *path)
 int git_filebuf_commit(git_filebuf *file)
 {
 	/* temporary files cannot be committed */
-	assert(file && file->path_original);
+	GIT_ASSERT_ARG(file);
+	GIT_ASSERT(file->path_original);
 
 	file->flush_mode = Z_FINISH;
 	flush_buffer(file);

data/vendor/libgit2/src/filebuf.h

@@ -87,7 +87,7 @@ int git_filebuf_open_withsize(git_filebuf *file, const char *path, int flags, mo
 int git_filebuf_commit(git_filebuf *lock);
 int git_filebuf_commit_at(git_filebuf *lock, const char *path);
 void git_filebuf_cleanup(git_filebuf *lock);
-int git_filebuf_hash(git_oid *oid, git_filebuf *file);
+int git_filebuf_hash(unsigned char *out, git_filebuf *file);
 int git_filebuf_flush(git_filebuf *file);
 int git_filebuf_stats(time_t *mtime, size_t *size, git_filebuf *file);