chainable 0.2.1 → 0.3.0

data/README.rdoc

@@ -2,12 +2,16 @@
 
 This is heavy ruby abuse. It even got the Evil of the Day Award™ from zenspider.
 
+Forks are welcome!
+
 == Thou shalt not use alias_method_chain!
 - http://yehudakatz.com/2009/03/06/alias_method_chain-in-models
 - http://yehudakatz.com/2009/01/18/other-ways-to-wrap-a-method
 - http://www.codefluency.com/articles/2009/01/03/wrapping-a-method-in-ruby
 
 == What it does
+
+=== Chaining Methods
 Chainable is an alternative to alias_method_chain, that uses inheritance, rather
 than aliasing. It does the following when "chaining" a method:
 
@@ -74,15 +78,96 @@ Of course you can do this with any class (or module):
 
 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).
+given, which produces slower methods.
+
+=== Merging Methods
+
+But wait, there is more:
+
+  class Foo
+    def foo
+      10
+    end
+    merge_method :foo do
+      super * 3
+    end
+  end
+
+  puts Ruby2Ruby.translate Foo, :foo
+
+The output:
+
+  def foo
+    (10) * 3
+  end
+
+<b>Before you yell at me about how insane I am, read on!</b>
+
+The library will only allow merging, if it thinks, it is possible:
+
+  class Foo
+    def foo
+      x = 10
+    end
+    merge_method :foo do
+      x = 20
+      super
+      puts x
+    end
+  end
+
+Will give you:
+
+   ArgumentError: cannot merge foo.
+
+Same goes for this one:
+
+   class Foo
+     def foo x
+       puts x
+     end
+     merge_method :foo do
+       super
+     end
+   end
+
+   # => ArgumentError: cannot merge foo.
+
+But where is the fun in that one? You probably don't want your ruby script
+throwing such errors at you.
+
+Enter "try_merge":
+
+  SomeEvilClassWithoutHooks.class_eval do
+    chain_method instance_methods(false), :try_merge => true do
+      old_value = self.value.dup
+      super.tap { observer.notify if old_value != value }
+    end
+    attr_accessor :observer
+  end
+
+  some_evil_instance.observer = MyObserver.new
+
+== When to use it?
+
+As with alias_method_chain, you should use this as seldom as possible. Prefer
+clean inheritance over evil hacks. There actually is only one case one may use
+chainable (or alias_method_chain, for that matter): If there is a class you
+need to modify that is not part of your own code and the instances you deal with
+may already exists when you modify the class. In case you can modify the class
+before instance creation, just create another class inheriting from the first
+one and overwrite new to return instances of the latter.
 
 == Benchmark
 chain_method tends do produce slightly faster methods than alias_method_chain:
+  $ rake benchmark
                                            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)
+  no wrappers                          0.000000   0.000000   0.000000 (  0.004887)
+  merge_method                         0.000000   0.000000   0.000000 (  0.004830)
+  chain_method (def)                   1.040000   0.350000   1.390000 (  1.392329)
+  chain_method (define_method)         1.150000   0.240000   1.390000 (  1.396007)
+  alias_method_chain (def)             1.210000   0.260000   1.470000 (  1.472633)
+  alias_method_chain (define_method)   3.470000   0.590000   4.060000 (  4.096245)
 
 == Installation
 Add github gems, if you haven't already:

data/benchmark/chainable.rb

@@ -2,50 +2,69 @@ 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 } }
+class BenchMe
+
+  CALL_TIMES = 5000
+  DEF_TIMES = 500
+  BENCH_ME = []
+
+  def self.report
+    @report || "unknown"
+  end
+
+  def self.inherited klass
+    BENCH_ME << klass
+    klass.class_eval "def a_method; nil; end"
+  end
+
+  def self.run
+    Benchmark.bmbm do |x|
+      BENCH_ME.each do |klass|
+        object = klass.new
+        x.report(klass.report) { CALL_TIMES.times { object.a_method } }
+      end
     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
+class NoWrappers < BenchMe
+  @report = "no wrappers"
+end
+
+class MergeMethod < BenchMe
+  @report = "merge_method"
+  DEF_TIMES.times { merge_method(:a_method) { super } }
+end
+
+class ChainMethodDef < BenchMe
+  @report = "chain_method (def)"
+  DEF_TIMES.times do
+    chain_method(:a_method)
+    def a_method; 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
+class ChainMethod < BenchMe
+  @report = "chain_method (define_method)"
+  DEF_TIMES.times { chain_method(:a_method) { super } }
+end
+
+class AliasMethodChainDef < BenchMe
+  @report = "alias_method_chain (def)"
+  DEF_TIMES.times do |i|
+    eval "def a_method_with_#{i}; a_method_without_#{i}; end"
+    alias_method_chain :a_method, i
   end
 end
 
-def bench(x, klass)
-  obj = klass.new
+class AliasMethodChain < BenchMe
+  @report = "alias_method_chain (define_method)"
+  DEF_TIMES.times do |i|
+    without = "a_method_without_#{i}".to_sym
+    define_method("a_method_with_#{i}") { send without }
+    alias_method_chain :a_method, i
+  end
 end
 
-Benchmark.bmbm do |x|
-  BenchmarkChainable.bm1(x)
-  BenchmarkAliasMethodChain.bm1(x)
-  BenchmarkChainable.bm2(x)
-  BenchmarkAliasMethodChain.bm2(x)
-end
+BenchMe.run

data/lib/chainable.rb

@@ -9,26 +9,91 @@ module Chainable
     @auto_chain = false
   end
 
+  def self.wrapped_source klass, name, wrapper
+    begin
+      inner = unifier.process(parse_tree.parse_tree_for_method(klass, name))
+      outer = unifier.process(parse_tree.parse_tree_for_proc(wrapper))
+    rescue Exception
+      raise ArgumentError, "cannot merge #{name}"
+    end
+    raise ArgumentError, "cannot merge #{name}" if inner[2] != s(:args) or outer[2]
+    inner_locals = []
+    sexp_walk(inner) do |e|
+      raise ArgumentError, "cannot merge #{name}" if [:zsuper, :super].include? e[0]
+      inner_locals << e if e[0] == :lvar
+    end
+    sexp_walk(outer) do |e|
+      if inner_locals.include? e or (e[0] == :super and e.length > 1)
+        raise ArgumentError, "cannot merge #{name}"
+      end
+      e.replace inner[3][1] if [:zsuper, :super].include? e[0]
+    end
+    src = Ruby2Ruby.new.process s(:defn, name, s(:args), s(:scope, s(:block, outer[3])))
+    src.gsub "# do nothing", "nil"
+  end
+
+  def self.unifier
+    return @unifier if @unifier
+    @unifier = Unifier.new
+    # HACK (stolen from ruby2ruby)
+    @unifier.processors.each { |p| p.unsupported.delete :cfunc }
+    @unifier
+  end
+
+  def self.parse_tree
+    return @parse_tree if @parse_tree
+    require "parse_tree"
+    @parse_tree = ParseTree.new
+  end
+
   # This will "chain" a method (read: push it to a module and include it).
   # If a block is given, it will do a define_method(name, &block).
   # 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(*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
-        include Module.new { eval code }
-      rescue NameError
-        m = instance_method name
-        include Module.new { define_method(name) { |*a, &b| m.bind(self).call(*a, &b) } }
+    options = names.grep(Hash).inject({}) { |a, b| a.merge names.delete(b) }
+    if options[:try_merge]
+      names.reject! do |name|
+        begin
+          merge_method(name, &block)
+          true
+        rescue ArgumentError
+          false
+        end
+      end
+    end
+    names.each do |name|
+      name = name.to_s
+      if instance_methods(false).include? name
+        begin
+          code = Ruby2Ruby.translate self, name
+          include Module.new { eval code }
+        rescue NameError
+          m = instance_method name
+          include Module.new { define_method(name) { |*a, &b| m.bind(self).call(*a, &b) } }
+        end
       end
+      block ||= Proc.new { super }
+      define_method(name, &block)
     end
-    block ||= Proc.new { super }
-    define_method(name, &block)
-    chain_method(*names, &block) unless names.empty?
+  end
+
+  def merge_method(*names, &block)
+    names.each do |name|
+      name = name.to_s
+      unless instance_methods(false).include? name
+        define_method(name, &block)
+        next
+      end
+      class_eval Chainable.wrapped_source(self, name, block)
+    end
+  end
+
+  def self.sexp_walk sexp, &block
+    return unless sexp.is_a? Sexp
+    yield sexp
+    sexp.each { |e| sexp_walk e, &block }
   end
 
   # If you define a method inside a block passed to auto_chain, chain_method

data/spec/chainable/auto_chain_spec.rb

@@ -1,8 +1,8 @@
 require "lib/chainable"
 
-describe Chainable do
+describe "Chainable#auto_chain" do
 
-  it "should chain all methods defined inside auto_chain" do
+  it "should chain all methods defined inside given block" do
     a_class = Class.new do
       auto_chain do
         define_method(:foo) { 100 }
@@ -13,7 +13,7 @@ describe Chainable do
     a_class.new.foo.should == 222
   end
 
-  it "should allow defining methods both inside and outside of auto_chain" do
+  it "should allow defining methods both inside and outside of the block" do
     a_class = Class.new do
       define_method(:foo) { 100 }
       chain_method :foo
@@ -23,7 +23,7 @@ describe Chainable do
     a_class.new.foo.should == 222
   end
 
-  it "should allow auto_chain with core functions" do
+  it "should work with core functions" do
     # We screw with String#reverse, this could mess up other specs.
     String.class_eval do
       chain_method :reverse # or we would overwrite the original

data/spec/chainable/chain_method_spec.rb

@@ -1,6 +1,6 @@
 require "lib/chainable"
 
-describe Chainable do
+describe "Chainable#chain_method" do
 
   before :each do
     @a_class = Class.new do
@@ -60,7 +60,7 @@ 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
+  it "should allow passing multiple method names" do
     @a_class.class_eval do
       chain_method :random, :foo2
       chain_method(:foo, :to_i) { super.to_s }

data/spec/chainable/chain_method_try_merge_spec.rb

@@ -0,0 +1,72 @@
+require "lib/chainable"
+
+describe "Chainable#chain_method(..., :try_merge => true)" do
+
+  before :each do
+    @a_class = Class.new do
+      def foo
+        :foo
+      end
+      def foo2
+        foo.to_s.upcase
+      end
+      def to_i
+        42
+      end
+      def inspect
+        random
+        super
+      end
+      define_method(:random) { @some_value ||= rand(1000) }
+    end
+    @an_instance = @a_class.new
+    @original_results = @a_class.instance_methods(false).inject({}) do |h, m|
+      h.merge m => @an_instance.send(m)
+    end
+  end
+
+  it "should not change the behaviour of the original methods" do
+    5.times do
+      @original_results.each do |method_name, method_result|
+        @a_class.class_eval { chain_method method_name, :try_merge => true }
+        @an_instance.send(method_name).should == method_result
+      end
+    end
+  end
+
+  it "should work for core methods" do
+    String.class_eval do
+      chain_method(:upcase, :try_merge => true) do |*x|
+        return super if x.empty?
+        x.first
+      end
+    end
+    "foo".upcase("bar").should == "bar"
+  end
+
+  it "should define a new method, when block given" do
+    @a_class.class_eval do
+      chain_method(:to_i, :try_merge => true) { super - 5 }
+      chain_method(:foo2, :try_merge => true) { "foo2" }
+    end
+    @an_instance.to_i.should == @original_results["to_i"] - 5
+    @an_instance.foo2.should == "foo2"
+  end
+
+  it "should allow passing multiple method names" do
+    @a_class.class_eval do
+      chain_method(:foo, :to_i, :try_merge => true) { super.to_s }
+    end
+    @an_instance.foo.should == @original_results["foo"].to_s
+    @an_instance.to_i.should == @original_results["to_i"].to_s
+  end
+
+  it "should merge, if possible" do
+    old_ancestors = @a_class.ancestors
+    @a_class.class_eval do
+      chain_method(:to_i, :foo, :try_merge => true) { super.to_s }
+    end
+    @a_class.ancestors.should == old_ancestors
+  end
+
+end

data/spec/chainable/merge_method_spec.rb

@@ -0,0 +1,39 @@
+require "lib/chainable"
+
+describe "Chainable#merge_method" do
+
+  it "should be able to merge \"simple\" methods" do
+    Class.new do
+      old_ancestors = ancestors
+      define_method(:simple) { 100 + 100 }
+      new.simple.should == 200
+      merge_method(:simple) { super - 100 }
+      new.simple.should == 100
+      ancestors.should == old_ancestors
+    end
+  end
+
+  it "should refuse merging methods, if the merge would cause harm" do
+    forbidden = []
+    forbidden << lambda do
+      Class.new do
+        define_method(:same_lvars) { x = 10; x * 2 }
+        merge_method(:same_lvars) { x = 5; super; puts x }
+      end
+    end
+    forbidden << lambda do
+      Class.new do
+        define_method(:args) { |x| x }
+        merge_method(:args) { super }
+      end
+    end
+    forbidden << lambda do
+      Class.new do
+        define_method(:args) { |x| x = 0 }
+        merge_method(:args) { |x| x.to_s; super; puts x }
+      end
+    end
+    forbidden.each { |block| block.should raise_error(ArgumentError) }
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: chainable
 version: !ruby/object:Gem::Version 
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors: 
 - Konstantin Haase
@@ -33,7 +33,9 @@ extra_rdoc_files:
 - LICENSE
 - lib/chainable.rb
 - spec/chainable/auto_chain_spec.rb
+- spec/chainable/merge_method_spec.rb
 - spec/chainable/chain_method_spec.rb
+- spec/chainable/chain_method_try_merge_spec.rb
 - benchmark/chainable.rb
 files: 
 - LICENSE
@@ -41,7 +43,9 @@ files:
 - README.rdoc
 - lib/chainable.rb
 - spec/chainable/auto_chain_spec.rb
+- spec/chainable/merge_method_spec.rb
 - spec/chainable/chain_method_spec.rb
+- spec/chainable/chain_method_try_merge_spec.rb
 - benchmark/chainable.rb
 has_rdoc: true
 homepage: http://rkh.github.com/chainable