rugged 0.18.0.gh.de28323 → 0.19.0

data/vendor/libgit2/src/merge.h

@@ -7,16 +7,143 @@
 #ifndef INCLUDE_merge_h__
 #define INCLUDE_merge_h__
 
-#include "git2/types.h"
-#include "git2/merge.h"
-#include "commit_list.h"
 #include "vector.h"
+#include "commit_list.h"
+#include "pool.h"
+
+#include "git2/merge.h"
+#include "git2/types.h"
 
 #define GIT_MERGE_MSG_FILE		"MERGE_MSG"
 #define GIT_MERGE_MODE_FILE		"MERGE_MODE"
 
-#define MERGE_CONFIG_FILE_MODE	0666
+#define GIT_MERGE_TREE_RENAME_THRESHOLD	50
+#define GIT_MERGE_TREE_TARGET_LIMIT		1000
+
+/** Types of changes when files are merged from branch to branch. */
+typedef enum {
+	/* No conflict - a change only occurs in one branch. */
+	GIT_MERGE_DIFF_NONE = 0,
+
+	/* Occurs when a file is modified in both branches. */
+	GIT_MERGE_DIFF_BOTH_MODIFIED = (1 << 0),
+
+	/* Occurs when a file is added in both branches. */
+	GIT_MERGE_DIFF_BOTH_ADDED = (1 << 1),
+
+	/* Occurs when a file is deleted in both branches. */
+	GIT_MERGE_DIFF_BOTH_DELETED = (1 << 2),
+
+	/* Occurs when a file is modified in one branch and deleted in the other. */
+	GIT_MERGE_DIFF_MODIFIED_DELETED = (1 << 3),
+
+	/* Occurs when a file is renamed in one branch and modified in the other. */
+	GIT_MERGE_DIFF_RENAMED_MODIFIED = (1 << 4),
+
+	/* Occurs when a file is renamed in one branch and deleted in the other. */
+	GIT_MERGE_DIFF_RENAMED_DELETED = (1 << 5),
+
+	/* Occurs when a file is renamed in one branch and a file with the same
+	 * name is added in the other.  Eg, A->B and new file B.  Core git calls
+	 * this a "rename/delete". */
+	GIT_MERGE_DIFF_RENAMED_ADDED = (1 << 6),
+
+	/* Occurs when both a file is renamed to the same name in the ours and
+	 * theirs branches.  Eg, A->B and A->B in both.  Automergeable. */
+	GIT_MERGE_DIFF_BOTH_RENAMED = (1 << 7),
+
+	/* Occurs when a file is renamed to different names in the ours and theirs
+	 * branches.  Eg, A->B and A->C. */
+	GIT_MERGE_DIFF_BOTH_RENAMED_1_TO_2 = (1 << 8),
+
+	/* Occurs when two files are renamed to the same name in the ours and
+	 * theirs branches.  Eg, A->C and B->C. */
+	GIT_MERGE_DIFF_BOTH_RENAMED_2_TO_1 = (1 << 9),
+
+	/* Occurs when an item at a path in one branch is a directory, and an
+	 * item at the same path in a different branch is a file. */
+	GIT_MERGE_DIFF_DIRECTORY_FILE = (1 << 10),
+
+	/* The child of a folder that is in a directory/file conflict. */
+	GIT_MERGE_DIFF_DF_CHILD = (1 << 11),
+} git_merge_diff_type_t;
+
+
+typedef struct {
+	git_repository *repo;
+	git_pool pool;
+
+	/* Vector of git_index_entry that represent the merged items that
+	 * have been staged, either because only one side changed, or because
+	 * the two changes were non-conflicting and mergeable.  These items
+	 * will be written as staged entries in the main index.
+	 */
+	git_vector staged;
+
+	/* Vector of git_merge_diff entries that represent the conflicts that
+	 * have not been automerged.  These items will be written to high-stage
+	 * entries in the main index.
+	 */
+	git_vector conflicts;
+
+	/* Vector of git_merge_diff that have been automerged.  These items
+	 * will be written to the REUC when the index is produced.
+	 */
+	git_vector resolved;
+} git_merge_diff_list;
+
+/**
+ * Description of changes to one file across three trees.
+ */
+typedef struct {
+	git_merge_diff_type_t type;
+
+	git_index_entry ancestor_entry;
+
+	git_index_entry our_entry;
+	git_delta_t our_status;
+
+	git_index_entry their_entry;
+	git_delta_t their_status;
+} git_merge_diff;
+
+/** Internal structure for merge inputs */
+struct git_merge_head {
+	char *ref_name;
+	char *remote_url;
+
+	git_oid oid;
+	git_commit *commit;
+};
+
+int git_merge__bases_many(
+	git_commit_list **out,
+	git_revwalk *walk,
+	git_commit_list_node *one,
+	git_vector *twos);
+
+/*
+ * Three-way tree differencing
+ */
+
+git_merge_diff_list *git_merge_diff_list__alloc(git_repository *repo);
+
+int git_merge_diff_list__find_differences(git_merge_diff_list *merge_diff_list,
+	const git_tree *ancestor_tree,
+	const git_tree *ours_tree,
+	const git_tree *theirs_tree);
+
+int git_merge_diff_list__find_renames(git_repository *repo, git_merge_diff_list *merge_diff_list, const git_merge_tree_opts *opts);
+
+void git_merge_diff_list__free(git_merge_diff_list *diff_list);
+
+/* Merge metadata setup */
 
-int git_merge__bases_many(git_commit_list **out, git_revwalk *walk, git_commit_list_node *one, git_vector *twos);
+int git_merge__setup(
+	git_repository *repo,
+	const git_merge_head *our_head,
+	const git_merge_head *their_heads[],
+	size_t their_heads_len,
+	unsigned int flags);
 
 #endif

data/vendor/libgit2/src/merge_file.c

@@ -0,0 +1,174 @@
+/*
+ * 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.
+ */
+
+#include "common.h"
+#include "repository.h"
+#include "merge_file.h"
+
+#include "git2/repository.h"
+#include "git2/object.h"
+#include "git2/index.h"
+
+#include "xdiff/xdiff.h"
+
+#define GIT_MERGE_FILE_SIDE_EXISTS(X)	((X)->mode != 0)
+
+GIT_INLINE(const char *) merge_file_best_path(
+	const git_merge_file_input *ancestor,
+	const git_merge_file_input *ours,
+	const git_merge_file_input *theirs)
+{
+	if (!GIT_MERGE_FILE_SIDE_EXISTS(ancestor)) {
+		if (strcmp(ours->path, theirs->path) == 0)
+			return ours->path;
+
+		return NULL;
+	}
+
+	if (strcmp(ancestor->path, ours->path) == 0)
+		return theirs->path;
+	else if(strcmp(ancestor->path, theirs->path) == 0)
+		return ours->path;
+
+	return NULL;
+}
+
+GIT_INLINE(int) merge_file_best_mode(
+	const git_merge_file_input *ancestor,
+	const git_merge_file_input *ours,
+	const git_merge_file_input *theirs)
+{
+	/*
+	 * If ancestor didn't exist and either ours or theirs is executable,
+	 * assume executable.  Otherwise, if any mode changed from the ancestor,
+	 * use that one.
+	 */
+	if (GIT_MERGE_FILE_SIDE_EXISTS(ancestor)) {
+		if (ours->mode == GIT_FILEMODE_BLOB_EXECUTABLE ||
+			theirs->mode == GIT_FILEMODE_BLOB_EXECUTABLE)
+			return GIT_FILEMODE_BLOB_EXECUTABLE;
+
+		return GIT_FILEMODE_BLOB;
+	}
+
+	if (ancestor->mode == ours->mode)
+		return theirs->mode;
+	else if(ancestor->mode == theirs->mode)
+		return ours->mode;
+
+	return 0;
+}
+
+int git_merge_file_input_from_index_entry(
+	git_merge_file_input *input,
+	git_repository *repo,
+	const git_index_entry *entry)
+{
+	git_odb *odb = NULL;
+	int error = 0;
+
+	assert(input && repo && entry);
+
+	if (entry->mode == 0)
+		return 0;
+
+	if ((error = git_repository_odb(&odb, repo)) < 0 ||
+		(error = git_odb_read(&input->odb_object, odb, &entry->oid)) < 0)
+		goto done;
+
+	input->mode = entry->mode;
+	input->path = git__strdup(entry->path);
+	input->mmfile.size = git_odb_object_size(input->odb_object);
+	input->mmfile.ptr = (char *)git_odb_object_data(input->odb_object);
+
+	if (input->label == NULL)
+		input->label = entry->path;
+
+done:
+	git_odb_free(odb);
+
+	return error;
+}
+
+int git_merge_file_input_from_diff_file(
+	git_merge_file_input *input,
+	git_repository *repo,
+	const git_diff_file *file)
+{
+	git_odb *odb = NULL;
+	int error = 0;
+
+	assert(input && repo && file);
+
+	if (file->mode == 0)
+		return 0;
+
+	if ((error = git_repository_odb(&odb, repo)) < 0 ||
+		(error = git_odb_read(&input->odb_object, odb, &file->oid)) < 0)
+		goto done;
+
+	input->mode = file->mode;
+	input->path = git__strdup(file->path);
+	input->mmfile.size = git_odb_object_size(input->odb_object);
+	input->mmfile.ptr = (char *)git_odb_object_data(input->odb_object);
+
+	if (input->label == NULL)
+		input->label = file->path;
+
+done:
+	git_odb_free(odb);
+
+	return error;
+}
+
+int git_merge_files(
+	git_merge_file_result *out,
+	git_merge_file_input *ancestor,
+	git_merge_file_input *ours,
+	git_merge_file_input *theirs,
+	git_merge_automerge_flags flags)
+{
+	xmparam_t xmparam;
+	mmbuffer_t mmbuffer;
+	int xdl_result;
+	int error = 0;
+
+	assert(out && ancestor && ours && theirs);
+
+	memset(out, 0x0, sizeof(git_merge_file_result));
+
+	if (!GIT_MERGE_FILE_SIDE_EXISTS(ours) || !GIT_MERGE_FILE_SIDE_EXISTS(theirs))
+		return 0;
+
+	memset(&xmparam, 0x0, sizeof(xmparam_t));
+	xmparam.ancestor = ancestor->label;
+	xmparam.file1 = ours->label;
+	xmparam.file2 = theirs->label;
+
+	out->path = merge_file_best_path(ancestor, ours, theirs);
+	out->mode = merge_file_best_mode(ancestor, ours, theirs);
+
+	if (flags == GIT_MERGE_AUTOMERGE_FAVOR_OURS)
+		xmparam.favor = XDL_MERGE_FAVOR_OURS;
+
+	if (flags == GIT_MERGE_AUTOMERGE_FAVOR_THEIRS)
+		xmparam.favor = XDL_MERGE_FAVOR_THEIRS;
+
+	if ((xdl_result = xdl_merge(&ancestor->mmfile, &ours->mmfile,
+		&theirs->mmfile, &xmparam, &mmbuffer)) < 0) {
+		giterr_set(GITERR_MERGE, "Failed to merge files.");
+		error = -1;
+		goto done;
+	}
+
+	out->automergeable = (xdl_result == 0);
+	out->data = (unsigned char *)mmbuffer.ptr;
+	out->len = mmbuffer.size;
+
+done:
+	return error;
+}

data/vendor/libgit2/src/merge_file.h

@@ -0,0 +1,71 @@
+/*
+ * 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_filediff_h__
+#define INCLUDE_filediff_h__
+
+#include "xdiff/xdiff.h"
+
+#include "git2/merge.h"
+
+typedef struct {
+	const char *label;
+	char *path;
+	unsigned int mode;
+	mmfile_t mmfile;
+
+	git_odb_object *odb_object;
+} git_merge_file_input;
+
+#define GIT_MERGE_FILE_INPUT_INIT	{0}
+
+typedef struct {
+	bool automergeable;
+
+	const char *path;
+	int mode;
+
+	unsigned char *data;
+	size_t len;
+} git_merge_file_result;
+
+#define GIT_MERGE_FILE_RESULT_INIT	{0}
+
+int git_merge_file_input_from_index_entry(
+	git_merge_file_input *input,
+	git_repository *repo,
+	const git_index_entry *entry);
+
+int git_merge_file_input_from_diff_file(
+	git_merge_file_input *input,
+	git_repository *repo,
+	const git_diff_file *file);
+
+int git_merge_files(
+	git_merge_file_result *out,
+	git_merge_file_input *ancestor,
+	git_merge_file_input *ours,
+	git_merge_file_input *theirs,
+	git_merge_automerge_flags flags);
+
+GIT_INLINE(void) git_merge_file_input_free(git_merge_file_input *input)
+{
+	assert(input);
+	git__free(input->path);
+	git_odb_object_free(input->odb_object);
+}
+
+GIT_INLINE(void) git_merge_file_result_free(git_merge_file_result *filediff)
+{
+	if (filediff == NULL)
+		return;
+
+	/* xdiff uses malloc() not git_malloc, so we use free(), not git_free() */
+	if (filediff->data != NULL)
+		free(filediff->data);
+}
+
+#endif

data/vendor/libgit2/src/mwindow.c

@@ -162,7 +162,7 @@ static git_mwindow *new_window(
 	git_mwindow *w;
 
 	w = git__malloc(sizeof(*w));
-	
+
 	if (w == NULL)
 		return NULL;
 

data/vendor/libgit2/src/notes.c

@@ -13,6 +13,12 @@
 #include "iterator.h"
 #include "signature.h"
 
+static int note_error_notfound(void)
+{
+	giterr_set(GITERR_INVALID, "Note could not be found");
+	return GIT_ENOTFOUND;
+}
+
 static int find_subtree_in_current_level(
 	git_tree **out,
 	git_repository *repo,
@@ -26,7 +32,7 @@ static int find_subtree_in_current_level(
 	*out = NULL;
 
 	if (parent == NULL)
-		return GIT_ENOTFOUND;
+		return note_error_notfound();
 
 	for (i = 0; i < git_tree_entrycount(parent); i++) {
 		entry = git_tree_entry_byindex(parent, i);
@@ -44,7 +50,7 @@ static int find_subtree_in_current_level(
 			return GIT_EEXISTS;
 	}
 
-	return GIT_ENOTFOUND;
+	return note_error_notfound();
 }
 
 static int find_subtree_r(git_tree **out, git_tree *root,
@@ -56,9 +62,8 @@ static int find_subtree_r(git_tree **out, git_tree *root,
 	*out = NULL;
 
 	error = find_subtree_in_current_level(&subtree, repo, root, target, *fanout);
-	if (error == GIT_EEXISTS) {
+	if (error == GIT_EEXISTS)
 		return git_tree_lookup(out, repo, git_tree_id(root));
-	}
 
 	if (error < 0)
 		return error;
@@ -85,7 +90,8 @@ static int find_blob(git_oid *blob, git_tree *tree, const char *target)
 			return 0;
 		}
 	}
-	return GIT_ENOTFOUND;
+
+	return note_error_notfound();
 }
 
 static int tree_write(
@@ -316,8 +322,8 @@ static int note_new(git_note **out, git_oid *note_oid, git_blob *blob)
 	return 0;
 }
 
-static int note_lookup(git_note **out, git_repository *repo,
-		       git_tree *tree, const char *target)
+static int note_lookup(
+	git_note **out, git_repository *repo, git_tree *tree, const char *target)
 {
 	int error, fanout = 0;
 	git_oid oid;
@@ -382,6 +388,7 @@ static int note_get_default_ref(const char **out, git_repository *repo)
 
 	ret = git_config_get_string(out, cfg, "core.notesRef");
 	if (ret == GIT_ENOTFOUND) {
+		giterr_clear();
 		*out = GIT_NOTES_DEFAULT_REF;
 		return 0;
 	}
@@ -432,12 +439,10 @@ int git_note_read(git_note **out, git_repository *repo,
 	target = git_oid_allocfmt(oid);
 	GITERR_CHECK_ALLOC(target);
 
-	if ((error = retrieve_note_tree_and_commit(&tree, &commit, repo, &notes_ref)) < 0)
-		goto cleanup;
-
-	error = note_lookup(out, repo, tree, target);
+	if (!(error = retrieve_note_tree_and_commit(
+			&tree, &commit, repo, &notes_ref)))
+		error = note_lookup(out, repo, tree, target);
 
-cleanup:
 	git__free(target);
 	git_tree_free(tree);
 	git_commit_free(commit);
@@ -489,13 +494,11 @@ int git_note_remove(git_repository *repo, const char *notes_ref,
 	target = git_oid_allocfmt(oid);
 	GITERR_CHECK_ALLOC(target);
 
-	if ((error = retrieve_note_tree_and_commit(&tree, &commit, repo, &notes_ref)) < 0)
-		goto cleanup;
+	if (!(error = retrieve_note_tree_and_commit(
+			&tree, &commit, repo, &notes_ref)))
+		error = note_remove(
+			repo, author, committer, notes_ref, tree, target, &commit);
 
-	error = note_remove(repo, author, committer, notes_ref,
-			    tree, target, &commit);
-
-cleanup:
 	git__free(target);
 	git_commit_free(commit);
 	git_tree_free(tree);
@@ -533,7 +536,7 @@ static int process_entry_path(
 	const char* entry_path,
 	git_oid *annotated_object_id)
 {
-	int error = -1;
+	int error = 0;
 	size_t i = 0, j = 0, len;
 	git_buf buf = GIT_BUF_INIT;
 
@@ -576,30 +579,30 @@ cleanup:
 }
 
 int git_note_foreach(
-    git_repository *repo,
-    const char *notes_ref,
-    git_note_foreach_cb note_cb,
-    void *payload)
+	git_repository *repo,
+	const char *notes_ref,
+	git_note_foreach_cb note_cb,
+	void *payload)
 {
-    int error;
-    git_note_iterator *iter = NULL;
-    git_oid note_id, annotated_id;
+	int error;
+	git_note_iterator *iter = NULL;
+	git_oid note_id, annotated_id;
 
-    if ((error = git_note_iterator_new(&iter, repo, notes_ref)) < 0)
-        return error;
+	if ((error = git_note_iterator_new(&iter, repo, notes_ref)) < 0)
+		return error;
 
-    while (!(error = git_note_next(&note_id, &annotated_id, iter))) {
-        if (note_cb(&note_id, &annotated_id, payload)) {
-            error = GIT_EUSER;
-            break;
-        }
-    }
+	while (!(error = git_note_next(&note_id, &annotated_id, iter))) {
+		if (note_cb(&note_id, &annotated_id, payload)) {
+			error = GIT_EUSER;
+			break;
+		}
+	}
 
-    if (error == GIT_ITEROVER)
-        error = 0;
+	if (error == GIT_ITEROVER)
+		error = 0;
 
-    git_note_iterator_free(iter);
-    return error;
+	git_note_iterator_free(iter);
+	return error;
 }
 
 
@@ -644,18 +647,12 @@ int git_note_next(
 	const git_index_entry *item;
 
 	if ((error = git_iterator_current(&item, it)) < 0)
-		goto exit;
+		return error;
 
-	if (item != NULL) {
-		git_oid_cpy(note_id, &item->oid);
-		error = process_entry_path(item->path, annotated_id);
+	git_oid_cpy(note_id, &item->oid);
 
-		if (error >= 0)
-			error = git_iterator_advance(NULL, it);
-	} else {
-		error = GIT_ITEROVER;
-	}
+	if (!(error = process_entry_path(item->path, annotated_id)))
+		git_iterator_advance(NULL, it);
 
-exit:
 	return error;
 }