rugged 0.19.0 → 0.28.0

data/ext/rugged/rugged_blob.c

@@ -1,29 +1,13 @@
 /*
- * 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"
 #include <ctype.h>
+#include <git2/sys/hashsig.h>
 
 extern VALUE rb_mRugged;
 extern VALUE rb_cRuggedObject;
@@ -31,6 +15,7 @@ extern VALUE rb_cRuggedRepo;
 static ID id_read;
 
 VALUE rb_cRuggedBlob;
+VALUE rb_cRuggedBlobSig;
 
 /*
  *  call-seq:
@@ -141,11 +126,11 @@ static VALUE rb_git_blob_rawsize(VALUE self)
 
 /*
  *  call-seq:
- *    Blob.from_buffer(repository, bytes) -> oid
+ *    Blob.from_buffer(repository, buffer) -> oid
  *
  *  Write a blob to +repository+ with the contents specified
- *  in +buffer+. In Ruby 1.9.x, the encoding of +buffer+ is
- *  ignored and bytes are copied as-is.
+ *  in +buffer+, where +buffer+ is a +String+.
+ *  The encoding of +buffer+ is ignored and bytes are copied as-is.
  */
 static VALUE rb_git_blob_from_buffer(VALUE self, VALUE rb_repo, VALUE rb_buffer)
 {
@@ -180,7 +165,7 @@ static VALUE rb_git_blob_from_workdir(VALUE self, VALUE rb_repo, VALUE rb_path)
 	git_oid oid;
 	git_repository *repo;
 
-	Check_Type(rb_path, T_STRING);
+	FilePathValue(rb_path);
 	rugged_check_repo(rb_repo);
 
 	Data_Get_Struct(rb_repo, git_repository, repo);
@@ -208,7 +193,7 @@ static VALUE rb_git_blob_from_disk(VALUE self, VALUE rb_repo, VALUE rb_path)
 	git_oid oid;
 	git_repository *repo;
 
-	Check_Type(rb_path, T_STRING);
+	FilePathValue(rb_path);
 	rugged_check_repo(rb_repo);
 
 	Data_Get_Struct(rb_repo, git_repository, repo);
@@ -219,40 +204,22 @@ static VALUE rb_git_blob_from_disk(VALUE self, VALUE rb_repo, VALUE rb_path)
 	return rugged_create_oid(&oid);
 }
 
-static VALUE rb_read_check(VALUE *args) {
-	return rb_funcall(args[0], id_read, 1, args[1]);
-}
+static VALUE rb_read_check(VALUE pointer) {
+	VALUE *args = (VALUE *)pointer;
+	VALUE rb_buffer = rb_funcall(args[0], id_read, 1, args[1]);
 
-static VALUE rb_read_failed(void) {
-	return Qnil;
-}
-
-static int cb_blob__get__chunk(char *content, size_t max_length, void *rb_io)
-{
-	VALUE rb_buffer, args[2];
-	size_t str_len, safe_len;
-
-	args[0] = (VALUE)rb_io;
-	args[1] = INT2FIX(max_length);
-
-	rb_buffer = rb_rescue(rb_read_check, (VALUE)args, rb_read_failed, 0);
-
-	if (NIL_P(rb_buffer) || TYPE(rb_buffer) != T_STRING )
-		return 0;
+	if (!NIL_P(rb_buffer))
+		Check_Type(rb_buffer, T_STRING);
 
-	str_len = (size_t)RSTRING_LEN(rb_buffer);
-	safe_len = str_len > max_length ? max_length : str_len;
-	memcpy(content, StringValuePtr(rb_buffer), safe_len);
-
-	return (int)safe_len;
+	return rb_buffer;
 }
 
 /*
  *  call-seq:
- *    Blob.from_chunks(repository, io [, hint_path]) -> oid
+ *    Blob.from_io(repository, io [, hint_path]) -> oid
  *
- *  Write a loose blob to the +repository+ from a provider
- *  of chunks of data.
+ *  Write a loose blob to the +repository+ from an +IO+ provider
+ *  of data.
  *
  *  The repository can be bare or not.
  *
@@ -262,25 +229,22 @@ static int cb_blob__get__chunk(char *content, size_t max_length, void *rb_io)
  *  return a +String+ with maximum size of +size+.
  *
  *  *NOTE:* If an exception is raised in the +io+ object's
- *  +read+ method, a blob will be created with the data up to that point
- *  and the exception will be rescued.
- *  It's recommended to compare the +blob.size+ with the expected data size
- *  to check if all the data was written.
+ *  +read+ method, no blob will be created.
  *
  *  Provided the +hint_path+ parameter is given, its value
  *  will help to determine what git filters should be applied
  *  to the object before it can be placed to the object database.
  *
  *    File.open('/path/to/file') do |file|
- *      Blob.from_chunks(repo, file, 'hint/blob.h') #=> '42cab3c0cde61e2b5a2392e1eadbeffa20ffa171'
+ *      Blob.from_io(repo, file, 'hint/blob.h') #=> '42cab3c0cde61e2b5a2392e1eadbeffa20ffa171'
  *    end
  */
-static VALUE rb_git_blob_from_chunks(int argc, VALUE *argv, VALUE klass)
+static VALUE rb_git_blob_from_io(int argc, VALUE *argv, VALUE klass)
 {
-	VALUE rb_repo, rb_io, rb_hint_path;
+	VALUE rb_repo, rb_io, rb_hint_path, rb_buffer, rb_read_args[2];
 	const char * hint_path = NULL;
-
-	int error;
+	git_writestream *stream;
+	int error = 0, exception = 0, max_length = 4096;
 	git_oid oid;
 	git_repository *repo;
 
@@ -290,22 +254,81 @@ static VALUE rb_git_blob_from_chunks(int argc, VALUE *argv, VALUE klass)
 	Data_Get_Struct(rb_repo, git_repository, repo);
 
 	if (!NIL_P(rb_hint_path)) {
-		Check_Type(rb_hint_path, T_STRING);
+		FilePathValue(rb_hint_path);
 		hint_path = StringValueCStr(rb_hint_path);
 	}
 
-	error = git_blob_create_fromchunks(
-			&oid,
-			repo,
-			hint_path,
-			cb_blob__get__chunk,
-			(void *)rb_io);
+	error = git_blob_create_fromstream(&stream, repo, hint_path);
+	if (error)
+		goto cleanup;
+
+	rb_read_args[0] = rb_io;
+	rb_read_args[1] = INT2FIX(max_length);
+
+	do {
+		rb_buffer = rb_protect(rb_read_check, (VALUE)rb_read_args, &exception);
+
+		if (exception)
+			goto cleanup;
+
+		if (NIL_P(rb_buffer))
+			break;
+
+		error = stream->write(stream, RSTRING_PTR(rb_buffer), RSTRING_LEN(rb_buffer));
+		if (error)
+			goto cleanup;
+	} while (RSTRING_LEN(rb_buffer) == max_length);
+
+	error = git_blob_create_fromstream_commit(&oid, stream);
+
+cleanup:
+
+	if (exception)
+		rb_jump_tag(exception);
 
 	rugged_exception_check(error);
 
 	return rugged_create_oid(&oid);
 }
 
+/*
+ *  call-seq:
+ *    blob.loc -> int
+ *
+ *  Return the number of lines for this blob,
+ *  assuming the blob is plaintext (i.e. not binary)
+ */
+static VALUE rb_git_blob_loc(VALUE self)
+{
+	git_blob *blob;
+	const char *data, *data_end;
+	size_t loc = 0;
+
+	Data_Get_Struct(self, git_blob, blob);
+
+	data = git_blob_rawcontent(blob);
+	data_end = data + git_blob_rawsize(blob);
+
+	if (data == data_end)
+		return INT2FIX(0);
+
+	for (; data < data_end; ++data) {
+		if (data[0] == '\n') {
+			loc++;
+		}
+		else if (data[0] == '\r') {
+			if (data + 1 < data_end && data[1] == '\n')
+				data++;
+			loc++;
+		}
+	}
+
+	if (data[-1] != '\n' && data[-1] != '\r')
+		loc++;
+
+	return INT2FIX(loc);
+}
+
 
 /*
  *  call-seq:
@@ -420,7 +443,7 @@ static VALUE rb_git_blob_diff(int argc, VALUE *argv, VALUE self)
 {
 	git_blob *blob;
 	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
-	git_diff_patch *patch;
+	git_patch *patch;
 	const char *old_path = NULL, *new_path = NULL;
 	VALUE rb_other, rb_options;
 	int error;
@@ -447,17 +470,17 @@ static VALUE rb_git_blob_diff(int argc, VALUE *argv, VALUE self)
 	Data_Get_Struct(self, git_blob, blob);
 
 	if (NIL_P(rb_other)) {
-		error = git_diff_patch_from_blobs(&patch, blob, old_path, NULL, new_path, &opts);
+		error = git_patch_from_blobs(&patch, blob, old_path, NULL, new_path, &opts);
 	} else if (rb_obj_is_kind_of(rb_other, rb_cRuggedBlob)) {
 		git_blob *other_blob;
 
 		Data_Get_Struct(rb_other, git_blob, other_blob);
 
-		error = git_diff_patch_from_blobs(&patch, blob, old_path, other_blob, new_path, &opts);
+		error = git_patch_from_blobs(&patch, blob, old_path, other_blob, new_path, &opts);
 	} else if (TYPE(rb_other) == T_STRING) {
 		const char * buffer = StringValueCStr(rb_other);
 
-		error = git_diff_patch_from_blob_and_buffer(&patch, blob, old_path, buffer, RSTRING_LEN(rb_other), new_path, &opts);
+		error = git_patch_from_blob_and_buffer(&patch, blob, old_path, buffer, RSTRING_LEN(rb_other), new_path, &opts);
 	} else {
 		rb_raise(rb_eTypeError, "wrong argument type %s (expected Rugged::Blob, String, or nil)",
 			rb_obj_classname(rb_other));
@@ -465,7 +488,203 @@ static VALUE rb_git_blob_diff(int argc, VALUE *argv, VALUE self)
 
 	rugged_exception_check(error);
 
-	return rugged_diff_patch_new(self, patch);
+	return rugged_patch_new(self, patch);
+}
+
+static VALUE rb_git_blob_to_buffer(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rb_repo, rb_sha1, rb_max_bytes;
+	VALUE rb_ret;
+
+	git_repository *repo = NULL;
+	git_blob *blob = NULL;
+
+	size_t size;
+	const char *content;
+
+	rb_scan_args(argc, argv, "21", &rb_repo, &rb_sha1, &rb_max_bytes);
+
+	rugged_check_repo(rb_repo);
+	Data_Get_Struct(rb_repo, git_repository, repo);
+
+	blob = (git_blob *)rugged_object_get(repo, rb_sha1, GIT_OBJ_BLOB);
+
+	content = git_blob_rawcontent(blob);
+	size = git_blob_rawsize(blob);
+
+	if (!NIL_P(rb_max_bytes)) {
+		int maxbytes;
+
+		Check_Type(rb_max_bytes, T_FIXNUM);
+		maxbytes = FIX2INT(rb_max_bytes);
+
+		if (maxbytes >= 0 && (size_t)maxbytes < size)
+			size = (size_t)maxbytes;
+	}
+
+	rb_ret = rb_ary_new();
+
+	rb_ary_push(rb_ret, rb_str_new(content, size));
+	rb_ary_push(rb_ret, INT2FIX(git_blob_rawsize(blob)));
+
+	git_object_free((git_object*)blob);
+
+	/* TODO: LOC */
+
+	return rb_ret;
+}
+
+#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);
+
+	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`.");
+
+		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->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->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_repo, rb_ancestor, rb_ours, rb_theirs, rb_options, rb_result = Qnil;
+
+	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, "41", &rb_repo, &rb_ancestor, &rb_ours, &rb_theirs, &rb_options);
+
+	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);
+
+	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;
+}
+
+static VALUE rb_git_blob_sig_new(int argc, VALUE *argv, VALUE klass)
+{
+	int error, opts = 0;
+	git_hashsig *sig;
+	VALUE rb_blob, rb_options;
+
+	if (rb_scan_args(argc, argv, "11", &rb_blob, &rb_options) == 2) {
+		Check_Type(rb_options, T_FIXNUM);
+		opts = FIX2INT(rb_options);
+	}
+
+	if (rb_obj_is_kind_of(rb_blob, rb_cRuggedBlob)) {
+		git_blob *blob;
+		Data_Get_Struct(rb_blob, git_blob, blob);
+
+		error = git_hashsig_create(&sig,
+				git_blob_rawcontent(blob),
+				git_blob_rawsize(blob),
+				opts);
+	} else {
+		Check_Type(rb_blob, T_STRING);
+		error = git_hashsig_create(&sig, RSTRING_PTR(rb_blob), RSTRING_LEN(rb_blob), opts);
+	}
+
+	rugged_exception_check(error);
+
+	return Data_Wrap_Struct(klass, NULL, &git_hashsig_free, sig);
+}
+
+static VALUE rb_git_blob_sig_compare(VALUE self, VALUE rb_sig_a, VALUE rb_sig_b)
+{
+	git_hashsig *sig_a;
+	git_hashsig *sig_b;
+	int result;
+
+	if (!rb_obj_is_kind_of(rb_sig_a, rb_cRuggedBlobSig) ||
+		!rb_obj_is_kind_of(rb_sig_b, rb_cRuggedBlobSig)) {
+		rb_raise(rb_eTypeError, "Expected Rugged::Blob::HashSignature");
+	}
+
+	Data_Get_Struct(rb_sig_a, git_hashsig, sig_a);
+	Data_Get_Struct(rb_sig_b, git_hashsig, sig_b);
+
+	result = git_hashsig_compare(sig_a, sig_b);
+
+	if (result < 0)
+		rugged_exception_check(result);
+
+	return INT2FIX(result);
 }
 
 void Init_rugged_blob(void)
@@ -478,12 +697,19 @@ void Init_rugged_blob(void)
 	rb_define_method(rb_cRuggedBlob, "content", rb_git_blob_content_GET, -1);
 	rb_define_method(rb_cRuggedBlob, "text", rb_git_blob_text_GET, -1);
 	rb_define_method(rb_cRuggedBlob, "sloc", rb_git_blob_sloc, 0);
+	rb_define_method(rb_cRuggedBlob, "loc", rb_git_blob_loc, 0);
 	rb_define_method(rb_cRuggedBlob, "binary?", rb_git_blob_is_binary, 0);
 	rb_define_method(rb_cRuggedBlob, "diff", rb_git_blob_diff, -1);
 
 	rb_define_singleton_method(rb_cRuggedBlob, "from_buffer", rb_git_blob_from_buffer, 2);
 	rb_define_singleton_method(rb_cRuggedBlob, "from_workdir", rb_git_blob_from_workdir, 2);
 	rb_define_singleton_method(rb_cRuggedBlob, "from_disk", rb_git_blob_from_disk, 2);
-	rb_define_singleton_method(rb_cRuggedBlob, "from_chunks", rb_git_blob_from_chunks, -1);
+	rb_define_singleton_method(rb_cRuggedBlob, "from_io", rb_git_blob_from_io, -1);
+
+	rb_define_singleton_method(rb_cRuggedBlob, "to_buffer", rb_git_blob_to_buffer, -1);
+	rb_define_singleton_method(rb_cRuggedBlob, "merge_files", rb_git_blob_merge_files, -1);
 
+	rb_cRuggedBlobSig = rb_define_class_under(rb_cRuggedBlob, "HashSignature", rb_cObject);
+	rb_define_singleton_method(rb_cRuggedBlobSig, "new", rb_git_blob_sig_new, -1);
+	rb_define_singleton_method(rb_cRuggedBlobSig, "compare", rb_git_blob_sig_compare, 2);
 }