rugged 0.24.6.1 → 0.25.0

data/ext/rugged/rugged_index.c

@@ -1,25 +1,8 @@
 /*
- * 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.
+ * 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"
@@ -691,146 +674,51 @@ static VALUE rb_git_index_readtree(VALUE self, VALUE rb_tree)
 	return Qnil;
 }
 
-/*
- *  call-seq:
- *    index.diff([options]) -> diff
- *    index.diff(diffable[, options]) -> diff
- *
- *  The first form returns a diff between the index and the current working
- *  directory.
- *
- *  The second form returns a diff between the index and the given diffable object.
- *  +diffable+ can either be a +Rugged::Commit+ or a +Rugged::Tree+.
- *
- *  The index will be used as the "old file" side of the diff, while the working
- *  directory or the +diffable+ will be used for the "new file" side.
- *
- *  The following options can be passed in the +options+ Hash:
- *
- *  :paths ::
- *    An array of paths / fnmatch patterns to constrain the diff to a specific
- *    set of files. Also see +:disable_pathspec_match+.
- *
- *  :max_size ::
- *    An integer specifying the maximum byte size of a file before a it will
- *    be treated as binary. The default value is 512MB.
- *
- *  :context_lines ::
- *    The number of unchanged lines that define the boundary of a hunk (and
- *    to display before and after the actual changes). The default is 3.
- *
- *  :interhunk_lines ::
- *    The maximum number of unchanged lines between hunk boundaries before the hunks
- *    will be merged into a one. The default is 0.
- *
- *  :reverse ::
- *    If true, the sides of the diff will be reversed.
- *
- *  :force_text ::
- *    If true, all files will be treated as text, disabling binary attributes & detection.
- *
- *  :ignore_whitespace ::
- *    If true, all whitespace will be ignored.
- *
- *  :ignore_whitespace_change ::
- *    If true, changes in amount of whitespace will be ignored.
- *
- *  :ignore_whitespace_eol ::
- *    If true, whitespace at end of line will be ignored.
- *
- *  :ignore_submodules ::
- *    if true, submodules will be excluded from the diff completely.
- *
- *  :patience ::
- *    If true, the "patience diff" algorithm will be used (currenlty unimplemented).
- *
- *  :include_ignored ::
- *    If true, ignored files will be included in the diff.
- *
- *  :include_untracked ::
- *   If true, untracked files will be included in the diff.
- *
- *  :include_unmodified ::
- *    If true, unmodified files will be included in the diff.
- *
- *  :recurse_untracked_dirs ::
- *    Even if +:include_untracked+ is true, untracked directories will only be
- *    marked with a single entry in the diff. If this flag is set to true,
- *    all files under ignored directories will be included in the diff, too.
- *
- *  :disable_pathspec_match ::
- *    If true, the given +:paths+ will be applied as exact matches, instead of
- *    as fnmatch patterns.
- *
- *  :deltas_are_icase ::
- *    If true, filename comparisons will be made with case-insensitivity.
- *
- *  :include_untracked_content ::
- *    if true, untracked content will be contained in the the diff patch text.
- *
- *  :skip_binary_check ::
- *    If true, diff deltas will be generated without spending time on binary
- *    detection. This is useful to improve performance in cases where the actual
- *    file content difference is not needed.
- *
- *  :include_typechange ::
- *    If true, type changes for files will not be interpreted as deletion of
- *    the "old file" and addition of the "new file", but will generate
- *    typechange records.
- *
- *  :include_typechange_trees ::
- *    Even if +:include_typechange+ is true, blob -> tree changes will still
- *    usually be handled as a deletion of the blob. If this flag is set to true,
- *    blob -> tree changes will be marked as typechanges.
- *
- *  :ignore_filemode ::
- *    If true, file mode changes will be ignored.
- *
- *  :recurse_ignored_dirs ::
- *    Even if +:include_ignored+ is true, ignored directories will only be
- *    marked with a single entry in the diff. If this flag is set to true,
- *    all files under ignored directories will be included in the diff, too.
- */
-static VALUE rb_git_index_diff(int argc, VALUE *argv, VALUE self)
+static VALUE rb_git_diff_tree_to_index(VALUE self, VALUE rb_other, VALUE rb_options)
 {
 	git_index *index;
 	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
 	git_repository *repo;
 	git_diff *diff = NULL;
-	VALUE owner, rb_other, rb_options;
+	VALUE owner;
 	int error;
+	git_tree *other_tree;
 
-	rb_scan_args(argc, argv, "01:", &rb_other, &rb_options);
 	rugged_parse_diff_options(&opts, rb_options);
 
 	Data_Get_Struct(self, git_index, index);
 	owner = rugged_owner(self);
 	Data_Get_Struct(owner, git_repository, repo);
 
-	if (NIL_P(rb_other)) {
-		error = git_diff_index_to_workdir(&diff, repo, index, &opts);
-	} else {
-		// Need to flip the reverse option, so that the index is by default
-		// the "old file" side of the diff.
-		opts.flags ^= GIT_DIFF_REVERSE;
-
-		if (rb_obj_is_kind_of(rb_other, rb_cRuggedCommit)) {
-			git_tree *other_tree;
-			git_commit *commit;
-			Data_Get_Struct(rb_other, git_commit, commit);
-			error = git_commit_tree(&other_tree, commit);
-
-			if (!error)
-				error = git_diff_tree_to_index(&diff, repo, other_tree, index, &opts);
-		} else if (rb_obj_is_kind_of(rb_other, rb_cRuggedTree)) {
-			git_tree *other_tree;
-			Data_Get_Struct(rb_other, git_tree, other_tree);
-			error = git_diff_tree_to_index(&diff, repo, other_tree, index, &opts);
-		} else {
-			xfree(opts.pathspec.strings);
-			rb_raise(rb_eTypeError, "A Rugged::Commit or Rugged::Tree instance is required");
-		}
-	}
+	// Need to flip the reverse option, so that the index is by default
+	// the "old file" side of the diff.
+	opts.flags ^= GIT_DIFF_REVERSE;
+
+	Data_Get_Struct(rb_other, git_tree, other_tree);
+	error = git_diff_tree_to_index(&diff, repo, other_tree, index, &opts);
+
+	xfree(opts.pathspec.strings);
+	rugged_exception_check(error);
+
+	return rugged_diff_new(rb_cRuggedDiff, owner, diff);
+}
+
+static VALUE rb_git_diff_index_to_workdir(VALUE self, VALUE rb_options)
+{
+	git_index *index;
+	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
+	git_repository *repo;
+	git_diff *diff = NULL;
+	VALUE owner;
+	int error;
+
+	rugged_parse_diff_options(&opts, rb_options);
+
+	Data_Get_Struct(self, git_index, index);
+	owner = rugged_owner(self);
+	Data_Get_Struct(owner, git_repository, repo);
+
+	error = git_diff_index_to_workdir(&diff, repo, index, &opts);
 
 	xfree(opts.pathspec.strings);
 	rugged_exception_check(error);
@@ -952,76 +840,6 @@ static VALUE rb_git_conflict_get(VALUE self, VALUE rb_path)
 	return rb_result;
 }
 
-void rugged_parse_merge_file_options(git_merge_file_options *opts, 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("ancestor_label"));
-		if (!NIL_P(rb_value)) {
-			Check_Type(rb_value, T_FIXNUM);
-			opts->ancestor_label = StringValueCStr(rb_value);
-		}
-
-		rb_value = rb_hash_aref(rb_options, CSTR2SYM("our_label"));
-		if (!NIL_P(rb_value)) {
-			Check_Type(rb_value, T_FIXNUM);
-			opts->our_label = StringValueCStr(rb_value);
-		}
-
-		rb_value = rb_hash_aref(rb_options, CSTR2SYM("their_label"));
-		if (!NIL_P(rb_value)) {
-			Check_Type(rb_value, T_FIXNUM);
-			opts->their_label = StringValueCStr(rb_value);
-		}
-
-		rb_value = rb_hash_aref(rb_options, CSTR2SYM("favor"));
-		if (!NIL_P(rb_value)) {
-			ID id_favor;
-
-			Check_Type(rb_value, T_SYMBOL);
-			id_favor = SYM2ID(rb_value);
-
-			if (id_favor == rb_intern("normal")) {
-				opts->favor = GIT_MERGE_FILE_FAVOR_NORMAL;
-			} else if (id_favor == rb_intern("ours")) {
-				opts->favor = GIT_MERGE_FILE_FAVOR_OURS;
-			} else if (id_favor == rb_intern("theirs")) {
-				opts->favor = GIT_MERGE_FILE_FAVOR_THEIRS;
-			} else if (id_favor == rb_intern("union")) {
-				opts->favor = GIT_MERGE_FILE_FAVOR_UNION;
-			} else {
-				rb_raise(rb_eTypeError,
-					"Invalid favor mode. Expected `:normal`, `:ours`, `:theirs` or `:union`");
-			}
-		}
-
-		rb_value = rb_hash_aref(rb_options, CSTR2SYM("style"));
-		if (!NIL_P(rb_value)) {
-			ID id_style;
-
-			Check_Type(rb_value, T_SYMBOL);
-			id_style = SYM2ID(rb_value);
-
-			if (id_style == rb_intern("standard")) {
-				opts->flags |= GIT_MERGE_FILE_STYLE_MERGE;
-			} else if (id_style == rb_intern("diff3")) {
-				opts->flags |= GIT_MERGE_FILE_STYLE_DIFF3;
-			} else {
-				rb_raise(rb_eTypeError,
-					"Invalid style mode. Expected `:standard`, or `:diff3`");
-			}
-		} else {
-			opts->flags |= GIT_MERGE_FILE_STYLE_MERGE;
-		}
-
-		if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("simplify")))) {
-			opts->flags |= GIT_MERGE_FILE_SIMPLIFY_ALNUM;
-		}
-	}
-}
-
 /*
  *  call-seq:
  *    index.merge_file(path[, options]) -> merge_file or nil
@@ -1061,8 +879,7 @@ void rugged_parse_merge_file_options(git_merge_file_options *opts, VALUE rb_opti
 
 static VALUE rb_git_merge_file(int argc, VALUE *argv, VALUE self)
 {
-	VALUE rb_path, rb_options;
-	VALUE rb_result = rb_hash_new();
+	VALUE rb_path, rb_options, rb_result;
 	VALUE rb_repo = rugged_owner(self);
 
 	git_repository *repo;
@@ -1074,10 +891,8 @@ static VALUE rb_git_merge_file(int argc, VALUE *argv, VALUE self)
 
 	rb_scan_args(argc, argv, "1:", &rb_path, &rb_options);
 
-	if (!NIL_P(rb_options)) {
-		Check_Type(rb_options, T_HASH);
+	if (!NIL_P(rb_options))
 		rugged_parse_merge_file_options(&opts, rb_options);
-	}
 
 	Check_Type(rb_path, T_STRING);
 
@@ -1092,14 +907,15 @@ static VALUE rb_git_merge_file(int argc, VALUE *argv, VALUE self)
 	else
 		rugged_exception_check(error);
 
+	if (ours == NULL)
+		rb_raise(rb_eRuntimeError, "The conflict does not have a stage 2 entry");
+	else if (theirs == NULL)
+		rb_raise(rb_eRuntimeError, "The conflict does not have a stage 3 entry");
+
 	error = git_merge_file_from_index(&merge_file_result, repo, ancestor, ours, theirs, &opts);
 	rugged_exception_check(error);
 
-	rb_hash_aset(rb_result, CSTR2SYM("automergeable"), merge_file_result.automergeable ? Qtrue : Qfalse);
-	rb_hash_aset(rb_result, CSTR2SYM("path"),         rb_path);
-	rb_hash_aset(rb_result, CSTR2SYM("filemode"),     INT2FIX(merge_file_result.mode));
-	rb_hash_aset(rb_result, CSTR2SYM("data"),         rb_str_new(merge_file_result.ptr, merge_file_result.len));
-
+	rb_result = rb_merge_file_result_fromC(&merge_file_result);
 	git_merge_file_result_free(&merge_file_result);
 
 	return rb_result;
@@ -1224,7 +1040,8 @@ void Init_rugged_index(void)
 	rb_define_method(rb_cRuggedIndex, "get", rb_git_index_get, -1);
 	rb_define_method(rb_cRuggedIndex, "[]", rb_git_index_get, -1);
 	rb_define_method(rb_cRuggedIndex, "each", rb_git_index_each, 0);
-	rb_define_method(rb_cRuggedIndex, "diff", rb_git_index_diff, -1);
+	rb_define_private_method(rb_cRuggedIndex, "diff_tree_to_index", rb_git_diff_tree_to_index, 2);
+	rb_define_private_method(rb_cRuggedIndex, "diff_index_to_workdir", rb_git_diff_index_to_workdir, 1);
 
 	rb_define_method(rb_cRuggedIndex, "conflicts?", rb_git_index_conflicts_p, 0);
 	rb_define_method(rb_cRuggedIndex, "conflicts", rb_git_index_conflicts, 0);

data/ext/rugged/rugged_note.c

@@ -1,25 +1,8 @@
 /*
- * The MIT License
+ * Copyright (C) the Rugged contributors.  All rights reserved.
  *
- * 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.
+ * This file is part of Rugged, distributed under the MIT license.
+ * For full terms see the included LICENSE file.
  */
 
 #include "rugged.h"

data/ext/rugged/rugged_object.c

@@ -1,25 +1,8 @@
 /*
- * The MIT License
+ * Copyright (C) the Rugged contributors.  All rights reserved.
  *
- * 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.
+ * This file is part of Rugged, distributed under the MIT license.
+ * For full terms see the included LICENSE file.
  */
 
 #include "rugged.h"

data/ext/rugged/rugged_patch.c

@@ -1,25 +1,8 @@
 /*
- * 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.
+ * 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"
@@ -173,21 +156,157 @@ static VALUE rb_git_diff_patch_stat(VALUE self)
 	return rb_ary_new3(2, INT2FIX(additions), INT2FIX(deletions));
 }
 
+enum {
+	EXCLUDE_CONTEXT   = (1u << 0),
+	EXCLUDE_ADDITIONS = (1u << 1),
+	EXCLUDE_DELETIONS = (1u << 2),
+	EXCLUDE_EOFNL     = (1u << 3)
+};
+
+/*
+ *  call-seq:
+ *    patch.lines(options = {}) -> int
+ *
+ *  The following options can be passed in the +options+ Hash:
+ *
+ *  :exclude_context ::
+ *    Boolean value specifying that context line counts should be excluded from
+ *    the returned total.
+ *
+ *  :exclude_additions ::
+ *    Boolean value specifying that addition line counts should be excluded from
+ *    the returned total.
+ *
+ *  :exclude_deletions ::
+ *    Boolean value specifying that deletion line counts should be excluded from
+ *    the returned total.
+ *
+ *  :exclude_eofnl ::
+ *    Boolean value specifying that end-of-file newline change lines should
+ *    be excluded from the returned total.
+ *
+ *  Returns the total number of lines in the patch, depending on the options
+ *  specified.
+ */
+static VALUE rb_git_diff_patch_lines(int argc, VALUE *argv, VALUE self)
+{
+	git_patch *patch;
+	size_t lines = 0;
+	int options = 0;
+	VALUE rb_options;
+	Data_Get_Struct(self, git_patch, patch);
+
+	rb_scan_args(argc, argv, "0:", &rb_options);
+	if (!NIL_P(rb_options)) {
+		if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("exclude_context")))) {
+			options |= EXCLUDE_CONTEXT;
+		}
+
+		if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("exclude_additions")))) {
+			options |= EXCLUDE_ADDITIONS;
+		}
+
+		if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("exclude_deletions")))) {
+			options |= EXCLUDE_DELETIONS;
+		}
+
+		if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("exclude_eofnl")))) {
+			options |= EXCLUDE_EOFNL;
+		}
+	}
+
+	if (options == 0) {
+		size_t i = 0, hunks_count = git_patch_num_hunks(patch);
+		for (i = 0; i < hunks_count; ++i) {
+			lines += git_patch_num_lines_in_hunk(patch, i);
+		}
+	} else {
+		size_t i = 0, hunks_count = git_patch_num_hunks(patch);
+		for (i = 0; i < hunks_count; ++i) {
+			size_t lines_in_hunk = git_patch_num_lines_in_hunk(patch, i), l = 0;
+
+			for (l = 0; l < lines_in_hunk; ++l) {
+				const git_diff_line *line;
+				rugged_exception_check(
+					git_patch_get_line_in_hunk(&line, patch, i, l)
+				);
+
+				switch (line->origin) {
+				case GIT_DIFF_LINE_CONTEXT:
+					if (options & EXCLUDE_CONTEXT) continue;
+					break;
+
+				case GIT_DIFF_LINE_ADDITION:
+					if (options & EXCLUDE_ADDITIONS) continue;
+					break;
+
+				case GIT_DIFF_LINE_DELETION:
+					if (options & EXCLUDE_DELETIONS) continue;
+					break;
+
+				case GIT_DIFF_LINE_ADD_EOFNL:
+				case GIT_DIFF_LINE_DEL_EOFNL:
+					if (options & EXCLUDE_EOFNL) continue;
+					break;
+				}
+
+				lines += 1;
+			}
+		}
+	}
+
+	return INT2FIX(lines);
+}
+
 /*
  *  call-seq:
- *    patch.lines -> int
+ *    patch.bytesize(options = {}) -> int
+ *
+ *  The following options can be passed in the +options+ Hash:
  *
- *  Returns the total number of lines in the patch.
+ *  :exclude_context ::
+ *    Boolean value specifying that context lines should be excluded when
+ *    counting the number of bytes in the patch.
+ *
+ *  :exclude_hunk_headers ::
+ *    Boolean value specifying that hunk headers should be excluded when
+ *    counting the number of bytes in the patch.
+ *
+ *  :exclude_file_headers ::
+ *    Boolean value specifying that file headers should be excluded when
+ *    counting the number of bytes in the patch.
+ *
+ *  Returns the number of bytes in the patch, depending on which options are
+ *  specified.
  */
-static VALUE rb_git_diff_patch_lines(VALUE self)
+static VALUE rb_git_diff_patch_bytesize(int argc, VALUE *argv, VALUE self)
 {
 	git_patch *patch;
-	size_t context, adds, dels;
+	size_t bytesize;
+	VALUE rb_options;
+	int include_context, include_hunk_headers, include_file_headers;
 	Data_Get_Struct(self, git_patch, patch);
 
-	git_patch_line_stats(&context, &adds, &dels, patch);
+	include_context = include_hunk_headers = include_file_headers = 1;
 
-	return INT2FIX(context + adds + dels);
+	rb_scan_args(argc, argv, "0:", &rb_options);
+	if (!NIL_P(rb_options)) {
+		if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("exclude_context")))) {
+			include_context = 0;
+		}
+
+		if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("exclude_hunk_headers")))) {
+			include_hunk_headers = 0;
+		}
+
+		if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("exclude_file_headers")))) {
+			include_file_headers = 0;
+		}
+	}
+
+	bytesize = git_patch_size(patch, include_context, include_hunk_headers, include_file_headers);
+
+	return INT2FIX(bytesize);
 }
 
 static int patch_print_cb(
@@ -196,20 +315,36 @@ static int patch_print_cb(
 	const git_diff_line *line,
 	void *payload)
 {
-	VALUE rb_str = (VALUE)payload;
+	VALUE rb_buffer = (VALUE)payload;
 
 	switch (line->origin) {
 		case GIT_DIFF_LINE_CONTEXT:
 		case GIT_DIFF_LINE_ADDITION:
 		case GIT_DIFF_LINE_DELETION:
-			rb_str_cat(rb_str, &line->origin, 1);
+			rb_ary_push(rb_buffer, rb_str_new(&line->origin, 1));
 	}
 
-	rb_str_cat(rb_str, line->content, line->content_len);
+	rb_ary_push(rb_buffer, rb_str_new(line->content, line->content_len));
 
 	return GIT_OK;
 }
 
+static int patch_print_header_cb(
+	const git_diff_delta *delta,
+	const git_diff_hunk *hunk,
+	const git_diff_line *line,
+	void *payload)
+{
+	VALUE rb_buffer = (VALUE)payload;
+
+	if (line->origin == GIT_DIFF_LINE_FILE_HDR) {
+		rb_ary_push(rb_buffer, rb_str_new(line->content, line->content_len));
+		return GIT_OK;
+	} else {
+		return GIT_ITEROVER;
+	}
+}
+
 /*
  *  call-seq:
  *    patch.to_s -> str
@@ -219,14 +354,35 @@ static int patch_print_cb(
 static VALUE rb_git_diff_patch_to_s(VALUE self)
 {
 	git_patch *patch;
-	VALUE rb_str = rb_str_new(NULL, 0);
+	VALUE rb_buffer = rb_ary_new();
 	Data_Get_Struct(self, git_patch, patch);
 
-	rugged_exception_check(git_patch_print(patch, patch_print_cb, (void*)rb_str));
+	rugged_exception_check(git_patch_print(patch, patch_print_cb, (void*)rb_buffer));
 
-	return rb_str;
+	return rb_ary_join(rb_buffer, Qnil);
 }
 
+/*
+ *  call-seq:
+ *    patch.header -> str
+ *
+ *  Returns only the header of the patch as a string.
+ */
+static VALUE rb_git_diff_patch_header(VALUE self)
+{
+	git_patch *patch;
+	int error = 0;
+	VALUE rb_buffer = rb_ary_new();
+	Data_Get_Struct(self, git_patch, patch);
+
+	error = git_patch_print(patch, patch_print_header_cb, (void*)rb_buffer);
+	if (error && error != GIT_ITEROVER)
+		rugged_exception_check(error);
+
+	return rb_ary_join(rb_buffer, Qnil);
+}
+
+
 void Init_rugged_patch(void)
 {
 	rb_cRuggedPatch = rb_define_class_under(rb_mRugged, "Patch", rb_cObject);
@@ -234,10 +390,12 @@ void Init_rugged_patch(void)
 	rb_define_singleton_method(rb_cRuggedPatch, "from_strings", rb_git_patch_from_strings, -1);
 
 	rb_define_method(rb_cRuggedPatch, "stat", rb_git_diff_patch_stat, 0);
-	rb_define_method(rb_cRuggedPatch, "lines", rb_git_diff_patch_lines, 0);
+	rb_define_method(rb_cRuggedPatch, "lines", rb_git_diff_patch_lines, -1);
+	rb_define_method(rb_cRuggedPatch, "bytesize", rb_git_diff_patch_bytesize, -1);
 
 	rb_define_method(rb_cRuggedPatch, "delta", rb_git_diff_patch_delta, 0);
 
+	rb_define_method(rb_cRuggedPatch, "header", rb_git_diff_patch_header, 0);
 	rb_define_method(rb_cRuggedPatch, "to_s", rb_git_diff_patch_to_s, 0);
 
 	rb_define_method(rb_cRuggedPatch, "each_hunk", rb_git_diff_patch_each_hunk, 0);