rugged 0.19.0 → 0.28.0

data/ext/rugged/rugged_index.c

@@ -1,25 +1,8 @@
 /*
- * The MIT License
- *
- * Copyright (c) 2013 GitHub, Inc
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
+ * Copyright (C) the Rugged contributors.  All rights reserved.
+ *
+ * This file is part of Rugged, distributed under the MIT license.
+ * For full terms see the included LICENSE file.
  */
 
 #include "rugged.h"
@@ -106,7 +89,7 @@ static VALUE rb_git_index_read(VALUE self)
 
 	Data_Get_Struct(self, git_index, index);
 
-	error = git_index_read(index);
+	error = git_index_read(index, 0);
 	rugged_exception_check(error);
 
 	return Qnil;
@@ -207,11 +190,9 @@ static VALUE rb_git_index_each(VALUE self)
 	git_index *index;
 	unsigned int i, count;
 
+	RETURN_ENUMERATOR(self, 0, 0);
 	Data_Get_Struct(self, git_index, index);
 
-	if (!rb_block_given_p())
-		return rb_funcall(self, rb_intern("to_enum"), 0);
-
 	count = (unsigned int)git_index_entrycount(index);
 	for (i = 0; i < count; ++i) {
 		const git_index_entry *entry = git_index_get_byindex(index, i);
@@ -450,7 +431,7 @@ static VALUE rb_git_index_add_all(int argc, VALUE *argv, VALUE self)
  */
 static VALUE rb_git_index_update_all(int argc, VALUE *argv, VALUE self)
 {
-	VALUE rb_pathspecs = rb_ary_new();;
+	VALUE rb_pathspecs = rb_ary_new();
 
 	git_index *index;
 	git_strarray pathspecs;
@@ -531,7 +512,7 @@ static VALUE rb_git_indexentry_fromC(const git_index_entry *entry)
 	rb_entry = rb_hash_new();
 
 	rb_hash_aset(rb_entry, CSTR2SYM("path"), rb_str_new_utf8(entry->path));
-	rb_hash_aset(rb_entry, CSTR2SYM("oid"), rugged_create_oid(&entry->oid));
+	rb_hash_aset(rb_entry, CSTR2SYM("oid"), rugged_create_oid(&entry->id));
 
 	rb_hash_aset(rb_entry, CSTR2SYM("dev"), INT2FIX(entry->dev));
 	rb_hash_aset(rb_entry, CSTR2SYM("ino"), INT2FIX(entry->ino));
@@ -555,7 +536,7 @@ static VALUE rb_git_indexentry_fromC(const git_index_entry *entry)
 	return rb_entry;
 }
 
-static inline unsigned int
+static inline uint32_t
 default_entry_value(VALUE rb_entry, const char *key)
 {
 	VALUE val = rb_hash_aref(rb_entry, CSTR2SYM(key));
@@ -579,7 +560,7 @@ static void rb_git_indexentry_toC(git_index_entry *entry, VALUE rb_entry)
 	val = rb_hash_aref(rb_entry, CSTR2SYM("oid"));
 	Check_Type(val, T_STRING);
 	rugged_exception_check(
-		git_oid_fromstr(&entry->oid, StringValueCStr(val))
+		git_oid_fromstr(&entry->id, StringValueCStr(val))
 	);
 
 	entry->dev = default_entry_value(rb_entry, "dev");
@@ -587,7 +568,7 @@ static void rb_git_indexentry_toC(git_index_entry *entry, VALUE rb_entry)
 	entry->mode = default_entry_value(rb_entry, "mode");
 	entry->gid = default_entry_value(rb_entry, "gid");
 	entry->uid = default_entry_value(rb_entry, "uid");
-	entry->file_size = (git_off_t)default_entry_value(rb_entry, "file_size");
+	entry->file_size = default_entry_value(rb_entry, "file_size");
 
 	if ((val = rb_hash_aref(rb_entry, CSTR2SYM("mtime"))) != Qnil) {
 		if (!rb_obj_is_kind_of(val, rb_cTime))
@@ -624,8 +605,6 @@ static void rb_git_indexentry_toC(git_index_entry *entry, VALUE rb_entry)
 		entry->flags &= ~GIT_IDXENTRY_VALID;
 		if (rugged_parse_bool(val))
 			entry->flags |= GIT_IDXENTRY_VALID;
-	} else {
-		entry->flags |= GIT_IDXENTRY_VALID;
 	}
 }
 
@@ -681,172 +660,322 @@ static VALUE rb_git_index_readtree(VALUE self, VALUE rb_tree)
 	Data_Get_Struct(self, git_index, index);
 	Data_Get_Struct(rb_tree, git_tree, tree);
 
+	if (!rb_obj_is_kind_of(rb_tree, rb_cRuggedTree)) {
+		rb_raise(rb_eTypeError, "A Rugged::Tree instance is required");
+	}
+
 	error = git_index_read_tree(index, tree);
 	rugged_exception_check(error);
 
 	return Qnil;
 }
 
+static VALUE rb_git_diff_tree_to_index(VALUE self, VALUE rb_other, VALUE rb_options)
+{
+	git_index *index;
+	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
+	git_repository *repo;
+	git_diff *diff = NULL;
+	VALUE owner;
+	int error;
+	git_tree *other_tree;
+
+	rugged_parse_diff_options(&opts, rb_options);
+
+	Data_Get_Struct(self, git_index, index);
+	owner = rugged_owner(self);
+	Data_Get_Struct(owner, git_repository, repo);
+
+	// Need to flip the reverse option, so that the index is by default
+	// the "old file" side of the diff.
+	opts.flags ^= GIT_DIFF_REVERSE;
+
+	Data_Get_Struct(rb_other, git_tree, other_tree);
+	error = git_diff_tree_to_index(&diff, repo, other_tree, index, &opts);
+
+	xfree(opts.pathspec.strings);
+	rugged_exception_check(error);
+
+	return rugged_diff_new(rb_cRuggedDiff, owner, diff);
+}
+
+static VALUE rb_git_diff_index_to_workdir(VALUE self, VALUE rb_options)
+{
+	git_index *index;
+	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
+	git_repository *repo;
+	git_diff *diff = NULL;
+	VALUE owner;
+	int error;
+
+	rugged_parse_diff_options(&opts, rb_options);
+
+	Data_Get_Struct(self, git_index, index);
+	owner = rugged_owner(self);
+	Data_Get_Struct(owner, git_repository, repo);
+
+	error = git_diff_index_to_workdir(&diff, repo, index, &opts);
+
+	xfree(opts.pathspec.strings);
+	rugged_exception_check(error);
+
+	return rugged_diff_new(rb_cRuggedDiff, owner, diff);
+}
+
 /*
  *  call-seq:
- *    index.diff([options]) -> diff
- *    index.diff(diffable[, options]) -> diff
- *
- *  The first form returns a diff between the index and the current working
- *  directory.
- *
- *  The second form returns a diff between the index and the given diffable object.
- *  +diffable+ can either be a +Rugged::Commit+ or a +Rugged::Tree+.
- *
- *  The index will be used as the "old file" side of the diff, while the working
- *  directory or the +diffable+ will be used for the "new file" side.
- *
- *  The following options can be passed in the +options+ Hash:
- *
- *  :paths ::
- *    An array of paths / fnmatch patterns to constrain the diff to a specific
- *    set of files. Also see +:disable_pathspec_match+.
- *
- *  :max_size ::
- *    An integer specifying the maximum byte size of a file before a it will
- *    be treated as binary. The default value is 512MB.
- *
- *  :context_lines ::
- *    The number of unchanged lines that define the boundary of a hunk (and
- *    to display before and after the actual changes). The default is 3.
- *
- *  :interhunk_lines ::
- *    The maximum number of unchanged lines between hunk boundaries before the hunks
- *    will be merged into a one. The default is 0.
- *
- *  :reverse ::
- *    If true, the sides of the diff will be reversed.
- *
- *  :force_text ::
- *    If true, all files will be treated as text, disabling binary attributes & detection.
+ *    index.conflicts? -> true or false
  *
- *  :ignore_whitespace ::
- *    If true, all whitespace will be ignored.
+ *  Determines if the index contains entries representing conflicts.
+ */
+static VALUE rb_git_index_conflicts_p(VALUE self)
+{
+	git_index *index;
+	Data_Get_Struct(self, git_index, index);
+	return git_index_has_conflicts(index) ? Qtrue : Qfalse;
+}
+
+/*
+ *  call-seq:
+ *    index.conflict_add(conflict) -> nil
  *
- *  :ignore_whitespace_change ::
- *    If true, changes in amount of whitespace will be ignored.
+ *  Add or update index entries that represent a conflict.
  *
- *  :ignore_whitespace_eol ::
- *    If true, whitespace at end of line will be ignored.
+ *  +conflict+ has to be a hash containing +:ancestor+, +:ours+ and
+ *  +:theirs+ key/value pairs. Any of those paris can be +nil+ (or left out)
+ *  to indicate that the file was not present in the respective tree during
+ *  the merge.
+ */
+static VALUE rb_git_conflict_add(VALUE self, VALUE rb_conflict)
+{
+	VALUE rb_ancestor, rb_ours, rb_theirs;
+	git_index *index;
+	git_index_entry ancestor, ours, theirs;
+	int error;
+
+	Check_Type(rb_conflict, T_HASH);
+
+	rb_ancestor = rb_hash_aref(rb_conflict, CSTR2SYM("ancestor"));
+	rb_ours     = rb_hash_aref(rb_conflict, CSTR2SYM("ours"));
+	rb_theirs   = rb_hash_aref(rb_conflict, CSTR2SYM("theirs"));
+
+	if (!NIL_P(rb_ancestor))
+		rb_git_indexentry_toC(&ancestor, rb_ancestor);
+
+	if (!NIL_P(rb_ours))
+		rb_git_indexentry_toC(&ours, rb_ours);
+
+	if (!NIL_P(rb_theirs))
+		rb_git_indexentry_toC(&theirs, rb_theirs);
+
+	Data_Get_Struct(self, git_index, index);
+
+	error = git_index_conflict_add(index,
+		NIL_P(rb_ancestor) ? NULL : &ancestor,
+		NIL_P(rb_theirs) ? NULL : &ours,
+		NIL_P(rb_ours) ? NULL : &theirs);
+	rugged_exception_check(error);
+
+	return Qnil;
+}
+
+/*
+ *  call-seq:
+ *    index.conflict_remove(path) -> nil
  *
- *  :ignore_submodules ::
- *    if true, submodules will be excluded from the diff completely.
+ *  Removes the index entries that represent the conflict at +path+.
+ */
+static VALUE rb_git_conflict_remove(VALUE self, VALUE rb_path)
+{
+	git_index *index;
+	int error;
+
+	Check_Type(rb_path, T_STRING);
+
+	Data_Get_Struct(self, git_index, index);
+
+	error = git_index_conflict_remove(index, StringValueCStr(rb_path));
+	rugged_exception_check(error);
+
+	return Qnil;
+}
+
+/*
+ *  call-seq:
+ *    index.conflict_get(path) -> conflict or nil
  *
- *  :patience ::
- *    If true, the "patience diff" algorithm will be used (currenlty unimplemented).
+ *  Return index entries from the ancestor, our side and their side of
+ *  the conflict at +path+.
  *
- *  :include_ignored ::
- *    If true, ignored files will be included in the diff.
+ *  If +:ancestor+, +:ours+ or +:theirs+ is +nil+, that indicates that +path+
+ *  did not exist in the respective tree.
  *
- *  :include_untracked ::
- *   If true, untracked files will be included in the diff.
+ *  Returns nil if no conflict is present at +path+.
+ */
+static VALUE rb_git_conflict_get(VALUE self, VALUE rb_path)
+{
+	VALUE rb_result = rb_hash_new();
+	git_index *index;
+	const git_index_entry *ancestor, *ours, *theirs;
+	int error;
+
+	Check_Type(rb_path, T_STRING);
+
+	Data_Get_Struct(self, git_index, index);
+
+	error = git_index_conflict_get(&ancestor, &ours, &theirs, index, StringValueCStr(rb_path));
+	if (error == GIT_ENOTFOUND)
+		return Qnil;
+	else
+		rugged_exception_check(error);
+
+	rb_hash_aset(rb_result, CSTR2SYM("ancestor"), rb_git_indexentry_fromC(ancestor));
+	rb_hash_aset(rb_result, CSTR2SYM("ours"),     rb_git_indexentry_fromC(ours));
+	rb_hash_aset(rb_result, CSTR2SYM("theirs"),   rb_git_indexentry_fromC(theirs));
+
+	return rb_result;
+}
+
+/*
+ *  call-seq:
+ *    index.merge_file(path[, options]) -> merge_file or nil
+ *    index.merge_file(path) -> merge_file or nil
  *
- *  :include_unmodified ::
- *    If true, unmodified files will be included in the diff.
+ *  Return merge_file (in memory) from the ancestor, our side and their side of
+ *  the conflict at +path+.
  *
- *  :recurse_untracked_dirs ::
- *    Even if +:include_untracked+ is true, untracked directories will only be
- *    marked with a single entry in the diff. If this flag is set to true,
- *    all files under ignored directories will be included in the di ff, too.
+ *  If +:ancestor+, +:ours+ or +:theirs+ is +nil+, that indicates that +path+
+ *  did not exist in the respective tree.
  *
- *  :disable_pathspec_match ::
- *    If true, the given +:paths+ will be applied as exact matches, instead of
- *    as fnmatch patterns.
+ *  Returns nil if no conflict is present at +path+.
+
+ *  The following options can be passed in the +options+ Hash:
  *
- *  :deltas_are_icase ::
- *    If true, filename comparisons will be made with case-insensitivity.
+ *  :ancestor_label ::
+ *    The name of the ancestor branch used to decorate conflict markers.
  *
- *  :include_untracked_content ::
- *    if true, untracked content will be contained in the the diff patch text.
+ *  :our_label ::
+ *    The name of our branch used to decorate conflict markers.
  *
- *  :skip_binary_check ::
- *    If true, diff deltas will be generated without spending time on binary
- *    detection. This is useful to improve performance in cases where the actual
- *    file content difference is not needed.
+ *  :their_label ::
+ *    The name of their branch used to decorate conflict markers.
  *
- *  :include_typechange ::
- *    If true, type changes for files will not be interpreted as deletion of
- *    the "old file" and addition of the "new file", but will generate
- *    typechange records.
+ *  :favor ::
+ *    Specifies how and if conflicts are auto-resolved by favoring a specific
+ *    file output. Can be one of `:normal`, `:ours`, `:theirs` or `:union`.
+ *    Defaults to `:normal`.
  *
- *  :include_typechange_trees ::
- *    Even if +:include_typechange+ is true, blob -> tree changes will still
- *    usually be handled as a deletion of the blob. If this flag is set to true,
- *    blob -> tree changes will be marked as typechanges.
+ *  :style ::
+ *    Specifies the type of merge file to produce. Can be one of `:standard`, `:diff3`. Defaults to `:standard`
  *
- *  :ignore_filemode ::
- *    If true, file mode changes will be ignored.
+ *  :simplify ::
+ *    If true, the merge file is simplified by condensing non-alphanumeric regions.
  *
- *  :recurse_ignored_dirs ::
- *    Even if +:include_ignored+ is true, ignored directories will only be
- *    marked with a single entry in the diff. If this flag is set to true,
- *    all files under ignored directories will be included in the diff, too.
  */
-static VALUE rb_git_index_diff(int argc, VALUE *argv, VALUE self)
+
+static VALUE rb_git_merge_file(int argc, VALUE *argv, VALUE self)
 {
-	git_index *index;
-	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
+	VALUE rb_path, rb_options, rb_result;
+	VALUE rb_repo = rugged_owner(self);
+
 	git_repository *repo;
-	git_diff_list *diff = NULL;
-	VALUE owner, rb_other, rb_options;
+	git_index *index;
+	const git_index_entry *ancestor, *ours, *theirs;
+	git_merge_file_result merge_file_result = {0};
+	git_merge_file_options opts = GIT_MERGE_FILE_OPTIONS_INIT;
 	int error;
 
-	rb_scan_args(argc, argv, "01:", &rb_other, &rb_options);
-	rugged_parse_diff_options(&opts, rb_options);
+	rb_scan_args(argc, argv, "1:", &rb_path, &rb_options);
+
+	if (!NIL_P(rb_options))
+		rugged_parse_merge_file_options(&opts, rb_options);
+
+	Check_Type(rb_path, T_STRING);
 
 	Data_Get_Struct(self, git_index, index);
-	owner = rugged_owner(self);
-	Data_Get_Struct(owner, git_repository, repo);
 
-	if (NIL_P(rb_other)) {
-		error = git_diff_index_to_workdir(&diff, repo, index, &opts);
-	} else {
-		// Need to flip the reverse option, so that the index is by default
-		// the "old file" side of the diff.
-		opts.flags ^= GIT_DIFF_REVERSE;
-
-		if (rb_obj_is_kind_of(rb_other, rb_cRuggedCommit)) {
-			git_tree *other_tree;
-			git_commit *commit;
-			Data_Get_Struct(rb_other, git_commit, commit);
-			error = git_commit_tree(&other_tree, commit);
-
-			if (!error)
-				error = git_diff_tree_to_index(&diff, repo, other_tree, index, &opts);
-		} else if (rb_obj_is_kind_of(rb_other, rb_cRuggedTree)) {
-			git_tree *other_tree;
-			Data_Get_Struct(rb_other, git_tree, other_tree);
-			error = git_diff_tree_to_index(&diff, repo, other_tree, index, &opts);
-		} else {
-			xfree(opts.pathspec.strings);
-			rb_raise(rb_eTypeError, "A Rugged::Commit or Rugged::Tree instance is required");
-		}
-	}
+	rugged_check_repo(rb_repo);
+	Data_Get_Struct(rb_repo, git_repository, repo);
 
-	xfree(opts.pathspec.strings);
+	error = git_index_conflict_get(&ancestor, &ours, &theirs, index, StringValueCStr(rb_path));
+	if (error == GIT_ENOTFOUND)
+		return Qnil;
+	else
+		rugged_exception_check(error);
+
+	if (ours == NULL)
+		rb_raise(rb_eRuntimeError, "The conflict does not have a stage 2 entry");
+	else if (theirs == NULL)
+		rb_raise(rb_eRuntimeError, "The conflict does not have a stage 3 entry");
+
+	error = git_merge_file_from_index(&merge_file_result, repo, ancestor, ours, theirs, &opts);
 	rugged_exception_check(error);
 
-	return rugged_diff_new(rb_cRuggedDiff, self, diff);
+	rb_result = rb_merge_file_result_fromC(&merge_file_result);
+	git_merge_file_result_free(&merge_file_result);
+
+	return rb_result;
 }
 
 /*
  *  call-seq:
- *    index.conflicts? -> true or false
+ *    index.conflict_cleanup -> nil
  *
- *  Determines if the index contains entries representing conflicts.
+ *  Remove all conflicting entries (entries with a stage greater than 0)
+ *  from the index.
  */
-static VALUE rb_git_index_conflicts_p(VALUE self)
+static VALUE rb_git_conflict_cleanup(VALUE self)
 {
 	git_index *index;
+
 	Data_Get_Struct(self, git_index, index);
-	return git_index_has_conflicts(index) ? Qtrue : Qfalse;
+	git_index_conflict_cleanup(index);
+
+	return Qnil;
 }
 
+/*
+ *  call-seq:
+ *    index.conflicts -> conflicts
+ *
+ *  Return all conflicts in +index+.
+ *
+ *  Each conflict is represented as a Hash with +:ancestor+, +:ours+ or
+ *  +:theirs+ key-value pairs, each containing index entry data.
+ *
+ *  If the value of the +:ancestor+, +:ours+ or +:theirs+ key is +nil+,
+ *  that indicates that file in conflict did not exists in the respective tree.
+ */
+static VALUE rb_git_index_conflicts(VALUE self)
+{
+	VALUE rb_conflicts = rb_ary_new();
+	git_index *index;
+	git_index_conflict_iterator *iter;
+	const git_index_entry *ancestor, *ours, *theirs;
+	int error;
+
+	Data_Get_Struct(self, git_index, index);
+
+	error = git_index_conflict_iterator_new(&iter, index);
+	rugged_exception_check(error);
+
+	while ((error = git_index_conflict_next(&ancestor, &ours, &theirs, iter)) == GIT_OK) {
+		VALUE rb_conflict = rb_hash_new();
+
+		rb_hash_aset(rb_conflict, CSTR2SYM("ancestor"), rb_git_indexentry_fromC(ancestor));
+		rb_hash_aset(rb_conflict, CSTR2SYM("ours"),     rb_git_indexentry_fromC(ours));
+		rb_hash_aset(rb_conflict, CSTR2SYM("theirs"),   rb_git_indexentry_fromC(theirs));
+
+		rb_ary_push(rb_conflicts, rb_conflict);
+	}
+
+	git_index_conflict_iterator_free(iter);
+
+	if (error != GIT_ITEROVER)
+		rugged_exception_check(error);
+
+	return rb_conflicts;
+}
 
 /*
  *  Document-class: Rugged::Index
@@ -907,9 +1036,17 @@ void Init_rugged_index(void)
 	rb_define_method(rb_cRuggedIndex, "get", rb_git_index_get, -1);
 	rb_define_method(rb_cRuggedIndex, "[]", rb_git_index_get, -1);
 	rb_define_method(rb_cRuggedIndex, "each", rb_git_index_each, 0);
-	rb_define_method(rb_cRuggedIndex, "diff", rb_git_index_diff, -1);
+	rb_define_private_method(rb_cRuggedIndex, "diff_tree_to_index", rb_git_diff_tree_to_index, 2);
+	rb_define_private_method(rb_cRuggedIndex, "diff_index_to_workdir", rb_git_diff_index_to_workdir, 1);
 
 	rb_define_method(rb_cRuggedIndex, "conflicts?", rb_git_index_conflicts_p, 0);
+	rb_define_method(rb_cRuggedIndex, "conflicts", rb_git_index_conflicts, 0);
+	rb_define_method(rb_cRuggedIndex, "conflict_get", rb_git_conflict_get, 1);
+	rb_define_method(rb_cRuggedIndex, "conflict_add", rb_git_conflict_add, 1);
+	rb_define_method(rb_cRuggedIndex, "conflict_remove", rb_git_conflict_remove, 1);
+	rb_define_method(rb_cRuggedIndex, "conflict_cleanup", rb_git_conflict_cleanup, 0);
+
+	rb_define_method(rb_cRuggedIndex, "merge_file", rb_git_merge_file, -1);
 
 	rb_define_method(rb_cRuggedIndex, "add", rb_git_index_add, 1);
 	rb_define_method(rb_cRuggedIndex, "update", rb_git_index_add, 1);