rugged 0.18.0.gh.de28323 → 0.19.0

data/ext/rugged/rugged_note.c

@@ -33,21 +33,10 @@ static VALUE rugged_git_note_message(const git_note *note)
 	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
+	 * assume the note message is utf8 compatible, because that's
+	 * the sensible thing to do.
 	 */
-	return rugged_str_ascii(message, strlen(message));
+	return rb_str_new_utf8(message);
 }
 
 static VALUE rugged_git_note_oid(const git_note* note)
@@ -59,15 +48,15 @@ static VALUE rugged_git_note_oid(const git_note* note)
 }
 
 /*
- *	call-seq:
- *		obj.notes(notes_ref = 'refs/notes/commits') -> hash
+ *  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"
+ *  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.
+ *  Returns a new Hash object.
  *
- *		obj.notes #=> {:message=>"note text\n", :oid=>"94eca2de348d5f672faf56b0decafa5937e3235e"}
+ *    obj.notes #=> {:message=>"note text\n", :oid=>"94eca2de348d5f672faf56b0decafa5937e3235e"}
  */
 static VALUE rb_git_note_lookup(int argc, VALUE *argv, VALUE self)
 {
@@ -109,29 +98,29 @@ static VALUE rb_git_note_lookup(int argc, VALUE *argv, VALUE self)
 }
 
 /*
- *	call-seq:
- *		obj.create_note(data = {}) -> oid
+ *  call-seq:
+ *    obj.create_note(data = {}) -> oid
  *
- *	Write a new +note+ to +object+, with the given +data+
- *	arguments, passed as a +Hash+:
+ *  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)
+ *  - +: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+.
+ *  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"}
+ *    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'
- *			)
+ *    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)
 {
@@ -197,26 +186,26 @@ static VALUE rb_git_note_create(VALUE self, VALUE rb_data)
 }
 
 /*
- *	call-seq:
- *		obj.remove_note(data = {}) -> boolean
+ *  call-seq:
+ *    obj.remove_note(data = {}) -> boolean
  *
- *	Removes a +note+ from +object+, with the given +data+
- *	arguments, passed as a +Hash+:
+ *  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"
+ *  - +: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+.
+ *  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"}
+ *    author = {:email=>"tanoku@gmail.com", :time=>Time.now, :name=>"Vicent Mart\303\255"}
  *
- *		obj.remove_note(
- *			:author    => author,
- *			:committer => author,
- *			:ref       => 'refs/notes/builds'
- *			)
+ *    obj.remove_note(
+ *      :author    => author,
+ *      :committer => author,
+ *      :ref       => 'refs/notes/builds'
+ *    )
  */
 static VALUE rb_git_note_remove(VALUE self, VALUE rb_data)
 {
@@ -271,16 +260,16 @@ static VALUE rb_git_note_remove(VALUE self, VALUE rb_data)
 	return Qtrue;
 }
 
-static int cb_note__each(const git_oid *blob_id, const git_oid *annotated_object_id, void *payload)
+static int cb_note__each(const git_oid *blob_id, const git_oid *annotated_object_id, void *data)
 {
-	VALUE rb_repo = (VALUE)payload;
-
+	VALUE rb_args = rb_ary_new2(2);
+	struct rugged_cb_payload *payload = data;
 	git_object *annotated_object;
 	git_object *note_blob;
 
 	git_repository *repo;
 
-	Data_Get_Struct(rb_repo, git_repository, repo);
+	Data_Get_Struct(payload->rb_data, git_repository, repo);
 
 	rugged_exception_check(
 		git_object_lookup(&annotated_object, repo, annotated_object_id, GIT_OBJ_ANY)
@@ -290,33 +279,34 @@ static int cb_note__each(const git_oid *blob_id, const git_oid *annotated_object
 		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;
+	rb_ary_push(rb_args, rugged_object_new(payload->rb_data, note_blob));
+	rb_ary_push(rb_args, rugged_object_new(payload->rb_data, annotated_object));
+
+	rb_protect(rb_yield_splat, rb_args, &payload->exception);
+
+	return payload->exception ? GIT_ERROR : 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-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"
+ *  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.
+ *  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
+ *    @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;
-
+	struct rugged_cb_payload payload = { self, 0 };
 	VALUE rb_notes_ref;
 
 	rb_scan_args(argc, argv, "01", &rb_notes_ref);
@@ -332,20 +322,24 @@ static VALUE rb_git_note_each(int argc, VALUE *argv, VALUE self)
 
 	Data_Get_Struct(self, git_repository, repo);
 
-	error = git_note_foreach(repo, notes_ref, &cb_note__each, (void *)self);
+	error = git_note_foreach(repo, notes_ref, &cb_note__each, &payload);
+
+	if (payload.exception)
+		rb_jump_tag(payload.exception);
 	rugged_exception_check(error);
+
 	return Qnil;
 }
 
 /*
- *	call-seq:
- *		repo.notes_default_ref() -> string
+ *  call-seq:
+ *    repo.notes_default_ref() -> string
  *
- *	Get the default notes reference for a +repository+:
+ *  Get the default notes reference for a +repository+:
  *
- *	Returns a new String object.
+ *  Returns a new String object.
  *
- *		repo.default_notes_ref #=> "refs/notes/commits"
+ *    repo.default_notes_ref #=> "refs/notes/commits"
  */
 static VALUE rb_git_note_default_ref_GET(VALUE self)
 {
@@ -358,10 +352,10 @@ static VALUE rb_git_note_default_ref_GET(VALUE self)
 		git_note_default_ref(&ref_name, repo)
 	);
 
-	return rugged_str_new2(ref_name, NULL);
+	return rb_str_new_utf8(ref_name);
 }
 
-void Init_rugged_notes()
+void Init_rugged_notes(void)
 {
 	rb_define_method(rb_cRuggedObject, "notes", rb_git_note_lookup, -1);
 	rb_define_method(rb_cRuggedObject, "create_note", rb_git_note_create, 1);

data/ext/rugged/rugged_object.c

@@ -85,7 +85,7 @@ VALUE rugged_otype_new(git_otype t)
 	}
 }
 
-void rugged_oid_get(git_oid *oid, git_repository *repo, VALUE p)
+int rugged_oid_get(git_oid *oid, git_repository *repo, VALUE p)
 {
 	git_object *object;
 	int error;
@@ -99,14 +99,16 @@ void rugged_oid_get(git_oid *oid, git_repository *repo, VALUE p)
 		/* 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;
+			return GIT_OK;
 
-		error = git_revparse_single(&object, repo, StringValueCStr(p));
-		rugged_exception_check(error);
+		if ((error = git_revparse_single(&object, repo, StringValueCStr(p))))
+			return error;
 
 		git_oid_cpy(oid, git_object_id(object));
 		git_object_free(object);
 	}
+
+	return GIT_OK;
 }
 
 git_object *rugged_object_get(git_repository *repo, VALUE object_value, git_otype type)
@@ -202,6 +204,16 @@ static git_otype class2otype(VALUE klass)
 	return GIT_OBJ_BAD;
 }
 
+/*
+ *  call-seq:
+ *    Object.new(repo, oid) -> object
+ *    Object.lookup(repo, oid) -> object
+ *
+ *  Find and return the git object inside +repo+ with the given +oid+.
+ *
+ *  +oid+ can either have be the complete, 40 character string or any
+ *  unique prefix.
+ */
 VALUE rb_git_object_lookup(VALUE klass, VALUE rb_repo, VALUE rb_hex)
 {
 	git_object *object;
@@ -240,7 +252,7 @@ VALUE rb_git_object_lookup(VALUE klass, VALUE rb_repo, VALUE rb_hex)
 	return rugged_object_new(rb_repo, object);
 }
 
-static VALUE rugged_object_rev_parse(VALUE klass, VALUE rb_repo, VALUE rb_spec, int as_obj)
+VALUE rugged_object_rev_parse(VALUE rb_repo, VALUE rb_spec, int as_obj)
 {
 	git_object *object;
 	const char *spec;
@@ -267,16 +279,44 @@ static VALUE rugged_object_rev_parse(VALUE klass, VALUE rb_repo, VALUE rb_spec,
 	return ret;
 }
 
+/*
+ *  call-seq: Object.rev_parse(repo, str) -> object
+ *
+ *  Find and return a single object inside +repo+ as specified by the
+ *  git revision string +str+.
+ *
+ *  See http://git-scm.com/docs/git-rev-parse.html#_specifying_revisions or 
+ *  <code>man gitrevisions</code> for information on the accepted syntax.
+ *
+ *  Raises a Rugged::InvalidError if +str+ does not contain a valid revision string.
+ */
 VALUE rb_git_object_rev_parse(VALUE klass, VALUE rb_repo, VALUE rb_spec)
 {
-	return rugged_object_rev_parse(klass, rb_repo, rb_spec, 1);
+	return rugged_object_rev_parse(rb_repo, rb_spec, 1);
 }
 
+/*
+ *  call-seq: Object.rev_parse_oid(repo, str) -> oid
+ *
+ *  Find and return the id of the object inside +repo+ as specified by the
+ *  git revision string +str+.
+ *
+ *  See http://git-scm.com/docs/git-rev-parse.html#_specifying_revisions or 
+ *  <code>man gitrevisions</code> for information on the accepted syntax.
+ *
+ *  Raises a Rugged::InvalidError if +str+ does not contain a valid revision string.
+ */
 VALUE rb_git_object_rev_parse_oid(VALUE klass, VALUE rb_repo, VALUE rb_spec)
 {
-	return rugged_object_rev_parse(klass, rb_repo, rb_spec, 0);
+	return rugged_object_rev_parse(rb_repo, rb_spec, 0);
 }
 
+/*
+ *  call-seq: object == other
+ *
+ *  Returns true only if +object+ and other are both instances or subclasses of
+ *  Rugged::Object and have the same object id, false otherwise.
+ */
 static VALUE rb_git_object_equal(VALUE self, VALUE other)
 {
 	git_object *a, *b;
@@ -290,6 +330,11 @@ static VALUE rb_git_object_equal(VALUE self, VALUE other)
 	return git_oid_cmp(git_object_id(a), git_object_id(b)) == 0 ? Qtrue : Qfalse;
 }
 
+/*
+ *  call-seq: object.oid -> oid
+ *
+ *  Return the Object ID (a 40 character SHA1 hash) for +object+.
+ */
 static VALUE rb_git_object_oid_GET(VALUE self)
 {
 	git_object *object;
@@ -297,6 +342,11 @@ static VALUE rb_git_object_oid_GET(VALUE self)
 	return rugged_create_oid(git_object_id(object));
 }
 
+/*
+ *  call-seq: object.type -> type
+ *
+ *  Returns the object's type. Can be one of +:commit+, +:tag+, +:tree+ or +:blob+.
+ */
 static VALUE rb_git_object_type_GET(VALUE self)
 {
 	git_object *object;
@@ -305,6 +355,11 @@ static VALUE rb_git_object_type_GET(VALUE self)
 	return rugged_otype_new(git_object_type(object));
 }
 
+/*
+ *  call-seq: object.read_raw -> raw_object
+ *
+ *  Returns the git object as a Rugged::OdbObject instance.
+ */
 static VALUE rb_git_object_read_raw(VALUE self)
 {
 	git_object *object;
@@ -313,7 +368,7 @@ static VALUE rb_git_object_read_raw(VALUE self)
 	return rugged_raw_read(git_object_owner(object), git_object_id(object));
 }
 
-void Init_rugged_object()
+void Init_rugged_object(void)
 {
 	rb_cRuggedObject = rb_define_class_under(rb_mRugged, "Object", rb_cObject);
 	rb_define_singleton_method(rb_cRuggedObject, "lookup", rb_git_object_lookup, 2);

data/ext/rugged/rugged_reference.c

@@ -40,75 +40,102 @@ VALUE rugged_ref_new(VALUE klass, VALUE owner, git_reference *ref)
 	return rb_ref;
 }
 
-static int ref_foreach__block(const char *ref_name, void *opaque)
-{
-	rb_funcall((VALUE)opaque, rb_intern("call"), 1, rugged_str_new2(ref_name, rb_utf8_encoding()));
-	return GIT_OK;
-}
-
-/*
- *	call-seq:
- *		Reference.each(repository, filter = :all, glob = nil) { |ref_name| block }
- *		Reference.each(repository, filter = :all, glob = nil) -> Iterator
- *
- *	Iterate through all the references in +repository+. Iteration can be
- *	optionally filtered to only +:oid+ or +:symbolic+ references, or to
- *	the ones matching the given +glob+, a standard Unix filename glob.
- *
- *	The given block will be called once with the name of each reference.
- *	If no block is given, an iterator will be returned.
- */
-static VALUE rb_git_ref_each(int argc, VALUE *argv, VALUE self)
+static VALUE rb_git_ref__each(int argc, VALUE *argv, VALUE self, int only_names)
 {
 	git_repository *repo;
-	int error, flags = GIT_REF_LISTALL;
-	VALUE rb_repo, rb_list, rb_glob, rb_block;
+	git_reference_iterator *iter;
+	int error, exception = 0;
+	VALUE rb_repo, rb_glob;
 
-	rb_scan_args(argc, argv, "12&", &rb_repo, &rb_list, &rb_glob, &rb_block);
+	rb_scan_args(argc, argv, "11", &rb_repo, &rb_glob);
 
-	if (!rb_block_given_p())
-		return rb_funcall(self, rb_intern("to_enum"), 4, CSTR2SYM("each"), rb_repo, rb_list, rb_glob);
+	if (!rb_block_given_p()) {
+		return rb_funcall(self,
+			rb_intern("to_enum"), 3,
+			only_names ? CSTR2SYM("each_name") : CSTR2SYM("each"),
+			rb_repo, rb_glob);
+	}
 
 	if (!rb_obj_is_kind_of(rb_repo, rb_cRuggedRepo))
 		rb_raise(rb_eTypeError, "Expecting a Rugged::Repository instance");
 
 	Data_Get_Struct(rb_repo, git_repository, repo);
 
-	if (!NIL_P(rb_list)) {
-		ID list;
-
-		Check_Type(rb_list, T_SYMBOL);
-		list = SYM2ID(rb_list);
-
-		if (list == rb_intern("all"))
-			flags = GIT_REF_LISTALL;
-		else if (list == rb_intern("oid"))
-			flags = GIT_REF_OID;
-		else if (list == rb_intern("symbolic"))
-			flags = GIT_REF_SYMBOLIC;
-		else {
-			rb_raise(rb_eArgError, "Invalid list value (must be `all`, `oid` or `symbolic`)");
-		}
-	}
-
 	if (!NIL_P(rb_glob)) {
 		Check_Type(rb_glob, T_STRING);
-		error = git_reference_foreach_glob(repo,
-			StringValueCStr(rb_glob), flags, &ref_foreach__block, (void *)rb_block);
+		error = git_reference_iterator_glob_new(&iter, repo, StringValueCStr(rb_glob));
 	} else {
-		error = git_reference_foreach(repo, flags, &ref_foreach__block, (void *)rb_block);
+		error = git_reference_iterator_new(&iter, repo);
 	}
 
 	rugged_exception_check(error);
+
+	if (only_names) {
+		const char *ref_name;
+		while (!exception && (error = git_reference_next_name(&ref_name, iter)) == GIT_OK) {
+			rb_protect(rb_yield, rb_str_new_utf8(ref_name), &exception);
+		}
+	} else {
+		git_reference *ref;
+		while (!exception && (error = git_reference_next(&ref, iter)) == GIT_OK) {
+			rb_protect(rb_yield, rugged_ref_new(rb_cRuggedReference, rb_repo, ref), &exception);
+		}
+	}
+
+	git_reference_iterator_free(iter);
+
+	if (exception)
+		rb_jump_tag(exception);
+
+	if (error != GIT_ITEROVER)
+		rugged_exception_check(error);
+
 	return Qnil;
 }
 
 /*
- *	call-seq:
- *		Reference.lookup(repository, ref_name) -> new_ref
+ *  call-seq:
+ *    Reference.each(repository, glob = nil) { |ref| block } -> nil
+ *    Reference.each(repository, glob = nil) -> enumerator
+ *
+ *  Iterate through all the references in +repository+. Iteration
+ *  can be optionally filtered to the ones matching the given
+ *  +glob+, a standard Unix filename glob.
+ *
+ *  The given block will be called once with a Rugged::Reference
+ *  instance for each reference.
+ *
+ *  If no block is given, an enumerator will be returned.
+ */
+static VALUE rb_git_ref_each(int argc, VALUE *argv, VALUE self)
+{
+	return rb_git_ref__each(argc, argv, self, 0);
+}
+
+/*
+ *  call-seq:
+ *    Reference.each_name(repository, glob = nil) { |ref_name| block } -> nil
+ *    Reference.each_name(repository, glob = nil) -> enumerator
+ *
+ *  Iterate through all the reference names in +repository+. Iteration
+ *  can be optionally filtered to the ones matching the given
+ *  +glob+, a standard Unix filename glob.
  *
- *	Lookup a reference from the +repository+.
- *	Returns a new +Rugged::Reference+ object.
+ *  The given block will be called once with the name of each reference.
+ *
+ *  If no block is given, an enumerator will be returned.
+ */
+static VALUE rb_git_ref_each_name(int argc, VALUE *argv, VALUE self)
+{
+	return rb_git_ref__each(argc, argv, self, 1);
+}
+
+/*
+ *  call-seq:
+ *    Reference.lookup(repository, ref_name) -> new_ref
+ *
+ *  Lookup a reference from the +repository+.
+ *  Returns a new Rugged::Reference object.
  */
 static VALUE rb_git_ref_lookup(VALUE klass, VALUE rb_repo, VALUE rb_name)
 {
@@ -129,11 +156,67 @@ static VALUE rb_git_ref_lookup(VALUE klass, VALUE rb_repo, VALUE rb_name)
 }
 
 /*
- *	call-seq:
- *		Reference.exist?(repository, ref_name) -> true or false
- *		Reference.exists?(repository, ref_name) -> true or false
+ *  call-seq:
+ *    Reference.valid_name?(ref_name) -> true or false
+ *
+ *  Check if a reference name is well-formed.
+ *
+ *  Valid reference names must follow one of two patterns:
+ *
+ *  1. Top-level names must contain only capital letters and underscores,
+ *     and must begin and end with a letter. (e.g. "HEAD", "ORIG_HEAD").
+ *  2. Names prefixed with "refs/" can be almost anything.  You must avoid
+ *     the characters '~', '^', ':', '\\', '?', '[', and '*', and the
+ *     sequences ".." and "@{" which have special meaning to revparse.
+ *
+ *  Returns true if the reference name is valid, false if not.
+ */
+static VALUE rb_git_ref_valid_name(VALUE klass, VALUE rb_name)
+{
+	Check_Type(rb_name, T_STRING);
+	return git_reference_is_valid_name(StringValueCStr(rb_name)) == 1 ? Qtrue : Qfalse;
+}
+
+/*
+ *  call-seq:
+ *    ref.peel -> oid
  *
- *	Check if a given reference exists on +repository+.
+ *  Peels tag objects to the sha that they point at. Replicates
+ *  +git show-ref --dereference+.
+ */
+static VALUE rb_git_ref_peel(VALUE self)
+{
+	/* Leave room for \0 */
+	git_reference *ref;
+	git_object *object;
+	char oid[GIT_OID_HEXSZ + 1];
+	int error;
+
+	Data_Get_Struct(self, git_reference, ref);
+
+	error = git_reference_peel(&object, ref, GIT_OBJ_ANY);
+	if (error == GIT_ENOTFOUND)
+		return Qnil;
+	else
+		rugged_exception_check(error);
+
+	if (git_reference_type(ref) == GIT_REF_OID &&
+			!git_oid_cmp(git_object_id(object), git_reference_target(ref))) {
+		git_object_free(object);
+		return Qnil;
+	} else {
+		git_oid_tostr(oid, sizeof(oid), git_object_id(object));
+		git_object_free(object);
+		return rb_str_new_utf8(oid);
+	}
+}
+
+/*
+ *  call-seq:
+ *    Reference.exist?(repository, ref_name) -> true or false
+ *    Reference.exists?(repository, ref_name) -> true or false
+ *
+ *  Check if a given reference exists on +repository+.
  */
 static VALUE rb_git_ref_exist(VALUE klass, VALUE rb_repo, VALUE rb_name)
 {
@@ -156,16 +239,16 @@ static VALUE rb_git_ref_exist(VALUE klass, VALUE rb_repo, VALUE rb_name)
 }
 
 /*
- *	call-seq:
- *		Reference.create(repository, name, oid, force = false) -> new_ref
- *		Reference.create(repository, name, target, force = false) -> new_ref
+ *  call-seq:
+ *    Reference.create(repository, name, oid, force = false) -> new_ref
+ *    Reference.create(repository, name, target, force = false) -> new_ref
  *
- *	Create a symbolic or direct reference on +repository+ with the given +name+.
- *	If the third argument is a valid OID, the reference will be created as direct.
- *	Otherwise, it will be assumed the target is the name of another reference.
+ *  Create a symbolic or direct reference on +repository+ with the given +name+.
+ *  If the third argument is a valid OID, the reference will be created as direct.
+ *  Otherwise, it will be assumed the target is the name of another reference.
  *
- *	If a reference with the given +name+ already exists and +force+ is +true+,
- *	it will be overwritten. Otherwise, an exception will be raised.
+ *  If a reference with the given +name+ already exists and +force+ is +true+,
+ *  it will be overwritten. Otherwise, an exception will be raised.
  */
 static VALUE rb_git_ref_create(int argc, VALUE *argv, VALUE klass)
 {
@@ -197,18 +280,18 @@ static VALUE rb_git_ref_create(int argc, VALUE *argv, VALUE klass)
 }
 
 /*
- *	call-seq:
- *		reference.target -> oid
- *		reference.target -> ref_name
+ *  call-seq:
+ *    reference.target -> oid
+ *    reference.target -> ref_name
  *
- *	Return the target of the reference, which is an OID for +:direct+
- *	references, and the name of another reference for +:symbolic+ ones.
+ *  Return the target of the reference, which is an OID for +:direct+
+ *  references, and the name of another reference for +:symbolic+ ones.
  *
- *		r1.type #=> :symbolic
- *		r1.target #=> "refs/heads/master"
+ *    r1.type #=> :symbolic
+ *    r1.target #=> "refs/heads/master"
  *
- *		r2.type #=> :direct
- *		r2.target #=> "de5ba987198bcf2518885f0fc1350e5172cded78"
+ *    r2.type #=> :direct
+ *    r2.target #=> "de5ba987198bcf2518885f0fc1350e5172cded78"
  */
 static VALUE rb_git_ref_target(VALUE self)
 {
@@ -218,29 +301,30 @@ static VALUE rb_git_ref_target(VALUE self)
 	if (git_reference_type(ref) == GIT_REF_OID) {
 		return rugged_create_oid(git_reference_target(ref));
 	} else {
-		return rugged_str_new2(git_reference_symbolic_target(ref), rb_utf8_encoding());
+		return rb_str_new_utf8(git_reference_symbolic_target(ref));
 	}
 }
 
 /*
- *	call-seq:
- *		reference.set_target(t) -> Reference
+ *  call-seq:
+ *    reference.set_target(oid) -> new_ref
+ *    reference.set_target(ref_name) -> new_ref
  *
- *	Set the target of a reference. If +reference+ is a direct reference,
- *	the new target must be a +String+ representing a SHA1 OID.
+ *  Set the target of a reference. If +reference+ is a direct reference,
+ *  the new target must be a +String+ representing a SHA1 OID.
  *
- *	If +reference+ is symbolic, the new target must be a +String+ with
- *	the name of another reference.
+ *  If +reference+ is symbolic, the new target must be a +String+ with
+ *  the name of another reference.
  *
- *	The original reference is unaltered; a new reference object is
- *	returned with the new target, and the changes are persisted to
- *	disk.
+ *  The original reference is unaltered; a new reference object is
+ *  returned with the new target, and the changes are persisted to
+ *  disk.
  *
- *		r1.type #=> :symbolic
- *		r1.set_target("refs/heads/master") #=> <Reference>
+ *    r1.type #=> :symbolic
+ *    r1.set_target("refs/heads/master") #=> <Reference>
  *
- *		r2.type #=> :direct
- *		r2.set_target("de5ba987198bcf2518885f0fc1350e5172cded78") #=> <Reference>
+ *    r2.type #=> :direct
+ *    r2.set_target("de5ba987198bcf2518885f0fc1350e5172cded78") #=> <Reference>
  */
 static VALUE rb_git_ref_set_target(VALUE self, VALUE rb_target)
 {
@@ -266,10 +350,10 @@ static VALUE rb_git_ref_set_target(VALUE self, VALUE rb_target)
 }
 
 /*
- *	call-seq:
- *		reference.type -> :symbolic or :direct
+ *  call-seq:
+ *    reference.type -> :symbolic or :direct
  *
- *	Return whether the reference is +:symbolic+ or +:direct+
+ *  Return whether the reference is +:symbolic+ or +:direct+
  */
 static VALUE rb_git_ref_type(VALUE self)
 {
@@ -287,32 +371,32 @@ static VALUE rb_git_ref_type(VALUE self)
 }
 
 /*
- *	call-seq:
- *		reference.name -> name
+ *  call-seq:
+ *    reference.name -> name
  *
- *	Returns the name of the reference
+ *  Returns the name of the reference
  *
- *		reference.name #=> 'HEAD'
+ *    reference.name #=> 'HEAD'
  */
 static VALUE rb_git_ref_name(VALUE self)
 {
 	git_reference *ref;
 	Data_Get_Struct(self, git_reference, ref);
-	return rugged_str_new2(git_reference_name(ref), rb_utf8_encoding());
+	return rb_str_new_utf8(git_reference_name(ref));
 }
 
 /*
- *	call-seq:
- *		reference.resolve -> peeled_ref
+ *  call-seq:
+ *    reference.resolve -> peeled_ref
  *
- *	Peel a symbolic reference to its target reference.
+ *  Peel a symbolic reference to its target reference.
  *
- *		r1.type #=> :symbolic
- *		r1.name #=> 'HEAD'
- *		r1.target #=> 'refs/heads/master'
+ *    r1.type #=> :symbolic
+ *    r1.name #=> 'HEAD'
+ *    r1.target #=> 'refs/heads/master'
  *
- *		r2 = r1.resolve #=> #<Rugged::Reference:0x401b3948>
- *		r2.target #=> '9d09060c850defbc7711d08b57def0d14e742f4e'
+ *    r2 = r1.resolve #=> #<Rugged::Reference:0x401b3948>
+ *    r2.target #=> '9d09060c850defbc7711d08b57def0d14e742f4e'
  */
 static VALUE rb_git_ref_resolve(VALUE self)
 {
@@ -329,17 +413,17 @@ static VALUE rb_git_ref_resolve(VALUE self)
 }
 
 /*
- *	call-seq:
- *		reference.rename(new_name, force = false)
+ *  call-seq:
+ *    reference.rename(new_name, force = false)
  *
- *	Change the name of a reference. If +force+ is +true+, any previously
- *	existing references will be overwritten when renaming.
+ *  Change the name of a reference. If +force+ is +true+, any previously
+ *  existing references will be overwritten when renaming.
  *
- *	Return a new reference object with the new object
+ *  Return a new reference object with the new object
  *
- *		reference.name #=> 'refs/heads/master'
- *		new_ref = reference.rename('refs/heads/development') #=> <Reference>
- *		new_ref.name #=> 'refs/heads/development'
+ *    reference.name #=> 'refs/heads/master'
+ *    new_ref = reference.rename('refs/heads/development') #=> <Reference>
+ *    new_ref.name #=> 'refs/heads/development'
  */
 static VALUE rb_git_ref_rename(int argc, VALUE *argv, VALUE self)
 {
@@ -361,14 +445,14 @@ static VALUE rb_git_ref_rename(int argc, VALUE *argv, VALUE self)
 }
 
 /*
- *	call-seq:
- *		reference.delete!
+ *  call-seq:
+ *    reference.delete! -> nil
  *
- *	Delete this reference from disk. 
+ *  Delete this reference from disk. 
  *
- *		reference.name #=> 'HEAD'
- *		reference.delete!
- *		# Reference no longer exists on disk
+ *    reference.name #=> 'HEAD'
+ *    reference.delete!
+ *    # Reference no longer exists on disk
  */
 static VALUE rb_git_ref_delete(VALUE self)
 {
@@ -404,35 +488,34 @@ static VALUE reflog_entry_new(const git_reflog_entry *entry)
 	);
 
 	if ((message = git_reflog_entry_message(entry)) != NULL) {
-		rb_hash_aset(rb_entry,
-			CSTR2SYM("message"),
-			rugged_str_new2(message, NULL)
-		);
+		rb_hash_aset(rb_entry, CSTR2SYM("message"), rb_str_new_utf8(message));
 	}
 
 	return rb_entry;
 }
 
 /*
- *	call-seq:
- *		reference.log -> [reflog_entry, ...]
+ *  call-seq:
+ *    reference.log -> [reflog_entry, ...]
+ *
+ *  Return an array with the log of all modifications to this reference
  *
- *	Return an array with the log of all modifications to this reference
+ *  Each +reflog_entry+ is a hash with the following keys:
  *
- *	Each +reflog_entry+ is a hash with the following keys:
+ *  - +:id_old+: previous OID before the change
+ *  - +:id_new+: OID after the change
+ *  - +:committer+: author of the change
+ *  - +:message+: message for the change
  *
- *	- +:id_old+: previous OID before the change
- *	- +:id_new+: OID after the change
- *	- +:committer+: author of the change
- *	- +:message+: message for the change
+ *  Example:
  *
- *		reference.log #=> [
- *		# {
- *		#	:id_old => nil,
- *		#	:id_new => '9d09060c850defbc7711d08b57def0d14e742f4e',
- *		#	:committer => {:name => 'Vicent Marti', :email => {'vicent@github.com'}},
- *		#	:message => 'created reference'
- *		# }, ... ]
+ *    reference.log #=> [
+ *    # {
+ *    #  :id_old => nil,
+ *    #  :id_new => '9d09060c850defbc7711d08b57def0d14e742f4e',
+ *    #  :committer => {:name => 'Vicent Marti', :email => {'vicent@github.com'}},
+ *    #  :message => 'created reference'
+ *    # }, ... ]
  */
 static VALUE rb_git_reflog(VALUE self)
 {
@@ -462,10 +545,10 @@ static VALUE rb_git_reflog(VALUE self)
 }
 
 /*
- *	call-seq:
- *		reference.log? -> Boolean
+ *  call-seq:
+ *    reference.log? -> true or false
  *
- *	Return whether a given reference has a reflog.
+ *  Return +true+ if the reference has a reflog, +false+ otherwise.
  */
 static VALUE rb_git_has_reflog(VALUE self)
 {
@@ -475,10 +558,10 @@ static VALUE rb_git_has_reflog(VALUE self)
 }
 
 /*
- *	call-seq:
- *		reference.log!(committer, message = nil)
+ *  call-seq:
+ *    reference.log!(committer, message = nil) -> nil
  *
- *	Log a modification for this reference to the reflog.
+ *  Log a modification for this reference to the reflog.
  */
 static VALUE rb_git_reflog_write(int argc, VALUE *argv, VALUE self)
 {
@@ -520,10 +603,10 @@ static VALUE rb_git_reflog_write(int argc, VALUE *argv, VALUE self)
 }
 
 /*
- *	call-seq:
- *		reference.branch? -> Boolean
+ *  call-seq:
+ *    reference.branch? -> true or false
  *
- *	Return whether a given reference is a branch
+ *  Return whether a given reference is a branch
  */
 static VALUE rb_git_ref_is_branch(VALUE self)
 {
@@ -533,10 +616,10 @@ static VALUE rb_git_ref_is_branch(VALUE self)
 }
 
 /*
- *	call-seq:
- *		reference.remote? -> Boolean
+ *  call-seq:
+ *    reference.remote? -> true or false
  *
- *	Return whether a given reference is a remote
+ *  Return whether a given reference is a remote
  */
 static VALUE rb_git_ref_is_remote(VALUE self)
 {
@@ -545,7 +628,7 @@ static VALUE rb_git_ref_is_remote(VALUE self)
 	return git_reference_is_remote(ref) ? Qtrue : Qfalse;
 }
 
-void Init_rugged_reference()
+void Init_rugged_reference(void)
 {
 	rb_cRuggedReference = rb_define_class_under(rb_mRugged, "Reference", rb_cObject);
 
@@ -554,8 +637,11 @@ void Init_rugged_reference()
 	rb_define_singleton_method(rb_cRuggedReference, "exists?", rb_git_ref_exist, 2);
 	rb_define_singleton_method(rb_cRuggedReference, "create", rb_git_ref_create, -1);
 	rb_define_singleton_method(rb_cRuggedReference, "each", rb_git_ref_each, -1);
+	rb_define_singleton_method(rb_cRuggedReference, "each_name", rb_git_ref_each_name, -1);
+	rb_define_singleton_method(rb_cRuggedReference, "valid_name?", rb_git_ref_valid_name, 1);
 
 	rb_define_method(rb_cRuggedReference, "target", rb_git_ref_target, 0);
+	rb_define_method(rb_cRuggedReference, "peel", rb_git_ref_peel, 0);
 	rb_define_method(rb_cRuggedReference, "set_target", rb_git_ref_set_target, 1);
 
 	rb_define_method(rb_cRuggedReference, "type", rb_git_ref_type, 0);