chainable 0.3.0 → 0.3.1

data/README.rdoc

@@ -139,7 +139,7 @@ throwing such errors at you.
 Enter "try_merge":
 
   SomeEvilClassWithoutHooks.class_eval do
-    chain_method instance_methods(false), :try_merge => true do
+    chain_method *instance_methods(false), :try_merge => true do
       old_value = self.value.dup
       super.tap { observer.notify if old_value != value }
     end

data/lib/chainable.rb

@@ -2,50 +2,6 @@ require "ruby2ruby"
 
 module Chainable
 
-  def self.skip_chain
-    return if @auto_chain
-    @auto_chain = true
-    yield
-    @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
@@ -53,49 +9,31 @@ module Chainable
   # after chain_method instead.
   def chain_method(*names, &block)
     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 = Chainable.try_merge(self, *names, &block) if options[:try_merge]
     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
+        mod = Module.new
+        Chainable.copy_method(self, mod, name)
+        include mod
       end
       block ||= Proc.new { super }
       define_method(name, &block)
     end
   end
 
+  # This will try to merge into the method, instead of chaining to it (see
+  # README.rdoc). You probably don't want to use this directly but try
+  #   chain_method(:some_method, :try_merge => true) { ... }
+  # instead, which will fall back to chain_method if merge fails.
   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
+      raise ArgumentError, "cannot merge #{name}" unless instance_methods(false).include? name
       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
   # will be called on that method right after it has been defined. This will
   # only affect methods defined for the class (or module) auto_chain has been
@@ -112,9 +50,107 @@ module Chainable
     end
     result
   end
+
+  # Used internally. See source of Chainbale#auto_chain.
+  def self.skip_chain
+    return if @auto_chain
+    @auto_chain = true
+    yield
+    @auto_chain = false
+  end
+
+  # Given a class, a method name and a proc, it will try to merge the sexp
+  # of the method into the sexp of the proc and return the source code (as
+  # method definition). While doing so, it tries to prevent harm.
+  # 
+  # Raises an ArgumentError on failure.
+  def self.wrapped_source(klass, name, wrapper)
+    begin
+      src = Ruby2Ruby.new.process wrapped_sexp(klass, name, wrapper)
+      src.gsub "# do nothing", "nil"
+    rescue Exception
+      raise ArgumentError, "cannot merge #{name}"
+    end
+  end
+
+  def self.wrapped_sexp(klass, name, wrapper)
+    inner = unified sexp_for(klass, name)
+    outer = unified sexp_for(wrapper)
+    raise if inner[2] != s(:args) or outer[2]
+    inner_locals = sexp_walk(inner) { raise }
+    sexp_walk(outer, inner_locals) { |e| e.replace inner[3][1] }
+    s(:defn, name, s(:args), s(:scope, s(:block, outer[3])))
+  end
+
+  def self.sexp_walk(sexp, forbidden_locals = [], &block)
+    return [] unless sexp.is_a? Sexp
+    local = nil
+    case sexp[0]
+    when :lvar then local = sexp[1]
+    when :lasgn then local = sexp[1] if sexp[1].to_s =~ /^\w+$/
+    when :zsuper, :super
+      raise if sexp.length > 1
+      yield(sexp)
+    when :call then raise if sexp[2] == :eval
+    end
+    locals = []
+    if local
+      raise if forbidden_locals.include? local
+      locals << local
+    end
+    sexp.inject(locals) { |l, e| l + sexp_walk(e, forbidden_locals, &block) }
+  end
+
+  def self.unified sexp
+    unifier.process sexp
+  end
+
+  def self.sexp_for a, b = nil
+    require "parse_tree"
+    case a
+    when Class, String then ParseTree.translate(a, b)
+    when Proc then ParseTree.new.parse_tree_for_proc(a)
+    when Sexp then a
+    else raise ArgumentError, "no sexp for #{a.inspect}"
+    end
+  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
+
+  # Tries merge_method on all given methods for klass.
+  # Returns names of the methods that could not be merged.
+  def self.try_merge(klass, *names, &wrapper)
+    names.reject do |name|
+      begin
+        klass.class_eval { merge_method(name, &wrapper) }
+        true
+      rescue ArgumentError
+        false
+      end
+    end
+  end
+
+  # Copies a method from one module to another.
+  def self.copy_method(source_class, target_class, name)
+    begin
+      target_class.class_eval Ruby2Ruby.translate(source_class, name)
+    rescue NameError
+      m = source_class.instance_method name
+      target_class.class_eval do
+        define_method(name) { |*a, &b| m.bind(self).call(*a, &b) }
+      end
+    end
+  end
     
 end
 
 Module.class_eval do
   include Chainable
+  private *Chainable.instance_methods(false)
 end

data/sexp_stuff.rb

@@ -0,0 +1,27 @@
+require "parse_tree"
+require "ruby2ruby"
+
+module FastSexp
+
+  def r2r(a, b = nil)
+    return Ruby2Ruby.new.process a if a.is_a? Sexp
+    r2r u(a, b = nil)
+  end
+
+  def u(a, b = nil)
+    unless @unifier
+      @unifier = Unifier.new
+      @unifier.processors.each { |p| p.unsupported.delete :cfunc }
+    end
+    case a
+    when Sexp then sexp = a
+    when String, Class then sexp = ParseTree.translate(a, b)
+    when Proc then sexp = ParseTree.new.parse_tree_for_proc(a)
+    else raise ArgumentError, "dunno how to handle #{a.inspect}"
+    end
+    @unifier.process sexp
+  end
+
+end
+
+include FastSexp

data/spec/chainable/merge_method_spec.rb

@@ -17,10 +17,16 @@ describe "Chainable#merge_method" do
     forbidden = []
     forbidden << lambda do
       Class.new do
-        define_method(:same_lvars) { x = 10; x * 2 }
+        define_method(:same_lvars) { x = 10 }
         merge_method(:same_lvars) { x = 5; super; puts x }
       end
     end
+    forbidden << lambda do
+      Class.new do
+        define_method(:do_eval) { eval "x = 10" }
+        merge_method(:do_eval) { x = 5; super; puts x }
+      end
+    end
     forbidden << lambda do
       Class.new do
         define_method(:args) { |x| x }
@@ -33,6 +39,13 @@ describe "Chainable#merge_method" do
         merge_method(:args) { |x| x.to_s; super; puts x }
       end
     end
+    forbidden << lambda do
+      Class.new { merge_method(:i_dont_exist) { } }
+    end
+    forbidden << lambda do
+      superclass = Class.new { define_method(:inherited_method) { } }
+      Class.new(superclass) { merge_method(:inherited_method) { } }
+    end
     forbidden.each { |block| block.should raise_error(ArgumentError) }
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: chainable
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors: 
 - Konstantin Haase
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-22 00:00:00 +01:00
+date: 2009-03-25 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -37,6 +37,7 @@ extra_rdoc_files:
 - spec/chainable/chain_method_spec.rb
 - spec/chainable/chain_method_try_merge_spec.rb
 - benchmark/chainable.rb
+- sexp_stuff.rb
 files: 
 - LICENSE
 - Rakefile
@@ -47,6 +48,7 @@ files:
 - spec/chainable/chain_method_spec.rb
 - spec/chainable/chain_method_try_merge_spec.rb
 - benchmark/chainable.rb
+- sexp_stuff.rb
 has_rdoc: true
 homepage: http://rkh.github.com/chainable
 post_install_message: