rugged 1.3.2 → 1.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0d3a62d428f320d5ee63e21ce25ffc00ac84912e9980b782e4663b9c339f32f6
-  data.tar.gz: '09e9ef581a5ce5248505535edcef74dcf3e52cb0f1019285c258bd03f4b48471'
+  metadata.gz: 352d7cd2514026a9539c7b3bca08450118cc29721d7ea969548aceb7a10a42f2
+  data.tar.gz: cba7b10bdc897406044a8205b8278fd6bd042e714df11fc868d663d9e6f39c73
 SHA512:
-  metadata.gz: 21505d114417de7410ea8f34f05bb4347f6610f64e219d4687f33b89b8b52fccc9c6d99f2ee581a92080033ad40e81572310c6d0b2cf6f64c0359f3e976d088e
-  data.tar.gz: d3aeea031ffb9598fc2b8b313eefc2927d1a7b1fe3b594c6010d06d8c1c557791fdb68134b2ac3c6573290d46eb8c38c6d502f098d43986e1abc7c3fda20c97a
+  metadata.gz: dfa9a28f28da9f52660f93ee665bcb0763cd5f1ada9a52fefaf2ea9582dd83f741c8bae512b0fd1337273055bab93dd1d6d0d0d096b7ff9412bc63c562a815fe
+  data.tar.gz: 348ee2757446376a08aeed8dec122867578963c22d7d491462552391d315cb5a92ff571ea9bb91e1dfacdea98558dc321d914e1030105885cecd936f624c8e04

data/README.md

@@ -1,4 +1,4 @@
-# Rugged [![Build Status](https://travis-ci.org/libgit2/rugged.svg?branch=master)](https://travis-ci.org/libgit2/rugged)
+# Rugged [![Rugged CI](https://github.com/libgit2/rugged/actions/workflows/ci.yml/badge.svg)](https://github.com/libgit2/rugged/actions/workflows/ci.yml)
 **libgit2 bindings in Ruby**
 
 Rugged is a library for accessing [libgit2](https://github.com/libgit2/libgit2) in Ruby. It gives you the speed and
@@ -17,21 +17,53 @@ Rugged is a self-contained gem. You can install it by running:
 
     $ gem install rugged
 
-You need to have CMake and `pkg-config` installed on your system to be able to build the included version of `libgit2`. On OS X, after installing [Homebrew](http://brew.sh/), you can get the required packages with:
+## Prerequisites
+You need to have CMake and `pkg-config` installed on your system to be able to build the included version of `libgit2`. 
+
+### Debian, Including Ubuntu
+All Debian-derived Linux distros provide `apt`:
+```bash
+$ sudo apt install libgit2-dev cmake pkg-config
+```
+
+Note that you only need `libgit2-dev` if you want to build with the system
+libgit2 rather than the vendored version. In this case, note that the major and
+minor versions of libgit2 and rugged must match.
+
+### Mac
+On OS X, after installing [Homebrew](http://brew.sh/), you can get the required packages with:
 ```bash
 $ brew install cmake pkg-config
 ```
 
 Please follow the above in case installation of the gem fails with `ERROR: CMake is required to build Rugged.`.
 
+### Options
+
 If you want to build Rugged with HTTPS and SSH support, check out the list of optional [libgit2 dependencies](https://github.com/libgit2/libgit2#optional-dependencies).
 
+To install `rugged` with SSH support ensure you have the `LibSSH2` library present, then pass the required `CMAKE_FLAGS`:
+```bash
+CMAKE_FLAGS='-DUSE_SSH=ON' gem install rugged
+```
+
+Or pass the `--with-ssh` build option:
+```bash
+gem install rugged -- --with-ssh
+```
+
 If you're using bundler and want to bundle `libgit2` with Rugged, you can use the `:submodules` option:
 
 ```ruby
 gem 'rugged', git: 'git://github.com/libgit2/rugged.git', submodules: true
 ```
 
+If you would like to bundle rugged with SSH support add the `--with-ssh` build option to the bundler config:
+```bash
+bundle config build.rugged --with-ssh
+```
+
+## Usage
 To load Rugged, you'll usually want to add something like this:
 
 ```ruby

data/ext/rugged/extconf.rb

@@ -14,8 +14,11 @@ $CFLAGS << " -O3" unless $CFLAGS[/-O\d/]
 $CFLAGS << " -Wall -Wno-comment"
 
 cmake_flags = [ ENV["CMAKE_FLAGS"] ]
+cmake_flags << "-DBUILD_CLI=OFF"
+cmake_flags << "-DBUILD_TESTS=OFF"
 cmake_flags << "-DREGEX_BACKEND=builtin"
 cmake_flags << "-DUSE_SHA1DC=ON" if with_config("sha1dc")
+cmake_flags << "-DUSE_SSH=ON"    if with_config("ssh")
 
 def sys(cmd)
   puts " -- #{cmd}"
@@ -68,12 +71,12 @@ if arg_config("--use-system-libraries", !!ENV['RUGGED_USE_SYSTEM_LIBRARIES'])
   major = minor = nil
 
   File.readlines(File.join(LIBGIT2_DIR, "include", "git2", "version.h")).each do |line|
-    if !major && (matches = line.match(/^#define LIBGIT2_VER_MAJOR ([0-9]+)$/))
+    if !major && (matches = line.match(/^#define LIBGIT2_VER_MAJOR\s+([0-9]+)$/))
       major = matches[1]
       next
     end
 
-    if !minor && (matches = line.match(/^#define LIBGIT2_VER_MINOR ([0-9]+)$/))
+    if !minor && (matches = line.match(/^#define LIBGIT2_VER_MINOR\s+([0-9]+)$/))
       minor = matches[1]
       next
     end
@@ -98,12 +101,12 @@ else
   end
 
   Dir.chdir(LIBGIT2_DIR) do
-    Dir.mkdir("build") if !Dir.exists?("build")
+    Dir.mkdir("build") if !Dir.exist?("build")
 
     Dir.chdir("build") do
       # On Windows, Ruby-DevKit is MSYS-based, so ensure to use MSYS Makefiles.
       generator = "-G \"MSYS Makefiles\"" if Gem.win_platform?
-      run_cmake(5 * 60, ".. -DBUILD_CLAR=OFF -DTHREADSAFE=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_C_FLAGS=-fPIC -DCMAKE_BUILD_TYPE=RelWithDebInfo #{cmake_flags.join(' ')} #{generator}")
+      run_cmake(5 * 60, ".. -DBUILD_TESTS=OFF -DUSE_THREADS=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_C_FLAGS=-fPIC -DCMAKE_BUILD_TYPE=RelWithDebInfo #{cmake_flags.join(' ')} #{generator}")
       sys(MAKE)
 
       # "normal" libraries (and libgit2 builds) get all these when they build but we're doing it

data/ext/rugged/rugged.c

@@ -75,6 +75,21 @@ static VALUE rb_git_libgit2_version(VALUE self)
 	return rb_ary_new3(3, INT2NUM(major), INT2NUM(minor), INT2NUM(rev));
 }
 
+/*
+ *  call-seq:
+ *     Rugged.libgit2_prerelease -> prerelease string
+ *
+ *  Returns a string with the prerelease string for libgit2. This will be empty
+ *  for tagged releases.
+ */
+static VALUE rb_git_libgit2_prerelease(VALUE self)
+{
+	const char *prerelease;
+
+	prerelease = git_libgit2_prerelease();
+	return rb_str_new_utf8(prerelease ? prerelease : "");
+}
+
 /*
  *  call-seq:
  *     Rugged.features -> [feature, ...]
@@ -585,6 +600,7 @@ void Init_rugged(void)
 	}
 
 	rb_define_module_function(rb_mRugged, "libgit2_version", rb_git_libgit2_version, 0);
+	rb_define_module_function(rb_mRugged, "libgit2_prerelease", rb_git_libgit2_prerelease, 0);
 	rb_define_module_function(rb_mRugged, "features", rb_git_features, 0);
 	rb_define_module_function(rb_mRugged, "valid_full_oid?", rb_git_valid_full_oid, 1);
 	rb_define_module_function(rb_mRugged, "hex_to_raw", rb_git_hex_to_raw, 1);

data/ext/rugged/rugged.h

@@ -165,6 +165,10 @@ struct rugged_remote_cb_payload
 	int exception;
 };
 
+void rugged_remote_init_custom_headers(VALUE rb_options, git_strarray *custom_headers);
+
+void rugged_remote_init_proxy_options(VALUE rb_options, git_proxy_options *proxy_options);
+
 void rugged_remote_init_callbacks_and_payload_from_options(
 	VALUE rb_options,
 	git_remote_callbacks *callbacks,

data/ext/rugged/rugged_blame.c

@@ -264,6 +264,8 @@ static VALUE rb_git_blame_each(VALUE self)
 void Init_rugged_blame(void)
 {
 	rb_cRuggedBlame = rb_define_class_under(rb_mRugged, "Blame", rb_cObject);
+	rb_undef_alloc_func(rb_cRuggedBlame);
+
 	rb_include_module(rb_cRuggedBlame, rb_mEnumerable);
 
 	rb_define_singleton_method(rb_cRuggedBlame, "new", rb_git_blame_new, -1);

data/ext/rugged/rugged_blob.c

@@ -694,6 +694,7 @@ void Init_rugged_blob(void)
 	id_read = rb_intern("read");
 
 	rb_cRuggedBlob = rb_define_class_under(rb_mRugged, "Blob", rb_cRuggedObject);
+	rb_undef_alloc_func(rb_cRuggedBlob);
 
 	rb_define_method(rb_cRuggedBlob, "size", rb_git_blob_rawsize, 0);
 	rb_define_method(rb_cRuggedBlob, "content", rb_git_blob_content_GET, -1);
@@ -712,6 +713,8 @@ void Init_rugged_blob(void)
 	rb_define_singleton_method(rb_cRuggedBlob, "merge_files", rb_git_blob_merge_files, -1);
 
 	rb_cRuggedBlobSig = rb_define_class_under(rb_cRuggedBlob, "HashSignature", rb_cObject);
+	rb_undef_alloc_func(rb_cRuggedBlobSig);
+
 	rb_define_singleton_method(rb_cRuggedBlobSig, "new", rb_git_blob_sig_new, -1);
 	rb_define_singleton_method(rb_cRuggedBlobSig, "compare", rb_git_blob_sig_compare, 2);
 }

data/ext/rugged/rugged_commit.c

@@ -869,6 +869,7 @@ static VALUE rb_git_commit_create_with_signature(int argc, VALUE *argv, VALUE se
 void Init_rugged_commit(void)
 {
 	rb_cRuggedCommit = rb_define_class_under(rb_mRugged, "Commit", rb_cRuggedObject);
+	rb_undef_alloc_func(rb_cRuggedCommit);
 
 	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);

data/ext/rugged/rugged_config.c

@@ -181,17 +181,22 @@ static int cb_config__each_key(const git_config_entry *entry, void *payload)
 static int cb_config__each_pair(const git_config_entry *entry, void *payload)
 {
 	int *exception = (int *) payload;
+	VALUE value;
 
-	rb_protect(rb_yield, rb_ary_new3(2, rb_str_new_utf8(entry->name), rb_str_new_utf8(entry->value)), exception);
+	value = entry->value ? rb_str_new_utf8(entry->value) : Qnil;
+	rb_protect(rb_yield, rb_ary_new3(2, rb_str_new_utf8(entry->name), value), exception);
 
 	return (*exception != 0) ? GIT_EUSER : GIT_OK;
 }
 
 static int cb_config__to_hash(const git_config_entry *entry, void *opaque)
 {
+	VALUE value;
+
+	value = entry->value ? rb_str_new_utf8(entry->value) : Qnil;
 	rb_hash_aset((VALUE)opaque,
 		rb_str_new_utf8(entry->name),
-		rb_str_new_utf8(entry->value)
+		value
 	);
 
 	return GIT_OK;
@@ -406,6 +411,8 @@ void Init_rugged_config(void)
 	 * Config
 	 */
 	rb_cRuggedConfig = rb_define_class_under(rb_mRugged, "Config", rb_cObject);
+	rb_undef_alloc_func(rb_cRuggedConfig);
+
 	rb_define_singleton_method(rb_cRuggedConfig, "new", rb_git_config_new, 1);
 
 	rb_define_singleton_method(rb_cRuggedConfig, "global", rb_git_config_open_default, 0);

data/ext/rugged/rugged_diff.c

@@ -640,6 +640,7 @@ static VALUE rb_git_diff_sorted_icase_p(VALUE self)
 void Init_rugged_diff(void)
 {
 	rb_cRuggedDiff = rb_define_class_under(rb_mRugged, "Diff", rb_cObject);
+	rb_undef_alloc_func(rb_cRuggedDiff);
 
 	rb_define_method(rb_cRuggedDiff, "patch", rb_git_diff_patch, -1);
 	rb_define_method(rb_cRuggedDiff, "write_patch", rb_git_diff_write_patch, -1);

data/ext/rugged/rugged_index.c

@@ -1029,6 +1029,8 @@ void Init_rugged_index(void)
 	 * Index
 	 */
 	rb_cRuggedIndex = rb_define_class_under(rb_mRugged, "Index", rb_cObject);
+	rb_undef_alloc_func(rb_cRuggedIndex);
+
 	rb_define_singleton_method(rb_cRuggedIndex, "new", rb_git_index_new, -1);
 
 	rb_define_method(rb_cRuggedIndex, "count", rb_git_index_count, 0);

data/ext/rugged/rugged_patch.c

@@ -383,6 +383,7 @@ static VALUE rb_git_diff_patch_header(VALUE self)
 void Init_rugged_patch(void)
 {
 	rb_cRuggedPatch = rb_define_class_under(rb_mRugged, "Patch", rb_cObject);
+	rb_undef_alloc_func(rb_cRuggedPatch);
 
 	rb_define_singleton_method(rb_cRuggedPatch, "from_strings", rb_git_patch_from_strings, -1);
 

data/ext/rugged/rugged_rebase.c

@@ -389,6 +389,7 @@ static VALUE rebase_operation_type(git_rebase_operation *operation)
 void Init_rugged_rebase(void)
 {
 	rb_cRuggedRebase = rb_define_class_under(rb_mRugged, "Rebase", rb_cObject);
+	rb_undef_alloc_func(rb_cRuggedRebase);
 
 	rb_define_singleton_method(rb_cRuggedRebase, "new", rb_git_rebase_new, -1);
 	rb_define_method(rb_cRuggedRebase, "next",  rb_git_rebase_next,  0);

data/ext/rugged/rugged_reference.c

@@ -368,6 +368,7 @@ static VALUE rb_git_ref_is_tag(VALUE self)
 void Init_rugged_reference(void)
 {
 	rb_cRuggedReference = rb_define_class_under(rb_mRugged, "Reference", rb_cObject);
+	rb_undef_alloc_func(rb_cRuggedReference);
 
 	rb_define_singleton_method(rb_cRuggedReference, "valid_name?", rb_git_ref_valid_name, 1);
 

data/ext/rugged/rugged_remote.c

@@ -198,7 +198,7 @@ void rugged_remote_init_callbacks_and_payload_from_options(
 	}
 }
 
-static void init_custom_headers(VALUE rb_options, git_strarray *custom_headers)
+void rugged_remote_init_custom_headers(VALUE rb_options, git_strarray *custom_headers)
 {
 	if (!NIL_P(rb_options))
 	{
@@ -207,7 +207,7 @@ static void init_custom_headers(VALUE rb_options, git_strarray *custom_headers)
 	}
 }
 
-static void init_proxy_options(VALUE rb_options, git_proxy_options *proxy_options)
+void rugged_remote_init_proxy_options(VALUE rb_options, git_proxy_options *proxy_options)
 {
 	if (NIL_P(rb_options)) return;
 
@@ -219,6 +219,17 @@ static void init_proxy_options(VALUE rb_options, git_proxy_options *proxy_option
 	}
 }
 
+static void init_pb_parallelism(VALUE rb_options, git_push_options *opts)
+{
+	if (NIL_P(rb_options)) return;
+
+	VALUE val = rb_hash_aref(rb_options, CSTR2SYM("pb_parallelism"));
+	if (!NIL_P(val)) {
+		Check_Type(val, T_FIXNUM);
+		opts->pb_parallelism = FIX2UINT(val);
+	}
+}
+
 static int parse_prune_type(VALUE rb_prune_type)
 {
 	if (rb_prune_type == Qtrue) {
@@ -319,8 +330,8 @@ static VALUE rb_git_remote_ls(int argc, VALUE *argv, VALUE self)
 	rb_scan_args(argc, argv, ":", &rb_options);
 
 	rugged_remote_init_callbacks_and_payload_from_options(rb_options, &callbacks, &payload);
-	init_custom_headers(rb_options, &custom_headers);
-	init_proxy_options(rb_options, &proxy_options);
+	rugged_remote_init_custom_headers(rb_options, &custom_headers);
+	rugged_remote_init_proxy_options(rb_options, &proxy_options);
 
 	if ((error = git_remote_connect(remote, GIT_DIRECTION_FETCH, &callbacks, &proxy_options, &custom_headers)) ||
 	    (error = git_remote_ls(&heads, &heads_len, remote)))
@@ -524,8 +535,8 @@ static VALUE rb_git_remote_check_connection(int argc, VALUE *argv, VALUE self)
 		rb_raise(rb_eTypeError, "Invalid direction. Expected :fetch or :push");
 
 	rugged_remote_init_callbacks_and_payload_from_options(rb_options, &callbacks, &payload);
-	init_custom_headers(rb_options, &custom_headers);
-	init_proxy_options(rb_options, &proxy_options);
+	rugged_remote_init_custom_headers(rb_options, &custom_headers);
+	rugged_remote_init_proxy_options(rb_options, &proxy_options);
 
 	error = git_remote_connect(remote, direction, &callbacks, &proxy_options, &custom_headers);
 	git_remote_disconnect(remote);
@@ -617,8 +628,8 @@ static VALUE rb_git_remote_fetch(int argc, VALUE *argv, VALUE self)
 	Data_Get_Struct(self, git_remote, remote);
 
 	rugged_remote_init_callbacks_and_payload_from_options(rb_options, &opts.callbacks, &payload);
-	init_custom_headers(rb_options, &opts.custom_headers);
-	init_proxy_options(rb_options, &opts.proxy_opts);
+	rugged_remote_init_custom_headers(rb_options, &opts.custom_headers);
+	rugged_remote_init_proxy_options(rb_options, &opts.proxy_opts);
 
 	if (!NIL_P(rb_options)) {
 		VALUE rb_prune_type;
@@ -683,6 +694,11 @@ static VALUE rb_git_remote_fetch(int argc, VALUE *argv, VALUE self)
  *  :proxy_url ::
  *    The url of an http proxy to use to access the remote repository.
  *
+ *  :pb_parallelism ::
+ *    Sets the number of worker threads that will be available to the packbuilder when generating
+ *    a pack file, if required by the transport being used. A value of 0 means the packbuilder will
+ *    auto-detect the number of of threads to use.
+ *
  *  Example:
  *
  *    remote = Rugged::Remote.lookup(@repo, 'origin')
@@ -707,8 +723,9 @@ static VALUE rb_git_remote_push(int argc, VALUE *argv, VALUE self)
 	Data_Get_Struct(self, git_remote, remote);
 
 	rugged_remote_init_callbacks_and_payload_from_options(rb_options, &opts.callbacks, &payload);
-	init_custom_headers(rb_options, &opts.custom_headers);
-	init_proxy_options(rb_options, &opts.proxy_opts);
+	rugged_remote_init_custom_headers(rb_options, &opts.custom_headers);
+	rugged_remote_init_proxy_options(rb_options, &opts.proxy_opts);
+	init_pb_parallelism(rb_options, &opts);
 
 	error = git_remote_push(remote, &refspecs, &opts);
 
@@ -726,6 +743,7 @@ static VALUE rb_git_remote_push(int argc, VALUE *argv, VALUE self)
 void Init_rugged_remote(void)
 {
 	rb_cRuggedRemote = rb_define_class_under(rb_mRugged, "Remote", rb_cObject);
+	rb_undef_alloc_func(rb_cRuggedRemote);
 
 	rb_define_method(rb_cRuggedRemote, "name", rb_git_remote_name, 0);
 	rb_define_method(rb_cRuggedRemote, "url", rb_git_remote_url, 0);

data/ext/rugged/rugged_repo.c

@@ -528,14 +528,9 @@ static void parse_clone_options(git_clone_options *ret, VALUE rb_options, struct
 		ret->checkout_branch = StringValueCStr(val);
 	}
 
-	val = rb_hash_aref(rb_options, CSTR2SYM("proxy_url"));
-	if (!NIL_P(val)) {
-		Check_Type(val, T_STRING);
-		ret->fetch_opts.proxy_opts.type = GIT_PROXY_SPECIFIED;
-		ret->fetch_opts.proxy_opts.url = StringValueCStr(val);
-	}
-
 	rugged_remote_init_callbacks_and_payload_from_options(rb_options, &ret->fetch_opts.callbacks, remote_payload);
+	rugged_remote_init_custom_headers(rb_options, &ret->fetch_opts.custom_headers);
+	rugged_remote_init_proxy_options(rb_options, &ret->fetch_opts.proxy_opts);
 }
 
 /*
@@ -2743,7 +2738,7 @@ static VALUE rb_git_repo_cherrypick_commit(int argc, VALUE *argv, VALUE self)
 
 /*
  *  call-seq: repo.diff_from_buffer(buffer) -> Rugged::Diff object
- *  
+ *
  *  Where +buffer+ is a +String+.
  *  Returns A Rugged::Diff object
  */
@@ -2769,6 +2764,7 @@ void Init_rugged_repo(void)
 	id_call = rb_intern("call");
 
 	rb_cRuggedRepo = rb_define_class_under(rb_mRugged, "Repository", rb_cObject);
+	rb_undef_alloc_func(rb_cRuggedRepo);
 
 	rb_define_singleton_method(rb_cRuggedRepo, "new", rb_git_repo_new, -1);
 	rb_define_singleton_method(rb_cRuggedRepo, "bare", rb_git_repo_open_bare, -1);
@@ -2822,7 +2818,7 @@ void Init_rugged_repo(void)
 	rb_define_method(rb_cRuggedRepo, "apply", rb_git_repo_apply, -1);
 
 	rb_define_method(rb_cRuggedRepo, "revert_commit", rb_git_repo_revert_commit, -1);
-	
+
 	rb_define_method(rb_cRuggedRepo, "diff_from_buffer", rb_git_diff_from_buffer, 1);
 
 	rb_define_method(rb_cRuggedRepo, "path_ignored?", rb_git_repo_is_path_ignored, 1);
@@ -2846,6 +2842,8 @@ void Init_rugged_repo(void)
 	rb_define_method(rb_cRuggedRepo, "fetch_attributes", rb_git_repo_attributes, -1);
 
 	rb_cRuggedOdbObject = rb_define_class_under(rb_mRugged, "OdbObject", rb_cObject);
+	rb_undef_alloc_func(rb_cRuggedOdbObject);
+
 	rb_define_method(rb_cRuggedOdbObject, "data",  rb_git_odbobj_data,  0);
 	rb_define_method(rb_cRuggedOdbObject, "len",  rb_git_odbobj_size,  0);
 	rb_define_method(rb_cRuggedOdbObject, "type",  rb_git_odbobj_type,  0);

data/ext/rugged/rugged_revwalk.c

@@ -11,6 +11,8 @@ extern VALUE rb_mRugged;
 extern VALUE rb_cRuggedObject;
 VALUE rb_cRuggedWalker;
 
+extern const rb_data_type_t rugged_object_type;
+
 static void rb_git_walk__free(git_revwalk *walk)
 {
 	git_revwalk_free(walk);
@@ -43,7 +45,7 @@ static void push_commit_1(git_revwalk *walk, VALUE rb_commit, int hide)
 {
 	if (rb_obj_is_kind_of(rb_commit, rb_cRuggedObject)) {
 		git_object *object;
-		Data_Get_Struct(rb_commit, git_object, object);
+		TypedData_Get_Struct(rb_commit, git_object, &rugged_object_type, object);
 
 		push_commit_oid(walk, git_object_id(object), hide);
 		return;
@@ -481,6 +483,8 @@ static VALUE rb_git_walker_each_oid(int argc, VALUE *argv, VALUE self)
 void Init_rugged_revwalk(void)
 {
 	rb_cRuggedWalker = rb_define_class_under(rb_mRugged, "Walker", rb_cObject);
+	rb_undef_alloc_func(rb_cRuggedWalker);
+
 	rb_define_singleton_method(rb_cRuggedWalker, "new", rb_git_walker_new, 1);
 	rb_define_singleton_method(rb_cRuggedWalker, "walk", rb_git_walk, -1);
 

data/ext/rugged/rugged_settings.c

@@ -86,6 +86,11 @@ static VALUE rb_git_set_option(VALUE self, VALUE option, VALUE value)
 		git_libgit2_opts(GIT_OPT_ENABLE_STRICT_OBJECT_CREATION, strict);
 	}
 
+	else if (strcmp(opt, "fsync_gitdir") == 0) {
+		int fsync = RTEST(value) ? 1 : 0;
+		git_libgit2_opts(GIT_OPT_ENABLE_FSYNC_GITDIR, fsync);
+	}
+
 	else {
 		rb_raise(rb_eArgError, "Unknown option specified");
 	}

data/ext/rugged/rugged_submodule.c

@@ -792,6 +792,7 @@ void Init_rugged_submodule(void)
 	id_update_none  = rb_intern("none");
 
 	rb_cRuggedSubmodule = rb_define_class_under(rb_mRugged, "Submodule", rb_cObject);
+	rb_undef_alloc_func(rb_cRuggedSubmodule);
 
 	rb_define_method(rb_cRuggedSubmodule, "finalize_add", rb_git_submodule_finalize_add, 0);
 

data/ext/rugged/rugged_tag.c

@@ -225,6 +225,7 @@ void Init_rugged_tag(void)
 	rb_define_method(rb_cRuggedTag, "target", rb_git_tag_target, 0);
 
 	rb_cRuggedTagAnnotation = rb_define_class_under(rb_cRuggedTag, "Annotation", rb_cRuggedObject);
+	rb_undef_alloc_func(rb_cRuggedTagAnnotation);
 
 	rb_define_method(rb_cRuggedTagAnnotation, "message", rb_git_tag_annotation_message, 0);
 	rb_define_method(rb_cRuggedTagAnnotation, "name", rb_git_tag_annotation_name, 0);

data/ext/rugged/rugged_tree.c

@@ -899,6 +899,8 @@ void Init_rugged_tree(void)
 	 * Tree
 	 */
 	rb_cRuggedTree = rb_define_class_under(rb_mRugged, "Tree", rb_cRuggedObject);
+	rb_undef_alloc_func(rb_cRuggedTree);
+
 	rb_define_method(rb_cRuggedTree, "count", rb_git_tree_entrycount, 0);
 	rb_define_method(rb_cRuggedTree, "count_recursive", rb_git_tree_entrycount_recursive, -1);
 	rb_define_method(rb_cRuggedTree, "length", rb_git_tree_entrycount, 0);
@@ -917,6 +919,8 @@ void Init_rugged_tree(void)
 	rb_define_private_method(rb_singleton_class(rb_cRuggedTree), "diff_tree_to_tree", rb_git_diff_tree_to_tree, 4);
 
 	rb_cRuggedTreeBuilder = rb_define_class_under(rb_cRuggedTree, "Builder", rb_cObject);
+	rb_undef_alloc_func(rb_cRuggedTreeBuilder);
+
 	rb_define_singleton_method(rb_cRuggedTreeBuilder, "new", rb_git_treebuilder_new, -1);
 	rb_define_method(rb_cRuggedTreeBuilder, "clear", rb_git_treebuilder_clear, 0);
 	rb_define_method(rb_cRuggedTreeBuilder, "[]", rb_git_treebuilder_get, 1);

data/lib/rugged/index.rb

@@ -81,7 +81,7 @@ module Rugged
     # :deltas_are_icase ::
     #   If true, filename comparisons will be made with case-insensitivity.
     #
-    # :include_untracked_content ::
+    # :show_untracked_content ::
     #   if true, untracked content will be contained in the the diff patch text.
     #
     # :skip_binary_check ::

data/lib/rugged/tree.rb

@@ -87,7 +87,7 @@ module Rugged
     # :deltas_are_icase ::
     #   If true, filename comparisons will be made with case-insensitivity.
     #
-    # :include_untracked_content ::
+    # :show_untracked_content ::
     #   if true, untracked content will be contained in the the diff patch text.
     #
     # :skip_binary_check ::
@@ -172,21 +172,25 @@ module Rugged
 
     # Walks the tree but only yields blobs
     def walk_blobs(mode=:postorder)
+      return to_enum(__method__) unless block_given?
       self.walk(mode) { |root, e| yield root, e if e[:type] == :blob }
     end
 
     # Walks the tree but only yields subtrees
     def walk_trees(mode=:postorder)
+      return to_enum(__method__) unless block_given?
       self.walk(mode) { |root, e| yield root, e if e[:type] == :tree }
     end
 
     # Iterate over the blobs in this tree
     def each_blob
+      return to_enum(__method__) unless block_given?
       self.each { |e| yield e if e[:type] == :blob }
     end
 
     # Iterate over the subtrees in this tree
     def each_tree
+      return to_enum(__method__) unless block_given?
       self.each { |e| yield e if e[:type] == :tree }
     end
   end

data/lib/rugged/version.rb

@@ -4,5 +4,5 @@
 # For full terms see the included LICENSE file.
 
 module Rugged
-  Version = VERSION = '1.3.2'
+  Version = VERSION = '1.6.2'
 end