rugged 1.0.1 → 1.3.0

data/vendor/libgit2/src/blame.c

@@ -59,7 +59,7 @@ static bool hunk_starts_at_or_after_line(git_blame_hunk *hunk, size_t line)
 	return line <= hunk->final_start_line_number;
 }
 
-static git_blame_hunk* new_hunk(
+static git_blame_hunk *new_hunk(
 		size_t start,
 		size_t lines,
 		size_t orig_start,
@@ -76,7 +76,15 @@ static git_blame_hunk* new_hunk(
 	return hunk;
 }
 
-static git_blame_hunk* dup_hunk(git_blame_hunk *hunk)
+static void free_hunk(git_blame_hunk *hunk)
+{
+	git__free((void*)hunk->orig_path);
+	git_signature_free(hunk->final_signature);
+	git_signature_free(hunk->orig_signature);
+	git__free(hunk);
+}
+
+static git_blame_hunk *dup_hunk(git_blame_hunk *hunk)
 {
 	git_blame_hunk *newhunk = new_hunk(
 			hunk->final_start_line_number,
@@ -90,17 +98,14 @@ static git_blame_hunk* dup_hunk(git_blame_hunk *hunk)
 	git_oid_cpy(&newhunk->orig_commit_id, &hunk->orig_commit_id);
 	git_oid_cpy(&newhunk->final_commit_id, &hunk->final_commit_id);
 	newhunk->boundary = hunk->boundary;
-	git_signature_dup(&newhunk->final_signature, hunk->final_signature);
-	git_signature_dup(&newhunk->orig_signature, hunk->orig_signature);
-	return newhunk;
-}
 
-static void free_hunk(git_blame_hunk *hunk)
-{
-	git__free((void*)hunk->orig_path);
-	git_signature_free(hunk->final_signature);
-	git_signature_free(hunk->orig_signature);
-	git__free(hunk);
+	if (git_signature_dup(&newhunk->final_signature, hunk->final_signature) < 0 ||
+		git_signature_dup(&newhunk->orig_signature, hunk->orig_signature) < 0) {
+		free_hunk(newhunk);
+		return NULL;
+	}
+
+	return newhunk;
 }
 
 /* Starting with the hunk that includes start_line, shift all following hunks'
@@ -117,7 +122,7 @@ static void shift_hunks_by(git_vector *v, size_t start_line, int shift_by)
 	}
 }
 
-git_blame* git_blame__alloc(
+git_blame *git_blame__alloc(
 	git_repository *repo,
 	git_blame_options opts,
 	const char *path)
@@ -171,20 +176,21 @@ void git_blame_free(git_blame *blame)
 
 uint32_t git_blame_get_hunk_count(git_blame *blame)
 {
-	assert(blame);
+	GIT_ASSERT_ARG(blame);
 	return (uint32_t)blame->hunks.length;
 }
 
 const git_blame_hunk *git_blame_get_hunk_byindex(git_blame *blame, uint32_t index)
 {
-	assert(blame);
+	GIT_ASSERT_ARG_WITH_RETVAL(blame, NULL);
 	return (git_blame_hunk*)git_vector_get(&blame->hunks, index);
 }
 
 const git_blame_hunk *git_blame_get_hunk_byline(git_blame *blame, size_t lineno)
 {
 	size_t i, new_lineno = lineno;
-	assert(blame);
+
+	GIT_ASSERT_ARG_WITH_RETVAL(blame, NULL);
 
 	if (!git_vector_bsearch2(&i, &blame->hunks, hunk_byfinalline_search_cmp, &new_lineno)) {
 		return git_blame_get_hunk_byindex(blame, (uint32_t)i);
@@ -293,7 +299,7 @@ static int index_blob_lines(git_blame *blame)
     return blame->num_lines;
 }
 
-static git_blame_hunk* hunk_from_entry(git_blame__entry *e, git_blame *blame)
+static git_blame_hunk *hunk_from_entry(git_blame__entry *e, git_blame *blame)
 {
 	git_blame_hunk *h = new_hunk(
 			e->lno+1, e->num_lines, e->s_lno+1, e->suspect->path);
@@ -388,7 +394,10 @@ int git_blame_file(
 	git_blame_options normOptions = GIT_BLAME_OPTIONS_INIT;
 	git_blame *blame = NULL;
 
-	assert(out && repo && path);
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(repo);
+	GIT_ASSERT_ARG(path);
+
 	if ((error = normalize_options(&normOptions, options, repo)) < 0)
 		goto on_error;
 
@@ -509,7 +518,9 @@ int git_blame_buffer(
 
 	diffopts.context_lines = 0;
 
-	assert(out && reference && buffer && buffer_len);
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(reference);
+	GIT_ASSERT_ARG(buffer && buffer_len);
 
 	blame = git_blame__alloc(reference->repository, reference->options, reference->path);
 	GIT_ERROR_CHECK_ALLOC(blame);
@@ -538,7 +549,9 @@ int git_blame_options_init(git_blame_options *opts, unsigned int version)
 	return 0;
 }
 
+#ifndef GIT_DEPRECATE_HARD
 int git_blame_init_options(git_blame_options *opts, unsigned int version)
 {
 	return git_blame_options_init(opts, version);
 }
+#endif

data/vendor/libgit2/src/blame_git.c

@@ -365,11 +365,14 @@ static void trim_common_tail(mmfile_t *a, mmfile_t *b, long ctx)
 	b->size -= trimmed - recovered;
 }
 
-static int diff_hunks(mmfile_t file_a, mmfile_t file_b, void *cb_data)
+static int diff_hunks(mmfile_t file_a, mmfile_t file_b, void *cb_data, git_blame_options *options)
 {
-	xpparam_t xpp = {0};
 	xdemitconf_t xecfg = {0};
 	xdemitcb_t ecb = {0};
+	xpparam_t xpp = {0};
+
+	if (options->flags & GIT_BLAME_IGNORE_WHITESPACE)
+		xpp.flags |= XDF_IGNORE_WHITESPACE;
 
 	xecfg.hunk_func = my_emit;
 	ecb.priv = cb_data;
@@ -409,7 +412,7 @@ static int pass_blame_to_parent(
 	fill_origin_blob(parent, &file_p);
 	fill_origin_blob(target, &file_o);
 
-	if (diff_hunks(file_p, file_o, &d) < 0)
+	if (diff_hunks(file_p, file_o, &d, &blame->options) < 0)
 		return -1;
 
 	/* The reset (i.e. anything after tlno) are the same as the parent */
@@ -426,7 +429,7 @@ static int paths_on_dup(void **old, void *new)
 	return -1;
 }
 
-static git_blame__origin* find_origin(
+static git_blame__origin *find_origin(
 		git_blame *blame,
 		git_commit *parent,
 		git_blame__origin *origin)

data/vendor/libgit2/src/blob.c

@@ -14,11 +14,11 @@
 
 #include "filebuf.h"
 #include "filter.h"
-#include "buf_text.h"
 
 const void *git_blob_rawcontent(const git_blob *blob)
 {
-	assert(blob);
+	GIT_ASSERT_ARG_WITH_RETVAL(blob, NULL);
+
 	if (blob->raw)
 		return blob->data.raw.data;
 	else
@@ -27,7 +27,8 @@ const void *git_blob_rawcontent(const git_blob *blob)
 
 git_object_size_t git_blob_rawsize(const git_blob *blob)
 {
-	assert(blob);
+	GIT_ASSERT_ARG(blob);
+
 	if (blob->raw)
 		return blob->data.raw.size;
 	else
@@ -53,7 +54,9 @@ void git_blob__free(void *_blob)
 int git_blob__parse_raw(void *_blob, const char *data, size_t size)
 {
 	git_blob *blob = (git_blob *) _blob;
-	assert(blob);
+
+	GIT_ASSERT_ARG(blob);
+
 	blob->raw = 1;
 	blob->data.raw.data = data;
 	blob->data.raw.size = size;
@@ -63,7 +66,9 @@ int git_blob__parse_raw(void *_blob, const char *data, size_t size)
 int git_blob__parse(void *_blob, git_odb_object *odb_obj)
 {
 	git_blob *blob = (git_blob *) _blob;
-	assert(blob);
+
+	GIT_ASSERT_ARG(blob);
+
 	git_cached_obj_incref((git_cached_obj *)odb_obj);
 	blob->raw = 0;
 	blob->data.odb = odb_obj;
@@ -77,7 +82,8 @@ int git_blob_create_from_buffer(
 	git_odb *odb;
 	git_odb_stream *stream;
 
-	assert(id && repo);
+	GIT_ASSERT_ARG(id);
+	GIT_ASSERT_ARG(repo);
 
 	if ((error = git_repository_odb__weakptr(&odb, repo)) < 0 ||
 		(error = git_odb_open_wstream(&stream, odb, len, GIT_OBJECT_BLOB)) < 0)
@@ -132,12 +138,13 @@ static int write_file_filtered(
 	git_object_size_t *size,
 	git_odb *odb,
 	const char *full_path,
-	git_filter_list *fl)
+	git_filter_list *fl,
+	git_repository* repo)
 {
 	int error;
 	git_buf tgt = GIT_BUF_INIT;
 
-	error = git_filter_list_apply_to_file(&tgt, fl, NULL, full_path);
+	error = git_filter_list_apply_to_file(&tgt, fl, repo, full_path);
 
 	/* Write the file to disk if it was properly filtered */
 	if (!error) {
@@ -188,14 +195,10 @@ int git_blob__create_from_paths(
 	mode_t mode;
 	git_buf path = GIT_BUF_INIT;
 
-	assert(hint_path || !try_load_filters);
+	GIT_ASSERT_ARG(hint_path || !try_load_filters);
 
 	if (!content_path) {
-		if (git_repository__ensure_not_bare(repo, "create blob from file") < 0)
-			return GIT_EBAREREPO;
-
-		if (git_buf_joinpath(
-				&path, git_repository_workdir(repo), hint_path) < 0)
+		if (git_repository_workdir_path(&path, repo, hint_path) < 0)
 			return -1;
 
 		content_path = path.ptr;
@@ -236,7 +239,7 @@ int git_blob__create_from_paths(
 			error = write_file_stream(id, odb, content_path, size);
 		else {
 			/* We need to apply one or more filters */
-			error = write_file_filtered(id, &size, odb, content_path, fl);
+			error = write_file_filtered(id, &size, odb, content_path, fl, repo);
 
 			git_filter_list_free(fl);
 		}
@@ -274,21 +277,20 @@ int git_blob_create_from_disk(
 {
 	int error;
 	git_buf full_path = GIT_BUF_INIT;
-	const char *workdir, *hintpath;
+	const char *workdir, *hintpath = NULL;
 
 	if ((error = git_path_prettify(&full_path, path, NULL)) < 0) {
 		git_buf_dispose(&full_path);
 		return error;
 	}
 
-	hintpath = git_buf_cstr(&full_path);
 	workdir  = git_repository_workdir(repo);
 
-	if (workdir && !git__prefixcmp(hintpath, workdir))
-		hintpath += strlen(workdir);
+	if (workdir && !git__prefixcmp(full_path.ptr, workdir))
+		hintpath = full_path.ptr + strlen(workdir);
 
 	error = git_blob__create_from_paths(
-		id, NULL, repo, git_buf_cstr(&full_path), hintpath, 0, true);
+		id, NULL, repo, git_buf_cstr(&full_path), hintpath, 0, !!hintpath);
 
 	git_buf_dispose(&full_path);
 	return error;
@@ -331,7 +333,8 @@ int git_blob_create_from_stream(git_writestream **out, git_repository *repo, con
 	git_buf path = GIT_BUF_INIT;
 	blob_writestream *stream;
 
-	assert(out && repo);
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(repo);
 
 	stream = git__calloc(1, sizeof(blob_writestream));
 	GIT_ERROR_CHECK_ALLOC(stream);
@@ -391,13 +394,22 @@ int git_blob_is_binary(const git_blob *blob)
 	git_buf content = GIT_BUF_INIT;
 	git_object_size_t size;
 
-	assert(blob);
+	GIT_ASSERT_ARG(blob);
 
 	size = git_blob_rawsize(blob);
 
 	git_buf_attach_notowned(&content, git_blob_rawcontent(blob),
 		(size_t)min(size, GIT_FILTER_BYTES_TO_CHECK_NUL));
-	return git_buf_text_is_binary(&content);
+	return git_buf_is_binary(&content);
+}
+
+int git_blob_filter_options_init(
+	git_blob_filter_options *opts,
+	unsigned int version)
+{
+	GIT_INIT_STRUCTURE_FROM_TEMPLATE(opts, version,
+		git_blob_filter_options, GIT_BLOB_FILTER_OPTIONS_INIT);
+	return 0;
 }
 
 int git_blob_filter(
@@ -409,15 +421,18 @@ int git_blob_filter(
 	int error = 0;
 	git_filter_list *fl = NULL;
 	git_blob_filter_options opts = GIT_BLOB_FILTER_OPTIONS_INIT;
-	git_filter_flag_t flags = GIT_FILTER_DEFAULT;
+	git_filter_options filter_opts = GIT_FILTER_OPTIONS_INIT;
 
-	assert(blob && path && out);
-
-	git_buf_sanitize(out);
+	GIT_ASSERT_ARG(blob);
+	GIT_ASSERT_ARG(path);
+	GIT_ASSERT_ARG(out);
 
 	GIT_ERROR_CHECK_VERSION(
 		given_opts, GIT_BLOB_FILTER_OPTIONS_VERSION, "git_blob_filter_options");
 
+	if (git_buf_sanitize(out) < 0)
+		return -1;
+
 	if (given_opts != NULL)
 		memcpy(&opts, given_opts, sizeof(git_blob_filter_options));
 
@@ -426,14 +441,25 @@ int git_blob_filter(
 		return 0;
 
 	if ((opts.flags & GIT_BLOB_FILTER_NO_SYSTEM_ATTRIBUTES) != 0)
-		flags |= GIT_FILTER_NO_SYSTEM_ATTRIBUTES;
+		filter_opts.flags |= GIT_FILTER_NO_SYSTEM_ATTRIBUTES;
+
+	if ((opts.flags & GIT_BLOB_FILTER_ATTRIBUTES_FROM_HEAD) != 0)
+		filter_opts.flags |= GIT_FILTER_ATTRIBUTES_FROM_HEAD;
 
-	if ((opts.flags & GIT_BLOB_FILTER_ATTTRIBUTES_FROM_HEAD) != 0)
-		flags |= GIT_FILTER_ATTRIBUTES_FROM_HEAD;
+	if ((opts.flags & GIT_BLOB_FILTER_ATTRIBUTES_FROM_COMMIT) != 0) {
+		filter_opts.flags |= GIT_FILTER_ATTRIBUTES_FROM_COMMIT;
+
+#ifndef GIT_DEPRECATE_HARD
+		if (opts.commit_id)
+			git_oid_cpy(&filter_opts.attr_commit_id, opts.commit_id);
+		else
+#endif
+		git_oid_cpy(&filter_opts.attr_commit_id, &opts.attr_commit_id);
+	}
 
-	if (!(error = git_filter_list_load(
+	if (!(error = git_filter_list_load_ext(
 			&fl, git_blob_owner(blob), blob, path,
-			GIT_FILTER_TO_WORKTREE, flags))) {
+			GIT_FILTER_TO_WORKTREE, &filter_opts))) {
 
 		error = git_filter_list_apply_to_blob(out, fl, blob);
 
@@ -445,6 +471,7 @@ int git_blob_filter(
 
 /* Deprecated functions */
 
+#ifndef GIT_DEPRECATE_HARD
 int git_blob_create_frombuffer(
 	git_oid *id, git_repository *repo, const void *buffer, size_t len)
 {
@@ -491,3 +518,4 @@ int git_blob_filtered_content(
 
 	return git_blob_filter(out, blob, path, &opts);
 }
+#endif

data/vendor/libgit2/src/branch.c

@@ -67,8 +67,10 @@ static int create_branch(
 	int error = -1;
 	int bare = git_repository_is_bare(repository);
 
-	assert(branch_name && commit && ref_out);
-	assert(git_object_owner((const git_object *)commit) == repository);
+	GIT_ASSERT_ARG(branch_name);
+	GIT_ASSERT_ARG(commit);
+	GIT_ASSERT_ARG(ref_out);
+	GIT_ASSERT_ARG(git_commit_owner(commit) == repository);
 
 	if (!git__strcmp(branch_name, "HEAD")) {
 		git_error_set(GIT_ERROR_REFERENCE, "'HEAD' is not a valid branch name");
@@ -134,39 +136,39 @@ int git_branch_create_from_annotated(
 		repository, branch_name, commit->commit, commit->description, force);
 }
 
-static int branch_equals(git_repository *repo, const char *path, void *payload)
+static int branch_is_checked_out(git_repository *worktree, void *payload)
 {
 	git_reference *branch = (git_reference *) payload;
 	git_reference *head = NULL;
-	int equal = 0;
+	int error;
 
-	if (git_reference__read_head(&head, repo, path) < 0 ||
-		git_reference_type(head) != GIT_REFERENCE_SYMBOLIC)
-		goto done;
+	if (git_repository_is_bare(worktree))
+		return 0;
 
-	equal = !git__strcmp(head->target.symbolic, branch->name);
+	if ((error = git_reference_lookup(&head, worktree, GIT_HEAD_FILE)) < 0) {
+		if (error == GIT_ENOTFOUND)
+			error = 0;
+		goto out;
+	}
 
-done:
+	if (git_reference_type(head) != GIT_REFERENCE_SYMBOLIC)
+		goto out;
+
+	error = !git__strcmp(head->target.symbolic, branch->name);
+
+out:
 	git_reference_free(head);
-	return equal;
+	return error;
 }
 
 int git_branch_is_checked_out(const git_reference *branch)
 {
-	git_repository *repo;
-	int flags = 0;
-
-	assert(branch);
+	GIT_ASSERT_ARG(branch);
 
 	if (!git_reference_is_branch(branch))
 		return 0;
-
-	repo = git_reference_owner(branch);
-
-	if (git_repository_is_bare(repo))
-		flags |= GIT_REPOSITORY_FOREACH_HEAD_SKIP_REPO;
-
-	return git_repository_foreach_head(repo, branch_equals, flags, (void *) branch) == 1;
+	return git_repository_foreach_worktree(git_reference_owner(branch),
+					       branch_is_checked_out, (void *)branch) == 1;
 }
 
 int git_branch_delete(git_reference *branch)
@@ -175,7 +177,7 @@ int git_branch_delete(git_reference *branch)
 	git_buf config_section = GIT_BUF_INIT;
 	int error = -1;
 
-	assert(branch);
+	GIT_ASSERT_ARG(branch);
 
 	if (!git_reference_is_branch(branch) && !git_reference_is_remote(branch)) {
 		git_error_set(GIT_ERROR_INVALID, "reference '%s' is not a valid branch.",
@@ -290,7 +292,8 @@ int git_branch_move(
 	        log_message = GIT_BUF_INIT;
 	int error;
 
-	assert(branch && new_branch_name);
+	GIT_ASSERT_ARG(branch);
+	GIT_ASSERT_ARG(new_branch_name);
 
 	if (!git_reference_is_branch(branch))
 		return not_a_local_branch(git_reference_name(branch));
@@ -335,7 +338,10 @@ int git_branch_lookup(
 	git_branch_t branch_type)
 {
 	int error = -1;
-	assert(ref_out && repo && branch_name);
+
+	GIT_ASSERT_ARG(ref_out);
+	GIT_ASSERT_ARG(repo);
+	GIT_ASSERT_ARG(branch_name);
 
 	switch (branch_type) {
 	case GIT_BRANCH_LOCAL:
@@ -348,7 +354,7 @@ int git_branch_lookup(
 			error = retrieve_branch_reference(ref_out, repo, branch_name, true);
 		break;
 	default:
-		assert(false);
+		GIT_ASSERT(false);
 	}
 	return error;
 }
@@ -359,7 +365,8 @@ int git_branch_name(
 {
 	const char *branch_name;
 
-	assert(out && ref);
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(ref);
 
 	branch_name = ref->name;
 
@@ -407,9 +414,11 @@ int git_branch_upstream_name(
 	const git_refspec *refspec;
 	git_config *config;
 
-	assert(out && refname);
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(refname);
 
-	git_buf_sanitize(out);
+	if ((error = git_buf_sanitize(out)) < 0)
+		return error;
 
 	if (!git_reference__is_branch(refname))
 		return not_a_local_branch(refname);
@@ -459,7 +468,7 @@ cleanup:
 	return error;
 }
 
-int git_branch_upstream_remote(git_buf *buf, git_repository *repo, const char *refname)
+static int git_branch_upstream_with_format(git_buf *buf, git_repository *repo, const char *refname, const char *format, const char *format_name)
 {
 	int error;
 	git_config *cfg;
@@ -470,13 +479,12 @@ int git_branch_upstream_remote(git_buf *buf, git_repository *repo, const char *r
 	if ((error = git_repository_config__weakptr(&cfg, repo)) < 0)
 		return error;
 
-	git_buf_sanitize(buf);
-
-	if ((error = retrieve_upstream_configuration(buf, cfg, refname, "branch.%s.remote")) < 0)
+	if ((error = git_buf_sanitize(buf)) < 0 ||
+	    (error = retrieve_upstream_configuration(buf, cfg, refname, format)) < 0)
 		return error;
 
 	if (git_buf_len(buf) == 0) {
-		git_error_set(GIT_ERROR_REFERENCE, "branch '%s' does not have an upstream remote", refname);
+		git_error_set(GIT_ERROR_REFERENCE, "branch '%s' does not have an upstream %s", refname, format_name);
 		error = GIT_ENOTFOUND;
 		git_buf_clear(buf);
 	}
@@ -484,6 +492,16 @@ int git_branch_upstream_remote(git_buf *buf, git_repository *repo, const char *r
 	return error;
 }
 
+int git_branch_upstream_remote(git_buf *buf, git_repository *repo, const char *refname)
+{
+	return git_branch_upstream_with_format(buf, repo, refname, "branch.%s.remote", "remote");
+}
+
+int git_branch_upstream_merge(git_buf *buf, git_repository *repo, const char *refname)
+{
+	return git_branch_upstream_with_format(buf, repo, refname, "branch.%s.merge", "merge");
+}
+
 int git_branch_remote_name(git_buf *buf, git_repository *repo, const char *refname)
 {
 	git_strarray remote_list = {0};
@@ -493,9 +511,12 @@ int git_branch_remote_name(git_buf *buf, git_repository *repo, const char *refna
 	int error = 0;
 	char *remote_name = NULL;
 
-	assert(buf && repo && refname);
+	GIT_ASSERT_ARG(buf);
+	GIT_ASSERT_ARG(repo);
+	GIT_ASSERT_ARG(refname);
 
-	git_buf_sanitize(buf);
+	if ((error = git_buf_sanitize(buf)) < 0)
+		return error;
 
 	/* Verify that this is a remote branch */
 	if (!git_reference__is_remote(refname)) {
@@ -548,7 +569,7 @@ cleanup:
 	if (error < 0)
 		git_buf_dispose(buf);
 
-	git_strarray_free(&remote_list);
+	git_strarray_dispose(&remote_list);
 	return error;
 }
 
@@ -704,7 +725,7 @@ int git_branch_is_head(
 	bool is_same = false;
 	int error;
 
-	assert(branch);
+	GIT_ASSERT_ARG(branch);
 
 	if (!git_reference_is_branch(branch))
 		return false;
@@ -725,3 +746,32 @@ int git_branch_is_head(
 
 	return is_same;
 }
+
+int git_branch_name_is_valid(int *valid, const char *name)
+{
+	git_buf ref_name = GIT_BUF_INIT;
+	int error = 0;
+
+	GIT_ASSERT(valid);
+
+	*valid = 0;
+
+	/*
+	 * Discourage branch name starting with dash,
+	 * https://github.com/git/git/commit/6348624010888b
+	 * and discourage HEAD as branch name,
+	 * https://github.com/git/git/commit/a625b092cc5994
+	 */
+	if (!name || name[0] == '-' || !git__strcmp(name, "HEAD"))
+		goto done;
+
+	if ((error = git_buf_puts(&ref_name, GIT_REFS_HEADS_DIR)) < 0 ||
+	    (error = git_buf_puts(&ref_name, name)) < 0)
+		goto done;
+
+	error = git_reference_name_is_valid(valid, ref_name.ptr);
+
+done:
+	git_buf_dispose(&ref_name);
+	return error;
+}