rugged 0.25.0b2 → 0.25.0b3

data/vendor/libgit2/src/blame_git.c

@@ -525,7 +525,8 @@ static int pass_blame(git_blame *blame, git_blame__origin *origin, uint32_t opt)
 		if (sg_origin[i])
 			continue;
 
-		git_commit_parent(&p, origin->commit, i);
+		if ((error = git_commit_parent(&p, origin->commit, i)) < 0)
+			goto finish;
 		porigin = find_origin(blame, p, origin);
 
 		if (!porigin)

data/vendor/libgit2/src/blob.c

@@ -274,64 +274,96 @@ int git_blob_create_fromdisk(
 	return error;
 }
 
-#define BUFFER_SIZE 4096
+typedef struct {
+	git_writestream parent;
+	git_filebuf fbuf;
+	git_repository *repo;
+	char *hintpath;
+} blob_writestream;
+
+static int blob_writestream_close(git_writestream *_stream)
+{
+	blob_writestream *stream = (blob_writestream *) _stream;
 
-int git_blob_create_fromchunks(
-	git_oid *id,
-	git_repository *repo,
-	const char *hintpath,
-	int (*source_cb)(char *content, size_t max_length, void *payload),
-	void *payload)
+	git_filebuf_cleanup(&stream->fbuf);
+	return 0;
+}
+
+static void blob_writestream_free(git_writestream *_stream)
+{
+	blob_writestream *stream = (blob_writestream *) _stream;
+
+	git_filebuf_cleanup(&stream->fbuf);
+	git__free(stream->hintpath);
+	git__free(stream);
+}
+
+static int blob_writestream_write(git_writestream *_stream, const char *buffer, size_t len)
+{
+	blob_writestream *stream = (blob_writestream *) _stream;
+
+	return git_filebuf_write(&stream->fbuf, buffer, len);
+}
+
+int git_blob_create_fromstream(git_writestream **out, git_repository *repo, const char *hintpath)
 {
 	int error;
-	char *content = NULL;
-	git_filebuf file = GIT_FILEBUF_INIT;
 	git_buf path = GIT_BUF_INIT;
+	blob_writestream *stream;
 
-	assert(id && repo && source_cb);
+	assert(out && repo);
 
-	if ((error = git_buf_joinpath(
-			&path, git_repository_path(repo), GIT_OBJECTS_DIR "streamed")) < 0)
-		goto cleanup;
+	stream = git__calloc(1, sizeof(blob_writestream));
+	GITERR_CHECK_ALLOC(stream);
 
-	content = git__malloc(BUFFER_SIZE);
-	GITERR_CHECK_ALLOC(content);
+	if (hintpath) {
+		stream->hintpath = git__strdup(hintpath);
+		GITERR_CHECK_ALLOC(stream->hintpath);
+	}
 
-	if ((error = git_filebuf_open(
-			&file, git_buf_cstr(&path), GIT_FILEBUF_TEMPORARY, 0666)) < 0)
+	stream->repo = repo;
+	stream->parent.write = blob_writestream_write;
+	stream->parent.close = blob_writestream_close;
+	stream->parent.free  = blob_writestream_free;
+
+	if ((error = git_buf_joinpath(&path,
+				      git_repository_path(repo), GIT_OBJECTS_DIR "streamed")) < 0)
 		goto cleanup;
 
-	while (1) {
-		int read_bytes = source_cb(content, BUFFER_SIZE, payload);
+	if ((error = git_filebuf_open_withsize(&stream->fbuf, git_buf_cstr(&path), GIT_FILEBUF_TEMPORARY,
+					       0666, 2 * 1024 * 1024)) < 0)
+		goto cleanup;
 
-		if (!read_bytes)
-			break;
+	*out = (git_writestream *) stream;
 
-		if (read_bytes > BUFFER_SIZE) {
-			giterr_set(GITERR_OBJECT, "Invalid chunk size while creating blob");
-			error = GIT_EBUFS;
-		} else if (read_bytes < 0) {
-			error = giterr_set_after_callback(read_bytes);
-		} else {
-			error = git_filebuf_write(&file, content, read_bytes);
-		}
+cleanup:
+	if (error < 0)
+		blob_writestream_free((git_writestream *) stream);
 
-		if (error < 0)
-			goto cleanup;
-	}
+	git_buf_free(&path);
+	return error;
+}
 
-	if ((error = git_filebuf_flush(&file)) < 0)
+int git_blob_create_fromstream_commit(git_oid *out, git_writestream *_stream)
+{
+	int error;
+	blob_writestream *stream = (blob_writestream *) _stream;
+
+	/*
+	 * We can make this more officient by avoiding writing to
+	 * disk, but for now let's re-use the helper functions we
+	 * have.
+	 */
+	if ((error = git_filebuf_flush(&stream->fbuf)) < 0)
 		goto cleanup;
 
-	error = git_blob__create_from_paths(
-		id, NULL, repo, file.path_lock, hintpath, 0, hintpath != NULL);
+	error = git_blob__create_from_paths(out, NULL, stream->repo, stream->fbuf.path_lock,
+					    stream->hintpath, 0, !!stream->hintpath);
 
 cleanup:
-	git_buf_free(&path);
-	git_filebuf_cleanup(&file);
-	git__free(content);
-
+	blob_writestream_free(_stream);
 	return error;
+
 }
 
 int git_blob_is_binary(const git_blob *blob)

data/vendor/libgit2/src/branch.c

@@ -121,7 +121,8 @@ int git_branch_create_from_annotated(
 	const git_annotated_commit *commit,
 	int force)
 {
-	return create_branch(ref_out, repository, branch_name, commit->commit, commit->ref_name, force);
+	return create_branch(ref_out,
+		repository, branch_name, commit->commit, commit->description, force);
 }
 
 int git_branch_delete(git_reference *branch)

data/vendor/libgit2/src/checkout.c

@@ -66,8 +66,8 @@ typedef struct {
 	git_vector update_conflicts;
 	git_vector *update_reuc;
 	git_vector *update_names;
-	git_buf path;
-	size_t workdir_len;
+	git_buf target_path;
+	size_t target_len;
 	git_buf tmp;
 	unsigned int strategy;
 	int can_symlink;
@@ -294,14 +294,30 @@ static int checkout_action_no_wd(
 	return checkout_action_common(action, data, delta, NULL);
 }
 
-static bool wd_item_is_removable(git_iterator *iter, const git_index_entry *wd)
+static int checkout_target_fullpath(
+	git_buf **out, checkout_data *data, const char *path)
 {
-	git_buf *full = NULL;
+	git_buf_truncate(&data->target_path, data->target_len);
+
+	if (path && git_buf_puts(&data->target_path, path) < 0)
+		return -1;
+
+	*out = &data->target_path;
+
+	return 0;
+}
+
+static bool wd_item_is_removable(
+	checkout_data *data, const git_index_entry *wd)
+{
+	git_buf *full;
 
 	if (wd->mode != GIT_FILEMODE_TREE)
 		return true;
-	if (git_iterator_current_workdir_path(&full, iter) < 0)
-		return true;
+
+	if (checkout_target_fullpath(&full, data, wd->path) < 0)
+		return false;
+
 	return !full || !git_path_contains(full, DOT_GIT);
 }
 
@@ -363,14 +379,14 @@ static int checkout_action_wd_only(
 		if ((error = checkout_notify(data, notify, NULL, wd)) != 0)
 			return error;
 
-		if (remove && wd_item_is_removable(workdir, wd))
+		if (remove && wd_item_is_removable(data, wd))
 			error = checkout_queue_remove(data, wd->path);
 
 		if (!error)
 			error = git_iterator_advance(wditem, workdir);
 	} else {
 		/* untracked or ignored - can't know which until we advance through */
-		bool over = false, removable = wd_item_is_removable(workdir, wd);
+		bool over = false, removable = wd_item_is_removable(data, wd);
 		git_iterator_status_t untracked_state;
 
 		/* copy the entry for issuing notification callback later */
@@ -378,7 +394,7 @@ static int checkout_action_wd_only(
 		git_buf_sets(&data->tmp, wd->path);
 		saved_wd.path = data->tmp.ptr;
 
-		error = git_iterator_advance_over_with_status(
+		error = git_iterator_advance_over(
 			wditem, &untracked_state, workdir);
 		if (error == GIT_ITEROVER)
 			over = true;
@@ -428,10 +444,12 @@ static bool submodule_is_config_only(
 
 static bool checkout_is_empty_dir(checkout_data *data, const char *path)
 {
-	git_buf_truncate(&data->path, data->workdir_len);
-	if (git_buf_puts(&data->path, path) < 0)
+	git_buf *fullpath;
+
+	if (checkout_target_fullpath(&fullpath, data, path) < 0)
 		return false;
-	return git_path_is_empty_dir(data->path.ptr);
+
+	return git_path_is_empty_dir(fullpath->ptr);
 }
 
 static int checkout_action_with_wd(
@@ -639,7 +657,7 @@ static int checkout_action(
 			if (cmp == 0) {
 				if (wd->mode == GIT_FILEMODE_TREE) {
 					/* case 2 - entry prefixed by workdir tree */
-					error = git_iterator_advance_into_or_over(wditem, workdir);
+					error = git_iterator_advance_into(wditem, workdir);
 					if (error < 0 && error != GIT_ITEROVER)
 						goto done;
 					continue;
@@ -912,7 +930,7 @@ static int checkout_conflicts_load(checkout_data *data, git_iterator *workdir, g
 	git_index *index;
 
 	/* Only write conficts from sources that have them: indexes. */
-	if ((index = git_iterator_get_index(data->target)) == NULL)
+	if ((index = git_iterator_index(data->target)) == NULL)
 		return 0;
 
 	data->update_conflicts._cmp = checkout_conflictdata_cmp;
@@ -1062,7 +1080,7 @@ static int checkout_conflicts_coalesce_renames(
 	size_t i, names;
 	int error = 0;
 
-	if ((index = git_iterator_get_index(data->target)) == NULL)
+	if ((index = git_iterator_index(data->target)) == NULL)
 		return 0;
 
 	/* Juggle entries based on renames */
@@ -1120,7 +1138,7 @@ static int checkout_conflicts_mark_directoryfile(
 	const char *path;
 	int prefixed, error = 0;
 
-	if ((index = git_iterator_get_index(data->target)) == NULL)
+	if ((index = git_iterator_index(data->target)) == NULL)
 		return 0;
 
 	len = git_index_entrycount(index);
@@ -1342,9 +1360,11 @@ fail:
 
 static bool should_remove_existing(checkout_data *data)
 {
-	int ignorecase = 0;
+	int ignorecase;
 
-	git_repository__cvar(&ignorecase, data->repo, GIT_CVAR_IGNORECASE);
+	if (git_repository__cvar(&ignorecase, data->repo, GIT_CVAR_IGNORECASE) < 0) {
+		ignorecase = 0;
+	}
 
 	return (ignorecase &&
 		(data->strategy & GIT_CHECKOUT_DONT_REMOVE_EXISTING) == 0);
@@ -1582,18 +1602,18 @@ static int checkout_submodule_update_index(
 	checkout_data *data,
 	const git_diff_file *file)
 {
+	git_buf *fullpath;
 	struct stat st;
 
 	/* update the index unless prevented */
 	if ((data->strategy & GIT_CHECKOUT_DONT_UPDATE_INDEX) != 0)
 		return 0;
 
-	git_buf_truncate(&data->path, data->workdir_len);
-	if (git_buf_puts(&data->path, file->path) < 0)
+	if (checkout_target_fullpath(&fullpath, data, file->path) < 0)
 		return -1;
 
 	data->perfdata.stat_calls++;
-	if (p_stat(git_buf_cstr(&data->path), &st) < 0) {
+	if (p_stat(fullpath->ptr, &st) < 0) {
 		giterr_set(
 			GITERR_CHECKOUT, "Could not stat submodule %s\n", file->path);
 		return GIT_ENOTFOUND;
@@ -1718,22 +1738,23 @@ static int checkout_blob(
 	checkout_data *data,
 	const git_diff_file *file)
 {
-	int error = 0;
+	git_buf *fullpath;
 	struct stat st;
+	int error = 0;
 
-	git_buf_truncate(&data->path, data->workdir_len);
-	if (git_buf_puts(&data->path, file->path) < 0)
+	if (checkout_target_fullpath(&fullpath, data, file->path) < 0)
 		return -1;
 
 	if ((data->strategy & GIT_CHECKOUT_UPDATE_ONLY) != 0) {
 		int rval = checkout_safe_for_update_only(
-			data, git_buf_cstr(&data->path), file->mode);
+			data, fullpath->ptr, file->mode);
+
 		if (rval <= 0)
 			return rval;
 	}
 
 	error = checkout_write_content(
-		data, &file->id, git_buf_cstr(&data->path), NULL, file->mode, &st);
+		data, &file->id, fullpath->ptr, NULL, file->mode, &st);
 
 	/* update the index unless prevented */
 	if (!error && (data->strategy & GIT_CHECKOUT_DONT_UPDATE_INDEX) == 0)
@@ -1754,18 +1775,21 @@ static int checkout_remove_the_old(
 	git_diff_delta *delta;
 	const char *str;
 	size_t i;
-	const char *workdir = git_buf_cstr(&data->path);
+	git_buf *fullpath;
 	uint32_t flg = GIT_RMDIR_EMPTY_PARENTS |
 		GIT_RMDIR_REMOVE_FILES | GIT_RMDIR_REMOVE_BLOCKERS;
 
 	if (data->opts.checkout_strategy & GIT_CHECKOUT_SKIP_LOCKED_DIRECTORIES)
 		flg |= GIT_RMDIR_SKIP_NONEMPTY;
 
-	git_buf_truncate(&data->path, data->workdir_len);
+	if (checkout_target_fullpath(&fullpath, data, NULL) < 0)
+		return -1;
 
 	git_vector_foreach(&data->diff->deltas, i, delta) {
 		if (actions[i] & CHECKOUT_ACTION__REMOVE) {
-			error = git_futils_rmdir_r(delta->old_file.path, workdir, flg);
+			error = git_futils_rmdir_r(
+				delta->old_file.path, fullpath->ptr, flg);
+
 			if (error < 0)
 				return error;
 
@@ -1782,7 +1806,7 @@ static int checkout_remove_the_old(
 	}
 
 	git_vector_foreach(&data->removes, i, str) {
-		error = git_futils_rmdir_r(str, workdir, flg);
+		error = git_futils_rmdir_r(str, fullpath->ptr, flg);
 		if (error < 0)
 			return error;
 
@@ -1949,13 +1973,13 @@ static int checkout_write_entry(
 	const git_index_entry *side)
 {
 	const char *hint_path = NULL, *suffix;
+	git_buf *fullpath;
 	struct stat st;
 	int error;
 
 	assert (side == conflict->ours || side == conflict->theirs);
 
-	git_buf_truncate(&data->path, data->workdir_len);
-	if (git_buf_puts(&data->path, side->path) < 0)
+	if (checkout_target_fullpath(&fullpath, data, side->path) < 0)
 		return -1;
 
 	if ((conflict->name_collision || conflict->directoryfile) &&
@@ -1969,18 +1993,18 @@ static int checkout_write_entry(
 			suffix = data->opts.their_label ? data->opts.their_label :
 				"theirs";
 
-		if (checkout_path_suffixed(&data->path, suffix) < 0)
+		if (checkout_path_suffixed(fullpath, suffix) < 0)
 			return -1;
 
 		hint_path = side->path;
 	}
 
 	if ((data->strategy & GIT_CHECKOUT_UPDATE_ONLY) != 0 &&
-		(error = checkout_safe_for_update_only(data, git_buf_cstr(&data->path), side->mode)) <= 0)
+		(error = checkout_safe_for_update_only(data, fullpath->ptr, side->mode)) <= 0)
 		return error;
 
 	return checkout_write_content(data,
-		&side->id, git_buf_cstr(&data->path), hint_path, side->mode, &st);
+		&side->id, fullpath->ptr, hint_path, side->mode, &st);
 }
 
 static int checkout_write_entries(
@@ -2293,7 +2317,7 @@ static void checkout_data_clear(checkout_data *data)
 
 	git_strmap_free(data->mkdir_map);
 
-	git_buf_free(&data->path);
+	git_buf_free(&data->target_path);
 	git_buf_free(&data->tmp);
 
 	git_index_free(data->index);
@@ -2356,7 +2380,7 @@ static int checkout_data_init(
 		if ((error = git_repository_index(&data->index, data->repo)) < 0)
 			goto cleanup;
 
-		if (data->index != git_iterator_get_index(target)) {
+		if (data->index != git_iterator_index(target)) {
 			if ((error = git_index_read(data->index, true)) < 0)
 				goto cleanup;
 
@@ -2447,12 +2471,12 @@ static int checkout_data_init(
 	if ((error = git_vector_init(&data->removes, 0, git__strcmp_cb)) < 0 ||
 		(error = git_vector_init(&data->remove_conflicts, 0, NULL)) < 0 ||
 		(error = git_vector_init(&data->update_conflicts, 0, NULL)) < 0 ||
-		(error = git_buf_puts(&data->path, data->opts.target_directory)) < 0 ||
-		(error = git_path_to_dir(&data->path)) < 0 ||
+		(error = git_buf_puts(&data->target_path, data->opts.target_directory)) < 0 ||
+		(error = git_path_to_dir(&data->target_path)) < 0 ||
 		(error = git_strmap_alloc(&data->mkdir_map)) < 0)
 		goto cleanup;
 
-	data->workdir_len = git_buf_len(&data->path);
+	data->target_len = git_buf_len(&data->target_path);
 
 	git_attr_session__init(&data->attr_session, data->repo);
 
@@ -2508,7 +2532,7 @@ int git_checkout_iterator(
 	workdir_opts.start = data.pfx;
 	workdir_opts.end = data.pfx;
 
-	if ((error = git_iterator_reset(target, data.pfx, data.pfx)) < 0 ||
+	if ((error = git_iterator_reset_range(target, data.pfx, data.pfx)) < 0 ||
 		(error = git_iterator_for_workdir_ext(
 			&workdir, data.repo, data.opts.target_directory, index, NULL,
 			&workdir_opts)) < 0)
@@ -2578,7 +2602,7 @@ int git_checkout_iterator(
 		(error = checkout_create_conflicts(&data)) < 0)
 		goto cleanup;
 
-	if (data.index != git_iterator_get_index(target) &&
+	if (data.index != git_iterator_index(target) &&
 		(error = checkout_extensions_update_index(&data)) < 0)
 		goto cleanup;