Added Rugged::Walker#count

This method counts the amount of objects a Walker would iterate over
without allocating any Ruby objects. If one were to use the default
"count" method (as added by Enumerable) every call would end up
allocating Rugged::Commit objects for every commit (as "count" simply
calls "each").

Timing wise the differences aren't _that_ big. For example, take the
following benchmark:

    require 'rugged'
    require 'benchmark/ips'

    rugged = Rugged::Repository.new('path/to/gitlab-ce.git')
    from   = rugged.rev_parse_oid('5-4-stable')
    to     = rugged.rev_parse_oid('master')

    Benchmark.ips do |bench|
      bench.report 'each' do
        walker = Rugged::Walker.new(rugged)
        count  = 0

        walker.push(to)
        walker.hide(from)
        walker.each { count += 1 }
      end

      bench.report 'each_oid' do
        walker = Rugged::Walker.new(rugged)
        count  = 0

        walker.push(to)
        walker.hide(from)
        walker.each_oid { count += 1 }
      end

      bench.report 'count' do
        walker = Rugged::Walker.new(rugged)

        walker.push(to)
        walker.hide(from)
        walker.count
      end

      bench.compare!
    end

Here 'path/to/gitlab-ce.git' refers to a local clone of GitLab Community
Edition (https://gitlab.com/gitlab-org/gitlab-ce). This benchmark spits
out the following output:

    Warming up --------------------------------------
                    each     1.000  i/100ms
                each_oid     1.000  i/100ms
                   count     1.000  i/100ms
    Calculating -------------------------------------
                    each      6.753  (± 0.0%) i/s -     34.000
                each_oid      7.374  (± 0.0%) i/s -     37.000
                   count      7.557  (± 0.0%) i/s -     38.000

    Comparison:
                   count:        7.6 i/s
                each_oid:        7.4 i/s - 1.02x slower
                    each:        6.8 i/s - 1.12x slower

In other words, while the amount of object allocations can be greatly
reduced the actual runtime is not _that_ much better. Regardless, not
having to allocate as many objects as before is still a win.

Author: Yorick Peterse

ext/rugged/rugged_revwalk.c

@@ -190,6 +190,29 @@ static VALUE rb_git_walker_simplify_first_parent(VALUE self)
 	return Qnil;
 }
 
+/*
+ *  call-seq:
+ *    walker.count -> Fixnum
+ *
+ *  Returns the amount of objects a walker iterated over.
+ */
+static VALUE rb_git_walker_count(VALUE self)
+{
+	git_revwalk *walk;
+	git_oid commit_oid;
+	int error = 0;
+	uint64_t count = 0;
+
+	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
@@ -492,4 +515,5 @@ void Init_rugged_revwalk(void)
 	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, 0);
 }

test/walker_test.rb

@@ -143,6 +143,12 @@ def test_walk_api
     oids = data.sort { |a, b| a.oid <=> b.oid }.map {|a| a.oid[0,5]}.join('.')
     assert_equal "4a202.5b5b0.84960.9fd73", oids
   end
+
+  def test_walk_count
+    @walker.push("9fd738e8f7967c078dceed8190330fc8648ee56a")
+    @walker.hide("5b5b025afb0b4c913b4c338a42934a3863bf3644")
+    assert_equal 2, @walker.count
+  end
 end
 
 # testrepo (the non-bare repo) is the one with non-linear history,