rugged 0.19.0 → 0.21.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b0356879d784d17079ccdae0dfef24d5841c0774
+  data.tar.gz: 2a4d772157bcc8b25f61a7745d1694507bc56ca4
+SHA512:
+  metadata.gz: d6f0d49db816f5337decf934efda9529ddbf8beaf6edfa72737f661e7b5759afd7b4f27f21734de0098e101bc7b714b90aad674c450344d7cd7865de5fe73e3b
+  data.tar.gz: cf7dca7617881507c212c4c813bd41494d31ed1c3d8579092dc138a5b449d89af5264c9b673cf938f39a8781c000c768bcf498bd82136afb167e950d617b88bc

data/LICENSE

@@ -1,6 +1,6 @@
 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

data/README.md

@@ -17,7 +17,9 @@ Rugged is a self-contained gem. You can install it by running:
 
     $ gem install rugged
 
-If you're using bundler and want to bundle libgit2 with rugged, you can use the `:submodules` option:
+You need to have CMake installed on your system to be able to build the included version of `libgit2`. 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).
+
+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', branch: 'development', submodules: true
@@ -29,6 +31,24 @@ To load Rugged, you'll usually want to add something like this:
 require 'rugged'
 ```
 
+### Use the system provided libgit2
+
+By default, Rugged builds and uses a bundled version of libgit2. If you
+want to use the system library instead, you can install rugged as follows:
+
+```
+gem install rugged -- --use-system-libraries
+```
+
+Or if you are using bundler:
+
+```
+bundle config build.rugged --use-system-libraries
+bundle install
+```
+
+However, note that Rugged does only support specific versions of libgit2.
+
 ## Usage
 
 Rugged gives you access to the many parts of a Git repository. You can read and
@@ -122,7 +142,8 @@ more high-level, so it may be preferable:
 
 ```ruby
 oid = repo.write("This is a blob.", :blob)
-index = Rugged::Index.new
+index = repo.index
+index.read_tree(repo.head.target.tree)
 index.add(:path => "README.md", :oid => oid, :mode => 0100644)
 
 options = {}
@@ -254,6 +275,46 @@ options[:update_ref] = 'HEAD'
 Rugged::Commit.create(repo, options)
 ```
 
+### Blob Objects
+
+Blob objects represent the data in the files of a Tree Object.
+
+```ruby
+blob = repo.lookup('e1253910439ea902cf49be8a9f02f3c08d89ac73')
+blob.content # => Gives you the content of the blob.
+```
+
+#### Streaming Blob Objects
+
+There is currently no way to stream data from a blob, because `libgit2` itself does not (yet) support
+streaming blobs out of the git object database. While there are hooks and interfaces for supporting it,
+the default file system backend always loads the entire blob contents into memory. 
+
+If you need to access a Blob object through an IO-like API, you can wrap it with the `StringIO` class.
+Note that the only advantage here is a stream-compatible interface, the complete blob object will still
+be loaded into memory. Below is an example for streaming a Blob using the Sinatra framework:
+
+```ruby
+# Sinatra endpoint
+get "/blobs/:sha" do
+  repo = Rugged::Repository.new(my_repo_path)
+  blob = repo.lookup params[:sha]
+
+  headers({
+    "Vary" => "Accept",
+    "Connection" => "keep-alive",
+    "Transfer-Encoding" => "chunked",
+    "Content-Type" => "application/octet-stream",
+  })
+
+  stream do |out|
+    StringIO.new(blob.content).each(8000) do |chunk|
+      out << chunk
+    end
+  end
+end
+```
+
 ---
 
 ### Commit Walker
@@ -315,29 +376,28 @@ index.add(path)
 
 ### Refs
 
-The `Rugged::Reference` class allows you to list, create and delete packed and loose refs.
+You can access references through the `Rugged::ReferenceCollection` object returned by `Repository#references`.
 
 ```ruby
-ref = repo.head # or...
-ref = Rugged::Reference.lookup(repo, "refs/heads/master")
+ref = repo.references["refs/heads/master"]
 
-sha = ref.target
+sha = ref.target_id
 str = ref.type   # :direct
 str = ref.name   # "refs/heads/master"
 ```
 
-You can also easily get an array of references:
+You can also easily iterate over all references:
 
 ```ruby
-repo.refs.each do |ref|
+repo.references.each do |ref|
   puts ref.name
 end
 ```
 
-Or use a pattern (regex):
+Or only over references that match the given pattern (glob):
 
 ```ruby
-repo.refs(/tags/).each do |ref|
+repo.references.each("refs/tags/*") do |ref|
   puts ref.name
 end
 ```
@@ -345,19 +405,22 @@ end
 It is also easy to create, update, rename or delete a reference:
 
 ```ruby
-ref = Rugged::Reference.create(repo, "refs/heads/unit_test", some_commit_sha)
+ref = repo.references.create("refs/heads/unit_test", some_commit_sha)
 
-ref.set_target(new_sha)
+repo.references.update(ref, new_sha) # or...
+repo.references.update("refs/heads/unit_test", new_sha)
 
-ref.rename("refs/heads/blead")
+repo.references.rename(ref, "refs/heads/blead") # or...
+repo.references.rename("refs/heads/unit_test", "refs/heads/blead")
 
-ref.delete!
+repo.references.delete(ref) # or...
+repo.references.delete("refs/heads/unit_test") # or...
 ```
 
 Finally, you can access the reflog for any branch:
 
 ```ruby
-ref = Rugged::Reference.lookup(repo, "refs/heads/master")
+ref = repo.references["refs/heads/master"]
 entry = ref.log.first
 sha   = entry[:id_old]
 sha   = entry[:id_new]
@@ -369,42 +432,99 @@ prsn  = entry[:committer]
 
 ### Branches
 
-`Rugged::Branch` will help you with all of your branch-related needs.
+The `Rugged::BranchCollection` object returned by `Repository#branches` will help
+you with all of your branch-related needs.
 
 Iterate over all branches:
 
 ```ruby
-Rugged::Branch.each_name(repo).sort
+repo.branches.each_name().sort
 # => ["master", "origin/HEAD", "origin/master", "origin/packed"]
 
-Rugged::Branch.each_name(repo, :local).sort
+repo.branches.each_name(:local).sort
 # => ["master"]
 
-Rugged::Branch.each_name(repo, :remote).sort
+repo.branches.each_name(:remote).sort
 # => ["origin/HEAD", "origin/master", "origin/packed"]
 ```
 
 Look up branches and get attributes:
 
 ```ruby
-branch = Rugged::Branch.lookup(repo, "master")
+branch = repo.branches["master"]
 branch.name # => 'master'
 branch.canonical_name # => 'refs/heads/master'
 ```
 
-Look up the oid for the tip of a branch:
+Look up the id for the target of a branch:
 
 ```ruby
-Rugged::Branch.lookup(repo, "master").tip.oid
+repo.branches["master"].target_id
 # => "36060c58702ed4c2a40832c51758d5344201d89a"
 ```
 
 Creation and deletion:
 
 ```ruby
-branch = repo.create_branch("test_branch")
-branch.move("new_branch")
-branch.delete!
+branch = repo.branches.create("test_branch", "HEAD")
+
+repo.branches.rename("test_branch", "new_branch") # or...
+repo.branches.rename("refs/heads/test_branch", "new_branch") # or...
+repo.branches.rename(ref, "new_branch") # or...
+
+repo.branches.delete("test_branch") # or...
+repo.branches.delete("refs/heads/test_branch") # or...
+repo.branches.delete(ref) # or...
+```
+
+---
+
+### Diffs
+
+There are various ways to get hands on diffs:
+
+```ruby
+# Diff between two subsequent commits
+diff_commits = commit_object.parents[0].diff(commit_object)
+
+# Diff between two tree objects
+diff_trees = tree_object_a.diff(tree_object_b)
+
+# Diff between index/staging and current working directory
+diff_index = repository.index.diff
+
+# Diff between index/staging and another diffable (commit/tree/index)
+diff_index_diffable = repository.index.diff(some_diffable)
+```
+
+When you already have a diff object, you can examine it:
+
+```ruby
+# Get patch
+diff.patch
+=> "diff --git a/foo1 b/foo1\nnew file mode 100644\nindex 0000000..81b68f0\n--- /dev/null\n+++ b/foo1\n@@ -0,0 +1,2 @@\n+abc\n+add line1\ndiff --git a/txt1 b/txt1\ndeleted file mode 100644\nindex 81b68f0..0000000\n--- a/txt1\n+++ /dev/null\n@@ -1,2 +0,0 @@\n-abc\n-add line1\ndiff --git a/txt2 b/txt2\nindex a7bb42f..a357de7 100644\n--- a/txt2\n+++ b/txt2\n@@ -1,2 +1,3 @@\n abc2\n add line2-1\n+add line2-2\n"
+
+# Get delta (faster, if you only need information on what files changed)
+diff.each_delta{ |d| puts d.inspect }
+#<Rugged::Diff::Delta:70144372137380 {old_file: {:oid=>"0000000000000000000000000000000000000000", :path=>"foo1", :size=>0, :flags=>6, :mode=>0}, new_file: {:oid=>"81b68f040b120c9627518213f7fc317d1ed18e1c", :path=>"foo1", :size=>14, :flags=>6, :mode=>33188}, similarity: 0, status: :added>
+#<Rugged::Diff::Delta:70144372136540 {old_file: {:oid=>"81b68f040b120c9627518213f7fc317d1ed18e1c", :path=>"txt1", :size=>14, :flags=>6, :mode=>33188}, new_file: {:oid=>"0000000000000000000000000000000000000000", :path=>"txt1", :size=>0, :flags=>6, :mode=>0}, similarity: 0, status: :deleted>
+#<Rugged::Diff::Delta:70144372135780 {old_file: {:oid=>"a7bb42f71183c162efea5e4c80597437d716c62b", :path=>"txt2", :size=>17, :flags=>6, :mode=>33188}, new_file: {:oid=>"a357de7d870823acc3953f1b2471f9c18d0d56ea", :path=>"txt2", :size=>29, :flags=>6, :mode=>33188}, similarity: 0, status: :modified>
+
+# Detect renamed files
+# Note that the status field changed from :added/:deleted to :renamed
+diff.find_similar!
+diff.each_delta{ |d| puts d.inspect }
+#<Rugged::Diff::Delta:70144372230920 {old_file: {:oid=>"81b68f040b120c9627518213f7fc317d1ed18e1c", :path=>"txt1", :size=>14, :flags=>6, :mode=>33188}, new_file: {:oid=>"81b68f040b120c9627518213f7fc317d1ed18e1c", :path=>"foo1", :size=>14, :flags=>6, :mode=>33188}, similarity: 100, status: :renamed>
+#<Rugged::Diff::Delta:70144372230140 {old_file: {:oid=>"a7bb42f71183c162efea5e4c80597437d716c62b", :path=>"txt2", :size=>17, :flags=>6, :mode=>33188}, new_file: {:oid=>"a357de7d870823acc3953f1b2471f9c18d0d56ea", :path=>"txt2", :size=>29, :flags=>6, :mode=>33188}, similarity: 0, status: :modified>
+
+# Merge one diff into another (mutating the first one)
+diff1.merge!(diff2)
+
+# Write a patch into a file (or any other object responding to write)
+# Note that the patch as in diff.patch will be written, it won't be applied
+file = File.open('/some/file', 'w')
+diff.write_patch(file)
+file.close
 ```
 
 ---
@@ -458,11 +578,17 @@ Simply clone and install:
     $ rake compile
     $ rake test
 
+## Support
+
+We encourage you to use StackOverflow for any questions or concerns regarding Rugged. Please tag your questions with the [rugged](http://stackoverflow.com/questions/tagged/rugged) keyword.
+
+For bug reports, please open a ticket on the GitHub [issue tracker](https://github.com/libgit2/rugged/issues).
 
 ## Authors
 
 * Vicent Marti <tanoku@gmail.com>
 * Scott Chacon <schacon@gmail.com>
+* Arthur Schreiber <schreiber.arthur@gmail.com>
 
 
 ## License

data/ext/rugged/extconf.rb

@@ -4,11 +4,8 @@ RbConfig::MAKEFILE_CONFIG['CC'] = ENV['CC'] if ENV['CC']
 
 $CFLAGS << " #{ENV["CFLAGS"]}"
 $CFLAGS << " -g"
-
-if RbConfig::MAKEFILE_CONFIG['CC'] =~ /gcc|clang/
-  $CFLAGS << " -O3" unless $CFLAGS[/-O\d/]
-  $CFLAGS << " -Wall"
-end
+$CFLAGS << " -O3" unless $CFLAGS[/-O\d/]
+$CFLAGS << " -Wall -Wno-comment"
 
 def sys(cmd)
   puts " -- #{cmd}"
@@ -18,39 +15,63 @@ def sys(cmd)
   ret
 end
 
-MAKE_PROGRAM = find_executable('gmake') || find_executable('make')
+if !find_executable('cmake')
+  abort "ERROR: CMake is required to build Rugged."
+end
 
-if MAKE_PROGRAM.nil?
-  STDERR.puts "ERROR: GNU make is required to build Rugged"
-  exit(1)
+if !(MAKE = find_executable('gmake') || find_executable('make'))
+  abort "ERROR: GNU make is required to build Rugged."
 end
 
-if p = ENV['LIBGIT2_PATH']
-  $INCFLAGS[0,0] = " -I#{File.join(p, 'include')} "
-  $LDFLAGS << " -L#{p} "
-  unless have_library 'git2' and have_header 'git2.h'
-    STDERR.puts "ERROR: Invalid `LIBGIT2_PATH` environment"
-    exit(1)
-  end
+if !find_executable('pkg-config')
+  abort "ERROR: pkg-config is required to build Rugged."
+end
+
+if arg_config("--use-system-libraries", !!ENV['RUGGED_USE_SYSTEM_LIBRARIES'])
+  puts "Building Rugged using system libraries.\n"
+
+  dir_config('git2').any? or pkg_config('libgit2')
+
+  try_compile(<<-SRC) or abort "libgit2 version is not compatible"
+#include <git2/version.h>
+
+#if LIBGIT2_SOVERSION != 21
+#error libgit2 version is not compatible
+#endif
+  SRC
 else
   CWD = File.expand_path(File.dirname(__FILE__))
   LIBGIT2_DIR = File.join(CWD, '..', '..', 'vendor', 'libgit2')
-  LIBGIT2_LIB_PATH = "#{CWD}/libgit2_embed.a"
 
-  if !File.exists?(LIBGIT2_LIB_PATH)
-    Dir.chdir(LIBGIT2_DIR) do
-      sys("#{MAKE_PROGRAM} -f Makefile.embed")
-      FileUtils.cp 'libgit2.a', LIBGIT2_LIB_PATH
+  Dir.chdir(LIBGIT2_DIR) do
+    Dir.mkdir("build") if !Dir.exists?("build")
+
+    Dir.chdir("build") do
+      sys("cmake .. -DBUILD_CLAR=OFF -DTHREADSAFE=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_C_FLAGS=-fPIC -DCMAKE_BUILD_TYPE=RelWithDebInfo")
+      sys(MAKE)
+
+      pcfile = File.join(LIBGIT2_DIR, "build", "libgit2.pc")
+      $LDFLAGS << " " + `pkg-config --libs --static #{pcfile}`.strip
     end
   end
 
-  $INCFLAGS[0,0] = " -I#{LIBGIT2_DIR}/include "
-  $LDFLAGS << " -L#{CWD} "
+  # Prepend the vendored libgit2 build dir to the $DEFLIBPATH.
+  #
+  # By default, $DEFLIBPATH includes $(libpath), which usually points
+  # to something like /usr/lib for system ruby versions (not those
+  # installed through rbenv or rvm).
+  #
+  # This was causing system-wide libgit2 installations to be preferred
+  # over of our vendored libgit2 version when building rugged.
+  #
+  # By putting the path to the vendored libgit2 library at the front of
+  # $DEFLIBPATH, we can ensure that our bundled version is always used.
+  $DEFLIBPATH.unshift("#{LIBGIT2_DIR}/build")
+  dir_config('git2', "#{LIBGIT2_DIR}/include", "#{LIBGIT2_DIR}/build")
+end
 
-  unless have_library 'git2_embed' and have_header 'git2.h'
-    STDERR.puts "ERROR: Failed to build libgit2"
-    exit(1)
-  end
+unless have_library 'git2' and have_header 'git2.h'
+  abort "ERROR: Failed to build libgit2"
 end
 
 create_makefile("rugged/rugged")

data/ext/rugged/rugged.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
@@ -25,6 +25,7 @@
 #include "rugged.h"
 
 const char *RUGGED_ERROR_NAMES[] = {
+	"None",            /* GITERR_NONE */
 	"NoMemError",      /* GITERR_NOMEMORY, */
 	"OSError",         /* GITERR_OS, */
 	"InvalidError",    /* GITERR_INVALID, */
@@ -47,6 +48,8 @@ const char *RUGGED_ERROR_NAMES[] = {
 	"CheckoutError",   /* GITERR_CHECKOUT, */
 	"FetchheadError",  /* GITERR_FETCHHEAD, */
 	"MergeError",      /* GITERR_MERGE, */
+	"SshError",        /* GITERR_SSH, */
+	"FilterError"      /* GITERR_FILTER, */
 };
 
 #define RUGGED_ERROR_COUNT (int)((sizeof(RUGGED_ERROR_NAMES)/sizeof(RUGGED_ERROR_NAMES[0])))
@@ -81,29 +84,28 @@ static VALUE rb_git_libgit2_version(VALUE self)
 
 /*
  *  call-seq:
- *     Rugged.capabilities -> capabilities
+ *     Rugged.features -> [feature, ...]
  *
- *  Returns an array representing the 'capabilities' that libgit2 was compiled
- *  with — this includes GIT_CAP_THREADS (thread support) and GIT_CAP_HTTPS (https).
- *  This is implemented in libgit2 with simple bitwise ops; we offer Rubyland an array
- *  of symbols representing the capabilities.
+ *  Returns an array representing the features that libgit2 was compiled
+ *  with — this includes `:threads` (thread support), `:https` and `:ssh`.
  *
- *  The possible capabilities are "threads" and "https".
- *
- *    Rugged.capabilities #=> [:threads, :https]
+ *    Rugged.features #=> [:threads, :https]
  */
-static VALUE rb_git_capabilities(VALUE self)
+static VALUE rb_git_features(VALUE self)
 {
 	VALUE ret_arr = rb_ary_new();
 
-	int caps = git_libgit2_capabilities();
+	int caps = git_libgit2_features();
 
-	if (caps & GIT_CAP_THREADS)
+	if (caps & GIT_FEATURE_THREADS)
 		rb_ary_push(ret_arr, CSTR2SYM("threads"));
 
-	if (caps & GIT_CAP_HTTPS)
+	if (caps & GIT_FEATURE_HTTPS)
 		rb_ary_push(ret_arr, CSTR2SYM("https"));
 
+	if (caps & GIT_FEATURE_SSH)
+		rb_ary_push(ret_arr, CSTR2SYM("ssh"));
+
 	return ret_arr;
 }
 
@@ -155,28 +157,49 @@ static VALUE rb_git_raw_to_hex(VALUE self, VALUE raw)
 
 /*
  *  call-seq:
- *    Rugged.prettify_message(message, strip_comments) -> clean_message
+ *    Rugged.prettify_message(message, strip_comments = '#') -> clean_message
  *
  *  Process a commit or tag message into standard form, by stripping trailing spaces and
  *  comments, and making sure that the message has a proper header line.
  */
-static VALUE rb_git_prettify_message(VALUE self, VALUE rb_message, VALUE rb_strip_comments)
+static VALUE rb_git_prettify_message(int argc, VALUE *argv, VALUE self)
 {
-	char *message;
-	int strip_comments, message_len;
-	VALUE result;
+	char comment_char = '#';
+	int strip_comments = 1;
+
+	git_buf message = { NULL };
+	VALUE rb_message, rb_strip;
+	int error;
+	VALUE result = Qnil;
+
+	rb_scan_args(argc, argv, "11", &rb_message, &rb_strip);
 
 	Check_Type(rb_message, T_STRING);
-	strip_comments = rugged_parse_bool(rb_strip_comments);
+	
+	switch (TYPE(rb_strip)) {
+	case T_FALSE:
+		strip_comments = 0;
+		break;
+
+	case T_STRING:
+		if (RSTRING_LEN(rb_strip) > 0)
+			comment_char = RSTRING_PTR(rb_strip)[0];
+		break;
+
+	case T_TRUE:
+	case T_NIL:
+	default:
+		break;
+	}
 
-	message_len = (int)RSTRING_LEN(rb_message) + 2;
-	message = xmalloc(message_len);
+	error = git_message_prettify(&message,
+				StringValueCStr(rb_message), strip_comments, comment_char);
 
-	message_len = git_message_prettify(message, message_len, StringValueCStr(rb_message), strip_comments);
-	rugged_exception_check(message_len);
+	if (!error)
+		result = rb_enc_str_new(message.ptr, message.size, rb_utf8_encoding());
 
-	result = rb_enc_str_new(message, message_len - 1, rb_utf8_encoding());
-	xfree(message);
+	git_buf_free(&message);
+	rugged_exception_check(error);
 
 	return result;
 }
@@ -300,6 +323,25 @@ void rugged_exception_raise(void)
 	rb_exc_raise(err_obj);
 }
 
+VALUE rugged__block_yield_splat(VALUE args) {
+	VALUE block = rb_ary_shift(args);
+	int n = RARRAY_LENINT(args);
+
+	if (n == 0) {
+		return rb_funcall(block, rb_intern("call"), 0);
+	} else {
+		int i;
+		VALUE *argv;
+		argv = ALLOCA_N(VALUE, n);
+
+		for (i=0; i < n; i++) {
+			argv[i] = rb_ary_entry(args, i);
+		}
+
+		return rb_funcall2(block, rb_intern("call"), n, argv);
+	}
+}
+
 /*
  *  call-seq:
  *    Rugged.__cache_usage__ -> [current, max]
@@ -377,39 +419,69 @@ void Init_rugged(void)
 	}
 
 	rb_define_module_function(rb_mRugged, "libgit2_version", rb_git_libgit2_version, 0);
-	rb_define_module_function(rb_mRugged, "capabilities", rb_git_capabilities, 0);
+	rb_define_module_function(rb_mRugged, "features", rb_git_features, 0);
 	rb_define_module_function(rb_mRugged, "hex_to_raw", rb_git_hex_to_raw, 1);
 	rb_define_module_function(rb_mRugged, "raw_to_hex", rb_git_raw_to_hex, 1);
 	rb_define_module_function(rb_mRugged, "minimize_oid", rb_git_minimize_oid, -1);
-	rb_define_module_function(rb_mRugged, "prettify_message", rb_git_prettify_message, 2);
+	rb_define_module_function(rb_mRugged, "prettify_message", rb_git_prettify_message, -1);
 	rb_define_module_function(rb_mRugged, "__cache_usage__", rb_git_cache_usage, 0);
 
+	Init_rugged_reference();
+	Init_rugged_reference_collection();
+
 	Init_rugged_object();
 	Init_rugged_commit();
 	Init_rugged_tree();
 	Init_rugged_tag();
+	Init_rugged_tag_collection();
 	Init_rugged_blob();
 
 	Init_rugged_index();
 	Init_rugged_repo();
 	Init_rugged_revwalk();
-	Init_rugged_reference();
 	Init_rugged_branch();
+	Init_rugged_branch_collection();
 	Init_rugged_config();
 	Init_rugged_remote();
+	Init_rugged_remote_collection();
 	Init_rugged_notes();
 	Init_rugged_settings();
 	Init_rugged_diff();
-	Init_rugged_diff_patch();
+	Init_rugged_patch();
 	Init_rugged_diff_delta();
 	Init_rugged_diff_hunk();
 	Init_rugged_diff_line();
-
-	/* Constants */
-	rb_define_const(rb_mRugged, "SORT_NONE", INT2FIX(0));
-	rb_define_const(rb_mRugged, "SORT_TOPO", INT2FIX(1));
-	rb_define_const(rb_mRugged, "SORT_DATE", INT2FIX(2));
-	rb_define_const(rb_mRugged, "SORT_REVERSE", INT2FIX(4));
+	Init_rugged_blame();
+	Init_rugged_cred();
+
+	/*
+	 * Sort the repository contents in no particular ordering;
+	 * this sorting is arbitrary, implementation-specific
+	 * and subject to change at any time.
+	 * This is the default sorting for new walkers.
+	 */
+	rb_define_const(rb_mRugged, "SORT_NONE", INT2FIX(GIT_SORT_NONE));
+
+	/*
+	 * Sort the repository contents in topological order
+	 * (parents before children); this sorting mode
+	 * can be combined with time sorting.
+	 */
+	rb_define_const(rb_mRugged, "SORT_TOPO", INT2FIX(GIT_SORT_TOPOLOGICAL));
+
+	/*
+	 * Sort the repository contents by commit time;
+	 * this sorting mode can be combined with
+	 * topological sorting.
+	 */
+	rb_define_const(rb_mRugged, "SORT_DATE", INT2FIX(GIT_SORT_TIME));
+
+	/*
+	 * Iterate through the repository contents in reverse
+	 * order; this sorting mode can be combined with
+	 * any of the above.
+	 */
+	rb_define_const(rb_mRugged, "SORT_REVERSE", INT2FIX(GIT_SORT_REVERSE));
 
 	/* Initialize libgit2 */
 	git_threads_init();