Teach Rugged::Blob.merge_files to look up by oid

Accept an optional `oid` parameter that `merge_files` will use to look
up the file contents to merge.

Author: Edward Thomson

ext/rugged/rugged_blob.c

@@ -551,55 +551,105 @@ static VALUE rb_git_blob_to_buffer(int argc, VALUE *argv, VALUE self)
 	return rb_ret;
 }
 
-static void rugged_parse_merge_file_input(git_merge_file_input *input, VALUE rb_input)
+#define RUGGED_MERGE_FILE_INPUT_INIT { GIT_MERGE_FILE_INPUT_INIT }
+
+typedef struct {
+	git_merge_file_input parent;
+	int has_id;
+	git_oid id;
+} rugged_merge_file_input;
+
+static void rugged_parse_merge_file_input(rugged_merge_file_input *input, git_repository *repo, VALUE rb_input)
 {
 	VALUE rb_value;
 
 	Check_Type(rb_input, T_HASH);
 
-	rb_value = rb_hash_aref(rb_input, CSTR2SYM("content"));
-	if (NIL_P(rb_value))
-		rb_raise(rb_eArgError, "File input must have `:content`.");
+	if (!NIL_P(rb_value = rb_hash_aref(rb_input, CSTR2SYM("content")))) {
+		input->parent.ptr = RSTRING_PTR(rb_value);
+		input->parent.size = RSTRING_LEN(rb_value);
+	} else if (!NIL_P(rb_value = rb_hash_aref(rb_input, CSTR2SYM("oid")))) {
+		if (!repo)
+			rb_raise(rb_eArgError, "Rugged repository is required when file input is `:oid`.");
 
-	input->ptr = RSTRING_PTR(rb_value);
-	input->size = RSTRING_LEN(rb_value);
+		rugged_exception_check(git_oid_fromstr(&input->id, RSTRING_PTR(rb_value)));
+		input->has_id = 1;
+	} else {
+		rb_raise(rb_eArgError, "File input must have `:content` or `:oid`.");
+	}
 
 	rb_value = rb_hash_aref(rb_input, CSTR2SYM("filemode"));
 	if (!NIL_P(rb_value))
-		input->mode = FIX2UINT(rb_value);
+		input->parent.mode = FIX2UINT(rb_value);
 
 	rb_value = rb_hash_aref(rb_input, CSTR2SYM("path"));
 	if (!NIL_P(rb_value)) {
 		Check_Type(rb_value, T_STRING);
-		input->path = RSTRING_PTR(rb_value);
+		input->parent.path = RSTRING_PTR(rb_value);
 	}
 }
 
+static int rugged_load_merge_file_input(git_blob **out, git_repository *repo, rugged_merge_file_input *input)
+{
+	int error;
+
+	if (!input->has_id)
+		return 0;
+
+	if ((error = git_blob_lookup(out, repo, &input->id)) < 0)
+		return error;
+
+	input->parent.ptr = git_blob_rawcontent(*out);
+	input->parent.size = git_blob_rawsize(*out);
+
+	return 0;
+}
+
 static VALUE rb_git_blob_merge_files(int argc, VALUE *argv, VALUE klass)
 {
-	VALUE rb_ancestor, rb_ours, rb_theirs, rb_options, rb_result;
+	VALUE rb_repo, rb_ancestor, rb_ours, rb_theirs, rb_options, rb_result;
 
-	git_merge_file_input ancestor = GIT_MERGE_FILE_INPUT_INIT,
-		ours = GIT_MERGE_FILE_INPUT_INIT,
-		theirs = GIT_MERGE_FILE_INPUT_INIT;
+	git_repository *repo = NULL;
+	rugged_merge_file_input ancestor = RUGGED_MERGE_FILE_INPUT_INIT,
+		ours = RUGGED_MERGE_FILE_INPUT_INIT,
+		theirs = RUGGED_MERGE_FILE_INPUT_INIT;
+	git_blob *ancestor_blob = NULL, *our_blob = NULL, *their_blob = NULL;
 	git_merge_file_options opts = GIT_MERGE_FILE_OPTIONS_INIT;
 	git_merge_file_result result = {0};
 	int error;
 
-	rb_scan_args(argc, argv, "31", &rb_ancestor, &rb_ours, &rb_theirs, &rb_options);
+	rb_scan_args(argc, argv, "41", &rb_repo, &rb_ancestor, &rb_ours, &rb_theirs, &rb_options);
 
-	rugged_parse_merge_file_input(&ancestor, rb_ancestor);
-	rugged_parse_merge_file_input(&ours, rb_ours);
-	rugged_parse_merge_file_input(&theirs, rb_theirs);
+	if (!NIL_P(rb_repo)) {
+		rugged_check_repo(rb_repo);
+		Data_Get_Struct(rb_repo, git_repository, repo);
+	}
 
 	if (!NIL_P(rb_options))
 		rugged_parse_merge_file_options(&opts, rb_options);
 
-	rugged_exception_check(git_merge_file(&result, &ancestor, &ours, &theirs, &opts));
+	if (!NIL_P(rb_ancestor))
+		rugged_parse_merge_file_input(&ancestor, repo, rb_ancestor);
+	if (!NIL_P(rb_ours))
+		rugged_parse_merge_file_input(&ours, repo, rb_ours);
+	if (!NIL_P(rb_theirs))
+		rugged_parse_merge_file_input(&theirs, repo, rb_theirs);
+
+	if ((error = rugged_load_merge_file_input(&ancestor_blob, repo, &ancestor)) < 0 ||
+		(error = rugged_load_merge_file_input(&our_blob, repo, &ours)) < 0 ||
+		(error = rugged_load_merge_file_input(&their_blob, repo, &theirs)) < 0 ||
+		(error = git_merge_file(&result, &ancestor.parent, &ours.parent, &theirs.parent, &opts)) < 0)
+		goto done;
 
 	rb_result = rb_merge_file_result_fromC(&result);
+
+done:
+	git_blob_free(ancestor_blob);
+	git_blob_free(our_blob);
+	git_blob_free(their_blob);
 	git_merge_file_result_free(&result);
 
+	rugged_exception_check(error);
 	return rb_result;
 }
 

test/blob_test.rb

@@ -122,28 +122,57 @@ def test_blob_text_set_encoding
     blob = @repo.lookup(oid)
     assert_equal Encoding::ASCII_8BIT, blob.text(0, Encoding::ASCII_8BIT).encoding
   end
+end
+
+class BlobMergeTest < Rugged::TestCase
+  def setup
+    @source_repo = FixtureRepo.from_rugged("testrepo.git")
+    @repo = FixtureRepo.clone(@source_repo)
+
+    @ancestor_content = "Common ancestor"
+    @our_content = "Ours side"
+    @their_content = "Theirs side"
+
+    @expected_data = "<<<<<<< OURS\nOurs side\n" +
+      "||||||| ANCESTOR\nCommon ancestor\n" +
+      "=======\n" +
+      "Theirs side\n>>>>>>> THEIRS\n"
+
+    @opts = {
+      :ancestor_label => "ANCESTOR",
+      :our_label => "OURS",
+      :their_label => "THEIRS",
+      :style => :diff3 }
+  end
 
   def test_blob_merge_files
-    ancestor = { :content => "Common ancestor", :path => "file.txt",    :filemode => 0100644 }
-    ours =     { :content => "Ours side",       :path => "newfile.txt", :filemode => 0100644 }
-    theirs =   { :content => "Theirs side",     :path => "file.txt",    :filemode => 0100755 }
+    ancestor = { :content => @ancestor_content, :path => "file.txt",    :filemode => 0100644 }
+    ours =     { :content => @our_content,      :path => "newfile.txt", :filemode => 0100644 }
+    theirs =   { :content => @their_content,    :path => "file.txt",    :filemode => 0100755 }
 
-    result = Rugged::Blob.merge_files(ancestor, ours, theirs,
-      { :ancestor_label => "ANCESTOR",
-        :our_label => "OURS",
-        :their_label => "THEIRS",
-        :style => :diff3 })
+    result = Rugged::Blob.merge_files(nil, ancestor, ours, theirs, @opts)
 
     assert_equal false, result[:automergeable]
     assert_equal "newfile.txt", result[:path]
     assert_equal 0100755, result[:filemode]
-    assert_equal "<<<<<<< OURS\n" +
-      "Ours side\n" +
-      "||||||| ANCESTOR\n" +
-      "Common ancestor\n" +
-      "=======\n" +
-      "Theirs side\n" +
-      ">>>>>>> THEIRS\n", result[:data]
+    assert_equal @expected_data, result[:data]
+  end
+
+  def test_blob_merge_files_by_oid
+    ancestor_oid = Rugged::Blob.from_buffer(@repo, @ancestor_content)
+    our_oid = Rugged::Blob.from_buffer(@repo, @our_content)
+    their_oid = Rugged::Blob.from_buffer(@repo, @their_content)
+
+    ancestor = { :oid => ancestor_oid, :path => "file.txt",    :filemode => 0100644 }
+    ours =     { :oid => our_oid,      :path => "newfile.txt", :filemode => 0100644 }
+    theirs =   { :oid => their_oid,    :path => "file.txt",    :filemode => 0100755 }
+
+    result = Rugged::Blob.merge_files(@repo, ancestor, ours, theirs, @opts)
+
+    assert_equal false, result[:automergeable]
+    assert_equal "newfile.txt", result[:path]
+    assert_equal 0100755, result[:filemode]
+    assert_equal @expected_data, result[:data]
   end
 end