chainable 0.1.1 → 0.1.2

data/README.rdoc

@@ -50,6 +50,12 @@ Example:
       end
 
     end
+
+    # or chain multiple methods at once
+    chain_method :foo, :bar do
+      super.to_s
+    end
+
   end
 
   f = Foo.new
@@ -66,6 +72,18 @@ Of course you can do this with any class (or module):
     end
   end
 
+Note that there is a speed advantage when using chain_method without a block
+and doing a "def", since chain_method will use define_method if a block is
+given, which produces slower methods (but makes the method a real closure).
+
+== Benchmark
+chain_method tends do produce slightly faster methods than alias_method_chain:
+                                           user     system      total        real
+  chainable (define_method)            0.160000   0.010000   0.170000 (  0.183363)
+  chainable (def & eval)               0.170000   0.010000   0.180000 (  0.177084)
+  alias_method_chain (define_method)   0.570000   0.030000   0.600000 (  0.607330)
+  alias_method_chain (def & eval)      0.170000   0.020000   0.190000 (  0.190048)
+
 == Installation
 Add github gems, if you haven't already:
   gem sources -a http://gems.github.com

data/Rakefile

@@ -1,3 +1,9 @@
 require 'spec/rake/spectask'
 
-Spec::Rake::SpecTask.new { |t| t.spec_files = FileList['spec/**/*.rb'] }
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['spec/**/*.rb']
+  t.spec_opts << "-fs"
+end
+
+desc "Run benchmark"
+task(:benchmark) { load "benchmark/chainable.rb" }

data/benchmark/chainable.rb

@@ -0,0 +1,51 @@
+require "benchmark"
+require "lib/chainable"
+require "active_support"
+
+class BenchmarkChain
+  CHAIN_LENGTH = 1000
+  CALL_TIMES = 1000
+  class << self
+    def bm1(x)
+      obj = new
+      x.report("#{@name} (define_method)") { CALL_TIMES.times { obj.bm1 } }
+    end
+    def bm2(x)
+      obj = new
+      x.report("#{@name} (def & eval)") { CALL_TIMES.times { obj.bm2 } }
+    end
+  end
+  define_method(:bm1) { }
+  def bm2; end
+end
+
+class BenchmarkChainable < BenchmarkChain
+  @name = "chainable"
+  CHAIN_LENGTH.times do
+    chain_method(:bm1) { super }
+    chain_method(:bm2)
+    def bm2; super; end
+  end
+end
+
+class BenchmarkAliasMethodChain < BenchmarkChain
+  @name = "alias_method_chain"
+  CHAIN_LENGTH.times do |i|
+    method_without = "bm1_without_#{i}"
+    define_method("bm1_with_#{i}") { send(method_without) }
+    alias_method_chain :bm1, i.to_s
+    eval "def bm2_with_#{i}; bm2_without_#{i}; end"
+    alias_method_chain :bm2, i.to_s
+  end
+end
+
+def bench(x, klass)
+  obj = klass.new
+end
+
+Benchmark.bmbm do |x|
+  BenchmarkChainable.bm1(x)
+  BenchmarkAliasMethodChain.bm1(x)
+  BenchmarkChainable.bm2(x)
+  BenchmarkAliasMethodChain.bm2(x)
+end

data/lib/chainable.rb

@@ -14,8 +14,9 @@ module Chainable
   # Maybe that is not what you want, as methods defined by def tend to be
   # faster. If that is the case, simply don't pass the block and call def
   # after chain_method instead.
-  def chain_method(name, &block)
-    name = name.to_s
+  def chain_method(*names, &block)
+    raise ArgumentError, "no method name given" if names.empty?
+    name = names.shift.to_s
     if instance_methods(false).include? name
       begin
         code = Ruby2Ruby.translate self, name
@@ -27,6 +28,7 @@ module Chainable
     end
     block ||= Proc.new { super }
     define_method(name, &block)
+    chain_method(*names, &block) unless names.empty?
   end
 
   # If you define a method inside a block passed to auto_chain, chain_method

data/spec/chainable/chain_method_spec.rb

@@ -60,6 +60,17 @@ describe Chainable do
     @an_instance.to_i.should == @original_results["to_i"] + 20
   end
 
+  it "should allow passing multiple method names to chain_method" do
+    @a_class.class_eval do
+      chain_method :random, :foo2
+      chain_method(:foo, :to_i) { super.to_s }
+    end
+    @an_instance.random.should == @original_results["random"]
+    @an_instance.foo2.should == @original_results["foo2"]
+    @an_instance.foo.should == @original_results["foo"].to_s
+    @an_instance.to_i.should == @original_results["to_i"].to_s
+  end
+
   it "should keep inheritance intact" do
     a_module = Module.new do
       define_method(:inspect) { "some inspect result" }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: chainable
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors: 
 - Konstantin Haase
@@ -29,6 +29,7 @@ files:
 - lib/chainable.rb
 - spec/chainable/auto_chain_spec.rb
 - spec/chainable/chain_method_spec.rb
+- benchmark/chainable.rb
 has_rdoc: true
 homepage: http://rkh.github.com/chainable
 post_install_message: