chainable 0.1.0

data/LICENSE

@@ -0,0 +1,27 @@
+copyright (c) 2009 Konstantin Haase.  All rights reserved.
+
+Developed by: Konstantin Haase
+              http://github.com/rkh/chainable
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal with the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+  1. Redistributions of source code must retain the above copyright notice,
+     this list of conditions and the following disclaimers.
+  2. Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimers in the
+     documentation and/or other materials provided with the distribution.
+  3. Neither the name of Konstantin Haase, nor the names of other contributors
+     may be used to endorse or promote products derived from this Software without
+     specific prior written permission.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+WITH THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,67 @@
+<b>A word of warning:</b>
+
+This is heavy ruby abuse. It even got the Evil of the Day Award™ from zenspider.
+
+== 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
+Chainable is an alternative to alias_method_chain, that uses inheritance, rather
+than aliasing. Instead it does the following when "chaining" a method:
+
+- copy the original method to a new model
+- include the model
+- overwrite the method
+
+Thus you can use super and keep your method list clean, too!
+It even supports a (rather dangerous) auto chaining mode, so you do not have
+to explicitly chain a method, but chain a method when ever it would be
+overwritten.
+
+
+Example:
+
+  class Foo
+
+    def foo
+     10
+    end
+
+    # now chain to foo
+    chain_method :foo do
+      super + 3
+    end
+
+    # or turn on auto chaining
+    auto_chain do
+
+      def bar
+        10
+      end
+
+      def bar
+        super + 1
+      end
+
+      def bar
+        super ** 2
+      end
+
+    end
+  end
+
+  f = Foo.new
+  puts f.foo # => 13
+  puts f.bar # => 121
+
+Of course you can do this with any class (or module):
+
+  Array.class_eval do
+    chain_method :each
+    def each
+      return super if block_given? or RUBY_VERSION >= "1.8.7"
+      MyStuff::Enumerator.new self, :each
+    end
+  end

data/Rakefile

@@ -0,0 +1,3 @@
+require 'spec/rake/spectask'
+
+Spec::Rake::SpecTask.new { |t| t.spec_files = FileList['spec/**/*.rb'] }

data/lib/chainable.rb

@@ -0,0 +1,44 @@
+require "ruby2ruby"
+
+module Chainable
+
+  def self.skip_chain
+    return if @auto_chain
+    @auto_chain = true
+    yield
+    @auto_chain = false
+  end
+
+  def chain_method(name, &block)
+    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
+
+  def auto_chain &block
+    class << self
+      chain_method :method_added do |name|
+        Chainable.skip_chain { chain_method name }
+      end
+    end
+    result = yield
+    class << self
+      remove_method :method_added
+    end
+    result
+  end
+    
+end
+
+Module.class_eval do
+  include Chainable
+end

data/spec/chainable/auto_chain_spec.rb

@@ -0,0 +1,38 @@
+require "lib/chainable"
+
+describe Chainable do
+
+  it "should chain all methods defined inside auto_chain" do
+    a_class = Class.new do
+      auto_chain do
+        define_method(:foo) { 100 }
+        define_method(:foo) { super * 2 }
+        define_method(:foo) { super + 22 }
+      end
+    end
+    a_class.new.foo.should == 222
+  end
+
+  it "should allow defining methods both inside and outside of auto_chain" do
+    a_class = Class.new do
+      define_method(:foo) { 100 }
+      chain_method :foo
+      auto_chain { define_method(:foo) { super * 2 } }
+      define_method(:foo) { super + 22 }
+    end
+    a_class.new.foo.should == 222
+  end
+
+  it "should allow auto_chain 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
+      auto_chain do
+        define_method(:reverse) { super * 2 }
+        define_method(:reverse) { super.downcase }
+      end
+    end
+    "Test".reverse.should == "tsettset"
+  end
+
+end

data/spec/chainable/chain_method_spec.rb

@@ -0,0 +1,83 @@
+require "lib/chainable"
+
+describe Chainable 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 }
+        @an_instance.send(method_name).should == method_result
+      end
+    end
+  end
+
+  it "should work for core methods" do
+    Array.class_eval { chain_method :join }
+    ["hello", "world"].join(" ").should == "hello world"
+    String.class_eval { chain_method(:inspect) { "%#{super}" } }
+    "hello world".inspect.should == '%"hello world"'
+  end
+
+  it "should define a new method, when block given" do
+    @a_class.class_eval do
+      chain_method(:to_i) { super - 5 }
+      chain_method(:foo2) { "foo2" }
+    end
+    @an_instance.to_i.should == @original_results["to_i"] - 5
+    @an_instance.foo2.should == "foo2"
+  end
+
+  it "should allow redefining the method later" do
+    @a_class.class_eval do
+      chain_method :to_i
+      def to_i
+        super + 20
+      end
+    end
+    @an_instance.to_i.should == @original_results["to_i"] + 20
+  end
+
+  it "should keep inheritance intact" do
+    a_module = Module.new do
+      define_method(:inspect) { "some inspect result" }
+      define_method(:foo) { "not foo" }
+    end
+    @a_class.class_eval do
+      include a_module
+      chain_method(:foo) { super }
+    end
+    another_class = Class.new(@a_class) do
+      define_method(:foo) { :bar }
+      define_method(:inspect) { super }
+    end
+    another_instance = another_class.new
+    @an_instance.inspect.should == "some inspect result"
+    @an_instance.foo.should == @original_results["foo"]
+    another_instance.inspect.should == "some inspect result"
+    another_instance.foo.should == :bar
+  end
+
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification 
+name: chainable
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Konstantin Haase
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-20 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: never use alias_method_chain, again
+email: konstantin.mailinglists@googlemail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- LICENSE
+files: 
+- LICENSE
+- Rakefile
+- README.rdoc
+- lib/chainable.rb
+- spec/chainable/auto_chain_spec.rb
+- spec/chainable/chain_method_spec.rb
+has_rdoc: true
+homepage: http://rkh.github.com/chainable
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: never use alias_method_chain, again
+test_files: []
+