rugged 0.19.0 → 0.28.0

data/ext/rugged/rugged_revwalk.c

@@ -1,30 +1,14 @@
 /*
- * The MIT License
- *
- * Copyright (c) 2013 GitHub, Inc
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
+ * 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"
 
 extern VALUE rb_mRugged;
+extern VALUE rb_cRuggedObject;
 VALUE rb_cRuggedWalker;
 
 static void rb_git_walk__free(git_revwalk *walk)
@@ -39,6 +23,58 @@ VALUE rugged_walker_new(VALUE klass, VALUE owner, git_revwalk *walk)
 	return rb_walk;
 }
 
+static void push_commit_oid(git_revwalk *walk, const git_oid *oid, int hide)
+{
+	int error;
+	if (hide) error = git_revwalk_hide(walk, oid);
+	else error = git_revwalk_push(walk, oid);
+	rugged_exception_check(error);
+}
+
+static void push_commit_ref(git_revwalk *walk, const char *ref, int hide)
+{
+	int error;
+	if (hide) error = git_revwalk_hide_ref(walk, ref);
+	else error = git_revwalk_push_ref(walk, ref);
+	rugged_exception_check(error);
+}
+
+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);
+
+		push_commit_oid(walk, git_object_id(object), hide);
+		return;
+	}
+
+	Check_Type(rb_commit, T_STRING);
+
+	if (RSTRING_LEN(rb_commit) == 40) {
+		git_oid commit_oid;
+		if (git_oid_fromstr(&commit_oid, RSTRING_PTR(rb_commit)) == 0) {
+			push_commit_oid(walk, &commit_oid, hide);
+			return;
+		}
+	}
+
+	push_commit_ref(walk, StringValueCStr(rb_commit), hide);
+}
+
+static void push_commit(git_revwalk *walk, VALUE rb_commit, int hide)
+{
+	if (rb_type(rb_commit) == T_ARRAY) {
+		long i;
+		for (i = 0; i < RARRAY_LEN(rb_commit); ++i)
+			push_commit_1(walk, rb_ary_entry(rb_commit, i), hide);
+
+		return;
+	}
+
+	push_commit_1(walk, rb_commit, hide);
+}
+
 /*
  *  call-seq:
  *    Walker.new(repository) -> walker
@@ -60,58 +96,6 @@ static VALUE rb_git_walker_new(VALUE klass, VALUE rb_repo)
 	return rugged_walker_new(klass, rb_repo, walk);;
 }
 
-/*
- *  call-seq:
- *    walker.each { |commit| block }
- *    walker.each -> Iterator
- *
- *  Perform the walk through the repository, yielding each
- *  one of the commits found as a <tt>Rugged::Commit</tt> instance
- *  to +block+.
- *
- *  If no +block+ is given, an +Iterator+ will be returned.
- *
- *  The walker must have been previously set-up before a walk can be performed
- *  (i.e. at least one commit must have been pushed).
- *
- *    walker.push("92b22bbcb37caf4f6f53d30292169e84f5e4283b")
- *    walker.each { |commit| puts commit.oid }
- *
- *  generates:
- *
- *    92b22bbcb37caf4f6f53d30292169e84f5e4283b
- *    6b750d5800439b502de669465b385e5f469c78b6
- *    ef9207141549f4ffcd3c4597e270d32e10d0a6bc
- *    cb75e05f0f8ac3407fb3bd0ebd5ff07573b16c9f
- *    ...
- */
-static VALUE rb_git_walker_each(VALUE self)
-{
-	git_revwalk *walk;
-	git_commit *commit;
-	git_repository *repo;
-	git_oid commit_oid;
-	int error;
-
-	Data_Get_Struct(self, git_revwalk, walk);
-	repo = git_revwalk_repository(walk);
-
-	if (!rb_block_given_p())
-		return rb_funcall(self, rb_intern("to_enum"), 0);
-
-	while ((error = git_revwalk_next(&commit_oid, walk)) == 0) {
-		error = git_commit_lookup(&commit, repo, &commit_oid);
-		rugged_exception_check(error);
-
-		rb_yield(rugged_object_new(rugged_owner(self), (git_object *)commit));
-	}
-
-	if (error != GIT_ITEROVER)
-		rugged_exception_check(error);
-
-	return Qnil;
-}
-
 /*
  *  call-seq:
  *    walker.push(commit) -> nil
@@ -131,19 +115,16 @@ static VALUE rb_git_walker_each(VALUE self)
 static VALUE rb_git_walker_push(VALUE self, VALUE rb_commit)
 {
 	git_revwalk *walk;
-	git_commit *commit;
-	int error;
-
 	Data_Get_Struct(self, git_revwalk, walk);
+	push_commit(walk, rb_commit, 0);
+	return Qnil;
+}
 
-	commit = (git_commit *)rugged_object_get(
-		git_revwalk_repository(walk), rb_commit, GIT_OBJ_COMMIT);
-
-	error = git_revwalk_push(walk, git_object_id((git_object *)commit));
-
-	git_commit_free(commit);
-	rugged_exception_check(error);
-
+static VALUE rb_git_walker_push_range(VALUE self, VALUE range)
+{
+	git_revwalk *walk;
+	Data_Get_Struct(self, git_revwalk, walk);
+	rugged_exception_check(git_revwalk_push_range(walk, StringValueCStr(range)));
 	return Qnil;
 }
 
@@ -157,25 +138,14 @@ static VALUE rb_git_walker_push(VALUE self, VALUE rb_commit)
 static VALUE rb_git_walker_hide(VALUE self, VALUE rb_commit)
 {
 	git_revwalk *walk;
-	git_commit *commit;
-	int error;
-
 	Data_Get_Struct(self, git_revwalk, walk);
-
-	commit = (git_commit *)rugged_object_get(
-		git_revwalk_repository(walk), rb_commit, GIT_OBJ_COMMIT);
-
-	error = git_revwalk_hide(walk, git_object_id((git_object *)commit));
-
-	git_commit_free(commit);
-	rugged_exception_check(error);
-
+	push_commit(walk, rb_commit, 1);
 	return Qnil;
 }
 
 /*
  *  call-seq:
- *    walker.sorting = sort_mode
+ *    walker.sorting(sort_mode) -> nil
  *
  *  Change the sorting mode for the revision walk.
  *
@@ -189,6 +159,47 @@ static VALUE rb_git_walker_sorting(VALUE self, VALUE ruby_sort_mode)
 	return Qnil;
 }
 
+/*
+ *  call-seq:
+ *    walker.simplify_first_parent() -> nil
+ *
+ *  Simplify the walk to the first parent of each commit.
+ */
+static VALUE rb_git_walker_simplify_first_parent(VALUE self)
+{
+	git_revwalk *walk;
+	Data_Get_Struct(self, git_revwalk, walk);
+	git_revwalk_simplify_first_parent(walk);
+	return Qnil;
+}
+
+/*
+ *  call-seq:
+ *    walker.count -> Fixnum
+ *
+ *  Returns the amount of objects a walker iterated over. If an argument or
+ *  block is given this method delegates to +Enumerable#count+.
+ */
+static VALUE rb_git_walker_count(int argc, VALUE *argv, VALUE self)
+{
+	git_revwalk *walk;
+	git_oid commit_oid;
+	int error = 0;
+	uint64_t count = 0;
+
+	if (argc > 0 || rb_block_given_p())
+		return rb_call_super(argc, argv);
+
+	Data_Get_Struct(self, git_revwalk, walk);
+
+	while (((error = git_revwalk_next(&commit_oid, walk)) == 0) && ++count != UINT64_MAX);
+
+	if (error != GIT_ITEROVER)
+		rugged_exception_check(error);
+
+	return ULONG2NUM(count);
+}
+
 /*
  *  call-seq:
  *    walker.reset -> nil
@@ -204,15 +215,283 @@ static VALUE rb_git_walker_reset(VALUE self)
 	return Qnil;
 }
 
+struct walk_options {
+	VALUE rb_owner;
+	VALUE rb_options;
+
+	git_repository *repo;
+	git_revwalk *walk;
+	int oid_only;
+	uint64_t offset, limit;
+};
+
+static void load_walk_limits(struct walk_options *w, VALUE rb_options)
+{
+	VALUE rb_value = rb_hash_lookup(rb_options, CSTR2SYM("offset"));
+	if (!NIL_P(rb_value)) {
+		Check_Type(rb_value, T_FIXNUM);
+		w->offset = FIX2ULONG(rb_value);
+	}
+
+	rb_value = rb_hash_lookup(rb_options, CSTR2SYM("limit"));
+	if (!NIL_P(rb_value)) {
+		Check_Type(rb_value, T_FIXNUM);
+		w->limit = FIX2ULONG(rb_value);
+	}
+}
+
+static VALUE load_all_options(VALUE _payload)
+{
+	struct walk_options *w = (struct walk_options *)_payload;
+	VALUE rb_options = w->rb_options;
+	VALUE rb_show, rb_hide, rb_sort, rb_simp, rb_oid_only;
+
+	load_walk_limits(w, rb_options);
+
+	rb_sort = rb_hash_lookup(rb_options, CSTR2SYM("sort"));
+	if (!NIL_P(rb_sort)) {
+		Check_Type(rb_sort, T_FIXNUM);
+		git_revwalk_sorting(w->walk, FIX2INT(rb_sort));
+	}
+
+	rb_show = rb_hash_lookup(rb_options, CSTR2SYM("show"));
+	if (!NIL_P(rb_show)) {
+		push_commit(w->walk, rb_show, 0);
+	}
+
+	rb_hide = rb_hash_lookup(rb_options, CSTR2SYM("hide"));
+	if (!NIL_P(rb_hide)) {
+		push_commit(w->walk, rb_hide, 1);
+	}
+
+	rb_simp = rb_hash_lookup(rb_options, CSTR2SYM("simplify"));
+	if (RTEST(rb_simp)) {
+		git_revwalk_simplify_first_parent(w->walk);
+	}
+
+	rb_oid_only = rb_hash_lookup(rb_options, CSTR2SYM("oid_only"));
+	if (RTEST(rb_oid_only)) {
+		w->oid_only = 1;
+	}
+
+	return Qnil;
+}
+
+static VALUE do_walk(VALUE _payload)
+{
+	struct walk_options *w = (struct walk_options *)_payload;
+	int error;
+	git_oid commit_oid;
+
+	while ((error = git_revwalk_next(&commit_oid, w->walk)) == 0) {
+		if (w->offset > 0) {
+			w->offset--;
+			continue;
+		}
+
+		if (w->oid_only) {
+			rb_yield(rugged_create_oid(&commit_oid));
+		} else {
+			git_commit *commit;
+
+			error = git_commit_lookup(&commit, w->repo, &commit_oid);
+			rugged_exception_check(error);
+
+			rb_yield(
+				rugged_object_new(w->rb_owner, (git_object *)commit)
+			);
+		}
+
+		if (--w->limit == 0)
+			break;
+	}
+
+	if (error != GIT_ITEROVER)
+		rugged_exception_check(error);
+
+	return Qnil;
+}
+
+/*
+ *  call-seq:
+ *    Rugged::Walker.walk(repo, options={}) { |commit| block }
+ *
+ *	Create a Walker object, initialize it with the given options
+ *	and perform a walk on the repository; the lifetime of the
+ *	walker is bound to the call and it is immediately cleaned
+ *	up after the walk is over.
+ *
+ *	The following options are available:
+ *
+ *	- +sort+: Sorting mode for the walk (or an OR combination
+ *	of several sorting modes).
+ *
+ *	- +show+: Tips of the repository that will be walked;
+ *	this is necessary for the walk to yield any results.
+ *	A tip can be a 40-char object ID, an existing +Rugged::Commit+
+ *	object, a reference, or an +Array+ of several of these
+ *	(if you'd like to walk several tips in parallel).
+ *
+ *	- +hide+: Same as +show+, but hides the given tips instead
+ *	so they don't appear on the walk.
+ *
+ *	- +oid_only+: if +true+, the walker will yield 40-char OIDs
+ *	for each commit, instead of real +Rugged::Commit+ objects.
+ *	Defaults to +false+.
+ *
+ *	- +simplify+: if +true+, the walk will be simplified
+ *	to the first parent of each commit.
+ *
+ *	Example:
+ *
+ *    Rugged::Walker.walk(repo,
+ *            show: "92b22bbcb37caf4f6f53d30292169e84f5e4283b",
+ *            sort: Rugged::SORT_DATE|Rugged::SORT_TOPO,
+ *            oid_only: true) do |commit_oid|
+ *        puts commit_oid
+ *    end
+ *
+ *  generates:
+ *
+ *    92b22bbcb37caf4f6f53d30292169e84f5e4283b
+ *    6b750d5800439b502de669465b385e5f469c78b6
+ *    ef9207141549f4ffcd3c4597e270d32e10d0a6bc
+ *    cb75e05f0f8ac3407fb3bd0ebd5ff07573b16c9f
+ *    ...
+ */
+static VALUE rb_git_walk(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rb_repo, rb_options;
+	struct walk_options w;
+	int exception = 0;
+
+	RETURN_ENUMERATOR(self, argc, argv);
+	rb_scan_args(argc, argv, "10:", &rb_repo, &rb_options);
+
+	Data_Get_Struct(rb_repo, git_repository, w.repo);
+	rugged_exception_check(git_revwalk_new(&w.walk, w.repo));
+
+	w.rb_owner = rb_repo;
+	w.rb_options = rb_options;
+
+	w.oid_only = 0;
+	w.offset = 0;
+	w.limit = UINT64_MAX;
+
+	if (!NIL_P(w.rb_options))
+		rb_protect(load_all_options, (VALUE)&w, &exception);
+
+	if (!exception)
+		rb_protect(do_walk, (VALUE)&w, &exception);
+
+	git_revwalk_free(w.walk);
+
+	if (exception)
+		rb_jump_tag(exception);
+
+	return Qnil;
+}
+
+static VALUE rb_git_walk_with_opts(int argc, VALUE *argv, VALUE self, int oid_only)
+{
+	VALUE rb_options;
+	struct walk_options w;
+
+	RETURN_ENUMERATOR(self, argc, argv);
+	rb_scan_args(argc, argv, "01", &rb_options);
+
+	Data_Get_Struct(self, git_revwalk, w.walk);
+	w.repo = git_revwalk_repository(w.walk);
+
+	w.rb_owner = rugged_owner(self);
+	w.rb_options = Qnil;
+
+	w.oid_only = oid_only;
+	w.offset = 0;
+	w.limit = UINT64_MAX;
+
+	if (!NIL_P(rb_options))
+		load_walk_limits(&w, rb_options);
+
+	return do_walk((VALUE)&w);
+}
+
+/*
+ *  call-seq:
+ *    walker.each { |commit| block }
+ *    walker.each -> Enumerator
+ *
+ *  Perform the walk through the repository, yielding each
+ *  one of the commits found as a <tt>Rugged::Commit</tt> instance
+ *  to +block+.
+ *
+ *  If no +block+ is given, an +Enumerator+ will be returned.
+ *
+ *  The walker must have been previously set-up before a walk can be performed
+ *  (i.e. at least one commit must have been pushed).
+ *
+ *    walker.push("92b22bbcb37caf4f6f53d30292169e84f5e4283b")
+ *    walker.each { |commit| puts commit.oid }
+ *
+ *  generates:
+ *
+ *    92b22bbcb37caf4f6f53d30292169e84f5e4283b
+ *    6b750d5800439b502de669465b385e5f469c78b6
+ *    ef9207141549f4ffcd3c4597e270d32e10d0a6bc
+ *    cb75e05f0f8ac3407fb3bd0ebd5ff07573b16c9f
+ *    ...
+ */
+static VALUE rb_git_walker_each(int argc, VALUE *argv, VALUE self)
+{
+	return rb_git_walk_with_opts(argc, argv, self, 0);
+}
+
+/*
+ *  call-seq:
+ *    walker.each_oid { |commit| block }
+ *    walker.each_oid -> Enumerator
+ *
+ *  Perform the walk through the repository, yielding each
+ *  one of the commit oids found as a <tt>String</tt>
+ *  to +block+.
+ *
+ *  If no +block+ is given, an +Enumerator+ will be returned.
+ *
+ *  The walker must have been previously set-up before a walk can be performed
+ *  (i.e. at least one commit must have been pushed).
+ *
+ *    walker.push("92b22bbcb37caf4f6f53d30292169e84f5e4283b")
+ *    walker.each { |commit_oid| puts commit_oid }
+ *
+ *  generates:
+ *
+ *    92b22bbcb37caf4f6f53d30292169e84f5e4283b
+ *    6b750d5800439b502de669465b385e5f469c78b6
+ *    ef9207141549f4ffcd3c4597e270d32e10d0a6bc
+ *    cb75e05f0f8ac3407fb3bd0ebd5ff07573b16c9f
+ *    ...
+ */
+static VALUE rb_git_walker_each_oid(int argc, VALUE *argv, VALUE self)
+{
+	return rb_git_walk_with_opts(argc, argv, self, 1);
+}
+
+
+
 void Init_rugged_revwalk(void)
 {
 	rb_cRuggedWalker = rb_define_class_under(rb_mRugged, "Walker", rb_cObject);
 	rb_define_singleton_method(rb_cRuggedWalker, "new", rb_git_walker_new, 1);
+	rb_define_singleton_method(rb_cRuggedWalker, "walk", rb_git_walk, -1);
 
 	rb_define_method(rb_cRuggedWalker, "push", rb_git_walker_push, 1);
-	rb_define_method(rb_cRuggedWalker, "each", rb_git_walker_each, 0);
-	rb_define_method(rb_cRuggedWalker, "walk", rb_git_walker_each, 0);
+	rb_define_method(rb_cRuggedWalker, "push_range", rb_git_walker_push_range, 1);
+	rb_define_method(rb_cRuggedWalker, "each", rb_git_walker_each, -1);
+	rb_define_method(rb_cRuggedWalker, "each_oid", rb_git_walker_each_oid, -1);
+	rb_define_method(rb_cRuggedWalker, "walk", rb_git_walker_each, -1);
 	rb_define_method(rb_cRuggedWalker, "hide", rb_git_walker_hide, 1);
 	rb_define_method(rb_cRuggedWalker, "reset", rb_git_walker_reset, 0);
 	rb_define_method(rb_cRuggedWalker, "sorting", rb_git_walker_sorting, 1);
+	rb_define_method(rb_cRuggedWalker, "simplify_first_parent", rb_git_walker_simplify_first_parent, 0);
+	rb_define_method(rb_cRuggedWalker, "count", rb_git_walker_count, -1);
 }

data/ext/rugged/rugged_settings.c

@@ -1,25 +1,8 @@
 /*
- * The MIT License
+ * Copyright (C) the Rugged contributors.  All rights reserved.
  *
- * Copyright (c) 2013 GitHub, Inc
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
+ * This file is part of Rugged, distributed under the MIT license.
+ * For full terms see the included LICENSE file.
  */
 
 #include "rugged.h"
@@ -36,6 +19,29 @@
 
 extern VALUE rb_mRugged;
 
+static void set_search_path(int level, VALUE value)
+{
+	const char *path;
+
+	Check_Type(value, T_STRING);
+	path = StringValueCStr(value);
+
+	rugged_exception_check(git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, level, path));
+}
+
+static VALUE get_search_path(int level)
+{
+	git_buf buf = {NULL};
+	VALUE ret;
+
+	rugged_exception_check(git_libgit2_opts(GIT_OPT_GET_SEARCH_PATH, level, &buf));
+
+	ret = rb_str_new_utf8(buf.ptr);
+	git_buf_dispose(&buf);
+
+	return ret;
+}
+
 /*
  *  call-seq:
  *    Settings[option] = value
@@ -55,7 +61,7 @@ static VALUE rb_git_set_option(VALUE self, VALUE option, VALUE value)
 		val = NUM2SIZET(value);
 		git_libgit2_opts(GIT_OPT_SET_MWINDOW_SIZE, val);
 	}
-	
+
 	else if (strcmp(opt, "mwindow_mapped_limit") == 0) {
 		size_t val;
 		Check_Type(value, T_FIXNUM);
@@ -63,6 +69,23 @@ static VALUE rb_git_set_option(VALUE self, VALUE option, VALUE value)
 		git_libgit2_opts(GIT_OPT_SET_MWINDOW_MAPPED_LIMIT, val);
 	}
 
+	else if (strcmp(opt, "search_path_global") == 0) {
+		set_search_path(GIT_CONFIG_LEVEL_GLOBAL, value);
+	}
+
+	else if (strcmp(opt, "search_path_xdg") == 0) {
+		set_search_path(GIT_CONFIG_LEVEL_XDG, value);
+	}
+
+	else if (strcmp(opt, "search_path_system") == 0) {
+		set_search_path(GIT_CONFIG_LEVEL_SYSTEM, value);
+	}
+
+	else if (strcmp(opt, "strict_object_creation") == 0) {
+		int strict = RTEST(value) ? 1 : 0;
+		git_libgit2_opts(GIT_OPT_ENABLE_STRICT_OBJECT_CREATION, strict);
+	}
+
 	else {
 		rb_raise(rb_eArgError, "Unknown option specified");
 	}
@@ -88,21 +111,61 @@ static VALUE rb_git_get_option(VALUE self, VALUE option)
 		git_libgit2_opts(GIT_OPT_GET_MWINDOW_SIZE, &val);
 		return SIZET2NUM(val);
 	}
-	
+
 	else if (strcmp(opt, "mwindow_mapped_limit") == 0) {
 		size_t val;
 		git_libgit2_opts(GIT_OPT_GET_MWINDOW_MAPPED_LIMIT, &val);
 		return SIZET2NUM(val);
 	}
-	
+
+	else if (strcmp(opt, "search_path_global") == 0) {
+		return get_search_path(GIT_CONFIG_LEVEL_GLOBAL);
+	}
+
+	else if (strcmp(opt, "search_path_xdg") == 0) {
+		return get_search_path(GIT_CONFIG_LEVEL_XDG);
+	}
+
+	else if (strcmp(opt, "search_path_system") == 0) {
+		return get_search_path(GIT_CONFIG_LEVEL_SYSTEM);
+	}
+
 	else {
 		rb_raise(rb_eArgError, "Unknown option specified");
 	}
 }
 
+/*
+ *  call-seq:
+ *    Rugged::Settings.max_cache_size -> max cache size
+ *
+ *  Returns the maximum amount of memory the cache will consume.
+ */
+static VALUE rb_git_get_max_cache_size(VALUE mod) {
+    size_t val;
+    size_t max;
+    git_libgit2_opts(GIT_OPT_GET_CACHED_MEMORY, &val, &max);
+    return SIZET2NUM(max);
+}
+
+/*
+ *  call-seq:
+ *    Rugged::Settings.used_cache_size -> used cache size
+ *
+ *  Returns the amount of memory the cache is currently consuming.
+ */
+static VALUE rb_git_get_used_cache_size(VALUE mod) {
+    size_t val;
+    size_t max;
+    git_libgit2_opts(GIT_OPT_GET_CACHED_MEMORY, &val, &max);
+    return SIZET2NUM(val);
+}
+
 void Init_rugged_settings(void)
 {
 	VALUE rb_cRuggedSettings = rb_define_class_under(rb_mRugged, "Settings", rb_cObject);
 	rb_define_module_function(rb_cRuggedSettings, "[]=", rb_git_set_option, 2);
 	rb_define_module_function(rb_cRuggedSettings, "[]", rb_git_get_option, 1);
+	rb_define_module_function(rb_cRuggedSettings, "max_cache_size", rb_git_get_max_cache_size, 0);
+	rb_define_module_function(rb_cRuggedSettings, "used_cache_size", rb_git_get_used_cache_size, 0);
 }