rugged 0.24.0b12 → 0.24.0b13

data/vendor/libgit2/src/curl_stream.c

@@ -79,6 +79,7 @@ static int curls_certificate(git_cert **out, git_stream *stream)
 	for (slist = certinfo->certinfo[0]; slist; slist = slist->next) {
 		char *str = git__strdup(slist->data);
 		GITERR_CHECK_ALLOC(str);
+		git_vector_insert(&strings, str);
 	}
 
 	/* Copy the contents of the vector into a strarray so we can expose them */
@@ -207,11 +208,14 @@ int git_curl_stream_new(git_stream **out, const char *host, const char *port)
 	handle = curl_easy_init();
 	if (handle == NULL) {
 		giterr_set(GITERR_NET, "failed to create curl handle");
+		git__free(st);
 		return -1;
 	}
 
-	if ((error = git__strtol32(&iport, port, NULL, 10)) < 0)
+	if ((error = git__strtol32(&iport, port, NULL, 10)) < 0) {
+		git__free(st);
 		return error;
+	}
 
 	curl_easy_setopt(handle, CURLOPT_URL, host);
 	curl_easy_setopt(handle, CURLOPT_ERRORBUFFER, st->curl_error);

data/vendor/libgit2/src/diff.c

@@ -1371,7 +1371,7 @@ int git_diff_tree_to_index(
 
 	DIFF_FROM_ITERATORS(
 		git_iterator_for_tree(&a, old_tree, &a_opts), iflag,
-		git_iterator_for_index(&b, index, &b_opts), iflag
+		git_iterator_for_index(&b, repo, index, &b_opts), iflag
 	);
 
 	/* if index is in case-insensitive order, re-sort deltas to match */
@@ -1395,7 +1395,7 @@ int git_diff_index_to_workdir(
 		return error;
 
 	DIFF_FROM_ITERATORS(
-		git_iterator_for_index(&a, index, &a_opts),
+		git_iterator_for_index(&a, repo, index, &a_opts),
 		GIT_ITERATOR_INCLUDE_CONFLICTS,
 
 		git_iterator_for_workdir(&b, repo, index, NULL, &b_opts),
@@ -1472,8 +1472,8 @@ int git_diff_index_to_index(
 	assert(diff && old_index && new_index);
 
 	DIFF_FROM_ITERATORS(
-		git_iterator_for_index(&a, old_index, &a_opts), GIT_ITERATOR_DONT_IGNORE_CASE,
-		git_iterator_for_index(&b, new_index, &b_opts), GIT_ITERATOR_DONT_IGNORE_CASE
+		git_iterator_for_index(&a, repo, old_index, &a_opts), GIT_ITERATOR_DONT_IGNORE_CASE,
+		git_iterator_for_index(&b, repo, new_index, &b_opts), GIT_ITERATOR_DONT_IGNORE_CASE
 	);
 
 	/* if index is in case-insensitive order, re-sort deltas to match */

data/vendor/libgit2/src/index.c

@@ -2907,8 +2907,8 @@ int git_index_read_index(
 
 	opts.flags = GIT_ITERATOR_DONT_IGNORE_CASE;
 
-	if ((error = git_iterator_for_index(&index_iterator, index, &opts)) < 0 ||
-		(error = git_iterator_for_index(&new_iterator, (git_index *)new_index, &opts)) < 0)
+	if ((error = git_iterator_for_index(&index_iterator, git_index_owner(index), index, &opts)) < 0 ||
+		(error = git_iterator_for_index(&new_iterator, git_index_owner(new_index), (git_index *)new_index, &opts)) < 0)
 		goto done;
 
 	if (((error = git_iterator_current(&old_entry, index_iterator)) < 0 &&

data/vendor/libgit2/src/iterator.c

@@ -1080,6 +1080,7 @@ static void index_iterator__free(git_iterator *self)
 
 int git_iterator_for_index(
 	git_iterator **iter,
+	git_repository *repo,
 	git_index  *index,
 	git_iterator_options *options)
 {
@@ -1093,7 +1094,7 @@ int git_iterator_for_index(
 	}
 	ii->index = index;
 
-	ITERATOR_BASE_INIT(ii, index, INDEX, git_index_owner(index));
+	ITERATOR_BASE_INIT(ii, index, INDEX, repo);
 
 	if ((error = iterator__update_ignore_case((git_iterator *)ii, options ? options->flags : 0)) < 0) {
 		git_iterator_free((git_iterator *)ii);
@@ -2071,7 +2072,7 @@ int git_iterator_advance_over_with_status(
 
 			if (!error)
 				continue;
-			
+
 			else if (error == GIT_ENOTFOUND) {
 				/* we entered this directory only hoping to find child matches to
 				 * our pathlist (eg, this is `foo` and we had a pathlist entry for

data/vendor/libgit2/src/iterator.h

@@ -95,6 +95,7 @@ extern int git_iterator_for_tree(
  */
 extern int git_iterator_for_index(
 	git_iterator **out,
+	git_repository *repo,
 	git_index *index,
 	git_iterator_options *options);
 

data/vendor/libgit2/src/merge.c

@@ -1985,9 +1985,6 @@ static int create_virtual_base(
 	git_index *index = NULL;
 	git_merge_options virtual_opts = GIT_MERGE_OPTIONS_INIT;
 
-	result = git__calloc(1, sizeof(git_annotated_commit));
-	GITERR_CHECK_ALLOC(result);
-
 	/* Conflicts in the merge base creation do not propagate to conflicts
 	 * in the result; the conflicted base will act as the common ancestor.
 	 */
@@ -2001,6 +1998,8 @@ static int create_virtual_base(
 			recursion_level + 1, &virtual_opts)) < 0)
 		return -1;
 
+	result = git__calloc(1, sizeof(git_annotated_commit));
+	GITERR_CHECK_ALLOC(result);
 	result->type = GIT_ANNOTATED_COMMIT_VIRTUAL;
 	result->index = index;
 
@@ -2084,9 +2083,9 @@ static int iterator_for_annotated_commit(
 	opts.flags = GIT_ITERATOR_DONT_IGNORE_CASE;
 
 	if (commit == NULL) {
-		error = git_iterator_for_nothing(out, &opts); 
+		error = git_iterator_for_nothing(out, &opts);
 	} else if (commit->type == GIT_ANNOTATED_COMMIT_VIRTUAL) {
-		error = git_iterator_for_index(out, commit->index, &opts);
+		error = git_iterator_for_index(out, git_index_owner(commit->index), commit->index, &opts);
 	} else {
 		if (!commit->tree &&
 			(error = git_commit_tree(&commit->tree, commit->commit)) < 0)
@@ -2428,7 +2427,7 @@ static int write_merge_msg(
 	assert(repo && heads);
 
 	entries = git__calloc(heads_len, sizeof(struct merge_msg_entry));
-	GITERR_CHECK_ALLOC(entries); 
+	GITERR_CHECK_ALLOC(entries);
 
 	if (git_vector_init(&matching, heads_len, NULL) < 0) {
 		git__free(entries);
@@ -2482,7 +2481,7 @@ static int write_merge_msg(
 
 	if (matching.length)
 		sep =',';
-	
+
 	if ((error = merge_msg_entries(&matching, entries, heads_len, msg_entry_is_tag)) < 0 ||
 		(error = merge_msg_write_tags(&file, &matching, sep)) < 0)
 		goto cleanup;
@@ -2683,8 +2682,8 @@ static int merge_check_index(size_t *conflicts, git_repository *repo, git_index
 	iter_opts.pathlist.strings = (char **)staged_paths.contents;
 	iter_opts.pathlist.count = staged_paths.length;
 
-	if ((error = git_iterator_for_index(&iter_repo, index_repo, &iter_opts)) < 0 ||
-		(error = git_iterator_for_index(&iter_new, index_new, &iter_opts)) < 0 ||
+	if ((error = git_iterator_for_index(&iter_repo, repo, index_repo, &iter_opts)) < 0 ||
+		(error = git_iterator_for_index(&iter_new, repo, index_new, &iter_opts)) < 0 ||
 		(error = git_diff__from_iterators(&index_diff_list, repo, iter_repo, iter_new, &opts)) < 0)
 		goto done;
 
@@ -2760,7 +2759,7 @@ int git_merge__check_result(git_repository *repo, git_index *index_new)
 
 	if ((error = git_repository_head_tree(&head_tree, repo)) < 0 ||
 		(error = git_iterator_for_tree(&iter_head, head_tree, &iter_opts)) < 0 ||
-		(error = git_iterator_for_index(&iter_new, index_new, &iter_opts)) < 0 ||
+		(error = git_iterator_for_index(&iter_new, repo, index_new, &iter_opts)) < 0 ||
 		(error = git_diff__from_iterators(&merged_list, repo, iter_head, iter_new, &opts)) < 0)
 		goto done;
 

data/vendor/libgit2/src/pack-objects.c

@@ -91,7 +91,7 @@ static unsigned name_hash(const char *name)
 static int packbuilder_config(git_packbuilder *pb)
 {
 	git_config *config;
-	int ret;
+	int ret = 0;
 	int64_t val;
 
 	if ((ret = git_repository_config_snapshot(&config, pb->repo)) < 0)
@@ -100,8 +100,10 @@ static int packbuilder_config(git_packbuilder *pb)
 #define config_get(KEY,DST,DFLT) do { \
 	ret = git_config_get_int64(&val, config, KEY); \
 	if (!ret) (DST) = val; \
-	else if (ret == GIT_ENOTFOUND) (DST) = (DFLT); \
-	else if (ret < 0) return -1; } while (0)
+	else if (ret == GIT_ENOTFOUND) { \
+	    (DST) = (DFLT); \
+	    ret = 0; \
+	} else if (ret < 0) goto out; } while (0)
 
 	config_get("pack.deltaCacheSize", pb->max_delta_cache_size,
 		   GIT_PACK_DELTA_CACHE_SIZE);
@@ -113,9 +115,10 @@ static int packbuilder_config(git_packbuilder *pb)
 
 #undef config_get
 
+out:
 	git_config_free(config);
 
-	return 0;
+	return ret;
 }
 
 int git_packbuilder_new(git_packbuilder **out, git_repository *repo)
@@ -605,6 +608,7 @@ static git_pobject **compute_write_order(git_packbuilder *pb)
 	}
 
 	if (wo_end != pb->nr_objects) {
+		git__free(wo);
 		giterr_set(GITERR_INVALID, "invalid write order");
 		return NULL;
 	}

data/vendor/libgit2/src/pack.c

@@ -21,7 +21,7 @@ GIT__USE_OIDMAP
 
 static int packfile_open(struct git_pack_file *p);
 static git_off_t nth_packed_object_offset(const struct git_pack_file *p, uint32_t n);
-int packfile_unpack_compressed(
+static int packfile_unpack_compressed(
 		git_rawobj *obj,
 		struct git_pack_file *p,
 		git_mwindow **w_curs,
@@ -790,7 +790,6 @@ int git_packfile_stream_open(git_packfile_stream *obj, struct git_pack_file *p,
 	obj->zstream.next_out = Z_NULL;
 	st = inflateInit(&obj->zstream);
 	if (st != Z_OK) {
-		git__free(obj);
 		giterr_set(GITERR_ZLIB, "failed to init packfile stream");
 		return -1;
 	}
@@ -843,7 +842,7 @@ void git_packfile_stream_free(git_packfile_stream *obj)
 	inflateEnd(&obj->zstream);
 }
 
-int packfile_unpack_compressed(
+static int packfile_unpack_compressed(
 	git_rawobj *obj,
 	struct git_pack_file *p,
 	git_mwindow **w_curs,

data/vendor/libgit2/src/pack.h

@@ -138,13 +138,6 @@ int git_packfile_resolve_header(
 		git_off_t offset);
 
 int git_packfile_unpack(git_rawobj *obj, struct git_pack_file *p, git_off_t *obj_offset);
-int packfile_unpack_compressed(
-	git_rawobj *obj,
-	struct git_pack_file *p,
-	git_mwindow **w_curs,
-	git_off_t *curpos,
-	size_t size,
-	git_otype type);
 
 int git_packfile_stream_open(git_packfile_stream *obj, struct git_pack_file *p, git_off_t curpos);
 ssize_t git_packfile_stream_read(git_packfile_stream *obj, void *buffer, size_t len);

data/vendor/libgit2/src/pathspec.c

@@ -550,7 +550,7 @@ int git_pathspec_match_index(
 
 	iter_opts.flags = pathspec_match_iter_flags(flags);
 
-	if (!(error = git_iterator_for_index(&iter, index, &iter_opts))) {
+	if (!(error = git_iterator_for_index(&iter, git_index_owner(index), index, &iter_opts))) {
 		error = pathspec_match_from_iterator(out, iter, flags, ps);
 		git_iterator_free(iter);
 	}
@@ -718,4 +718,3 @@ const char * git_pathspec_match_list_failed_entry(
 
 	return entry ? *entry : NULL;
 }
-

data/vendor/libgit2/src/rebase.c

@@ -63,17 +63,23 @@ struct git_rebase {
 	char *state_path;
 
 	int head_detached : 1,
+		inmemory : 1,
 		quiet : 1,
 		started : 1;
 
-	char *orig_head_name;
+	git_array_t(git_rebase_operation) operations;
+	size_t current;
+
+	/* Used by in-memory rebase */
+	git_index *index;
+	git_commit *last_commit;
+
+	/* Used by regular (not in-memory) merge-style rebase */
 	git_oid orig_head_id;
+	char *orig_head_name;
 
 	git_oid onto_id;
 	char *onto_name;
-
-	git_array_t(git_rebase_operation) operations;
-	size_t current;
 };
 
 #define GIT_REBASE_STATE_INIT {0}
@@ -393,6 +399,9 @@ done:
 
 static int rebase_cleanup(git_rebase *rebase)
 {
+	if (!rebase || rebase->inmemory)
+		return 0;
+
 	return git_path_isdir(rebase->state_path) ?
 		git_futils_rmdir_r(rebase->state_path, NULL, GIT_RMDIR_REMOVE_FILES) :
 		0;
@@ -600,62 +609,66 @@ static int rebase_init_merge(
 	const git_annotated_commit *branch,
 	const git_annotated_commit *upstream,
 	const git_annotated_commit *onto)
-{
-	if (rebase_init_operations(rebase, repo, branch, upstream, onto) < 0)
-		return -1;
-
-	rebase->onto_name = git__strdup(rebase_onto_name(onto));
-	GITERR_CHECK_ALLOC(rebase->onto_name);
-
-	return 0;
-}
-
-static int rebase_init(
-	git_rebase *rebase,
-	git_repository *repo,
-	const git_annotated_commit *branch,
-	const git_annotated_commit *upstream,
-	const git_annotated_commit *onto)
 {
 	git_reference *head_ref = NULL;
-	git_annotated_commit *head_branch = NULL;
+	git_commit *onto_commit = NULL;
+	git_buf reflog = GIT_BUF_INIT;
 	git_buf state_path = GIT_BUF_INIT;
 	int error;
 
+	GIT_UNUSED(upstream);
+
 	if ((error = git_buf_joinpath(&state_path, repo->path_repository, REBASE_MERGE_DIR)) < 0)
 		goto done;
 
-	if (!branch) {
-		if ((error = git_repository_head(&head_ref, repo)) < 0 ||
-			(error = git_annotated_commit_from_ref(&head_branch, repo, head_ref)) < 0)
-			goto done;
-
-		branch = head_branch;
-	}
-
-	rebase->repo = repo;
-	rebase->type = GIT_REBASE_TYPE_MERGE;
 	rebase->state_path = git_buf_detach(&state_path);
+	GITERR_CHECK_ALLOC(rebase->state_path);
+
 	rebase->orig_head_name = git__strdup(branch->ref_name ? branch->ref_name : ORIG_DETACHED_HEAD);
+	GITERR_CHECK_ALLOC(rebase->orig_head_name);
+
+	rebase->onto_name = git__strdup(rebase_onto_name(onto));
+	GITERR_CHECK_ALLOC(rebase->onto_name);
+
 	rebase->quiet = rebase->options.quiet;
 
 	git_oid_cpy(&rebase->orig_head_id, git_annotated_commit_id(branch));
 	git_oid_cpy(&rebase->onto_id, git_annotated_commit_id(onto));
 
-	if (!rebase->orig_head_name || !rebase->state_path)
-		return -1;
-
-	error = rebase_init_merge(rebase, repo, branch, upstream, onto);
-
-	git_buf_free(&state_path);
+	if ((error = rebase_setupfiles(rebase)) < 0 ||
+		(error = git_buf_printf(&reflog,
+			"rebase: checkout %s", rebase_onto_name(onto))) < 0 ||
+		(error = git_commit_lookup(
+			&onto_commit, repo, git_annotated_commit_id(onto))) < 0 ||
+		(error = git_checkout_tree(repo,
+			(git_object *)onto_commit, &rebase->options.checkout_options)) < 0 ||
+		(error = git_reference_create(&head_ref, repo, GIT_HEAD_FILE,
+			git_annotated_commit_id(onto), 1, reflog.ptr)) < 0)
+		goto done;
 
 done:
 	git_reference_free(head_ref);
-	git_annotated_commit_free(head_branch);
+	git_commit_free(onto_commit);
+	git_buf_free(&reflog);
+	git_buf_free(&state_path);
 
 	return error;
 }
 
+static int rebase_init_inmemory(
+	git_rebase *rebase,
+	git_repository *repo,
+	const git_annotated_commit *branch,
+	const git_annotated_commit *upstream,
+	const git_annotated_commit *onto)
+{
+	GIT_UNUSED(branch);
+	GIT_UNUSED(upstream);
+
+	return git_commit_lookup(
+		&rebase->last_commit, repo, git_annotated_commit_id(onto));
+}
+
 int git_rebase_init(
 	git_rebase **out,
 	git_repository *repo,
@@ -665,9 +678,9 @@ int git_rebase_init(
 	const git_rebase_options *given_opts)
 {
 	git_rebase *rebase = NULL;
-	git_buf reflog = GIT_BUF_INIT;
-	git_commit *onto_commit = NULL;
+	git_annotated_commit *head_branch = NULL;
 	git_reference *head_ref = NULL;
+	bool inmemory = (given_opts && given_opts->inmemory);
 	int error;
 
 	assert(repo && (upstream || onto));
@@ -677,39 +690,51 @@ int git_rebase_init(
 	if (!onto)
 		onto = upstream;
 
-	if ((error = rebase_check_versions(given_opts)) < 0 ||
-		(error = git_repository__ensure_not_bare(repo, "rebase")) < 0 ||
-		(error = rebase_ensure_not_in_progress(repo)) < 0 ||
-		(error = rebase_ensure_not_dirty(repo, true, true, GIT_ERROR)) < 0 ||
-		(error = git_commit_lookup(
-			&onto_commit, repo, git_annotated_commit_id(onto))) < 0)
-		return error;
+	if ((error = rebase_check_versions(given_opts)) < 0)
+		goto done;
+
+	if (!inmemory) {
+		if ((error = git_repository__ensure_not_bare(repo, "rebase")) < 0 ||
+			(error = rebase_ensure_not_in_progress(repo)) < 0 ||
+			(error = rebase_ensure_not_dirty(repo, true, true, GIT_ERROR)) < 0)
+			goto done;
+	}
+
+	if (!branch) {
+		if ((error = git_repository_head(&head_ref, repo)) < 0 ||
+			(error = git_annotated_commit_from_ref(&head_branch, repo, head_ref)) < 0)
+			goto done;
+
+		branch = head_branch;
+	}
 
 	rebase = rebase_alloc(given_opts);
+	GITERR_CHECK_ALLOC(rebase);
 
-	if ((error = rebase_init(
-			rebase, repo, branch, upstream, onto)) < 0 ||
-		(error = rebase_setupfiles(rebase)) < 0 ||
-		(error = git_buf_printf(&reflog,
-			"rebase: checkout %s", rebase_onto_name(onto))) < 0 ||
-		(error = git_checkout_tree(
-			repo, (git_object *)onto_commit, &rebase->options.checkout_options)) < 0 ||
-		(error = git_reference_create(&head_ref, repo, GIT_HEAD_FILE,
-			git_annotated_commit_id(onto), 1, reflog.ptr)) < 0)
+	rebase->repo = repo;
+	rebase->inmemory = inmemory;
+	rebase->type = GIT_REBASE_TYPE_MERGE;
+
+	if ((error = rebase_init_operations(rebase, repo, branch, upstream, onto)) < 0)
 		goto done;
 
-	*out = rebase;
+	if (inmemory)
+		error = rebase_init_inmemory(rebase, repo, branch, upstream, onto);
+	else
+		rebase_init_merge(rebase, repo, branch ,upstream, onto);
+
+	if (error == 0)
+		*out = rebase;
 
 done:
 	git_reference_free(head_ref);
+	git_annotated_commit_free(head_branch);
+
 	if (error < 0) {
 		rebase_cleanup(rebase);
 		git_rebase_free(rebase);
 	}
 
-	git_commit_free(onto_commit);
-	git_buf_free(&reflog);
-
 	return error;
 }
 
@@ -764,9 +789,6 @@ static int rebase_next_merge(
 
 	*out = NULL;
 
-	if ((error = rebase_movenext(rebase)) < 0)
-		goto done;
-
 	operation = git_array_get(rebase->operations, rebase->current);
 
 	if ((error = git_commit_lookup(&current_commit, rebase->repo, &operation->id)) < 0 ||
@@ -791,7 +813,7 @@ static int rebase_next_merge(
 	if ((error = git_indexwriter_init_for_operation(&indexwriter, rebase->repo, &checkout_opts.checkout_strategy)) < 0 ||
 		(error = rebase_setupfile(rebase, MSGNUM_FILE, -1, "%" PRIuZ "\n", rebase->current+1)) < 0 ||
 		(error = rebase_setupfile(rebase, CURRENT_FILE, -1, "%.*s\n", GIT_OID_HEXSZ, current_idstr)) < 0 ||
-		(error = git_merge_trees(&index, rebase->repo, parent_tree, head_tree, current_tree, NULL)) < 0 ||
+		(error = git_merge_trees(&index, rebase->repo, parent_tree, head_tree, current_tree, &rebase->options.merge_options)) < 0 ||
 		(error = git_merge__check_result(rebase->repo, index)) < 0 ||
 		(error = git_checkout_index(rebase->repo, index, &checkout_opts)) < 0 ||
 		(error = git_indexwriter_commit(&indexwriter)) < 0)
@@ -812,6 +834,49 @@ done:
 	return error;
 }
 
+static int rebase_next_inmemory(
+	git_rebase_operation **out,
+	git_rebase *rebase)
+{
+	git_commit *current_commit = NULL, *parent_commit = NULL;
+	git_tree *current_tree = NULL, *head_tree = NULL, *parent_tree = NULL;
+	git_rebase_operation *operation;
+	git_index *index = NULL;
+	int error;
+
+	*out = NULL;
+
+	operation = git_array_get(rebase->operations, rebase->current);
+
+	if ((error = git_commit_lookup(&current_commit, rebase->repo, &operation->id)) < 0 ||
+		(error = git_commit_tree(&current_tree, current_commit)) < 0 ||
+		(error = git_commit_parent(&parent_commit, current_commit, 0)) < 0 ||
+		(error = git_commit_tree(&parent_tree, parent_commit)) < 0 ||
+		(error = git_commit_tree(&head_tree, rebase->last_commit)) < 0 ||
+		(error = git_merge_trees(&index, rebase->repo, parent_tree, head_tree, current_tree, &rebase->options.merge_options)) < 0)
+		goto done;
+
+	if (!rebase->index) {
+		rebase->index = index;
+		index = NULL;
+	} else {
+		if ((error = git_index_read_index(rebase->index, index)) < 0)
+			goto done;
+	}
+
+	*out = operation;
+
+done:
+	git_commit_free(current_commit);
+	git_commit_free(parent_commit);
+	git_tree_free(current_tree);
+	git_tree_free(head_tree);
+	git_tree_free(parent_tree);
+	git_index_free(index);
+
+	return error;
+}
+
 int git_rebase_next(
 	git_rebase_operation **out,
 	git_rebase *rebase)
@@ -820,66 +885,67 @@ int git_rebase_next(
 
 	assert(out && rebase);
 
-	switch (rebase->type) {
-	case GIT_REBASE_TYPE_MERGE:
+	if ((error = rebase_movenext(rebase)) < 0)
+		return error;
+
+	if (rebase->inmemory)
+		error = rebase_next_inmemory(out, rebase);
+	else if (rebase->type == GIT_REBASE_TYPE_MERGE)
 		error = rebase_next_merge(out, rebase);
-		break;
-	default:
+	else
 		abort();
-	}
 
 	return error;
 }
 
-static int rebase_commit_merge(
-	git_oid *commit_id,
+int git_rebase_inmemory_index(
+	git_index **out,
+	git_rebase *rebase)
+{
+	assert(out && rebase && rebase->index);
+
+	GIT_REFCOUNT_INC(rebase->index);
+	*out = rebase->index;
+
+	return 0;
+}
+
+static int rebase_commit__create(
+	git_commit **out,
 	git_rebase *rebase,
+	git_index *index,
+	git_commit *parent_commit,
 	const git_signature *author,
 	const git_signature *committer,
 	const char *message_encoding,
 	const char *message)
 {
-	git_index *index = NULL;
-	git_reference *head = NULL;
-	git_commit *current_commit = NULL, *head_commit = NULL, *commit = NULL;
 	git_rebase_operation *operation;
-	git_tree *head_tree = NULL, *tree = NULL;
-	git_diff *diff = NULL;
-	git_oid tree_id;
-	git_buf reflog_msg = GIT_BUF_INIT;
-	char old_idstr[GIT_OID_HEXSZ], new_idstr[GIT_OID_HEXSZ];
+	git_commit *current_commit = NULL, *commit = NULL;
+	git_tree *parent_tree = NULL, *tree = NULL;
+	git_oid tree_id, commit_id;
 	int error;
 
 	operation = git_array_get(rebase->operations, rebase->current);
-	assert(operation);
-
-	if ((error = git_repository_index(&index, rebase->repo)) < 0)
-		goto done;
 
 	if (git_index_has_conflicts(index)) {
-		giterr_set(GITERR_REBASE, "Conflicts have not been resolved");
+		giterr_set(GITERR_REBASE, "conflicts have not been resolved");
 		error = GIT_EUNMERGED;
 		goto done;
 	}
 
-	if ((error = rebase_ensure_not_dirty(rebase->repo, false, true, GIT_EUNMERGED)) < 0 ||
-		(error = git_commit_lookup(&current_commit, rebase->repo, &operation->id)) < 0 ||
-		(error = git_repository_head(&head, rebase->repo)) < 0 ||
-		(error = git_reference_peel((git_object **)&head_commit, head, GIT_OBJ_COMMIT)) < 0 ||
-		(error = git_commit_tree(&head_tree, head_commit)) < 0 ||
-		(error = git_diff_tree_to_index(&diff, rebase->repo, head_tree, index, NULL)) < 0)
+	if ((error = git_commit_lookup(&current_commit, rebase->repo, &operation->id)) < 0 ||
+		(error = git_commit_tree(&parent_tree, parent_commit)) < 0 ||
+		(error = git_index_write_tree_to(&tree_id, index, rebase->repo)) < 0 ||
+		(error = git_tree_lookup(&tree, rebase->repo, &tree_id)) < 0)
 		goto done;
 
-	if (git_diff_num_deltas(diff) == 0) {
-		giterr_set(GITERR_REBASE, "This patch has already been applied");
+	if (git_oid_equal(&tree_id, git_tree_id(parent_tree))) {
+		giterr_set(GITERR_REBASE, "this patch has already been applied");
 		error = GIT_EAPPLIED;
 		goto done;
 	}
 
-	if ((error = git_index_write_tree(&tree_id, index)) < 0 ||
-		(error = git_tree_lookup(&tree, rebase->repo, &tree_id)) < 0)
-		goto done;
-
 	if (!author)
 		author = git_commit_author(current_commit);
 
@@ -888,30 +954,100 @@ static int rebase_commit_merge(
 		message = git_commit_message(current_commit);
 	}
 
-	if ((error = git_commit_create(commit_id, rebase->repo, NULL, author,
-			committer, message_encoding, message, tree, 1,
-			(const git_commit **)&head_commit)) < 0 ||
-		(error = git_commit_lookup(&commit, rebase->repo, commit_id)) < 0 ||
+	if ((error = git_commit_create(&commit_id, rebase->repo, NULL, author,
+		committer, message_encoding, message, tree, 1,
+		(const git_commit **)&parent_commit)) < 0 ||
+		(error = git_commit_lookup(&commit, rebase->repo, &commit_id)) < 0)
+		goto done;
+
+	*out = commit;
+
+done:
+	if (error < 0)
+		git_commit_free(commit);
+
+	git_commit_free(current_commit);
+	git_tree_free(parent_tree);
+	git_tree_free(tree);
+
+	return error;
+}
+
+static int rebase_commit_merge(
+	git_oid *commit_id,
+	git_rebase *rebase,
+	const git_signature *author,
+	const git_signature *committer,
+	const char *message_encoding,
+	const char *message)
+{
+	git_rebase_operation *operation;
+	git_reference *head = NULL;
+	git_commit *head_commit = NULL, *commit = NULL;
+	git_index *index = NULL;
+	char old_idstr[GIT_OID_HEXSZ], new_idstr[GIT_OID_HEXSZ];
+	int error;
+
+	operation = git_array_get(rebase->operations, rebase->current);
+	assert(operation);
+
+	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_repository_index(&index, rebase->repo)) < 0 ||
+		(error = rebase_commit__create(&commit, rebase, index, head_commit,
+			author, committer, message_encoding, message)) < 0 ||
 		(error = git_reference__update_for_commit(
-			rebase->repo, NULL, "HEAD", commit_id, "rebase")) < 0)
+			rebase->repo, NULL, "HEAD", git_commit_id(commit), "rebase")) < 0)
 		goto done;
 
-	git_oid_fmt(old_idstr, git_commit_id(current_commit));
-	git_oid_fmt(new_idstr, commit_id);
+	git_oid_fmt(old_idstr, &operation->id);
+	git_oid_fmt(new_idstr, git_commit_id(commit));
 
-	error = rebase_setupfile(rebase, REWRITTEN_FILE, O_CREAT|O_WRONLY|O_APPEND,
-		"%.*s %.*s\n", GIT_OID_HEXSZ, old_idstr, GIT_OID_HEXSZ, new_idstr);
+	if ((error = rebase_setupfile(rebase, REWRITTEN_FILE, O_CREAT|O_WRONLY|O_APPEND,
+		"%.*s %.*s\n", GIT_OID_HEXSZ, old_idstr, GIT_OID_HEXSZ, new_idstr)) < 0)
+		goto done;
+
+	git_oid_cpy(commit_id, git_commit_id(commit));
 
 done:
-	git_buf_free(&reflog_msg);
-	git_commit_free(commit);
-	git_diff_free(diff);
-	git_tree_free(tree);
-	git_tree_free(head_tree);
-	git_commit_free(head_commit);
-	git_commit_free(current_commit);
-	git_reference_free(head);
 	git_index_free(index);
+	git_reference_free(head);
+	git_commit_free(head_commit);
+	git_commit_free(commit);
+	return error;
+}
+
+static int rebase_commit_inmemory(
+	git_oid *commit_id,
+	git_rebase *rebase,
+	const git_signature *author,
+	const git_signature *committer,
+	const char *message_encoding,
+	const char *message)
+{
+	git_rebase_operation *operation;
+	git_commit *commit = NULL;
+	int error = 0;
+
+	operation = git_array_get(rebase->operations, rebase->current);
+
+	assert(operation);
+	assert(rebase->index);
+	assert(rebase->last_commit);
+
+	if ((error = rebase_commit__create(&commit, rebase, rebase->index,
+		rebase->last_commit, author, committer, message_encoding, message)) < 0)
+		goto done;
+
+	git_commit_free(rebase->last_commit);
+	rebase->last_commit = commit;
+
+	git_oid_cpy(commit_id, git_commit_id(commit));
+
+done:
+	if (error < 0)
+		git_commit_free(commit);
 
 	return error;
 }
@@ -928,14 +1064,14 @@ int git_rebase_commit(
 
 	assert(rebase && committer);
 
-	switch (rebase->type) {
-	case GIT_REBASE_TYPE_MERGE:
+	if (rebase->inmemory)
+		error = rebase_commit_inmemory(
+			id, rebase, author, committer, message_encoding, message);
+	else if (rebase->type == GIT_REBASE_TYPE_MERGE)
 		error = rebase_commit_merge(
 			id, rebase, author, committer, message_encoding, message);
-		break;
-	default:
+	else
 		abort();
-	}
 
 	return error;
 }
@@ -948,6 +1084,9 @@ int git_rebase_abort(git_rebase *rebase)
 
 	assert(rebase);
 
+	if (rebase->inmemory)
+		return 0;
+
 	error = rebase->head_detached ?
 		git_reference_create(&orig_head_ref, rebase->repo, GIT_HEAD_FILE,
 			 &rebase->orig_head_id, 1, "rebase: aborting") :
@@ -1125,6 +1264,9 @@ int git_rebase_finish(
 
 	assert(rebase);
 
+	if (rebase->inmemory)
+		return 0;
+
 	git_oid_fmt(onto, &rebase->onto_id);
 
 	if ((error = git_buf_printf(&branch_msg, "rebase finished: %s onto %.*s",
@@ -1182,6 +1324,8 @@ void git_rebase_free(git_rebase *rebase)
 	if (rebase == NULL)
 		return;
 
+	git_index_free(rebase->index);
+	git_commit_free(rebase->last_commit);
 	git__free(rebase->onto_name);
 	git__free(rebase->orig_head_name);
 	git__free(rebase->state_path);