rugged 0.17.0.b7 → 0.18.0.b1

data/ext/rugged/rugged_note.c

@@ -0,0 +1,372 @@
+/*
+ * 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.
+ */
+
+#include "rugged.h"
+
+extern VALUE rb_cRuggedRepo;
+extern VALUE rb_cRuggedObject;
+
+static VALUE rugged_git_note_message(const git_note *note)
+{
+	const char *message;
+	message = git_note_message(note);
+
+	/*
+	 * the note object is just a blob, normally it should be human readable
+	 * and in unicode like annotated tag's message,
+	 * since git allows attaching any blob as a note message
+	 * we're just making sure this works for everyone and it doesn't
+	 * reencode things it shouldn't.
+	 *
+	 * since we don't really ever know the encoding of a blob
+	 * lets default to the binary encoding (ascii-8bit)
+	 * If there is a way to tell, we should just pass 0/null here instead
+	 *
+	 * we're skipping the use of STR_NEW because we don't want our string to
+	 * eventually end up converted to Encoding.default_internal because this
+	 * string could very well be binary data
+	 */
+	return rugged_str_ascii(message, strlen(message));
+}
+
+static VALUE rugged_git_note_oid(const git_note* note)
+{
+	const git_oid *oid;
+	oid = git_note_oid(note);
+
+	return rugged_create_oid(oid);
+}
+
+/*
+ *	call-seq:
+ *		obj.notes(notes_ref = 'refs/notes/commits') -> hash
+ *
+ *	Lookup a note for +obj+ from +notes_ref+:
+ *	- +notes_ref+: (optional): cannonical name of the reference to use, defaults to "refs/notes/commits"
+ *
+ *	Returns a new Hash object.
+ *
+ *		obj.notes #=> {:message=>"note text\n", :oid=>"94eca2de348d5f672faf56b0decafa5937e3235e"}
+ */
+static VALUE rb_git_note_lookup(int argc, VALUE *argv, VALUE self)
+{
+	git_repository *repo;
+	const char *notes_ref = NULL;
+	VALUE rb_notes_ref;
+	VALUE rb_note_hash;
+	VALUE owner;
+	git_note *note;
+	git_object *object;
+	int error;
+
+	rb_scan_args(argc, argv, "01", &rb_notes_ref);
+
+	if (!NIL_P(rb_notes_ref)) {
+		Check_Type(rb_notes_ref, T_STRING);
+		notes_ref = StringValueCStr(rb_notes_ref);
+	}
+
+	Data_Get_Struct(self, git_object, object);
+
+	owner = rugged_owner(self);
+	Data_Get_Struct(owner, git_repository, repo);
+
+	error = git_note_read(&note, repo, notes_ref, git_object_id(object));
+
+	if (error == GIT_ENOTFOUND)
+		return Qnil;
+
+	rugged_exception_check(error);
+
+	rb_note_hash = rb_hash_new();
+	rb_hash_aset(rb_note_hash, CSTR2SYM("message"), rugged_git_note_message(note));
+	rb_hash_aset(rb_note_hash, CSTR2SYM("oid"), rugged_git_note_oid(note));
+
+	git_note_free(note);
+
+	return rb_note_hash;
+}
+
+/*
+ *	call-seq:
+ *		obj.create_note(data = {}) -> oid
+ *
+ *	Write a new +note+ to +object+, with the given +data+
+ *	arguments, passed as a +Hash+:
+ *
+ *	- +:message+: the content of the note to add to the object
+ *	- +:committer+: a hash with the signature for the committer
+ *	- +:author+: a hash with the signature for the author
+ *	- +:ref+: (optional): cannonical name of the reference to use, defaults to "refs/notes/commits"
+ *	- +:force+: (optional): overwrite existing note (disabled by default)
+ *
+ *	When the note 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"}
+ *
+ *		obj.create_note(
+ *			:author    => author,
+ *			:committer => author,
+ *			:message   => "Hello world\n\n",
+ *			:ref       => 'refs/notes/builds'
+ *			)
+ */
+static VALUE rb_git_note_create(VALUE self, VALUE rb_data)
+{
+	VALUE rb_ref, rb_message, rb_force;
+	git_repository *repo = NULL;
+	const char *notes_ref = NULL;
+
+	VALUE owner;
+
+	git_signature *author, *committer;
+	git_oid note_oid;
+
+	git_object *target = NULL;
+	int error = 0;
+	int force = 0;
+
+	Check_Type(rb_data, T_HASH);
+
+	Data_Get_Struct(self, git_object, target);
+
+	owner = rugged_owner(self);
+	Data_Get_Struct(owner, git_repository, repo);
+
+	rb_ref = rb_hash_aref(rb_data, CSTR2SYM("ref"));
+
+	rb_force = rb_hash_aref(rb_data, CSTR2SYM("force"));
+	if (!NIL_P(rb_force))
+		force = rugged_parse_bool(rb_force);
+
+	if (!NIL_P(rb_ref)) {
+		Check_Type(rb_ref, T_STRING);
+		notes_ref = StringValueCStr(rb_ref);
+	}
+
+	rb_message = rb_hash_aref(rb_data, CSTR2SYM("message"));
+	Check_Type(rb_message, T_STRING);
+
+	committer = rugged_signature_get(
+		rb_hash_aref(rb_data, CSTR2SYM("committer"))
+	);
+
+	author = rugged_signature_get(
+		rb_hash_aref(rb_data, CSTR2SYM("author"))
+	);
+
+	error = git_note_create(
+			&note_oid,
+			repo,
+			author,
+			committer,
+			notes_ref,
+			git_object_id(target),
+			StringValueCStr(rb_message),
+			force);
+
+
+	git_signature_free(author);
+	git_signature_free(committer);
+
+	rugged_exception_check(error);
+
+	return rugged_create_oid(&note_oid);
+}
+
+/*
+ *	call-seq:
+ *		obj.remove_note(data = {}) -> boolean
+ *
+ *	Removes a +note+ from +object+, with the given +data+
+ *	arguments, passed as a +Hash+:
+ *
+ *	- +:committer+: a hash with the signature for the committer
+ *	- +:author+: a hash with the signature for the author
+ *	- +:ref+: (optional): cannonical name of the reference to use, defaults to "refs/notes/commits"
+ *
+ *	When the note is successfully removed +true+ will be
+ *	returned as a +Boolean+.
+ *
+ *		author = {:email=>"tanoku@gmail.com", :time=>Time.now, :name=>"Vicent Mart\303\255"}
+ *
+ *		obj.remove_note(
+ *			:author    => author,
+ *			:committer => author,
+ *			:ref       => 'refs/notes/builds'
+ *			)
+ */
+static VALUE rb_git_note_remove(VALUE self, VALUE rb_data)
+{
+	VALUE rb_ref;
+	git_repository *repo = NULL;
+	const char *notes_ref = NULL;
+
+	VALUE owner;
+
+	git_signature *author, *committer;
+
+	git_object *target = NULL;
+	int error = 0;
+
+	Check_Type(rb_data, T_HASH);
+
+	Data_Get_Struct(self, git_object, target);
+
+	owner = rugged_owner(self);
+	Data_Get_Struct(owner, git_repository, repo);
+
+	rb_ref = rb_hash_aref(rb_data, CSTR2SYM("ref"));
+
+	if (!NIL_P(rb_ref)) {
+		Check_Type(rb_ref, T_STRING);
+		notes_ref = StringValueCStr(rb_ref);
+	}
+
+	committer = rugged_signature_get(
+		rb_hash_aref(rb_data, CSTR2SYM("committer"))
+	);
+
+	author = rugged_signature_get(
+		rb_hash_aref(rb_data, CSTR2SYM("author"))
+	);
+
+	error = git_note_remove(
+			repo,
+			notes_ref,
+			author,
+			committer,
+			git_object_id(target));
+
+	git_signature_free(author);
+	git_signature_free(committer);
+
+	if (error == GIT_ENOTFOUND)
+		return Qfalse;
+
+	rugged_exception_check(error);
+
+	return Qtrue;
+}
+
+static int cb_note__each(const git_oid *blob_id, const git_oid *annotated_object_id, void *payload)
+{
+	VALUE rb_repo = (VALUE)payload;
+
+	git_object *annotated_object;
+	git_object *note_blob;
+
+	git_repository *repo;
+
+	Data_Get_Struct(rb_repo, git_repository, repo);
+
+	rugged_exception_check(
+		git_object_lookup(&annotated_object, repo, annotated_object_id, GIT_OBJ_ANY)
+	);
+
+	rugged_exception_check(
+		git_object_lookup(&note_blob, repo, blob_id, GIT_OBJ_BLOB)
+	);
+
+	rb_yield_values(2,
+			rugged_object_new(rb_repo, note_blob),
+			rugged_object_new(rb_repo, annotated_object)
+	);
+	return GIT_OK;
+}
+
+/*
+ *	call-seq:
+ *		repo.each_note(notes_ref = "refs/notes/commits") { |note_blob, annotated_object| block }
+ *		repo.each_note(notes_ref = "refs/notes/commits") -> an_enumerator
+ *
+ *	Call the given block once for each note_blob/annotated_object pair in +repository+
+ *	- +notes_ref+: (optional): cannonical name of the reference to use defaults to "refs/notes/commits"
+ *
+ *	If no block is given, an +Enumerator+ is returned.
+ *
+ *		@repo.each_note do |note_blob, annotated_object|
+ *			puts "#{note_blob.oid} => #{annotated_object.oid}"
+ *		end
+ */
+static VALUE rb_git_note_each(int argc, VALUE *argv, VALUE self)
+{
+	git_repository *repo;
+	const char *notes_ref = NULL;
+	int error;
+
+	VALUE rb_notes_ref;
+
+	rb_scan_args(argc, argv, "01", &rb_notes_ref);
+
+	if (!rb_block_given_p()) {
+		return rb_funcall(self, rb_intern("to_enum"), 3, CSTR2SYM("each_note"), self, rb_notes_ref);
+	}
+
+	if (!NIL_P(rb_notes_ref)) {
+		Check_Type(rb_notes_ref, T_STRING);
+		notes_ref = StringValueCStr(rb_notes_ref);
+	}
+
+	Data_Get_Struct(self, git_repository, repo);
+
+	error = git_note_foreach(repo, notes_ref, &cb_note__each, (void *)self);
+	rugged_exception_check(error);
+	return Qnil;
+}
+
+/*
+ *	call-seq:
+ *		repo.notes_default_ref() -> string
+ *
+ *	Get the default notes reference for a +repository+:
+ *
+ *	Returns a new String object.
+ *
+ *		repo.default_notes_ref #=> "refs/notes/commits"
+ */
+static VALUE rb_git_note_default_ref_GET(VALUE self)
+{
+	git_repository *repo = NULL;
+	const char * ref_name;
+
+	Data_Get_Struct(self, git_repository, repo);
+
+	rugged_exception_check(
+		git_note_default_ref(&ref_name, repo)
+	);
+
+	return rugged_str_new2(ref_name, NULL);
+}
+
+void Init_rugged_notes()
+{
+	rb_define_method(rb_cRuggedObject, "notes", rb_git_note_lookup, -1);
+	rb_define_method(rb_cRuggedObject, "create_note", rb_git_note_create, 1);
+	rb_define_method(rb_cRuggedObject, "remove_note", rb_git_note_remove, 1);
+
+	rb_define_method(rb_cRuggedRepo, "each_note", rb_git_note_each, -1);
+	rb_define_method(rb_cRuggedRepo, "default_notes_ref", rb_git_note_default_ref_GET, 0);
+}

data/ext/rugged/rugged_object.c

@@ -1,7 +1,7 @@
 /*
  * The MIT License
  *
- * Copyright (c) 2011 GitHub, Inc
+ * 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
@@ -85,35 +85,65 @@ VALUE rugged_otype_new(git_otype t)
 	}
 }
 
+void rugged_oid_get(git_oid *oid, git_repository *repo, VALUE p)
+{
+	git_object *object;
+	int error;
+
+	if (rb_obj_is_kind_of(p, rb_cRuggedObject)) {
+		Data_Get_Struct(p, git_object, object);
+		git_oid_cpy(oid, git_object_id(object));
+	} else {
+		Check_Type(p, T_STRING);
+
+		/* Fast path: see if the 40-char string is an OID */
+		if (RSTRING_LEN(p) == 40 &&
+			git_oid_fromstr(oid, RSTRING_PTR(p)) == 0)
+			return;
+
+		error = git_revparse_single(&object, repo, StringValueCStr(p));
+		rugged_exception_check(error);
+
+		git_oid_cpy(oid, git_object_id(object));
+		git_object_free(object);
+	}
+}
 
-git_object *rugged_object_load(git_repository *repo, VALUE object_value, git_otype type)
+git_object *rugged_object_get(git_repository *repo, VALUE object_value, git_otype type)
 {
 	git_object *object = NULL;
 
-	if (TYPE(object_value) == T_STRING) {
-		git_oid oid;
-		int oid_length = (int)RSTRING_LEN(object_value);
+	if (rb_obj_is_kind_of(object_value, rb_cRuggedObject)) {
+		git_object *owned_obj = NULL;
+		Data_Get_Struct(object_value, git_object, owned_obj);
+		git_object_dup(&object, owned_obj);
+	} else {
 		int error;
 
-		error = git_oid_fromstrn(&oid, RSTRING_PTR(object_value), oid_length);
-		rugged_exception_check(error);
+		Check_Type(object_value, T_STRING);
 
-		if (oid_length < GIT_OID_HEXSZ)
-			error = git_object_lookup_prefix(&object, repo, &oid, oid_length, type);
-		else
-			error = git_object_lookup(&object, repo, &oid, type);
-		rugged_exception_check(error);
+		/* Fast path: if we have a 40-char string, just perform the lookup directly */
+		if (RSTRING_LEN(object_value) == 40) {
+			git_oid oid;
 
-	} else if (rb_obj_is_kind_of(object_value, rb_cRuggedObject)) {
-		Data_Get_Struct(object_value, git_object, object);
+			/* If it's not an OID, we can still try the revparse */
+			if (git_oid_fromstr(&oid, RSTRING_PTR(object_value)) == 0) {
+				error = git_object_lookup(&object, repo, &oid, type);
+				rugged_exception_check(error);
+				return object;
+			}
+		}
 
-		if (type != GIT_OBJ_ANY && git_object_type(object) != type)
-			rb_raise(rb_eTypeError, "Object is not of the required type");
-	} else {
-		rb_raise(rb_eTypeError, "Invalid GIT object; an object reference must be a SHA1 id or an object itself");
+		/* Otherwise, assume the string is a revlist and try to parse it */
+		error = git_revparse_single(&object, repo, StringValueCStr(object_value));
+		rugged_exception_check(error);
 	}
 
 	assert(object);
+
+	if (type != GIT_OBJ_ANY && git_object_type(object) != type)
+		rb_raise(rb_eArgError, "Object is not of the required type");
+
 	return object;
 }
 
@@ -190,8 +220,7 @@ VALUE rb_git_object_lookup(VALUE klass, VALUE rb_repo, VALUE rb_hex)
 	Check_Type(rb_hex, T_STRING);
 	oid_length = (int)RSTRING_LEN(rb_hex);
 
-	if (!rb_obj_is_instance_of(rb_repo, rb_cRuggedRepo))
-		rb_raise(rb_eTypeError, "Expecting a Rugged Repository");
+	rugged_check_repo(rb_repo);
 
 	if (oid_length > GIT_OID_HEXSZ)
 		rb_raise(rb_eTypeError, "The given OID is too long");
@@ -222,8 +251,7 @@ static VALUE rugged_object_rev_parse(VALUE klass, VALUE rb_repo, VALUE rb_spec,
 	Check_Type(rb_spec, T_STRING);
 	spec = RSTRING_PTR(rb_spec);
 
-	if (!rb_obj_is_instance_of(rb_repo, rb_cRuggedRepo))
-		rb_raise(rb_eTypeError, "Expecting a Rugged Repository");
+	rugged_check_repo(rb_repo);
 
 	Data_Get_Struct(rb_repo, git_repository, repo);