rugged 0.25.0b2 → 0.25.0b3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4f92aa719b09c0bc6b851086d77eaceaee7d652c
-  data.tar.gz: e87ded2043f332eae518cdfd4405f7e05cf40413
+  metadata.gz: decef5bc39de7103a2e879463898551989f0356f
+  data.tar.gz: 0011b10ea74d9092eaa562c635a1fbfc9aa8603d
 SHA512:
-  metadata.gz: 3bcc955d28541daed191f26bc4ae37a336bd0cb2a701da8a31990255920e1b87f2d0d20081bf41cda7ec4af1094acab9b08ca4c531e94dba74cc8f84a6cedb45
-  data.tar.gz: 79d06e428b8d9b03a3d132530e88e7b85e3c4865959ce553c5751a23c10cacca27308edb43b655a7982dbd296d107b6deba0dcfebb9ffe94cfa3a9b09e0d87c0
+  metadata.gz: a72e1a7f4f0053397c15a3f995ed11b4fa3255202ff738a148652f4813ce619d62481423084b471659905a023d3c2ed42d83d182c86f0a66cfdb50ab18fe2aef
+  data.tar.gz: b45c43553374f7eb2ea44728f9fb9e15e2eb8bee4f70261c6336f38d9d8345d7b87b567289e040663426a2a3a0216a46197130ef0b3e386fe0d19cdb40388ba2

data/LICENSE

@@ -1,6 +1,6 @@
 The MIT License
 
-Copyright (c) 2015 GitHub, Inc
+Copyright (c) 2016 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

data/ext/rugged/extconf.rb

@@ -67,7 +67,9 @@ else
     Dir.mkdir("build") if !Dir.exists?("build")
 
     Dir.chdir("build") do
-      sys("cmake .. -DBUILD_CLAR=OFF -DTHREADSAFE=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_C_FLAGS=-fPIC -DCMAKE_BUILD_TYPE=RelWithDebInfo -G \"Unix Makefiles\"")
+      # On Windows, Ruby-DevKit is MSYS-based, so ensure to use MSYS Makefiles.
+      generator = "-G \"MSYS Makefiles\"" if windows?
+      sys("cmake .. -DBUILD_CLAR=OFF -DTHREADSAFE=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_C_FLAGS=-fPIC -DCMAKE_BUILD_TYPE=RelWithDebInfo #{generator}")
       sys(MAKE)
 
       # "normal" libraries (and libgit2 builds) get all these when they build but we're doing it

data/ext/rugged/rugged.c

@@ -181,7 +181,7 @@ static VALUE rb_git_raw_to_hex(VALUE self, VALUE raw)
 	git_oid_fromraw(&oid, (const unsigned char *)RSTRING_PTR(raw));
 	git_oid_fmt(out, &oid);
 
-	return rb_str_new(out, 40);
+	return rb_usascii_str_new(out, 40);
 }
 
 /*

data/ext/rugged/rugged.h

@@ -176,7 +176,7 @@ static inline VALUE rugged_create_oid(const git_oid *oid)
 {
 	char out[40];
 	git_oid_fmt(out, oid);
-	return rb_str_new(out, 40);
+	return rb_usascii_str_new(out, 40);
 }
 
 

data/ext/rugged/rugged_blob.c

@@ -231,30 +231,6 @@ static VALUE rb_read_check(VALUE pointer) {
 	return rb_buffer;
 }
 
-static int cb_blob__get__chunk(char *content, size_t max_length, void *data)
-{
-	VALUE rb_buffer, rb_args[2];
-	size_t str_len, safe_len;
-	struct rugged_cb_payload *payload = data;
-
-	rb_args[0] = payload->rb_data;
-	rb_args[1] = INT2FIX(max_length);
-
-	rb_buffer = rb_protect(rb_read_check, (VALUE)rb_args, &payload->exception);
-
-	if (payload->exception)
-		return GIT_ERROR;
-
-	if (NIL_P(rb_buffer))
-		return 0;
-
-	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;
-}
-
 /*
  *  call-seq:
  *    Blob.from_io(repository, io [, hint_path]) -> oid
@@ -282,11 +258,10 @@ static int cb_blob__get__chunk(char *content, size_t max_length, void *data)
  */
 static VALUE rb_git_blob_from_io(int argc, VALUE *argv, VALUE klass)
 {
-	VALUE rb_repo, rb_io, rb_hint_path;
-	struct rugged_cb_payload payload;
+	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;
 
@@ -300,18 +275,34 @@ static VALUE rb_git_blob_from_io(int argc, VALUE *argv, VALUE klass)
 		hint_path = StringValueCStr(rb_hint_path);
 	}
 
-	payload.exception = 0;
-	payload.rb_data = 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:
 
-	error = git_blob_create_fromchunks(
-			&oid,
-			repo,
-			hint_path,
-			cb_blob__get__chunk,
-			(void *)&payload);
+	if (exception)
+		rb_jump_tag(exception);
 
-	if (payload.exception)
-		rb_jump_tag(payload.exception);
 	rugged_exception_check(error);
 
 	return rugged_create_oid(&oid);

data/ext/rugged/rugged_commit.c

@@ -338,69 +338,44 @@ static VALUE rb_git_commit_amend(VALUE self, VALUE rb_data)
 	return rugged_create_oid(&commit_oid);
 }
 
-/*
- *  call-seq:
- *    Commit.create(repository, data = {}) -> oid
- *
- *  Write a new +Commit+ object to +repository+, with the given +data+
- *  arguments, passed as a +Hash+:
- *
- *  - +:message+: a string with the full text for the commit's message
- *  - +:committer+ (optional): a hash with the signature for the committer,
- *    defaults to the signature from the configuration
- *  - +:author+ (optional): a hash with the signature for the author,
- *    defaults to the signature from the configuration
- *  - +:parents+: an +Array+ with zero or more parents for this commit,
- *    represented as <tt>Rugged::Commit</tt> instances, or OID +String+.
- *  - +:tree+: the tree for this commit, represented as a <tt>Rugged::Tree</tt>
- *    instance or an OID +String+.
- *  - +:update_ref+ (optional): a +String+ with the name of a reference in the
- *    repository which should be updated to point to this commit (e.g. "HEAD")
- *
- *  When the commit is successfully written to disk, its +oid+ will be
- *  returned as a hex +String+.
- *
- *    author = {:email=>"tanoku@gmail.com", :time=>Time.now, :name=>"Vicent Mart\303\255"}
+struct commit_data {
+	VALUE rb_err_obj;
+
+	const char *update_ref;
+	const char *message;
+	git_tree *tree;
+	git_signature *author;
+	git_signature *committer;
+	int parent_count;
+	const git_commit **parents;
+};
+
+/**
+ * Parse the commit options into something we can re-use
  *
- *    Rugged::Commit.create(r,
- *      :author => author,
- *      :message => "Hello world\n\n",
- *      :committer => author,
- *      :parents => ["2cb831a8aea28b2c1b9c63385585b864e4d3bad1"],
- *      :tree => some_tree) #=> "f148106ca58764adc93ad4e2d6b1d168422b9796"
+ * Note that parents may be set even when the function errors, so make
+ * sure to free this data.
  */
-static VALUE rb_git_commit_create(VALUE self, VALUE rb_repo, VALUE rb_data)
+static VALUE parse_commit_options(struct commit_data *out, git_repository *repo, VALUE rb_data)
 {
 	VALUE rb_message, rb_tree, rb_parents, rb_ref;
-	VALUE rb_err_obj = Qnil;
-	int parent_count, i, error = 0;
-	const git_commit **parents = NULL;
-	git_commit **free_list = NULL;
-	git_tree *tree;
-	git_signature *author, *committer;
-	git_oid commit_oid;
-	git_repository *repo;
-	const char *update_ref = NULL;
-
-	Check_Type(rb_data, T_HASH);
-
-	rugged_check_repo(rb_repo);
-	Data_Get_Struct(rb_repo, git_repository, repo);
+	int error = 0, parent_count, i;
 
 	rb_ref = rb_hash_aref(rb_data, CSTR2SYM("update_ref"));
 	if (!NIL_P(rb_ref)) {
 		Check_Type(rb_ref, T_STRING);
-		update_ref = StringValueCStr(rb_ref);
+		out->update_ref = StringValueCStr(rb_ref);
 	}
 
 	rb_message = rb_hash_aref(rb_data, CSTR2SYM("message"));
 	Check_Type(rb_message, T_STRING);
+	out->message = StringValueCStr(rb_message);
 
-	committer = rugged_signature_get(
+	out->committer = rugged_signature_get(
 		rb_hash_aref(rb_data, CSTR2SYM("committer")), repo
 	);
 
-	author = rugged_signature_get(
+	out->author = rugged_signature_get(
 		rb_hash_aref(rb_data, CSTR2SYM("author")), repo
 	);
 
@@ -408,16 +383,15 @@ static VALUE rb_git_commit_create(VALUE self, VALUE rb_repo, VALUE rb_data)
 	Check_Type(rb_parents, T_ARRAY);
 
 	rb_tree = rb_hash_aref(rb_data, CSTR2SYM("tree"));
-	tree = (git_tree *)rugged_object_get(repo, rb_tree, GIT_OBJ_TREE);
+	out->tree = (git_tree *)rugged_object_get(repo, rb_tree, GIT_OBJ_TREE);
 
-	parents = alloca(RARRAY_LEN(rb_parents) * sizeof(void *));
-	free_list = alloca(RARRAY_LEN(rb_parents) * sizeof(void *));
+	out->parents = xcalloc(RARRAY_LEN(rb_parents), sizeof(void *));
 	parent_count = 0;
 
 	for (i = 0; i < (int)RARRAY_LEN(rb_parents); ++i) {
 		VALUE p = rb_ary_entry(rb_parents, i);
 		git_commit *parent = NULL;
-		git_commit *free_ptr = NULL;
+		git_commit *tmp = NULL;
 
 		if (NIL_P(p))
 			continue;
@@ -427,49 +401,106 @@ static VALUE rb_git_commit_create(VALUE self, VALUE rb_repo, VALUE rb_data)
 
 			error = git_oid_fromstr(&oid, StringValueCStr(p));
 			if (error < GIT_OK)
-				goto cleanup;
+				goto out;
 
 			error = git_commit_lookup(&parent, repo, &oid);
 			if (error < GIT_OK)
-				goto cleanup;
-
-			free_ptr = parent;
-
+				goto out;
 		} else if (rb_obj_is_kind_of(p, rb_cRuggedCommit)) {
-			Data_Get_Struct(p, git_commit, parent);
+			Data_Get_Struct(p, git_commit, tmp);
+			if ((error = git_object_dup((git_object **) &parent, (git_object *) tmp)) < 0)
+				goto out;
 		} else {
-			rb_err_obj = rb_exc_new2(rb_eTypeError, "Invalid type for parent object");
-			goto cleanup;
+			out->rb_err_obj = rb_exc_new2(rb_eTypeError, "Invalid type for parent object");
+			error = -1;
+			goto out;
 		}
 
-		parents[parent_count] = parent;
-		free_list[parent_count] = free_ptr;
+		out->parents[parent_count] = parent;
 		parent_count++;
 	}
 
+out:
+	out->parent_count = parent_count;
+	return error;
+}
+
+static void free_commit_options(struct commit_data *commit_data)
+{
+	int i;
+
+	git_signature_free(commit_data->author);
+	git_signature_free(commit_data->committer);
+
+	git_object_free((git_object *)commit_data->tree);
+
+	for (i = 0; i < commit_data->parent_count; ++i)
+		git_object_free((git_object *) commit_data->parents[i]);
+	xfree(commit_data->parents);
+}
+
+/*
+ *  call-seq:
+ *    Commit.create(repository, data = {}) -> oid
+ *
+ *  Write a new +Commit+ object to +repository+, with the given +data+
+ *  arguments, passed as a +Hash+:
+ *
+ *  - +:message+: a string with the full text for the commit's message
+ *  - +:committer+ (optional): a hash with the signature for the committer,
+ *    defaults to the signature from the configuration
+ *  - +:author+ (optional): a hash with the signature for the author,
+ *    defaults to the signature from the configuration
+ *  - +:parents+: an +Array+ with zero or more parents for this commit,
+ *    represented as <tt>Rugged::Commit</tt> instances, or OID +String+.
+ *  - +:tree+: the tree for this commit, represented as a <tt>Rugged::Tree</tt>
+ *    instance or an OID +String+.
+ *  - +:update_ref+ (optional): a +String+ with the name of a reference in the
+ *    repository which should be updated to point to this commit (e.g. "HEAD")
+ *
+ *  When the commit is successfully written to disk, its +oid+ will be
+ *  returned as a hex +String+.
+ *
+ *    author = {:email=>"tanoku@gmail.com", :time=>Time.now, :name=>"Vicent Mart\303\255"}
+ *
+ *    Rugged::Commit.create(r,
+ *      :author => author,
+ *      :message => "Hello world\n\n",
+ *      :committer => author,
+ *      :parents => ["2cb831a8aea28b2c1b9c63385585b864e4d3bad1"],
+ *      :tree => some_tree) #=> "f148106ca58764adc93ad4e2d6b1d168422b9796"
+ */
+static VALUE rb_git_commit_create(VALUE self, VALUE rb_repo, VALUE rb_data)
+{
+	int error = 0;
+	struct commit_data commit_data = { Qnil };
+	git_oid commit_oid;
+	git_repository *repo;
+
+	Check_Type(rb_data, T_HASH);
+
+	rugged_check_repo(rb_repo);
+	Data_Get_Struct(rb_repo, git_repository, repo);
+
+	if ((error = parse_commit_options(&commit_data, repo, rb_data)) < 0)
+		goto cleanup;
+
 	error = git_commit_create(
 		&commit_oid,
 		repo,
-		update_ref,
-		author,
-		committer,
+		commit_data.update_ref,
+		commit_data.author,
+		commit_data.committer,
 		NULL,
-		StringValueCStr(rb_message),
-		tree,
-		parent_count,
-		parents);
+		commit_data.message,
+		commit_data.tree,
+		commit_data.parent_count,
+		commit_data.parents);
 
 cleanup:
-	git_signature_free(author);
-	git_signature_free(committer);
-
-	git_object_free((git_object *)tree);
-
-	for (i = 0; i < parent_count; ++i)
-		git_object_free((git_object *)free_list[i]);
-
-	if (!NIL_P(rb_err_obj))
-		rb_exc_raise(rb_err_obj);
+	free_commit_options(&commit_data);
+	if (!NIL_P(commit_data.rb_err_obj))
+		rb_exc_raise(commit_data.rb_err_obj);
 
 	rugged_exception_check(error);
 
@@ -662,11 +693,117 @@ static VALUE rb_git_commit_extract_signature(int argc, VALUE *argv, VALUE self)
 	return ret;
 }
 
+/*
+ *  call-seq:
+ *    Commit.create_to_s(repository, data = {}) -> str
+ *
+ *  Create a string with the contents of the commit, created with the
+ *  given +data+ arguments, passed as a +Hash+:
+ *
+ *  - +:message+: a string with the full text for the commit's message
+ *  - +:committer+ (optional): a hash with the signature for the committer,
+ *    defaults to the signature from the configuration
+ *  - +:author+ (optional): a hash with the signature for the author,
+ *    defaults to the signature from the configuration
+ *  - +:parents+: an +Array+ with zero or more parents for this commit,
+ *    represented as <tt>Rugged::Commit</tt> instances, or OID +String+.
+ *  - +:tree+: the tree for this commit, represented as a <tt>Rugged::Tree</tt>
+ *    instance or an OID +String+.
+ *
+ *    author = {:email=>"tanoku@gmail.com", :time=>Time.now, :name=>"Vicent Mart\303\255"}
+ *
+ *    Rugged::Commit.create(r,
+ *      :author => author,
+ *      :message => "Hello world\n\n",
+ *      :committer => author,
+ *      :parents => ["2cb831a8aea28b2c1b9c63385585b864e4d3bad1"],
+ *      :tree => some_tree) #=> "tree some_tree\nparent 2cb831...."
+ */
+static VALUE rb_git_commit_create_to_s(VALUE self, VALUE rb_repo, VALUE rb_data)
+{
+	int error = 0;
+	struct commit_data commit_data = { Qnil };
+	git_repository *repo;
+	git_buf buf = { 0 };
+	VALUE ret;
+
+	Check_Type(rb_data, T_HASH);
+
+	rugged_check_repo(rb_repo);
+	Data_Get_Struct(rb_repo, git_repository, repo);
+
+	if ((error = parse_commit_options(&commit_data, repo, rb_data)) < 0)
+		goto cleanup;
+
+	error = git_commit_create_buffer(
+		&buf,
+		repo,
+		commit_data.author,
+		commit_data.committer,
+		NULL,
+		commit_data.message,
+		commit_data.tree,
+		commit_data.parent_count,
+		commit_data.parents);
+
+cleanup:
+	free_commit_options(&commit_data);
+	if (!NIL_P(commit_data.rb_err_obj))
+		rb_exc_raise(commit_data.rb_err_obj);
+
+	rugged_exception_check(error);
+
+	ret = rb_str_new_utf8(buf.ptr);
+	git_buf_free(&buf);
+
+	return ret;
+}
+
+/*
+ *  call-seq:
+ *    Rugged::Commit.create_with_signature(repo, content, signature, field_name = "gpgsig") -> oid
+ *
+ *  Create a commit from the +content+ string and the +signature+,
+ *  adding this data to the +field_name+ header field in the resulting
+ *  commit.
+ *
+ *  Returns the new commit's object id.
+ *
+ */
+static VALUE rb_git_commit_create_with_signature(int argc, VALUE *argv, VALUE self)
+{
+	int error;
+	git_oid id;
+	const char *field = NULL;
+	git_repository *repo;
+	VALUE rb_repo, rb_content, rb_signature, rb_field = Qnil;
+
+	rb_scan_args(argc, argv, "31", &rb_repo, &rb_content, &rb_signature, &rb_field);
+
+	rugged_check_repo(rb_repo);
+	Data_Get_Struct(rb_repo, git_repository, repo);
+
+	Check_Type(rb_content, T_STRING);
+	Check_Type(rb_signature, T_STRING);
+
+	if (!NIL_P(rb_field)) {
+		Check_Type(rb_field, T_STRING);
+		field = StringValueCStr(rb_field);
+	}
+
+	error = git_commit_create_with_signature(&id, repo, StringValueCStr(rb_content), StringValueCStr(rb_signature), field);
+	rugged_exception_check(error);
+
+	return rugged_create_oid(&id);
+}
+
 void Init_rugged_commit(void)
 {
 	rb_cRuggedCommit = rb_define_class_under(rb_mRugged, "Commit", rb_cRuggedObject);
 
 	rb_define_singleton_method(rb_cRuggedCommit, "create", rb_git_commit_create, 2);
+	rb_define_singleton_method(rb_cRuggedCommit, "create_to_s", rb_git_commit_create_to_s, 2);
+	rb_define_singleton_method(rb_cRuggedCommit, "create_with_signature", rb_git_commit_create_with_signature, -1);
 	rb_define_singleton_method(rb_cRuggedCommit, "extract_signature", rb_git_commit_extract_signature, -1);
 
 	rb_define_method(rb_cRuggedCommit, "message", rb_git_commit_message_GET, 0);