chainable 0.3.1 → 0.3.2

data/README.rdoc

@@ -1,6 +1,6 @@
 <b>A word of warning:</b>
 
-This is heavy ruby abuse. It even got the Evil of the Day Award™ from zenspider.
+This is heavy ruby abuse. It even got the <b>Evil of the Day Award™</b> from zenspider.
 
 Forks are welcome!
 
@@ -170,8 +170,13 @@ chain_method tends do produce slightly faster methods than alias_method_chain:
   alias_method_chain (define_method)   3.470000   0.590000   4.060000 (  4.096245)
 
 == Installation
-Add github gems, if you haven't already:
+From RubyForge:
+  gem install chainable
+
+From GitHub:
   gem sources -a http://gems.github.com
+  gem install rkh-chainable
+
+== Running test
 
-Install gem:
-  gem install rkh-chainable
+The specs should work with rspec, mspec and bacon.

data/lib/chainable.rb

@@ -1,5 +1,6 @@
 require "ruby2ruby"
 
+# This mixin will be included in Module.
 module Chainable
 
   # This will "chain" a method (read: push it to a module and include it).
@@ -7,13 +8,25 @@ 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.
+  #
+  # It takes the following options:
+  #
+  # === try_merge
+  # try_merge will try merge_method for every method given and only chain if
+  # that fails. Default is false.
+  # 
+  # === module_reuse
+  # Will try to reuse the last mixin to keep the inheritance chain short.
+  # Default is true.
   def chain_method(*names, &block)
-    options = names.grep(Hash).inject({}) { |a, b| a.merge names.delete(b) }
+    options = names.grep(Hash).inject(Chainable.default_options) do |a, b|
+      a.merge names.delete(b)
+    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
-        mod = Module.new
+        mod = Chainable.mixin_for(self, name, options[:module_reuse])
         Chainable.copy_method(self, mod, name)
         include mod
       end
@@ -27,6 +40,7 @@ module Chainable
   #   chain_method(:some_method, :try_merge => true) { ... }
   # instead, which will fall back to chain_method if merge fails.
   def merge_method(*names, &block)
+    raise ArgumentError, "no block given" unless block
     names.each do |name|
       name = name.to_s
       raise ArgumentError, "cannot merge #{name}" unless instance_methods(false).include? name
@@ -38,19 +52,38 @@ module Chainable
   # 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
   # send to. See README.rdoc or spec/chainable/auto_chain_spec.rb for examples.
-  def auto_chain
-    class << self
-      chain_method :method_added do |name|
-        Chainable.skip_chain { chain_method name }
+  #
+  # auto_chain takes a hash of options, just like chain_method does.
+  def auto_chain options = {}
+    eigenclass = (class << self; self; end)
+    eigenclass.class_eval do
+      chain_method :method_added, :try_merge => false do |name|
+        Chainable.skip_chain { chain_method name, options }
       end
     end
     result = yield
-    class << self
-      remove_method :method_added
-    end
+    eigenclass.class_eval { remove_method :method_added }
     result
   end
 
+  # Default options for auto_chain and chain_method.
+  #
+  # Example usage:
+  #   Chainable.default_options[:try_merge] = true
+  def self.default_options
+    @default_options ||= { :try_merge => false, :module_reuse => true }
+  end
+
+  # Creates mixin used by chain_method.
+  def self.mixin_for(klass, name, reuse = true)
+    @last_mixin ||= {}
+    if reuse and klass.ancestors[1] == @last_mixin[klass]
+      im = @last_mixin[klass].instance_methods(false)
+      return @last_mixin[klass] unless im.include?(name.to_s)
+    end
+    @last_mixin[klass] = Module.new
+  end
+
   # Used internally. See source of Chainbale#auto_chain.
   def self.skip_chain
     return if @auto_chain
@@ -73,6 +106,8 @@ module Chainable
     end
   end
 
+  # The sexp part of wrapped_source. Note: In rubinius, we could use this directly
+  # rather than generating the source again.
   def self.wrapped_sexp(klass, name, wrapper)
     inner = unified sexp_for(klass, name)
     outer = unified sexp_for(wrapper)
@@ -82,7 +117,9 @@ module Chainable
     s(:defn, name, s(:args), s(:scope, s(:block, outer[3])))
   end
 
-  def self.sexp_walk(sexp, forbidden_locals = [], &block)
+  # Traveling a methods sexp tree. Block will be called for every super.
+  def self.sexp_walk(sexp, forbidden_locals = [], &block) # :yield: sexp
+    # TODO: Refactor me, I'm ugly!
     return [] unless sexp.is_a? Sexp
     local = nil
     case sexp[0]
@@ -101,10 +138,12 @@ module Chainable
     sexp.inject(locals) { |l, e| l + sexp_walk(e, forbidden_locals, &block) }
   end
 
+  # Unify sexp.
   def self.unified sexp
     unifier.process sexp
   end
 
+  # Give a proc, class and method, string or sexp and get a sexp.
   def self.sexp_for a, b = nil
     require "parse_tree"
     case a
@@ -115,10 +154,10 @@ module Chainable
     end
   end
 
+  # Unifier with modifications for Ruby2Ruby. (Stolen from Ruby2Ruby.)
   def self.unifier
     return @unifier if @unifier
     @unifier = Unifier.new
-    # HACK (stolen from ruby2ruby)
     @unifier.processors.each { |p| p.unsupported.delete :cfunc }
     @unifier
   end
@@ -136,14 +175,37 @@ module Chainable
     end
   end
 
+  def self.store_method(block)
+    @method_store ||= []
+    @method_store << block
+    @method_store.length - 1
+  end
+
+  def self.call_stored_method(method_id, owner, *args, &block)
+    @method_store[method_id].bind(owner).call(*args, &block)
+  end
+
   # Copies a method from one module to another.
+  # TODO: This could be solved totally different in Rubinius.
   def self.copy_method(source_class, target_class, name)
     begin
       target_class.class_eval Ruby2Ruby.translate(source_class, name)
     rescue NameError
+      # If we get here, the method is written in C or something. So let's do
+      # some evil magic.
       m = source_class.instance_method name
       target_class.class_eval do
-        define_method(name) { |*a, &b| m.bind(self).call(*a, &b) }
+        begin
+          eval "define_method(name) { |*a, &b| m.bind(self).call(*a, &b) }"
+        rescue SyntaxError # Ruby < 1.8.7, JRuby
+          # Really really evil, have to change it.
+          method_id = Chainable.store_method(m)
+          eval %[
+            def #{name}(*a, &b)
+              Chainable.call_stored_method(#{method_id}, self, *a, &b)
+            end
+          ]
+        end
       end
     end
   end

data/spec/chainable/chain_method_spec.rb

@@ -2,7 +2,7 @@ require "lib/chainable"
 
 describe "Chainable#chain_method" do
 
-  before :each do
+  before do
     @a_class = Class.new do
       def foo
         :foo

data/spec/chainable/chain_method_try_merge_spec.rb

@@ -2,7 +2,7 @@ require "lib/chainable"
 
 describe "Chainable#chain_method(..., :try_merge => true)" do
 
-  before :each do
+  before do
     @a_class = Class.new do
       def foo
         :foo

data/spec/chainable/merge_method_spec.rb

@@ -46,7 +46,14 @@ describe "Chainable#merge_method" do
       superclass = Class.new { define_method(:inherited_method) { } }
       Class.new(superclass) { merge_method(:inherited_method) { } }
     end
-    forbidden.each { |block| block.should raise_error(ArgumentError) }
+    forbidden.each do |block|
+      # just for fun
+      if defined? Bacon
+        block.should.raise(ArgumentError)
+      else
+        block.should raise_error(ArgumentError)
+      end
+    end
   end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: chainable
 version: !ruby/object:Gem::Version 
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors: 
 - Konstantin Haase
@@ -37,7 +37,6 @@ 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
@@ -48,7 +47,6 @@ 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: 

data/sexp_stuff.rb

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