rugged 0.19.0 → 0.21.0

data/ext/rugged/rugged_diff_delta.c

@@ -1,7 +1,7 @@
 /*
  * The MIT License
  *
- * Copyright (c) 2012 GitHub, Inc
+ * Copyright (c) 2014 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
@@ -27,7 +27,7 @@
 extern VALUE rb_cRuggedDiff;
 VALUE rb_cRuggedDiffDelta;
 
-static VALUE rb_git_delta_file_fromC(const git_diff_file *file)
+VALUE rb_git_delta_file_fromC(const git_diff_file *file)
 {
 	VALUE rb_file;
 
@@ -36,7 +36,7 @@ static VALUE rb_git_delta_file_fromC(const git_diff_file *file)
 
 	rb_file = rb_hash_new();
 
-	rb_hash_aset(rb_file, CSTR2SYM("oid"), rugged_create_oid(&file->oid));
+	rb_hash_aset(rb_file, CSTR2SYM("oid"), rugged_create_oid(&file->id));
 	rb_hash_aset(rb_file, CSTR2SYM("path"), file->path ? rb_str_new2(file->path) : Qnil);
 	rb_hash_aset(rb_file, CSTR2SYM("size"), INT2FIX(file->size));
 	rb_hash_aset(rb_file, CSTR2SYM("flags"), UINT2NUM(file->flags));
@@ -71,6 +71,16 @@ static VALUE rb_git_delta_status_fromC(git_delta_t status)
 	}
 }
 
+static VALUE rb_git_delta_status_char_fromC(git_delta_t status)
+{
+	char status_char[2];
+	
+	status_char[0] = git_diff_status_char(status);
+	status_char[1] = '\0';
+
+	return CSTR2SYM(status_char);
+}
+
 VALUE rugged_diff_delta_new(VALUE owner, const git_diff_delta *delta)
 {
 	VALUE rb_delta = rb_class_new_instance(0, NULL, rb_cRuggedDiffDelta);
@@ -80,6 +90,7 @@ VALUE rugged_diff_delta_new(VALUE owner, const git_diff_delta *delta)
 	rb_iv_set(rb_delta, "@new_file", rb_git_delta_file_fromC(&delta->new_file));
 	rb_iv_set(rb_delta, "@similarity", INT2FIX(delta->similarity));
 	rb_iv_set(rb_delta, "@status", rb_git_delta_status_fromC(delta->status));
+	rb_iv_set(rb_delta, "@status_char", rb_git_delta_status_char_fromC(delta->status));
 	rb_iv_set(rb_delta, "@binary",
 		(!(delta->flags & GIT_DIFF_FLAG_NOT_BINARY) &&
 		 (delta->flags & GIT_DIFF_FLAG_BINARY)) ? Qtrue : Qfalse

data/ext/rugged/rugged_diff_hunk.c

@@ -1,7 +1,7 @@
 /*
  * The MIT License
  *
- * Copyright (c) 2012 GitHub, Inc
+ * Copyright (c) 2014 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
@@ -27,30 +27,21 @@
 extern VALUE rb_cRuggedDiff;
 VALUE rb_cRuggedDiffHunk;
 
-VALUE rugged_diff_hunk_new(
-	VALUE owner, int hunk_idx,
-	const git_diff_range *range,
-	const char *header,
-	size_t header_len,
-	size_t lines_in_hunk)
-{
-	VALUE rb_hunk;
-	VALUE rb_range;
 
-	rb_hunk = rb_class_new_instance(0, NULL, rb_cRuggedDiffHunk);
+VALUE rugged_diff_hunk_new(VALUE owner, size_t hunk_idx, const git_diff_hunk *hunk, size_t lines_in_hunk)
+{
+	VALUE rb_hunk = rb_class_new_instance(0, NULL, rb_cRuggedDiffHunk);
 	rugged_set_owner(rb_hunk, owner);
 
-	rb_range = rb_hash_new();
-	rb_hash_aset(rb_range, CSTR2SYM("old_start"), INT2FIX(range->old_start));
-	rb_hash_aset(rb_range, CSTR2SYM("old_lines"), INT2FIX(range->old_lines));
-	rb_hash_aset(rb_range, CSTR2SYM("new_start"), INT2FIX(range->new_start));
-	rb_hash_aset(rb_range, CSTR2SYM("new_lines"), INT2FIX(range->new_lines));
-	rb_iv_set(rb_hunk, "@range", rb_range);
-
-	rb_iv_set(rb_hunk, "@header", rb_str_new(header, header_len));
+	rb_iv_set(rb_hunk, "@header", rb_str_new(hunk->header, hunk->header_len));
 	rb_iv_set(rb_hunk, "@line_count", INT2FIX(lines_in_hunk));
 	rb_iv_set(rb_hunk, "@hunk_index", INT2FIX(hunk_idx));
 
+	rb_iv_set(rb_hunk, "@old_start", INT2FIX(hunk->old_start));
+	rb_iv_set(rb_hunk, "@old_lines", INT2FIX(hunk->old_lines));
+	rb_iv_set(rb_hunk, "@new_start", INT2FIX(hunk->new_start));
+	rb_iv_set(rb_hunk, "@new_lines", INT2FIX(hunk->new_lines));
+
 	return rb_hunk;
 }
 
@@ -65,27 +56,24 @@ VALUE rugged_diff_hunk_new(
  */
 static VALUE rb_git_diff_hunk_each_line(VALUE self)
 {
-	git_diff_patch *patch;
-	char line_origin;
-	const char *content;
-	size_t content_len = 0;
-	int error = 0, l, old_lineno, new_lineno, lines_count, hunk_idx;
+	git_patch *patch;
+	int error = 0, l, lines_count, hunk_idx;
 
 	if (!rb_block_given_p()) {
 		return rb_funcall(self, rb_intern("to_enum"), 1, CSTR2SYM("each_line"), self);
 	}
 
-	Data_Get_Struct(rugged_owner(self), git_diff_patch, patch);
+	Data_Get_Struct(rugged_owner(self), git_patch, patch);
 
 	lines_count = FIX2INT(rb_iv_get(self, "@line_count"));
 	hunk_idx = FIX2INT(rb_iv_get(self, "@hunk_index"));
 
 	for (l = 0; l < lines_count; ++l) {
-		error = git_diff_patch_get_line_in_hunk(
-			&line_origin, &content, &content_len, &old_lineno, &new_lineno, patch, hunk_idx, l);
+		const git_diff_line *line;
+		error = git_patch_get_line_in_hunk(&line, patch, hunk_idx, l);
 		if (error) break;
 
-		rb_yield(rugged_diff_line_new(self, line_origin, content, content_len, old_lineno, new_lineno));
+		rb_yield(rugged_diff_line_new(line));
 	}
 	rugged_exception_check(error);
 
@@ -96,5 +84,20 @@ void Init_rugged_diff_hunk(void)
 {
 	rb_cRuggedDiffHunk = rb_define_class_under(rb_cRuggedDiff, "Hunk", rb_cObject);
 
+	rb_include_module(rb_cRuggedDiffHunk, rb_mEnumerable);
+
+	rb_define_method(rb_cRuggedDiffHunk, "each", rb_git_diff_hunk_each_line, 0);
 	rb_define_method(rb_cRuggedDiffHunk, "each_line", rb_git_diff_hunk_each_line, 0);
+
+	rb_define_attr(rb_cRuggedDiffHunk, "header", 1, 0);
+	rb_define_attr(rb_cRuggedDiffHunk, "line_count", 1, 0);
+	rb_define_attr(rb_cRuggedDiffHunk, "hunk_index", 1, 0);
+
+	rb_define_attr(rb_cRuggedDiffHunk, "old_start", 1, 0);
+	rb_define_attr(rb_cRuggedDiffHunk, "old_lines", 1, 0);
+	rb_define_attr(rb_cRuggedDiffHunk, "new_start", 1, 0);
+	rb_define_attr(rb_cRuggedDiffHunk, "new_lines", 1, 0);
+
+	rb_define_alias(rb_cRuggedDiffHunk, "count", "line_count");
+	rb_define_alias(rb_cRuggedDiffHunk, "size", "line_count");
 }

data/ext/rugged/rugged_diff_line.c

@@ -1,7 +1,7 @@
 /*
  * The MIT License
  *
- * Copyright (c) 2012 GitHub, Inc
+ * Copyright (c) 2014 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
@@ -27,21 +27,11 @@
 extern VALUE rb_cRuggedDiff;
 VALUE rb_cRuggedDiffLine;
 
-VALUE rugged_diff_line_new(
-	VALUE owner,
-	const char line_origin,
-	const char *content,
-	size_t content_len,
-	int old_lineno,
-	int new_lineno)
+VALUE rugged_diff_line_new(const git_diff_line *line)
 {
-	VALUE rb_line;
-	VALUE rb_line_origin;
+	VALUE rb_line = rb_class_new_instance(0, NULL, rb_cRuggedDiffLine), rb_line_origin;
 
-	rb_line = rb_class_new_instance(0, NULL, rb_cRuggedDiffLine);
-	rugged_set_owner(rb_line, owner);
-
-	switch(line_origin) {
+	switch(line->origin) {
 		case GIT_DIFF_LINE_CONTEXT:
 			rb_line_origin = CSTR2SYM("context");
 			break;
@@ -60,15 +50,29 @@ VALUE rugged_diff_line_new(
 		case GIT_DIFF_LINE_DEL_EOFNL: /* removed at end of old file */
 			rb_line_origin = CSTR2SYM("eof_newline_removed");
 			break;
+		case GIT_DIFF_LINE_FILE_HDR:
+			rb_line_origin = CSTR2SYM("file_header");
+			break;
+		case GIT_DIFF_LINE_HUNK_HDR:
+			rb_line_origin = CSTR2SYM("hunk_header");
+			break;
+		case GIT_DIFF_LINE_BINARY:
+			rb_line_origin = CSTR2SYM("binary");
+			break;			
 		default:
 			/* FIXME: raise here instead? */
 			rb_line_origin = CSTR2SYM("unknown");
 	}
 
 	rb_iv_set(rb_line, "@line_origin", rb_line_origin);
-	rb_iv_set(rb_line, "@content", rb_str_new(content, content_len));
-	rb_iv_set(rb_line, "@old_lineno", INT2FIX(old_lineno));
-	rb_iv_set(rb_line, "@new_lineno", INT2FIX(new_lineno));
+	rb_iv_set(rb_line, "@content", rb_str_new(line->content, line->content_len));
+	rb_iv_set(rb_line, "@old_lineno", INT2FIX(line->old_lineno));
+	rb_iv_set(rb_line, "@new_lineno", INT2FIX(line->new_lineno));
+
+	if (line->content_offset == -1)
+		rb_iv_set(rb_line, "@content_offset", Qnil);
+	else
+		rb_iv_set(rb_line, "@content_offset", INT2FIX(line->content_offset));
 
 	return rb_line;
 }

data/ext/rugged/rugged_index.c

@@ -1,7 +1,7 @@
 /*
  * The MIT License
  *
- * Copyright (c) 2013 GitHub, Inc
+ * Copyright (c) 2014 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
@@ -106,7 +106,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;
@@ -450,7 +450,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 +531,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));
@@ -579,7 +579,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");
@@ -792,7 +792,7 @@ static VALUE rb_git_index_diff(int argc, VALUE *argv, VALUE self)
 	git_index *index;
 	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
 	git_repository *repo;
-	git_diff_list *diff = NULL;
+	git_diff *diff = NULL;
 	VALUE owner, rb_other, rb_options;
 	int error;
 
@@ -847,6 +847,319 @@ static VALUE rb_git_index_conflicts_p(VALUE self)
 	return git_index_has_conflicts(index) ? Qtrue : Qfalse;
 }
 
+/*
+ *  call-seq:
+ *    index.conflict_add(conflict) -> nil
+ *
+ *  Add or update index entries that represent a conflict.
+ *
+ *  +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
+ *
+ *  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
+ *
+ *  Return index entries from the ancestor, our side and their side of
+ *  the conflict at +path+.
+ *
+ *  If +:ancestor+, +:ours+ or +:theirs+ is +nil+, that indicates that +path+
+ *  did not exist in the respective tree.
+ *
+ *  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;
+}
+
+void rugged_parse_merge_file_options(git_merge_file_options *opts, VALUE rb_options)
+{
+	if (!NIL_P(rb_options)) {
+		VALUE rb_value;
+		Check_Type(rb_options, T_HASH);
+
+		rb_value = rb_hash_aref(rb_options, CSTR2SYM("ancestor_label"));
+		if (!NIL_P(rb_value)) {
+			Check_Type(rb_value, T_FIXNUM);
+			opts->ancestor_label = StringValueCStr(rb_value);
+		}
+
+		rb_value = rb_hash_aref(rb_options, CSTR2SYM("our_label"));
+		if (!NIL_P(rb_value)) {
+			Check_Type(rb_value, T_FIXNUM);
+			opts->our_label = StringValueCStr(rb_value);
+		}
+
+		rb_value = rb_hash_aref(rb_options, CSTR2SYM("their_label"));
+		if (!NIL_P(rb_value)) {
+			Check_Type(rb_value, T_FIXNUM);
+			opts->their_label = StringValueCStr(rb_value);
+		}
+
+		rb_value = rb_hash_aref(rb_options, CSTR2SYM("favor"));
+		if (!NIL_P(rb_value)) {
+			ID id_favor;
+
+			Check_Type(rb_value, T_SYMBOL);
+			id_favor = SYM2ID(rb_value);
+
+			if (id_favor == rb_intern("normal")) {
+				opts->favor = GIT_MERGE_FILE_FAVOR_NORMAL;
+			} else if (id_favor == rb_intern("ours")) {
+				opts->favor = GIT_MERGE_FILE_FAVOR_OURS;
+			} else if (id_favor == rb_intern("theirs")) {
+				opts->favor = GIT_MERGE_FILE_FAVOR_THEIRS;
+			} else if (id_favor == rb_intern("union")) {
+				opts->favor = GIT_MERGE_FILE_FAVOR_UNION;
+			} else {
+				rb_raise(rb_eTypeError,
+					"Invalid favor mode. Expected `:normal`, `:ours`, `:theirs` or `:union`");
+			}
+		}
+
+		rb_value = rb_hash_aref(rb_options, CSTR2SYM("style"));
+		if (!NIL_P(rb_value)) {
+			ID id_style;
+
+			Check_Type(rb_value, T_SYMBOL);
+			id_style = SYM2ID(rb_value);
+
+			if (id_style == rb_intern("standard")) {
+				opts->flags |= GIT_MERGE_FILE_STYLE_MERGE;
+			} else if (id_style == rb_intern("diff3")) {
+				opts->flags |= GIT_MERGE_FILE_STYLE_DIFF3;
+			} else {
+				rb_raise(rb_eTypeError,
+					"Invalid style mode. Expected `:standard`, or `:diff3`");
+			}
+		} else {
+			opts->flags |= GIT_MERGE_FILE_STYLE_MERGE;
+		}
+
+		if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("simplify")))) {
+			opts->flags |= GIT_MERGE_FILE_SIMPLIFY_ALNUM;
+		}
+	}
+}
+
+/*
+ *  call-seq:
+ *    index.merge_file(path[, options]) -> merge_file or nil
+ *    index.merge_file(path) -> merge_file or nil
+ *
+ *  Return merge_file (in memory) from the ancestor, our side and their side of
+ *  the conflict at +path+.
+ *
+ *  If +:ancestor+, +:ours+ or +:theirs+ is +nil+, that indicates that +path+
+ *  did not exist in the respective tree.
+ *
+ *  Returns nil if no conflict is present at +path+.
+
+ *  The following options can be passed in the +options+ Hash:
+ *
+ *  :ancestor_label ::
+ *    The name of the ancestor branch used to decorate conflict markers.
+ *
+ *  :our_label ::
+ *    The name of our branch used to decorate conflict markers.
+ *
+ *  :their_label ::
+ *    The name of their branch used to decorate conflict markers.
+ *
+ *  :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`.
+ *
+ *  :style ::
+ *    Specifies the type of merge file to produce. Can be one of `:standard`, `:diff3`. Defaults to `:standard`
+ *
+ *  :simplify ::
+ *    If true, the merge file is simplified by condensing non-alphanumeric regions.
+ *
+ */
+
+static VALUE rb_git_merge_file(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rb_path, rb_options;
+	VALUE rb_result = rb_hash_new();
+	VALUE rb_repo = rugged_owner(self);
+
+	git_repository *repo;
+	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, "1:", &rb_path, &rb_options);
+
+	if (!NIL_P(rb_options)) {
+		Check_Type(rb_options, T_HASH);
+		rugged_parse_merge_file_options(&opts, rb_options);
+	}
+
+	Check_Type(rb_path, T_STRING);
+
+	Data_Get_Struct(self, git_index, index);
+
+	rugged_check_repo(rb_repo);
+	Data_Get_Struct(rb_repo, git_repository, repo);
+
+	error = git_index_conflict_get(&ancestor, &ours, &theirs, index, StringValueCStr(rb_path));
+	if (error == GIT_ENOTFOUND)
+		return Qnil;
+	else
+		rugged_exception_check(error);
+
+	error = git_merge_file_from_index(&merge_file_result, repo, ancestor, ours, theirs, &opts);
+	rugged_exception_check(error);
+
+	rb_hash_aset(rb_result, CSTR2SYM("automergeable"), merge_file_result.automergeable ? Qtrue : Qfalse);
+	rb_hash_aset(rb_result, CSTR2SYM("path"),         rb_path);
+	rb_hash_aset(rb_result, CSTR2SYM("filemode"),     INT2FIX(merge_file_result.mode));
+	rb_hash_aset(rb_result, CSTR2SYM("data"),         rb_str_new(merge_file_result.ptr, merge_file_result.len));
+
+	git_merge_file_result_free(&merge_file_result);
+
+	return rb_result;
+}
+
+/*
+ *  call-seq:
+ *    index.conflict_cleanup -> nil
+ *
+ *  Remove all conflicting entries (entries with a stage greater than 0)
+ *  from the index.
+ */
+static VALUE rb_git_conflict_cleanup(VALUE self)
+{
+	git_index *index;
+
+	Data_Get_Struct(self, git_index, index);
+	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
@@ -910,6 +1223,13 @@ void Init_rugged_index(void)
 	rb_define_method(rb_cRuggedIndex, "diff", rb_git_index_diff, -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);