rugged 0.19.0 → 0.21.0

data/ext/rugged/rugged.h

@@ -1,7 +1,7 @@
 /*
  * The MIT License
  *
- * Copyright (c) 2013 GitHub, Inc
+ * Copyright (c) 2014 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
@@ -49,23 +49,29 @@
  */
 void Init_rugged_object(void);
 void Init_rugged_branch(void);
+void Init_rugged_branch_collection(void);
 void Init_rugged_commit(void);
 void Init_rugged_tree(void);
 void Init_rugged_tag(void);
+void Init_rugged_tag_collection(void);
 void Init_rugged_blob(void);
 void Init_rugged_index(void);
 void Init_rugged_repo(void);
 void Init_rugged_revwalk(void);
 void Init_rugged_reference(void);
+void Init_rugged_reference_collection(void);
 void Init_rugged_config(void);
 void Init_rugged_remote(void);
+void Init_rugged_remote_collection(void);
 void Init_rugged_notes(void);
 void Init_rugged_settings(void);
 void Init_rugged_diff(void);
-void Init_rugged_diff_patch(void);
+void Init_rugged_patch(void);
 void Init_rugged_diff_delta(void);
 void Init_rugged_diff_hunk(void);
 void Init_rugged_diff_line(void);
+void Init_rugged_blame(void);
+void Init_rugged_cred(void);
 
 VALUE rb_git_object_init(git_otype type, int argc, VALUE *argv, VALUE self);
 
@@ -78,18 +84,23 @@ VALUE rugged_config_new(VALUE klass, VALUE owner, git_config *cfg);
 VALUE rugged_object_new(VALUE owner, git_object *object);
 VALUE rugged_object_rev_parse(VALUE rb_repo, VALUE rb_spec, int as_obj);
 VALUE rugged_ref_new(VALUE klass, VALUE owner, git_reference *ref);
-VALUE rugged_diff_new(VALUE klass, VALUE owner, git_diff_list *diff);
-VALUE rugged_diff_patch_new(VALUE owner, git_diff_patch *patch);
+VALUE rugged_diff_new(VALUE klass, VALUE owner, git_diff *diff);
+VALUE rugged_patch_new(VALUE owner, git_patch *patch);
 VALUE rugged_diff_delta_new(VALUE owner, const git_diff_delta *delta);
-VALUE rugged_diff_hunk_new(VALUE owner, int hunk_idx, const git_diff_range *range, const char *header, size_t header_len, size_t lines_in_hunk);
-VALUE rugged_diff_line_new(VALUE owner, const char line_origin, const char *content, size_t content_len, int old_lineno, int new_lineno);
+VALUE rugged_diff_hunk_new(VALUE owner, size_t hunk_idx, const git_diff_hunk *hunk, size_t lines_in_hunk);
+VALUE rugged_diff_line_new(const git_diff_line *line);
+VALUE rugged_remote_new(VALUE owner, git_remote *remote);
+VALUE rb_git_delta_file_fromC(const git_diff_file *file);
 
 void rugged_parse_diff_options(git_diff_options *opts, VALUE rb_options);
+void rugged_parse_merge_options(git_merge_options *opts, VALUE rb_options);
+
+void rugged_cred_extract(git_cred **cred, int allowed_types, VALUE rb_credential);
 
 VALUE rugged_otype_new(git_otype t);
 git_otype rugged_otype_get(VALUE rb_type);
 
-git_signature *rugged_signature_get(VALUE rb_person);
+git_signature *rugged_signature_get(VALUE rb_person, git_repository *repo);
 git_object *rugged_object_get(git_repository *repo, VALUE object_value, git_otype type);
 int rugged_oid_get(git_oid *oid, git_repository *repo, VALUE p);
 
@@ -106,6 +117,13 @@ static inline VALUE rugged_owner(VALUE object)
 	return rb_iv_get(object, "@owner");
 }
 
+static inline void rugged_validate_remote_url(VALUE rb_url)
+{
+	Check_Type(rb_url, T_STRING);
+	if (!git_remote_valid_url(StringValueCStr(rb_url)))
+		rb_raise(rb_eArgError, "Invalid URL format");
+}
+
 extern void rugged_exception_raise(void);
 
 static inline void rugged_exception_check(int errorcode)
@@ -124,11 +142,29 @@ static inline int rugged_parse_bool(VALUE boolean)
 
 extern VALUE rb_cRuggedRepo;
 
-struct rugged_cb_payload {
+VALUE rugged__block_yield_splat(VALUE args);
+
+struct rugged_cb_payload
+{
     VALUE rb_data;
     int exception;
 };
 
+struct rugged_remote_cb_payload
+{
+	VALUE progress;
+	VALUE completion;
+	VALUE transfer_progress;
+	VALUE update_tips;
+	VALUE credentials;
+	int exception;
+};
+
+void rugged_remote_init_callbacks_and_payload_from_options(
+	VALUE rb_options,
+	git_remote_callbacks *callbacks,
+	struct rugged_remote_cb_payload *payload);
+
 static inline void rugged_check_repo(VALUE rb_repo)
 {
 	if (!rb_obj_is_kind_of(rb_repo, rb_cRuggedRepo))

data/ext/rugged/rugged_blame.c

@@ -0,0 +1,292 @@
+/*
+ * The MIT License
+ *
+ * Copyright (c) 2014 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_mRugged;
+VALUE rb_cRuggedBlame;
+
+static VALUE rb_git_blame_hunk_fromC(const git_blame_hunk *hunk)
+{
+	VALUE rb_hunk;
+	if (!hunk)  {
+		return Qnil;
+	}
+
+	rb_hunk = rb_hash_new();
+	rb_hash_aset(rb_hunk, CSTR2SYM("lines_in_hunk"), UINT2NUM(hunk->lines_in_hunk));
+
+	rb_hash_aset(rb_hunk, CSTR2SYM("final_commit_id"), rugged_create_oid(&(hunk->final_commit_id)));
+	rb_hash_aset(rb_hunk, CSTR2SYM("final_start_line_number"), UINT2NUM(hunk->final_start_line_number));
+	rb_hash_aset(rb_hunk, CSTR2SYM("final_signature"), hunk->final_signature ? rugged_signature_new(hunk->final_signature, NULL) : Qnil);
+
+	rb_hash_aset(rb_hunk, CSTR2SYM("orig_commit_id"), rugged_create_oid(&(hunk->orig_commit_id)));
+	rb_hash_aset(rb_hunk, CSTR2SYM("orig_path"), hunk->orig_path ? rb_str_new2(hunk->orig_path) : Qnil);
+	rb_hash_aset(rb_hunk, CSTR2SYM("orig_start_line_number"), UINT2NUM(hunk->orig_start_line_number));
+	rb_hash_aset(rb_hunk, CSTR2SYM("orig_signature"), hunk->orig_signature ? rugged_signature_new(hunk->orig_signature, NULL) : Qnil);
+
+	rb_hash_aset(rb_hunk, CSTR2SYM("boundary"), hunk->boundary ? Qtrue : Qfalse);
+
+	return rb_hunk;
+}
+
+static void rugged_parse_blame_options(git_blame_options *opts, git_repository *repo, VALUE rb_options)
+{
+	if (!NIL_P(rb_options)) {
+		VALUE rb_value;
+		Check_Type(rb_options, T_HASH);
+
+		rb_value = rb_hash_aref(rb_options, CSTR2SYM("min_line"));
+		if (!NIL_P(rb_value)) {
+			Check_Type(rb_value, T_FIXNUM);
+			opts->min_line = FIX2UINT(rb_value);
+		}
+
+		rb_value = rb_hash_aref(rb_options, CSTR2SYM("max_line"));
+		if (!NIL_P(rb_value)) {
+			Check_Type(rb_value, T_FIXNUM);
+			opts->max_line = FIX2UINT(rb_value);
+		}
+
+		rb_value = rb_hash_aref(rb_options, CSTR2SYM("newest_commit"));
+		if (!NIL_P(rb_value)) {
+			int error = rugged_oid_get(&opts->newest_commit, repo, rb_value);
+			rugged_exception_check(error);
+		}
+
+		rb_value = rb_hash_aref(rb_options, CSTR2SYM("oldest_commit"));
+		if (!NIL_P(rb_value)) {
+			int error = rugged_oid_get(&opts->oldest_commit, repo, rb_value);
+			rugged_exception_check(error);
+		}
+
+		if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("track_copies_same_file")))) {
+			opts->flags |= GIT_BLAME_TRACK_COPIES_SAME_FILE;
+		}
+
+		if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("track_copies_same_commit_moves")))) {
+			opts->flags |= GIT_BLAME_TRACK_COPIES_SAME_COMMIT_MOVES;
+		}
+
+		if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("track_copies_same_commit_copies")))) {
+			opts->flags |= GIT_BLAME_TRACK_COPIES_SAME_COMMIT_COPIES;
+		}
+
+		if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("track_copies_any_commit_copies")))) {
+			opts->flags |= GIT_BLAME_TRACK_COPIES_ANY_COMMIT_COPIES;
+		}
+	}
+}
+
+/*
+ *  call-seq:
+ *    Blame.new(repo, path, options = {}) -> blame
+ *
+ *  Get blame data for the file at +path+ in +repo+.
+ *
+ *  The following options can be passed in the +options+ Hash:
+ *
+ *  :newest_commit ::
+ *    The ID of the newest commit to consider in the blame. Defaults to +HEAD+.
+ *    This can either be a Rugged::Object instance, or a full or abbreviated
+ *    SHA1 id.
+ *
+ *  :oldest_commit ::
+ *    The id of the oldest commit to consider. Defaults to the first commit
+ *    encountered with a NULL parent. This can either be a Rugged::Object
+ *    instance, or a full or abbreviated SHA1 id.
+ *
+ *  :min_line ::
+ *    The first line in the file to blame. Line numbers start with 1.
+ *    Defaults to +1+.
+ *
+ *  :max_line ::
+ *    The last line in the file to blame. Defaults to the last line in
+ *    the file.
+ *
+ *  :track_copies_same_file
+ *    If this value is +true+, lines that have moved within a file will be
+ *    tracked (like `git blame -M`).
+ *
+ *  :track_copies_same_commit_moves
+ *    If this value is +true+, lines that have moved across files in the same
+ *    commit will be tracked (like `git blame -C`).
+ *
+ *  :track_copies_same_commit_copies
+ *    If this value is +true+, lines that have been copied from another file
+ *    that exists in the same commit will be tracked (like `git blame -CC`).
+ *
+ *  :track_copies_any_commit_copies
+ *    If this value is +true+, lines that have been copied from another file
+ *    that exists in *any* commit will be tracked (like `git blame -CCC`).
+ *
+ */
+static VALUE rb_git_blame_new(int argc, VALUE *argv, VALUE klass)
+{
+	VALUE rb_repo, rb_path, rb_options;
+	git_repository *repo;
+	git_blame *blame;
+	git_blame_options opts = GIT_BLAME_OPTIONS_INIT;
+
+	rb_scan_args(argc, argv, "20:", &rb_repo, &rb_path, &rb_options);
+
+	rugged_check_repo(rb_repo);
+	Data_Get_Struct(rb_repo, git_repository, repo);
+
+	Check_Type(rb_path, T_STRING);
+
+	rugged_parse_blame_options(&opts, repo, rb_options);
+
+	rugged_exception_check(git_blame_file(
+		&blame, repo, StringValueCStr(rb_path), &opts
+	));
+
+	return Data_Wrap_Struct(klass, NULL, &git_blame_free, blame);
+}
+
+/*
+ *  call-seq:
+ *    blame.for_line(line_no) -> hunk
+ *
+ *  Returns the blame hunk data for the given +line_no+ in +blame+.
+ *  Line number counting starts with +1+.
+ */
+static VALUE rb_git_blame_for_line(VALUE self, VALUE rb_line_no)
+{
+	git_blame *blame;
+	int line_no;
+
+	Data_Get_Struct(self, git_blame, blame);
+	Check_Type(rb_line_no, T_FIXNUM);
+
+	line_no = NUM2INT(rb_line_no);
+
+	if (line_no < 0) {
+		rb_raise(rb_eArgError, "line number can't be negative");
+	}
+
+	return rb_git_blame_hunk_fromC(
+		git_blame_get_hunk_byline(blame, (uint32_t)line_no)
+	);
+}
+
+/*
+ *  call-seq:
+ *    blame.count -> count
+ *    blame.size -> count
+ *
+ *  Returns the total +count+ of blame hunks in +blame+.
+ */
+static VALUE rb_git_blame_count(VALUE self)
+{
+	git_blame *blame;
+	Data_Get_Struct(self, git_blame, blame);
+	return UINT2NUM(git_blame_get_hunk_count(blame));
+}
+
+/*
+ *  call-seq:
+ *    blame[index] -> hunk
+ *
+ *  Returns the blame hunk data at the given +index+ in +blame+.
+ *
+ *  Negative indices count backward from the end of the blame hunks (-1 is the last
+ *  element).
+ *
+ *  Returns +nil+ if no blame hunk exists at the given +index+.
+ */
+static VALUE rb_git_blame_get_by_index(VALUE self, VALUE rb_index)
+{
+	git_blame *blame;
+	int index;
+	uint32_t blame_count;
+
+	Data_Get_Struct(self, git_blame, blame);
+	Check_Type(rb_index, T_FIXNUM);
+
+	index = NUM2INT(rb_index);
+	blame_count = git_blame_get_hunk_count(blame);
+
+	if (index < 0) {
+		if ((uint32_t)(-index) > blame_count) {
+			return Qnil;
+		}
+
+		return rb_git_blame_hunk_fromC(
+			git_blame_get_hunk_byindex(blame, (uint32_t)(blame_count + index))
+		);
+	}
+
+	if ((uint32_t)index > blame_count)
+		return Qnil;
+
+	return rb_git_blame_hunk_fromC(
+		git_blame_get_hunk_byindex(blame, (uint32_t)index)
+	);
+}
+
+/*
+ *  call-seq:
+ *    blame.each { |hunk| ... } -> blame
+ *    blame.each -> enumerator
+ *
+ *  If given a block, yields each +hunk+ that is part of +blame+.
+ *  If no block is given, an enumerator will be returned.
+ */
+static VALUE rb_git_blame_each(VALUE self)
+{
+	git_blame *blame;
+	uint32_t i, blame_count;
+
+	if (!rb_block_given_p()) {
+		return rb_funcall(self, rb_intern("to_enum"), 1, CSTR2SYM("each"), self);
+	}
+
+	Data_Get_Struct(self, git_blame, blame);
+
+	blame_count = git_blame_get_hunk_count(blame);
+	for (i = 0; i < blame_count; ++i) {
+		rb_yield(rb_git_blame_hunk_fromC(
+			git_blame_get_hunk_byindex(blame, i)
+		));
+	}
+
+	return self;
+}
+
+void Init_rugged_blame(void)
+{
+	rb_cRuggedBlame = rb_define_class_under(rb_mRugged, "Blame", rb_cObject);
+	rb_include_module(rb_cRuggedBlame, rb_mEnumerable);
+
+	rb_define_singleton_method(rb_cRuggedBlame, "new", rb_git_blame_new, -1);
+
+	rb_define_method(rb_cRuggedBlame, "[]", rb_git_blame_get_by_index, 1);
+	rb_define_method(rb_cRuggedBlame, "for_line", rb_git_blame_for_line, 1);
+
+	rb_define_method(rb_cRuggedBlame, "count", rb_git_blame_count, 0);
+	rb_define_method(rb_cRuggedBlame, "size", rb_git_blame_count, 0);
+
+	rb_define_method(rb_cRuggedBlame, "each", rb_git_blame_each, 0);
+}

data/ext/rugged/rugged_blob.c

@@ -1,7 +1,7 @@
 /*
  * The MIT License
  *
- * Copyright (c) 2013 GitHub, Inc
+ * Copyright (c) 2014 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
@@ -141,11 +141,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)
 {
@@ -219,25 +219,31 @@ 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]);
+
+	if (!NIL_P(rb_buffer))
+		Check_Type(rb_buffer, T_STRING);
 
-static VALUE rb_read_failed(void) {
-	return Qnil;
+	return rb_buffer;
 }
 
-static int cb_blob__get__chunk(char *content, size_t max_length, void *rb_io)
+static int cb_blob__get__chunk(char *content, size_t max_length, void *data)
 {
-	VALUE rb_buffer, args[2];
+	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);
 
-	args[0] = (VALUE)rb_io;
-	args[1] = INT2FIX(max_length);
+	rb_buffer = rb_protect(rb_read_check, (VALUE)rb_args, &payload->exception);
 
-	rb_buffer = rb_rescue(rb_read_check, (VALUE)args, rb_read_failed, 0);
+	if (payload->exception)
+		return GIT_ERROR;
 
-	if (NIL_P(rb_buffer) || TYPE(rb_buffer) != T_STRING )
+	if (NIL_P(rb_buffer))
 		return 0;
 
 	str_len = (size_t)RSTRING_LEN(rb_buffer);
@@ -249,10 +255,10 @@ static int cb_blob__get__chunk(char *content, size_t max_length, void *rb_io)
 
 /*
  *  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,22 +268,20 @@ 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;
+	struct rugged_cb_payload payload;
 	const char * hint_path = NULL;
 
 	int error;
@@ -294,13 +298,18 @@ static VALUE rb_git_blob_from_chunks(int argc, VALUE *argv, VALUE klass)
 		hint_path = StringValueCStr(rb_hint_path);
 	}
 
+	payload.exception = 0;
+	payload.rb_data = rb_io;
+
 	error = git_blob_create_fromchunks(
 			&oid,
 			repo,
 			hint_path,
 			cb_blob__get__chunk,
-			(void *)rb_io);
+			(void *)&payload);
 
+	if (payload.exception)
+		rb_jump_tag(payload.exception);
 	rugged_exception_check(error);
 
 	return rugged_create_oid(&oid);
@@ -420,7 +429,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 +456,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 +474,50 @@ 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;
 }
 
 void Init_rugged_blob(void)
@@ -484,6 +536,7 @@ void Init_rugged_blob(void)
 	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);
 }