rugged 0.27.10 → 0.27.10.1

data/vendor/libgit2/src/blame.h

@@ -67,7 +67,6 @@ typedef struct git_blame__entry {
 struct git_blame {
 	char *path;
 	git_repository *repository;
-	git_mailmap *mailmap;
 	git_blame_options options;
 
 	git_vector hunks;
@@ -84,7 +83,7 @@ struct git_blame {
 	git_blame__entry *ent;
 	int num_lines;
 	const char *final_buf;
-	size_t final_buf_size;
+	git_off_t final_buf_size;
 };
 
 git_blame *git_blame__alloc(

data/vendor/libgit2/src/blame_git.c

@@ -43,13 +43,13 @@ static int make_origin(git_blame__origin **out, git_commit *commit, const char *
 	int error = 0;
 
 	if ((error = git_object_lookup_bypath(&blob, (git_object*)commit,
-			path, GIT_OBJECT_BLOB)) < 0)
+			path, GIT_OBJ_BLOB)) < 0)
 		return error;
 
-	GIT_ERROR_CHECK_ALLOC_ADD(&alloc_len, sizeof(*o), path_len);
-	GIT_ERROR_CHECK_ALLOC_ADD(&alloc_len, alloc_len, 1);
+	GITERR_CHECK_ALLOC_ADD(&alloc_len, sizeof(*o), path_len);
+	GITERR_CHECK_ALLOC_ADD(&alloc_len, alloc_len, 1);
 	o = git__calloc(1, alloc_len);
-	GIT_ERROR_CHECK_ALLOC(o);
+	GITERR_CHECK_ALLOC(o);
 
 	o->commit = commit;
 	o->blob = (git_blob *) blob;
@@ -219,7 +219,7 @@ static void dup_entry(git_blame__entry *dst, git_blame__entry *src)
  * split_overlap() divided an existing blame e into up to three parts in split.
  * Adjust the linked list of blames in the scoreboard to reflect the split.
  */
-static int split_blame(git_blame *blame, git_blame__entry *split, git_blame__entry *e)
+static void split_blame(git_blame *blame, git_blame__entry *split, git_blame__entry *e)
 {
 	git_blame__entry *new_entry;
 
@@ -229,13 +229,11 @@ static int split_blame(git_blame *blame, git_blame__entry *split, git_blame__ent
 
 		/* The last part -- me */
 		new_entry = git__malloc(sizeof(*new_entry));
-		GIT_ERROR_CHECK_ALLOC(new_entry);
 		memcpy(new_entry, &(split[2]), sizeof(git_blame__entry));
 		add_blame_entry(blame, new_entry);
 
 		/* ... and the middle part -- parent */
 		new_entry = git__malloc(sizeof(*new_entry));
-		GIT_ERROR_CHECK_ALLOC(new_entry);
 		memcpy(new_entry, &(split[1]), sizeof(git_blame__entry));
 		add_blame_entry(blame, new_entry);
 	} else if (!split[0].suspect && !split[2].suspect) {
@@ -248,22 +246,18 @@ static int split_blame(git_blame *blame, git_blame__entry *split, git_blame__ent
 		/* me and then parent */
 		dup_entry(e, &split[0]);
 		new_entry = git__malloc(sizeof(*new_entry));
-		GIT_ERROR_CHECK_ALLOC(new_entry);
 		memcpy(new_entry, &(split[1]), sizeof(git_blame__entry));
 		add_blame_entry(blame, new_entry);
 	} else {
 		/* parent and then me */
 		dup_entry(e, &split[1]);
 		new_entry = git__malloc(sizeof(*new_entry));
-		GIT_ERROR_CHECK_ALLOC(new_entry);
 		memcpy(new_entry, &(split[2]), sizeof(git_blame__entry));
 		add_blame_entry(blame, new_entry);
 	}
-
-	return 0;
 }
 
-/*
+/* 
  * After splitting the blame, the origins used by the on-stack blame_entry
  * should lose one refcnt each.
  */
@@ -278,7 +272,7 @@ static void decref_split(git_blame__entry *split)
  * Helper for blame_chunk(). blame_entry e is known to overlap with the patch
  * hunk; split it and pass blame to the parent.
  */
-static int blame_overlap(
+static void blame_overlap(
 		git_blame *blame,
 		git_blame__entry *e,
 		size_t tlno,
@@ -290,11 +284,8 @@ static int blame_overlap(
 
 	split_overlap(split, e, tlno, plno, same, parent);
 	if (split[1].suspect)
-		if (split_blame(blame, split, e) < 0)
-			return -1;
+		split_blame(blame, split, e);
 	decref_split(split);
-
-	return 0;
 }
 
 /*
@@ -302,7 +293,7 @@ static int blame_overlap(
  * e and its parent. Find and split the overlap, and pass blame to the
  * overlapping part to the parent.
  */
-static int blame_chunk(
+static void blame_chunk(
 		git_blame *blame,
 		size_t tlno,
 		size_t plno,
@@ -318,12 +309,9 @@ static int blame_chunk(
 		if (same <= e->s_lno)
 			continue;
 		if (tlno < e->s_lno + e->num_lines) {
-			if (blame_overlap(blame, e, tlno, plno, same, parent) < 0)
-				return -1;
+			blame_overlap(blame, e, tlno, plno, same, parent);
 		}
 	}
-
-	return 0;
 }
 
 static int my_emit(
@@ -333,8 +321,7 @@ static int my_emit(
 {
 	blame_chunk_cb_data *d = (blame_chunk_cb_data *)cb_data;
 
-	if (blame_chunk(d->blame, d->tlno, d->plno, start_b, d->target, d->parent) < 0)
-		return -1;
+	blame_chunk(d->blame, d->tlno, d->plno, start_b, d->target, d->parent);
 	d->plno = start_a + count_a;
 	d->tlno = start_b + count_b;
 
@@ -378,7 +365,7 @@ static int diff_hunks(mmfile_t file_a, mmfile_t file_b, void *cb_data)
 
 	if (file_a.size > GIT_XDIFF_MAX_SIZE ||
 		file_b.size > GIT_XDIFF_MAX_SIZE) {
-		git_error_set(GIT_ERROR_INVALID, "file too large to blame");
+		giterr_set(GITERR_INVALID, "file too large to blame");
 		return -1;
 	}
 
@@ -413,8 +400,7 @@ static int pass_blame_to_parent(
 		return -1;
 
 	/* The reset (i.e. anything after tlno) are the same as the parent */
-	if (blame_chunk(blame, d.tlno, d.plno, last_in_target, target, parent) < 0)
-		return -1;
+	blame_chunk(blame, d.tlno, d.plno, last_in_target, target, parent);
 
 	return 0;
 }
@@ -500,7 +486,7 @@ static int pass_whole_blame(git_blame *blame,
 
 	if (!porigin->blob &&
 	    git_object_lookup((git_object**)&porigin->blob, blame->repository,
-				git_blob_id(origin->blob), GIT_OBJECT_BLOB) < 0)
+				git_blob_id(origin->blob), GIT_OBJ_BLOB) < 0)
 		return -1;
 	for (e=blame->ent; e; e=e->next) {
 		if (!same_suspect(e->suspect, origin))
@@ -536,7 +522,7 @@ static int pass_blame(git_blame *blame, git_blame__origin *origin, uint32_t opt)
 		memset(sg_buf, 0, sizeof(sg_buf));
 	else {
 		sg_origin = git__calloc(num_parents, sizeof(*sg_origin));
-		GIT_ERROR_CHECK_ALLOC(sg_origin);
+		GITERR_CHECK_ALLOC(sg_origin);
 	}
 
 	for (i=0; i<num_parents; i++) {
@@ -637,8 +623,6 @@ static void coalesce(git_blame *blame)
 
 int git_blame__like_git(git_blame *blame, uint32_t opt)
 {
-	int error = 0;
-
 	while (true) {
 		git_blame__entry *ent;
 		git_blame__origin *suspect = NULL;
@@ -648,13 +632,13 @@ int git_blame__like_git(git_blame *blame, uint32_t opt)
 			if (!ent->guilty)
 				suspect = ent->suspect;
 		if (!suspect)
-			break;
+			return 0; /* all done */
 
 		/* We'll use this suspect later in the loop, so hold on to it for now. */
 		origin_incref(suspect);
 
-		if ((error = pass_blame(blame, suspect, opt)) < 0)
-			break;
+		if (pass_blame(blame, suspect, opt) < 0)
+			return -1;
 
 		/* Take responsibility for the remaining entries */
 		for (ent = blame->ent; ent; ent = ent->next) {
@@ -668,10 +652,9 @@ int git_blame__like_git(git_blame *blame, uint32_t opt)
 		origin_decref(suspect);
 	}
 
-	if (!error)
-		coalesce(blame);
+	coalesce(blame);
 
-	return error;
+	return 0;
 }
 
 void git_blame__free_entry(git_blame__entry *ent)

data/vendor/libgit2/src/blob.c

@@ -19,58 +19,38 @@
 const void *git_blob_rawcontent(const git_blob *blob)
 {
 	assert(blob);
-	if (blob->raw)
-		return blob->data.raw.data;
-	else
-		return git_odb_object_data(blob->data.odb);
+	return git_odb_object_data(blob->odb_object);
 }
 
-git_object_size_t git_blob_rawsize(const git_blob *blob)
+git_off_t git_blob_rawsize(const git_blob *blob)
 {
 	assert(blob);
-	if (blob->raw)
-		return blob->data.raw.size;
-	else
-		return (git_object_size_t)git_odb_object_size(blob->data.odb);
+	return (git_off_t)git_odb_object_size(blob->odb_object);
 }
 
 int git_blob__getbuf(git_buf *buffer, git_blob *blob)
 {
-	git_object_size_t size = git_blob_rawsize(blob);
-
-	GIT_ERROR_CHECK_BLOBSIZE(size);
-	return git_buf_set(buffer, git_blob_rawcontent(blob), (size_t)size);
+	return git_buf_set(
+		buffer,
+		git_odb_object_data(blob->odb_object),
+		git_odb_object_size(blob->odb_object));
 }
 
-void git_blob__free(void *_blob)
+void git_blob__free(void *blob)
 {
-	git_blob *blob = (git_blob *) _blob;
-	if (!blob->raw)
-		git_odb_object_free(blob->data.odb);
+	git_odb_object_free(((git_blob *)blob)->odb_object);
 	git__free(blob);
 }
 
-int git_blob__parse_raw(void *_blob, const char *data, size_t size)
-{
-	git_blob *blob = (git_blob *) _blob;
-	assert(blob);
-	blob->raw = 1;
-	blob->data.raw.data = data;
-	blob->data.raw.size = size;
-	return 0;
-}
-
-int git_blob__parse(void *_blob, git_odb_object *odb_obj)
+int git_blob__parse(void *blob, git_odb_object *odb_obj)
 {
-	git_blob *blob = (git_blob *) _blob;
 	assert(blob);
 	git_cached_obj_incref((git_cached_obj *)odb_obj);
-	blob->raw = 0;
-	blob->data.odb = odb_obj;
+	((git_blob *)blob)->odb_object = odb_obj;
 	return 0;
 }
 
-int git_blob_create_from_buffer(
+int git_blob_create_frombuffer(
 	git_oid *id, git_repository *repo, const void *buffer, size_t len)
 {
 	int error;
@@ -80,7 +60,7 @@ int git_blob_create_from_buffer(
 	assert(id && repo);
 
 	if ((error = git_repository_odb__weakptr(&odb, repo)) < 0 ||
-		(error = git_odb_open_wstream(&stream, odb, len, GIT_OBJECT_BLOB)) < 0)
+		(error = git_odb_open_wstream(&stream, odb, len, GIT_OBJ_BLOB)) < 0)
 		return error;
 
 	if ((error = git_odb_stream_write(stream, buffer, len)) == 0)
@@ -91,16 +71,16 @@ int git_blob_create_from_buffer(
 }
 
 static int write_file_stream(
-	git_oid *id, git_odb *odb, const char *path, git_object_size_t file_size)
+	git_oid *id, git_odb *odb, const char *path, git_off_t file_size)
 {
 	int fd, error;
 	char buffer[FILEIO_BUFSIZE];
 	git_odb_stream *stream = NULL;
 	ssize_t read_len = -1;
-	git_object_size_t written = 0;
+	git_off_t written = 0;
 
 	if ((error = git_odb_open_wstream(
-			&stream, odb, file_size, GIT_OBJECT_BLOB)) < 0)
+			&stream, odb, file_size, GIT_OBJ_BLOB)) < 0)
 		return error;
 
 	if ((fd = git_futils_open_ro(path)) < 0) {
@@ -116,7 +96,7 @@ static int write_file_stream(
 	p_close(fd);
 
 	if (written != file_size || read_len < 0) {
-		git_error_set(GIT_ERROR_OS, "failed to read file into stream");
+		giterr_set(GITERR_OS, "failed to read file into stream");
 		error = -1;
 	}
 
@@ -129,7 +109,7 @@ static int write_file_stream(
 
 static int write_file_filtered(
 	git_oid *id,
-	git_object_size_t *size,
+	git_off_t *size,
 	git_odb *odb,
 	const char *full_path,
 	git_filter_list *fl)
@@ -143,10 +123,10 @@ static int write_file_filtered(
 	if (!error) {
 		*size = tgt.size;
 
-		error = git_odb_write(id, odb, tgt.ptr, tgt.size, GIT_OBJECT_BLOB);
+		error = git_odb_write(id, odb, tgt.ptr, tgt.size, GIT_OBJ_BLOB);
 	}
 
-	git_buf_dispose(&tgt);
+	git_buf_free(&tgt);
 	return error;
 }
 
@@ -158,16 +138,16 @@ static int write_symlink(
 	int error;
 
 	link_data = git__malloc(link_size);
-	GIT_ERROR_CHECK_ALLOC(link_data);
+	GITERR_CHECK_ALLOC(link_data);
 
 	read_len = p_readlink(path, link_data, link_size);
 	if (read_len != (ssize_t)link_size) {
-		git_error_set(GIT_ERROR_OS, "failed to create blob: cannot read symlink '%s'", path);
+		giterr_set(GITERR_OS, "failed to create blob: cannot read symlink '%s'", path);
 		git__free(link_data);
 		return -1;
 	}
 
-	error = git_odb_write(id, odb, (void *)link_data, link_size, GIT_OBJECT_BLOB);
+	error = git_odb_write(id, odb, (void *)link_data, link_size, GIT_OBJ_BLOB);
 	git__free(link_data);
 	return error;
 }
@@ -184,7 +164,7 @@ int git_blob__create_from_paths(
 	int error;
 	struct stat st;
 	git_odb *odb = NULL;
-	git_object_size_t size;
+	git_off_t size;
 	mode_t mode;
 	git_buf path = GIT_BUF_INIT;
 
@@ -206,7 +186,7 @@ int git_blob__create_from_paths(
 		goto done;
 
 	if (S_ISDIR(st.st_mode)) {
-		git_error_set(GIT_ERROR_ODB, "cannot create blob from '%s': it is a directory", content_path);
+		giterr_set(GITERR_ODB, "cannot create blob from '%s': it is a directory", content_path);
 		error = GIT_EDIRECTORY;
 		goto done;
 	}
@@ -258,18 +238,18 @@ int git_blob__create_from_paths(
 
 done:
 	git_odb_free(odb);
-	git_buf_dispose(&path);
+	git_buf_free(&path);
 
 	return error;
 }
 
-int git_blob_create_from_workdir(
+int git_blob_create_fromworkdir(
 	git_oid *id, git_repository *repo, const char *path)
 {
 	return git_blob__create_from_paths(id, NULL, repo, NULL, path, 0, true);
 }
 
-int git_blob_create_from_disk(
+int git_blob_create_fromdisk(
 	git_oid *id, git_repository *repo, const char *path)
 {
 	int error;
@@ -277,7 +257,7 @@ int git_blob_create_from_disk(
 	const char *workdir, *hintpath;
 
 	if ((error = git_path_prettify(&full_path, path, NULL)) < 0) {
-		git_buf_dispose(&full_path);
+		git_buf_free(&full_path);
 		return error;
 	}
 
@@ -290,7 +270,7 @@ int git_blob_create_from_disk(
 	error = git_blob__create_from_paths(
 		id, NULL, repo, git_buf_cstr(&full_path), hintpath, 0, true);
 
-	git_buf_dispose(&full_path);
+	git_buf_free(&full_path);
 	return error;
 }
 
@@ -325,7 +305,7 @@ static int blob_writestream_write(git_writestream *_stream, const char *buffer,
 	return git_filebuf_write(&stream->fbuf, buffer, len);
 }
 
-int git_blob_create_from_stream(git_writestream **out, git_repository *repo, const char *hintpath)
+int git_blob_create_fromstream(git_writestream **out, git_repository *repo, const char *hintpath)
 {
 	int error;
 	git_buf path = GIT_BUF_INIT;
@@ -334,11 +314,11 @@ int git_blob_create_from_stream(git_writestream **out, git_repository *repo, con
 	assert(out && repo);
 
 	stream = git__calloc(1, sizeof(blob_writestream));
-	GIT_ERROR_CHECK_ALLOC(stream);
+	GITERR_CHECK_ALLOC(stream);
 
 	if (hintpath) {
 		stream->hintpath = git__strdup(hintpath);
-		GIT_ERROR_CHECK_ALLOC(stream->hintpath);
+		GITERR_CHECK_ALLOC(stream->hintpath);
 	}
 
 	stream->repo = repo;
@@ -360,11 +340,11 @@ cleanup:
 	if (error < 0)
 		blob_writestream_free((git_writestream *) stream);
 
-	git_buf_dispose(&path);
+	git_buf_free(&path);
 	return error;
 }
 
-int git_blob_create_from_stream_commit(git_oid *out, git_writestream *_stream)
+int git_blob_create_fromstream_commit(git_oid *out, git_writestream *_stream)
 {
 	int error;
 	blob_writestream *stream = (blob_writestream *) _stream;
@@ -389,51 +369,34 @@ cleanup:
 int git_blob_is_binary(const git_blob *blob)
 {
 	git_buf content = GIT_BUF_INIT;
-	git_object_size_t size;
 
 	assert(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));
+	git_buf_attach_notowned(&content, blob->odb_object->buffer,
+		min(blob->odb_object->cached.size,
+		GIT_FILTER_BYTES_TO_CHECK_NUL));
 	return git_buf_text_is_binary(&content);
 }
 
-int git_blob_filter(
+int git_blob_filtered_content(
 	git_buf *out,
 	git_blob *blob,
 	const char *path,
-	git_blob_filter_options *given_opts)
+	int check_for_binary_data)
 {
 	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;
 
 	assert(blob && path && out);
 
 	git_buf_sanitize(out);
 
-	GIT_ERROR_CHECK_VERSION(
-		given_opts, GIT_BLOB_FILTER_OPTIONS_VERSION, "git_blob_filter_options");
-
-	if (given_opts != NULL)
-		memcpy(&opts, given_opts, sizeof(git_blob_filter_options));
-
-	if ((opts.flags & GIT_BLOB_FILTER_CHECK_FOR_BINARY) != 0 &&
-	    git_blob_is_binary(blob))
+	if (check_for_binary_data && git_blob_is_binary(blob))
 		return 0;
 
-	if ((opts.flags & GIT_BLOB_FILTER_NO_SYSTEM_ATTRIBUTES) != 0)
-		flags |= GIT_FILTER_NO_SYSTEM_ATTRIBUTES;
-
-	if ((opts.flags & GIT_BLOB_FILTER_ATTTRIBUTES_FROM_HEAD) != 0)
-		flags |= GIT_FILTER_ATTRIBUTES_FROM_HEAD;
-
 	if (!(error = git_filter_list_load(
 			&fl, git_blob_owner(blob), blob, path,
-			GIT_FILTER_TO_WORKTREE, flags))) {
+			GIT_FILTER_TO_WORKTREE, GIT_FILTER_DEFAULT))) {
 
 		error = git_filter_list_apply_to_blob(out, fl, blob);
 
@@ -442,52 +405,3 @@ int git_blob_filter(
 
 	return error;
 }
-
-/* Deprecated functions */
-
-int git_blob_create_frombuffer(
-	git_oid *id, git_repository *repo, const void *buffer, size_t len)
-{
-	return git_blob_create_from_buffer(id, repo, buffer, len);
-}
-
-int git_blob_create_fromworkdir(git_oid *id, git_repository *repo, const char *relative_path)
-{
-	return git_blob_create_from_workdir(id, repo, relative_path);
-}
-
-int git_blob_create_fromdisk(git_oid *id, git_repository *repo, const char *path)
-{
-	return git_blob_create_from_disk(id, repo, path);
-}
-
-int git_blob_create_fromstream(
-    git_writestream **out,
-    git_repository *repo,
-    const char *hintpath)
-{
-	return  git_blob_create_from_stream(out, repo, hintpath);
-}
-
-int git_blob_create_fromstream_commit(
-	git_oid *out,
-	git_writestream *stream)
-{
-	return git_blob_create_from_stream_commit(out, stream);
-}
-
-int git_blob_filtered_content(
-	git_buf *out,
-	git_blob *blob,
-	const char *path,
-	int check_for_binary_data)
-{
-	git_blob_filter_options opts = GIT_BLOB_FILTER_OPTIONS_INIT;
-
-	if (check_for_binary_data)
-		opts.flags |= GIT_BLOB_FILTER_CHECK_FOR_BINARY;
-	else
-		opts.flags &= ~GIT_BLOB_FILTER_CHECK_FOR_BINARY;
-
-	return git_blob_filter(out, blob, path, &opts);
-}