rugged 1.3.1 → 1.9.0

data/vendor/libgit2/src/{stash.c → libgit2/stash.c}

@@ -9,7 +9,6 @@
 
 #include "repository.h"
 #include "commit.h"
-#include "message.h"
 #include "tree.h"
 #include "reflog.h"
 #include "blob.h"
@@ -26,6 +25,7 @@
 #include "merge.h"
 #include "diff.h"
 #include "diff_generate.h"
+#include "strarray.h"
 
 static int create_error(int error, const char *msg)
 {
@@ -43,20 +43,20 @@ static int retrieve_head(git_reference **out, git_repository *repo)
 	return error;
 }
 
-static int append_abbreviated_oid(git_buf *out, const git_oid *b_commit)
+static int append_abbreviated_oid(git_str *out, const git_oid *b_commit)
 {
 	char *formatted_oid;
 
 	formatted_oid = git_oid_allocfmt(b_commit);
 	GIT_ERROR_CHECK_ALLOC(formatted_oid);
 
-	git_buf_put(out, formatted_oid, 7);
+	git_str_put(out, formatted_oid, 7);
 	git__free(formatted_oid);
 
-	return git_buf_oom(out) ? -1 : 0;
+	return git_str_oom(out) ? -1 : 0;
 }
 
-static int append_commit_description(git_buf *out, git_commit *commit)
+static int append_commit_description(git_str *out, git_commit *commit)
 {
 	const char *summary = git_commit_summary(commit);
 	GIT_ERROR_CHECK_ALLOC(summary);
@@ -64,16 +64,16 @@ static int append_commit_description(git_buf *out, git_commit *commit)
 	if (append_abbreviated_oid(out, git_commit_id(commit)) < 0)
 		return -1;
 
-	git_buf_putc(out, ' ');
-	git_buf_puts(out, summary);
-	git_buf_putc(out, '\n');
+	git_str_putc(out, ' ');
+	git_str_puts(out, summary);
+	git_str_putc(out, '\n');
 
-	return git_buf_oom(out) ? -1 : 0;
+	return git_str_oom(out) ? -1 : 0;
 }
 
 static int retrieve_base_commit_and_message(
 	git_commit **b_commit,
-	git_buf *stash_message,
+	git_str *stash_message,
 	git_repository *repo)
 {
 	git_reference *head = NULL;
@@ -83,9 +83,9 @@ static int retrieve_base_commit_and_message(
 		return error;
 
 	if (strcmp("HEAD", git_reference_name(head)) == 0)
-		error = git_buf_puts(stash_message, "(no branch): ");
+		error = git_str_puts(stash_message, "(no branch): ");
 	else
-		error = git_buf_printf(
+		error = git_str_printf(
 			stash_message,
 			"%s: ",
 			git_reference_name(head) + strlen(GIT_REFS_HEADS_DIR));
@@ -128,13 +128,13 @@ static int commit_index(
 {
 	git_tree *i_tree = NULL;
 	git_oid i_commit_oid;
-	git_buf msg = GIT_BUF_INIT;
+	git_str msg = GIT_STR_INIT;
 	int error;
 
 	if ((error = build_tree_from_index(&i_tree, repo, index)) < 0)
 		goto cleanup;
 
-	if ((error = git_buf_printf(&msg, "index on %s\n", message)) < 0)
+	if ((error = git_str_printf(&msg, "index on %s\n", message)) < 0)
 		goto cleanup;
 
 	if ((error = git_commit_create(
@@ -144,7 +144,7 @@ static int commit_index(
 		stasher,
 		stasher,
 		NULL,
-		git_buf_cstr(&msg),
+		git_str_cstr(&msg),
 		i_tree,
 		1,
 		&parent)) < 0)
@@ -154,7 +154,7 @@ static int commit_index(
 
 cleanup:
 	git_tree_free(i_tree);
-	git_buf_dispose(&msg);
+	git_str_dispose(&msg);
 	return error;
 }
 
@@ -194,6 +194,30 @@ static int stash_to_index(
 	return git_index_add(index, &entry);
 }
 
+static int stash_update_index_from_paths(
+	git_repository *repo,
+	git_index *index,
+	const git_strarray *paths)
+{
+	unsigned int status_flags;
+	size_t i;
+	int error = 0;
+
+	for (i = 0; i < paths->count; i++) {
+		git_status_file(&status_flags, repo, paths->strings[i]);
+
+		if (status_flags & (GIT_STATUS_WT_DELETED | GIT_STATUS_INDEX_DELETED)) {
+			if ((error = git_index_remove(index, paths->strings[i], 0)) < 0)
+				return error;
+		} else {
+			if ((error = stash_to_index(repo, index, paths->strings[i])) < 0)
+				return error;
+		}
+	}
+
+	return error;
+}
+
 static int stash_update_index_from_diff(
 	git_repository *repo,
 	git_index *index,
@@ -260,7 +284,7 @@ static int build_untracked_tree(
 	struct stash_update_rules data = {0};
 	int error;
 
-	if ((error = git_index_new(&i_index)) < 0)
+	if ((error = git_index__new(&i_index, repo->oid_type)) < 0)
 		goto cleanup;
 
 	if (flags & GIT_STASH_INCLUDE_UNTRACKED) {
@@ -303,13 +327,13 @@ static int commit_untracked(
 {
 	git_tree *u_tree = NULL;
 	git_oid u_commit_oid;
-	git_buf msg = GIT_BUF_INIT;
+	git_str msg = GIT_STR_INIT;
 	int error;
 
 	if ((error = build_untracked_tree(&u_tree, repo, i_commit, flags)) < 0)
 		goto cleanup;
 
-	if ((error = git_buf_printf(&msg, "untracked files on %s\n", message)) < 0)
+	if ((error = git_str_printf(&msg, "untracked files on %s\n", message)) < 0)
 		goto cleanup;
 
 	if ((error = git_commit_create(
@@ -319,7 +343,7 @@ static int commit_untracked(
 		stasher,
 		stasher,
 		NULL,
-		git_buf_cstr(&msg),
+		git_str_cstr(&msg),
 		u_tree,
 		0,
 		NULL)) < 0)
@@ -329,7 +353,7 @@ static int commit_untracked(
 
 cleanup:
 	git_tree_free(u_tree);
-	git_buf_dispose(&msg);
+	git_str_dispose(&msg);
 	return error;
 }
 
@@ -389,26 +413,81 @@ cleanup:
 	return error;
 }
 
-static int commit_worktree(
+static int build_stash_commit_from_tree(
 	git_oid *w_commit_oid,
 	git_repository *repo,
 	const git_signature *stasher,
 	const char *message,
 	git_commit *i_commit,
 	git_commit *b_commit,
-	git_commit *u_commit)
+	git_commit *u_commit,
+	const git_tree *tree)
 {
 	const git_commit *parents[] = {	NULL, NULL, NULL };
-	git_index *i_index = NULL, *r_index = NULL;
-	git_tree *w_tree = NULL;
-	int error = 0, ignorecase;
 
 	parents[0] = b_commit;
 	parents[1] = i_commit;
 	parents[2] = u_commit;
 
+	return git_commit_create(
+		w_commit_oid,
+		repo,
+		NULL,
+		stasher,
+		stasher,
+		NULL,
+		message,
+		tree,
+		u_commit ? 3 : 2,
+		parents);
+}
+
+static int build_stash_commit_from_index(
+	git_oid *w_commit_oid,
+	git_repository *repo,
+	const git_signature *stasher,
+	const char *message,
+	git_commit *i_commit,
+	git_commit *b_commit,
+	git_commit *u_commit,
+	git_index *index)
+{
+	git_tree *tree;
+	int error;
+
+	if ((error = build_tree_from_index(&tree, repo, index)) < 0)
+		goto cleanup;
+
+	error = build_stash_commit_from_tree(
+		w_commit_oid,
+		repo,
+		stasher,
+		message,
+		i_commit,
+		b_commit,
+		u_commit,
+		tree);
+
+cleanup:
+	git_tree_free(tree);
+	return error;
+}
+
+static int commit_worktree(
+	git_oid *w_commit_oid,
+	git_repository *repo,
+	const git_signature *stasher,
+	const char *message,
+	git_commit *i_commit,
+	git_commit *b_commit,
+	git_commit *u_commit)
+{
+	git_index *i_index = NULL, *r_index = NULL;
+	git_tree *w_tree = NULL;
+	int error = 0, ignorecase;
+
 	if ((error = git_repository_index(&r_index, repo) < 0) ||
-	    (error = git_index_new(&i_index)) < 0 ||
+	    (error = git_index__new(&i_index, repo->oid_type)) < 0 ||
 	    (error = git_index__fill(i_index, &r_index->entries) < 0) ||
 	    (error = git_repository__configmap_lookup(&ignorecase, repo, GIT_CONFIGMAP_IGNORECASE)) < 0)
 		goto cleanup;
@@ -418,17 +497,16 @@ static int commit_worktree(
 	if ((error = build_workdir_tree(&w_tree, repo, i_index, b_commit)) < 0)
 		goto cleanup;
 
-	error = git_commit_create(
+	error = build_stash_commit_from_tree(
 		w_commit_oid,
 		repo,
-		NULL,
-		stasher,
 		stasher,
-		NULL,
 		message,
-		w_tree,
-		u_commit ? 3 : 2,
-		parents);
+		i_commit,
+		b_commit,
+		u_commit,
+		w_tree
+	);
 
 cleanup:
 	git_tree_free(w_tree);
@@ -437,33 +515,33 @@ cleanup:
 	return error;
 }
 
-static int prepare_worktree_commit_message(git_buf *out, const char *user_message)
+static int prepare_worktree_commit_message(git_str *out, const char *user_message)
 {
-	git_buf buf = GIT_BUF_INIT;
+	git_str buf = GIT_STR_INIT;
 	int error = 0;
 
 	if (!user_message) {
-		git_buf_printf(&buf, "WIP on %s", git_buf_cstr(out));
+		git_str_printf(&buf, "WIP on %s", git_str_cstr(out));
 	} else {
 		const char *colon;
 
-		if ((colon = strchr(git_buf_cstr(out), ':')) == NULL)
+		if ((colon = strchr(git_str_cstr(out), ':')) == NULL)
 			goto cleanup;
 
-		git_buf_puts(&buf, "On ");
-		git_buf_put(&buf, git_buf_cstr(out), colon - out->ptr);
-		git_buf_printf(&buf, ": %s\n", user_message);
+		git_str_puts(&buf, "On ");
+		git_str_put(&buf, git_str_cstr(out), colon - out->ptr);
+		git_str_printf(&buf, ": %s\n", user_message);
 	}
 
-	if (git_buf_oom(&buf)) {
+	if (git_str_oom(&buf)) {
 		error = -1;
 		goto cleanup;
 	}
 
-	git_buf_swap(out, &buf);
+	git_str_swap(out, &buf);
 
 cleanup:
-	git_buf_dispose(&buf);
+	git_str_dispose(&buf);
 	return error;
 }
 
@@ -521,6 +599,54 @@ static int ensure_there_are_changes_to_stash(git_repository *repo, uint32_t flag
 	return error;
 }
 
+static int has_changes_cb(
+	const char *path,
+	unsigned int status,
+	void *payload)
+{
+	GIT_UNUSED(path);
+	GIT_UNUSED(status);
+	GIT_UNUSED(payload);
+
+	if (status == GIT_STATUS_CURRENT)
+		return GIT_ENOTFOUND;
+
+	return 0;
+}
+
+static int ensure_there_are_changes_to_stash_paths(
+	git_repository *repo,
+	uint32_t flags,
+	const git_strarray *paths)
+{
+	int error;
+	git_status_options opts = GIT_STATUS_OPTIONS_INIT;
+
+	opts.show  = GIT_STATUS_SHOW_INDEX_AND_WORKDIR;
+	opts.flags = GIT_STATUS_OPT_EXCLUDE_SUBMODULES |
+	             GIT_STATUS_OPT_INCLUDE_UNMODIFIED |
+		     GIT_STATUS_OPT_DISABLE_PATHSPEC_MATCH;
+
+	if (flags & GIT_STASH_INCLUDE_UNTRACKED)
+		opts.flags |= GIT_STATUS_OPT_INCLUDE_UNTRACKED |
+			GIT_STATUS_OPT_RECURSE_UNTRACKED_DIRS;
+
+	if (flags & GIT_STASH_INCLUDE_IGNORED)
+		opts.flags |= GIT_STATUS_OPT_INCLUDE_IGNORED |
+			GIT_STATUS_OPT_RECURSE_IGNORED_DIRS;
+
+	git_strarray_copy(&opts.pathspec, paths);
+
+	error = git_status_foreach_ext(repo, &opts, has_changes_cb, NULL);
+
+	git_strarray_dispose(&opts.pathspec);
+
+	if (error == GIT_ENOTFOUND)
+		return create_error(GIT_ENOTFOUND, "one of the files does not have any changes to stash.");
+
+	return error;
+}
+
 static int reset_index_and_workdir(git_repository *repo, git_commit *commit, uint32_t flags)
 {
 	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
@@ -541,14 +667,36 @@ int git_stash_save(
 	const char *message,
 	uint32_t flags)
 {
-	git_index *index = NULL;
+	git_stash_save_options opts = GIT_STASH_SAVE_OPTIONS_INIT;
+
+	GIT_ASSERT_ARG(stasher);
+
+	opts.stasher = stasher;
+	opts.message = message;
+	opts.flags = flags;
+
+	return git_stash_save_with_opts(out, repo, &opts);
+}
+
+int git_stash_save_with_opts(
+	git_oid *out,
+	git_repository *repo,
+	const git_stash_save_options *opts)
+{
+	git_index *index = NULL, *paths_index = NULL;
 	git_commit *b_commit = NULL, *i_commit = NULL, *u_commit = NULL;
-	git_buf msg = GIT_BUF_INIT;
+	git_str msg = GIT_STR_INIT;
+	git_tree *tree = NULL;
+	git_reference *head = NULL;
+	bool has_paths = false;
+
 	int error;
 
 	GIT_ASSERT_ARG(out);
 	GIT_ASSERT_ARG(repo);
-	GIT_ASSERT_ARG(stasher);
+	GIT_ASSERT_ARG(opts && opts->stasher);
+
+	has_paths = opts->paths.count > 0;
 
 	if ((error = git_repository__ensure_not_bare(repo, "stash save")) < 0)
 		return error;
@@ -556,44 +704,63 @@ int git_stash_save(
 	if ((error = retrieve_base_commit_and_message(&b_commit, &msg, repo)) < 0)
 		goto cleanup;
 
-	if ((error = ensure_there_are_changes_to_stash(repo, flags)) < 0)
+	if (!has_paths &&
+		  (error = ensure_there_are_changes_to_stash(repo, opts->flags)) < 0)
+		goto cleanup;
+	else if (has_paths &&
+		  (error = ensure_there_are_changes_to_stash_paths(
+			  repo, opts->flags, &opts->paths)) < 0)
 		goto cleanup;
 
 	if ((error = git_repository_index(&index, repo)) < 0)
 		goto cleanup;
 
-	if ((error = commit_index(&i_commit, repo, index, stasher,
-				  git_buf_cstr(&msg), b_commit)) < 0)
+	if ((error = commit_index(&i_commit, repo, index, opts->stasher,
+				  git_str_cstr(&msg), b_commit)) < 0)
 		goto cleanup;
 
-	if ((flags & (GIT_STASH_INCLUDE_UNTRACKED | GIT_STASH_INCLUDE_IGNORED)) &&
-	    (error = commit_untracked(&u_commit, repo, stasher,
-				      git_buf_cstr(&msg), i_commit, flags)) < 0)
+	if ((opts->flags & (GIT_STASH_INCLUDE_UNTRACKED | GIT_STASH_INCLUDE_IGNORED)) &&
+	    (error = commit_untracked(&u_commit, repo, opts->stasher,
+			  git_str_cstr(&msg), i_commit, opts->flags)) < 0)
 		goto cleanup;
 
-	if ((error = prepare_worktree_commit_message(&msg, message)) < 0)
+	if ((error = prepare_worktree_commit_message(&msg, opts->message)) < 0)
 		goto cleanup;
 
-	if ((error = commit_worktree(out, repo, stasher, git_buf_cstr(&msg),
-				     i_commit, b_commit, u_commit)) < 0)
-		goto cleanup;
+	if (!has_paths) {
+		if ((error = commit_worktree(out, repo, opts->stasher, git_str_cstr(&msg),
+					     i_commit, b_commit, u_commit)) < 0)
+			goto cleanup;
+	} else {
+		if ((error = git_index__new(&paths_index, repo->oid_type)) < 0 ||
+		    (error = retrieve_head(&head, repo)) < 0 ||
+		    (error = git_reference_peel((git_object**)&tree, head, GIT_OBJECT_TREE)) < 0 ||
+		    (error = git_index_read_tree(paths_index, tree)) < 0 ||
+		    (error = stash_update_index_from_paths(repo, paths_index, &opts->paths)) < 0 ||
+		    (error = build_stash_commit_from_index(out, repo, opts->stasher, git_str_cstr(&msg),
+				  i_commit, b_commit, u_commit, paths_index)) < 0)
+			goto cleanup;
+	}
 
-	git_buf_rtrim(&msg);
+	git_str_rtrim(&msg);
 
-	if ((error = update_reflog(out, repo, git_buf_cstr(&msg))) < 0)
+	if ((error = update_reflog(out, repo, git_str_cstr(&msg))) < 0)
 		goto cleanup;
 
-	if ((error = reset_index_and_workdir(repo, (flags & GIT_STASH_KEEP_INDEX) ? i_commit : b_commit,
-					     flags)) < 0)
+	if (!(opts->flags & GIT_STASH_KEEP_ALL) &&
+	    (error = reset_index_and_workdir(repo,
+		  (opts->flags & GIT_STASH_KEEP_INDEX) ? i_commit : b_commit,opts->flags)) < 0)
 		goto cleanup;
 
 cleanup:
-
-	git_buf_dispose(&msg);
+	git_str_dispose(&msg);
 	git_commit_free(i_commit);
 	git_commit_free(b_commit);
 	git_commit_free(u_commit);
+	git_tree_free(tree);
+	git_reference_free(head);
 	git_index_free(index);
+	git_index_free(paths_index);
 
 	return error;
 }
@@ -778,6 +945,13 @@ int git_stash_apply_options_init(git_stash_apply_options *opts, unsigned int ver
 	return 0;
 }
 
+int git_stash_save_options_init(git_stash_save_options *opts, unsigned int version)
+{
+	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
+		opts, version, git_stash_save_options, GIT_STASH_SAVE_OPTIONS_INIT);
+	return 0;
+}
+
 #ifndef GIT_DEPRECATE_HARD
 int git_stash_apply_init_options(git_stash_apply_options *opts, unsigned int version)
 {
@@ -829,6 +1003,7 @@ static int stage_new_file(const git_index_entry **entries, void *data)
 
 static int stage_new_files(
 	git_index **out,
+	git_repository *repo,
 	git_tree *parent_tree,
 	git_tree *tree)
 {
@@ -837,7 +1012,7 @@ static int stage_new_files(
 	git_index *index = NULL;
 	int error;
 
-	if ((error = git_index_new(&index)) < 0 ||
+	if ((error = git_index__new(&index, repo->oid_type)) < 0 ||
 		(error = git_iterator_for_tree(
 			&iterators[0], parent_tree, &iterator_options)) < 0 ||
 		(error = git_iterator_for_tree(
@@ -921,10 +1096,10 @@ int git_stash_apply(
 	 * previously unstaged contents are staged, not the previously staged.)
 	 */
 	} else if ((opts.flags & GIT_STASH_APPLY_REINSTATE_INDEX) == 0) {
-		if ((error = stage_new_files(
-				&stash_adds, stash_parent_tree, stash_tree)) < 0 ||
-			(error = merge_indexes(
-				&unstashed_index, repo, stash_parent_tree, repo_index, stash_adds)) < 0)
+		if ((error = stage_new_files(&stash_adds, repo,
+				stash_parent_tree, stash_tree)) < 0 ||
+		    (error = merge_indexes(&unstashed_index, repo,
+				stash_parent_tree, repo_index, stash_adds)) < 0)
 			goto cleanup;
 	}
 

data/vendor/libgit2/src/{status.c → libgit2/status.c}

@@ -84,7 +84,7 @@ static unsigned int workdir_delta2status(
 
 		if (!git_oid_equal(&idx2wd->old_file.id, &idx2wd->new_file.id)) {
 			/* if OIDs don't match, we might need to calculate them now to
-			 * discern between RENAMED vs RENAMED+MODIFED
+			 * discern between RENAMED vs RENAMED+MODIFIED
 			 */
 			if (git_oid_is_zero(&idx2wd->old_file.id) &&
 				diff->old_src == GIT_ITERATOR_WORKDIR &&
@@ -336,6 +336,9 @@ int git_status_list_new(
 			GIT_DIFF_FIND_RENAMES_FROM_REWRITES |
 			GIT_DIFF_BREAK_REWRITES_FOR_RENAMES_ONLY;
 
+	if (opts != NULL && opts->rename_threshold != 0)
+		findopt.rename_threshold = opts->rename_threshold;
+
 	if (show != GIT_STATUS_SHOW_WORKDIR_ONLY) {
 		if ((error = git_diff_tree_to_index(
 				&status->head2idx, repo, head, index, &diffopt)) < 0)
@@ -411,7 +414,7 @@ void git_status_list_free(git_status_list *status)
 	git_diff_free(status->head2idx);
 	git_diff_free(status->idx2wd);
 
-	git_vector_free_deep(&status->paired);
+	git_vector_dispose_deep(&status->paired);
 
 	git__memzero(status, sizeof(*status));
 	git__free(status);

data/vendor/libgit2/src/{strarray.c → libgit2/strarray.c}

@@ -8,6 +8,7 @@
 #include "util.h"
 
 #include "common.h"
+#include "strarray.h"
 
 int git_strarray_copy(git_strarray *tgt, const git_strarray *src)
 {

data/vendor/libgit2/src/libgit2/strarray.h

@@ -0,0 +1,25 @@
+/*
+ * 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_strarray_h__
+#define INCLUDE_strarray_h__
+
+#include "common.h"
+#include "git2/strarray.h"
+
+/**
+ * Copy a string array object from source to target.
+ *
+ * Note: target is overwritten and hence should be empty, otherwise its
+ * contents are leaked.  Call git_strarray_free() if necessary.
+ *
+ * @param tgt target
+ * @param src source
+ * @return 0 on success, < 0 on allocation failure
+ */
+extern int git_strarray_copy(git_strarray *tgt, const git_strarray *src);
+
+#endif