rugged 0.27.10.1 → 0.28.0

data/vendor/libgit2/src/reader.h

@@ -0,0 +1,107 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#ifndef INCLUDE_reader_h__
+#define INCLUDE_reader_h__
+
+#include "common.h"
+
+/* Returned when the workdir does not match the index */
+#define GIT_READER_MISMATCH	1
+
+typedef struct git_reader git_reader;
+
+/*
+ * The `git_reader` structure is a generic interface for reading the
+ * contents of a file by its name, and implementations are provided
+ * for reading out of a tree, the index, and the working directory.
+ *
+ * Note that the reader implementation is meant to have a short
+ * lifecycle and does not increase the refcount of the object that
+ * it's reading.  Callers should ensure that they do not use a
+ * reader after disposing the underlying object that it reads.
+ */
+struct git_reader {
+	int (*read)(git_buf *out, git_oid *out_oid, git_filemode_t *mode, git_reader *reader, const char *filename);
+};
+
+/**
+ * Create a `git_reader` that will allow random access to the given
+ * tree.  Paths requested via `git_reader_read` will be rooted at this
+ * tree, callers are not expected to recurse through tree lookups.  Thus,
+ * you can request to read `/src/foo.c` and the tree provided to this
+ * function will be searched to find another tree named `src`, which
+ * will then be opened to find `foo.c`.
+ *
+ * @param out The reader for the given tree
+ * @param tree The tree object to read
+ * @return 0 on success, or an error code < 0
+ */
+extern int git_reader_for_tree(
+	git_reader **out,
+	git_tree *tree);
+
+/**
+ * Create a `git_reader` that will allow random access to the given
+ * index, or the repository's index.
+ *
+ * @param out The reader for the given index
+ * @param repo The repository containing the index
+ * @param index The index to read, or NULL to use the repository's index
+ * @return 0 on success, or an error code < 0
+ */
+extern int git_reader_for_index(
+	git_reader **out,
+	git_repository *repo,
+	git_index *index);
+
+/**
+ * Create a `git_reader` that will allow random access to the given
+ * repository's working directory.  Note that the contents are read
+ * in repository format, meaning any workdir -> odb filters are
+ * applied.
+ *
+ * If `validate_index` is set to true, reads of files will hash the
+ * on-disk contents and ensure that the resulting object ID matches
+ * the repository's index.  This ensures that the working directory
+ * is unmodified from the index contents.
+ *
+ * @param out The reader for the given working directory
+ * @param repo The repository containing the working directory
+ * @param validate_index If true, the working directory contents will
+ *        be compared to the index contents during read to ensure that
+ *        the working directory is unmodified.
+ * @return 0 on success, or an error code < 0
+ */
+extern int git_reader_for_workdir(
+	git_reader **out,
+	git_repository *repo,
+	bool validate_index);
+
+/**
+ * Read the given filename from the reader and populate the given buffer
+ * with the contents and the given oid with the object ID.
+ *
+ * @param out The buffer to populate with the file contents
+ * @param out_id The oid to populate with the object ID
+ * @param reader The reader to read
+ * @param filename The filename to read from the reader
+ */
+extern int git_reader_read(
+	git_buf *out,
+	git_oid *out_id,
+	git_filemode_t *out_filemode,
+	git_reader *reader,
+	const char *filename);
+
+/**
+ * Free the given reader and any associated objects.
+ *
+ * @param reader The reader to free
+ */
+extern void git_reader_free(git_reader *reader);
+
+#endif

data/vendor/libgit2/src/rebase.c

@@ -116,7 +116,7 @@ done:
 	if (type != GIT_REBASE_TYPE_NONE && path_out)
 		*path_out = git_buf_detach(&path);
 
-	git_buf_free(&path);
+	git_buf_dispose(&path);
 
 	return 0;
 }
@@ -153,7 +153,7 @@ GIT_INLINE(int) rebase_readint(
 		return error;
 
 	if (git__strntol32(&num, asc_out->ptr, asc_out->size, &eol, 10) < 0 || num < 0 || *eol) {
-		giterr_set(GITERR_REBASE, "the file '%s' contains an invalid numeric value", filename);
+		git_error_set(GIT_ERROR_REBASE, "the file '%s' contains an invalid numeric value", filename);
 		return -1;
 	}
 
@@ -171,7 +171,7 @@ GIT_INLINE(int) rebase_readoid(
 		return error;
 
 	if (str_out->size != GIT_OID_HEXSZ || git_oid_fromstr(out, str_out->ptr) < 0) {
-		giterr_set(GITERR_REBASE, "the file '%s' contains an invalid object ID", filename);
+		git_error_set(GIT_ERROR_REBASE, "the file '%s' contains an invalid object ID", filename);
 		return -1;
 	}
 
@@ -231,7 +231,7 @@ static int rebase_open_merge(git_rebase *rebase)
 
 	/* Read cmt.* */
 	git_array_init_to_size(rebase->operations, end);
-	GITERR_CHECK_ARRAY(rebase->operations);
+	GIT_ERROR_CHECK_ARRAY(rebase->operations);
 
 	for (i = 0; i < end; i++) {
 		git_buf_clear(&cmt);
@@ -241,7 +241,7 @@ static int rebase_open_merge(git_rebase *rebase)
 			goto done;
 
 		operation = rebase_operation_alloc(rebase, GIT_REBASE_OPERATION_PICK, &id, NULL);
-		GITERR_CHECK_ALLOC(operation);
+		GIT_ERROR_CHECK_ALLOC(operation);
 	}
 
 	/* Read 'onto_name' */
@@ -251,9 +251,9 @@ static int rebase_open_merge(git_rebase *rebase)
 	rebase->onto_name = git_buf_detach(&buf);
 
 done:
-	git_buf_free(&cmt);
-	git_buf_free(&state_path);
-	git_buf_free(&buf);
+	git_buf_dispose(&cmt);
+	git_buf_dispose(&state_path);
+	git_buf_dispose(&buf);
 
 	return error;
 }
@@ -261,7 +261,7 @@ done:
 static int rebase_alloc(git_rebase **out, const git_rebase_options *rebase_opts)
 {
 	git_rebase *rebase = git__calloc(1, sizeof(git_rebase));
-	GITERR_CHECK_ALLOC(rebase);
+	GIT_ERROR_CHECK_ALLOC(rebase);
 
 	*out = NULL;
 
@@ -272,12 +272,9 @@ static int rebase_alloc(git_rebase **out, const git_rebase_options *rebase_opts)
 
 	if (rebase_opts && rebase_opts->rewrite_notes_ref) {
 		rebase->options.rewrite_notes_ref = git__strdup(rebase_opts->rewrite_notes_ref);
-		GITERR_CHECK_ALLOC(rebase->options.rewrite_notes_ref);
+		GIT_ERROR_CHECK_ALLOC(rebase->options.rewrite_notes_ref);
 	}
 
-	if ((rebase->options.checkout_options.checkout_strategy & (GIT_CHECKOUT_SAFE | GIT_CHECKOUT_FORCE)) == 0)
-		rebase->options.checkout_options.checkout_strategy = GIT_CHECKOUT_SAFE;
-
 	*out = rebase;
 
 	return 0;
@@ -285,10 +282,10 @@ static int rebase_alloc(git_rebase **out, const git_rebase_options *rebase_opts)
 
 static int rebase_check_versions(const git_rebase_options *given_opts)
 {
-	GITERR_CHECK_VERSION(given_opts, GIT_REBASE_OPTIONS_VERSION, "git_rebase_options");
+	GIT_ERROR_CHECK_VERSION(given_opts, GIT_REBASE_OPTIONS_VERSION, "git_rebase_options");
 
 	if (given_opts)
-		GITERR_CHECK_VERSION(&given_opts->checkout_options, GIT_CHECKOUT_OPTIONS_VERSION, "git_checkout_options");
+		GIT_ERROR_CHECK_VERSION(&given_opts->checkout_options, GIT_CHECKOUT_OPTIONS_VERSION, "git_checkout_options");
 
 	return 0;
 }
@@ -317,7 +314,7 @@ int git_rebase_open(
 		goto done;
 
 	if (rebase->type == GIT_REBASE_TYPE_NONE) {
-		giterr_set(GITERR_REBASE, "there is no rebase in progress");
+		git_error_set(GIT_ERROR_REBASE, "there is no rebase in progress");
 		error = GIT_ENOTFOUND;
 		goto done;
 	}
@@ -373,14 +370,14 @@ int git_rebase_open(
 
 	switch (rebase->type) {
 	case GIT_REBASE_TYPE_INTERACTIVE:
-		giterr_set(GITERR_REBASE, "interactive rebase is not supported");
+		git_error_set(GIT_ERROR_REBASE, "interactive rebase is not supported");
 		error = -1;
 		break;
 	case GIT_REBASE_TYPE_MERGE:
 		error = rebase_open_merge(rebase);
 		break;
 	case GIT_REBASE_TYPE_APPLY:
-		giterr_set(GITERR_REBASE, "patch application rebase is not supported");
+		git_error_set(GIT_ERROR_REBASE, "patch application rebase is not supported");
 		error = -1;
 		break;
 	default:
@@ -393,10 +390,10 @@ done:
 	else
 		git_rebase_free(rebase);
 
-	git_buf_free(&path);
-	git_buf_free(&orig_head_name);
-	git_buf_free(&orig_head_id);
-	git_buf_free(&onto_id);
+	git_buf_dispose(&path);
+	git_buf_dispose(&orig_head_name);
+	git_buf_dispose(&orig_head_id);
+	git_buf_dispose(&onto_id);
 	return error;
 }
 
@@ -424,8 +421,8 @@ static int rebase_setupfile(git_rebase *rebase, const char *filename, int flags,
 	if ((error = git_buf_joinpath(&path, rebase->state_path, filename)) == 0)
 		error = git_futils_writebuffer(&contents, path.ptr, flags, REBASE_FILE_MODE);
 
-	git_buf_free(&path);
-	git_buf_free(&contents);
+	git_buf_dispose(&path);
+	git_buf_dispose(&contents);
 
 	return error;
 }
@@ -466,7 +463,7 @@ static int rebase_setupfiles_merge(git_rebase *rebase)
 	}
 
 done:
-	git_buf_free(&commit_filename);
+	git_buf_dispose(&commit_filename);
 	return error;
 }
 
@@ -479,7 +476,7 @@ static int rebase_setupfiles(git_rebase *rebase)
 	git_oid_fmt(orig_head, &rebase->orig_head_id);
 
 	if (p_mkdir(rebase->state_path, REBASE_DIR_MODE) < 0) {
-		giterr_set(GITERR_OS, "failed to create rebase directory '%s'", rebase->state_path);
+		git_error_set(GIT_ERROR_OS, "failed to create rebase directory '%s'", rebase->state_path);
 		return -1;
 	}
 
@@ -512,7 +509,7 @@ static int rebase_ensure_not_in_progress(git_repository *repo)
 		return error;
 
 	if (type != GIT_REBASE_TYPE_NONE) {
-		giterr_set(GITERR_REBASE, "there is an existing rebase in progress");
+		git_error_set(GIT_ERROR_REBASE, "there is an existing rebase in progress");
 		return -1;
 	}
 
@@ -537,7 +534,7 @@ static int rebase_ensure_not_dirty(
 			goto done;
 
 		if (git_diff_num_deltas(diff) > 0) {
-			giterr_set(GITERR_REBASE, "uncommitted changes exist in index");
+			git_error_set(GIT_ERROR_REBASE, "uncommitted changes exist in index");
 			error = fail_with;
 			goto done;
 		}
@@ -553,7 +550,7 @@ static int rebase_ensure_not_dirty(
 			goto done;
 
 		if (git_diff_num_deltas(diff) > 0) {
-			giterr_set(GITERR_REBASE, "unstaged changes exist in workdir");
+			git_error_set(GIT_ERROR_REBASE, "unstaged changes exist in workdir");
 			error = fail_with;
 			goto done;
 		}
@@ -602,7 +599,7 @@ static int rebase_init_operations(
 			continue;
 
 		operation = rebase_operation_alloc(rebase, GIT_REBASE_OPERATION_PICK, &id, NULL);
-		GITERR_CHECK_ALLOC(operation);
+		GIT_ERROR_CHECK_ALLOC(operation);
 	}
 
 	error = 0;
@@ -631,17 +628,17 @@ static int rebase_init_merge(
 		goto done;
 
 	rebase->state_path = git_buf_detach(&state_path);
-	GITERR_CHECK_ALLOC(rebase->state_path);
+	GIT_ERROR_CHECK_ALLOC(rebase->state_path);
 
 	if (branch->ref_name && strcmp(branch->ref_name, "HEAD")) {
 		rebase->orig_head_name = git__strdup(branch->ref_name);
-		GITERR_CHECK_ALLOC(rebase->orig_head_name);
+		GIT_ERROR_CHECK_ALLOC(rebase->orig_head_name);
 	} else {
 		rebase->head_detached = 1;
 	}
 
 	rebase->onto_name = git__strdup(rebase_onto_name(onto));
-	GITERR_CHECK_ALLOC(rebase->onto_name);
+	GIT_ERROR_CHECK_ALLOC(rebase->onto_name);
 
 	rebase->quiet = rebase->options.quiet;
 
@@ -662,8 +659,8 @@ static int rebase_init_merge(
 done:
 	git_reference_free(head_ref);
 	git_commit_free(onto_commit);
-	git_buf_free(&reflog);
-	git_buf_free(&state_path);
+	git_buf_dispose(&reflog);
+	git_buf_dispose(&state_path);
 
 	return error;
 }
@@ -810,7 +807,7 @@ static int rebase_next_merge(
 		goto done;
 
 	if ((parent_count = git_commit_parentcount(current_commit)) > 1) {
-		giterr_set(GITERR_REBASE, "cannot rebase a merge commit");
+		git_error_set(GIT_ERROR_REBASE, "cannot rebase a merge commit");
 		error = -1;
 		goto done;
 	} else if (parent_count) {
@@ -842,7 +839,7 @@ done:
 	git_tree_free(parent_tree);
 	git_commit_free(parent_commit);
 	git_commit_free(current_commit);
-	git_buf_free(&path);
+	git_buf_dispose(&path);
 
 	return error;
 }
@@ -867,7 +864,7 @@ static int rebase_next_inmemory(
 		goto done;
 
 	if ((parent_count = git_commit_parentcount(current_commit)) > 1) {
-		giterr_set(GITERR_REBASE, "cannot rebase a merge commit");
+		git_error_set(GIT_ERROR_REBASE, "cannot rebase a merge commit");
 		error = -1;
 		goto done;
 	} else if (parent_count) {
@@ -953,7 +950,7 @@ static int rebase_commit__create(
 	operation = git_array_get(rebase->operations, rebase->current);
 
 	if (git_index_has_conflicts(index)) {
-		giterr_set(GITERR_REBASE, "conflicts have not been resolved");
+		git_error_set(GIT_ERROR_REBASE, "conflicts have not been resolved");
 		error = GIT_EUNMERGED;
 		goto done;
 	}
@@ -965,7 +962,7 @@ static int rebase_commit__create(
 		goto done;
 
 	if (git_oid_equal(&tree_id, git_tree_id(parent_tree))) {
-		giterr_set(GITERR_REBASE, "this patch has already been applied");
+		git_error_set(GIT_ERROR_REBASE, "this patch has already been applied");
 		error = GIT_EAPPLIED;
 		goto done;
 	}
@@ -1017,7 +1014,7 @@ static int rebase_commit_merge(
 
 	if ((error = rebase_ensure_not_dirty(rebase->repo, false, true, GIT_EUNMERGED)) < 0 ||
 		(error = git_repository_head(&head, rebase->repo)) < 0 ||
-		(error = git_reference_peel((git_object **)&head_commit, head, GIT_OBJ_COMMIT)) < 0 ||
+		(error = git_reference_peel((git_object **)&head_commit, head, GIT_OBJECT_COMMIT)) < 0 ||
 		(error = git_repository_index(&index, rebase->repo)) < 0 ||
 		(error = rebase_commit__create(&commit, rebase, index, head_commit,
 			author, committer, message_encoding, message)) < 0 ||
@@ -1151,7 +1148,7 @@ static int notes_ref_lookup(git_buf *out, git_rebase *rebase)
 		if (error != GIT_ENOTFOUND)
 			goto done;
 
-		giterr_clear();
+		git_error_clear();
 		do_rewrite = 1;
 	}
 
@@ -1178,7 +1175,7 @@ static int rebase_copy_note(
 
 	if ((error = git_note_read(&note, rebase->repo, notes_ref, from)) < 0) {
 		if (error == GIT_ENOTFOUND) {
-			giterr_clear();
+			git_error_clear();
 			error = 0;
 		}
 
@@ -1191,7 +1188,7 @@ static int rebase_copy_note(
 				(error = git_signature_now(&who, "unknown", "unknown")) < 0)
 				goto done;
 
-			giterr_clear();
+			git_error_clear();
 		}
 
 		committer = who;
@@ -1219,7 +1216,7 @@ static int rebase_copy_notes(
 
 	if ((error = notes_ref_lookup(&notes_ref, rebase)) < 0) {
 		if (error == GIT_ENOTFOUND) {
-			giterr_clear();
+			git_error_clear();
 			error = 0;
 		}
 
@@ -1262,13 +1259,13 @@ static int rebase_copy_notes(
 	goto done;
 
 on_error:
-	giterr_set(GITERR_REBASE, "invalid rewritten file at line %d", linenum);
+	git_error_set(GIT_ERROR_REBASE, "invalid rewritten file at line %d", linenum);
 	error = -1;
 
 done:
-	git_buf_free(&rewritten);
-	git_buf_free(&path);
-	git_buf_free(&notes_ref);
+	git_buf_dispose(&rewritten);
+	git_buf_dispose(&path);
+	git_buf_dispose(&notes_ref);
 
 	return error;
 }
@@ -1291,7 +1288,7 @@ static int return_to_orig_head(git_rebase *rebase)
 			rebase->orig_head_name)) == 0 &&
 		(error = git_repository_head(&terminal_ref, rebase->repo)) == 0 &&
 		(error = git_reference_peel((git_object **)&terminal_commit,
-			terminal_ref, GIT_OBJ_COMMIT)) == 0 &&
+			terminal_ref, GIT_OBJECT_COMMIT)) == 0 &&
 		(error = git_reference_create_matching(&branch_ref,
 			rebase->repo, rebase->orig_head_name,
 			git_commit_id(terminal_commit), 1,
@@ -1300,8 +1297,8 @@ static int return_to_orig_head(git_rebase *rebase)
 			rebase->repo, GIT_HEAD_FILE, rebase->orig_head_name, 1,
 			head_msg.ptr);
 
-	git_buf_free(&head_msg);
-	git_buf_free(&branch_msg);
+	git_buf_dispose(&head_msg);
+	git_buf_dispose(&branch_msg);
 	git_commit_free(terminal_commit);
 	git_reference_free(head_ref);
 	git_reference_free(branch_ref);