proxy_machine 0.0.5 → 0.0.6

data/README.rdoc

@@ -1,38 +1,85 @@
 = proxy_machine
 
-== Description
-  
 A cool proxy implementation pattern in ruby
 
+== Details
+  
+Proxy Machine is a proxy/delegate framework. It can create a proxy for  standalone objects or change the behavior of the entire class, also it is possible to create an execution stack with the proxy life cycle.
+
 == Install
 
   sudo gem install proxy_machine
   
 == Example usage
 
-=== The awesome way:
+=== Proxy standalone objects
 
   p = proxy_for [1, 2, 3]
-  p.reverse => [3, 2, 1]
+  p.proxied? # => true
+  p.reverse # => [3, 2, 1]
+
+=== Proxy the entire class
+
+  class MyClass
+    attr_accessor :name
+    
+    # Configuring the proxy
+    auto_proxy do
+      before :name => lambda {|obj, args| puts "old name: #{obj.name}"}
+    end
+    
+  end
+  
+  obj = MyClass.new
+  obj.proxied? # => true
+  obj.name # => old name: nil
+                nil
             
 === Defining callbefores and callafters in method level
                      
 Callbefores:
 
+==== Standalone way
   p = proxy_for [1, 2, 3], :before => {
     :reverse => lambda {|obj, args| puts 'before reverse'}
   }   
   
-  p.reverse => before reverse
-               [3, 2, 1]
+  p.reverse # => before reverse
+                 [3, 2, 1]
+
+==== Class way
+
+  class MyClass
+    # ...
+    auto_proxy do
+      before :method => lambda {|obj, args| puts 'implementation'}
+    end
+    # ...
+  end
+  
+  obj = MyClass.new
+  obj.proxied? # => true
+  
+Every instance of "MyClass" will be proxied
 
 Callafters:
-               
+
+==== Standalone way               
   p = proxy_for [1, 2, 3], :after => {
    :reverse => lambda {|obj, result, args| result.sort}
   }   
 
-  p.reverse => [1, 2, 3] # We reordered the list
+  p.reverse # => [1, 2, 3] # We reordered the list
+  
+==== Class way
+
+  class MyClass
+    # ...
+    auto_proxy do
+      after :method => lambda {|obj, result, args| puts 'implementation'}
+    end
+    # ...
+  end
                   
 You will always receive the arguments passed to the original method.               
                
@@ -42,23 +89,47 @@ Callbefores:
 This callback will receive a reference of the object, the symbol of the called method and the
 original arguments passed.
 
+==== Standalone way
+
   p = proxy_for [1, 2, 3], :before_all => lambda {|obj, method, args| puts 'before all'}
-  p.reverse => before all
-               [3, 2, 1]
+  p.reverse # => before all
+                 [3, 2, 1]
   
-  p.size => before all
-            3
+  p.size # => before all
+              3
 
+==== Class way
+
+  class MyClass
+    # ...
+    auto_proxy do
+      before_all {|obj, method, args| puts 'implementation'}
+    end
+    # ...
+  end
+  
 Callafters:
 This callback will receive a reference of the object, the result of execution (this result could be nil), 
 the symbol of the called method and the arguments passed.
+
+==== Standalone way
                
   p = proxy_for [1, 2, 3], :after_all => lambda {|obj, result, method, args| puts result}
-  p.reverse => [1, 2, 3]
-               [1, 2, 3] # puts
+  p.reverse # => [1, 2, 3]
+                 [1, 2, 3] # puts
                
-  p.size => 3
-            3 # puts
+  p.size # => 3
+              3 # puts
+              
+==== Class way
+
+  class MyClass
+    # ...
+    auto_proxy do
+      after_all {|obj, result, method, args| puts 'implementation'}
+    end
+    # ...
+  end
 
 === Registering a class to perform the callafter or callbefore
                        
@@ -74,12 +145,24 @@ every time it need to use it. You could use this feature with the before_all and
                              
     def call; @object.sort! end
   end
+
+==== Standalone way
   
   p = proxy_for [1, 2, 3], :after => {
     :reverse => SortPerformer
   }
   
-  p.reverse => [1, 2, 3]
+  p.reverse # => [1, 2, 3]
+  
+==== Class way
+
+  class MyClass
+    # ...
+    auto_proxy do
+      after :method => Performer
+    end
+    # ...
+  end
 
 === Controlling the method execution with regexp
                        
@@ -93,27 +176,56 @@ For before_all and after_all you could use regexp to configure which methods wil
     def another_method; @value ? @value : 'another' end
     def crazy_one; @value ? @value : 'crazy' end
   end
+
+==== Standalone way
    
   p = proxy_for MyRegexMethods.new, :before_all => [
     [/^get_/, lambda {|obj, method, args| obj.value = 'gotcha!' }]
   ]
   
-  p.get_value1 => gotcha!
-  p.get_value2 => gotcha!
-  p.another_method => 'another
-  proxy.crazy_one => 'crazy'
+  p.get_value1 # => gotcha!
+  p.get_value2 # => gotcha!
+  p.another_method # => 'another
+  proxy.crazy_one # => 'crazy'
+  
+==== Class way
+
+  class MyRegexMethods
+    # ...
+    auto_proxy do
+      before_all [
+        [/^get_/, lambda {|obj, method, args| obj.value = 'gotcha!' }]
+      ]
+    end
+    # ...
+  end
 
 You could use many definitions if you want, the calls will happen in the declared order.
 
+==== Standalone way
+
   p = proxy_for MyRegexMethods.new, :before_all => [
     [/get_/, lambda {|obj, method, args| obj.value = "it_"}]
     [/value/, lambda {|obj, method, args| obj.value = "#{obj.value}works"}]
   ]
   
-  p.get_value1 => it_works
-  p.get_value2 => it_works
-  p.another_method => another
-  p.crazy_one => crazy
+  p.get_value1 # => it_works
+  p.get_value2 # => it_works
+  p.another_method # => another
+  p.crazy_one # => crazy
+
+==== Class way
+
+  class MyRegexMethods
+    # ...
+    auto_proxy do
+      before_all [
+        [/get_/, lambda {|obj, method, args| obj.value = "it_"}]
+        [/value/, lambda {|obj, method, args| obj.value = "#{obj.value}works"}]
+      ]
+    end
+    # ...
+  end
 
 It is also possible to use classes instead of procs.
             
@@ -131,10 +243,10 @@ It is also possible to use classes instead of procs.
     [/value/, Change2Performer]
   ]
   
-  p.get_value1 => it_works
-  p.get_value2 => it_works
-  p.another_method => another
-  p.crazy_one => crazy
+  p.get_value1 # => it_works
+  p.get_value2 # => it_works
+  p.another_method # => another
+  p.crazy_one # => crazy
 
 === Building an execution stack
 
@@ -160,18 +272,20 @@ It is also possible to use classes instead of procs.
     :company_name => [make_lower, make_round_brackets2]
   }
                    
-  p.name => (IMPORTANT-NAME)                 
-  p.company_name => [company name]                 
+  p.name # => (IMPORTANT-NAME)                 
+  p.company_name # => [company name]                 
                    
 === How to detect that the object is a proxy?
 
 The beautiful way:
 
   o1 = [1, 2, 3]
-  o1.proxied? => false
+  o1.proxied? # => false
 
   o2 = proxy_for [1, 2, 3] 
-  o2.proxied? => true
+  o2.proxied? # => true
+  
+It will work with +auto_proxy+ usage too.
 
 Other way:
 
@@ -183,8 +297,10 @@ Other way:
 Call original_object method in the proxy object.
 
   proxy = proxy_for [1, 2, 3]
-  proxy.proxied? => true
-  proxy.original_object.proxied? => false
+  proxy.proxied? # => true
+  proxy.original_object.proxied? # => false
+  
+It will work with +auto_proxy+ usage too.
   
 === Special options
 
@@ -197,15 +313,30 @@ Default is false.
     attr_accessor :value
     def method_missing(symbol, *args); 'nice!'; end
   end
+
+==== Standalone way
   
   p = proxy_for MyClass.new, :allow_dinamic => true, :before => {
     :magic_method => lambda {|obj| obj.value = 'other value' }
   }
   
-  p.magic_method => 'other value'
+  p.magic_method # => 'other value'
+
+==== Class way
+
+  class MyClass
+    # ...
+    auto_proxy do
+      allow_dinamic true
+      before :magic_method => lambda {|obj| obj.value = 'other value' }
+    end
+    # ...
+  end
   
 2 - avoid_original_execution: When this option is enabled, proxy_machine will not call the original method.
 Default is false.
+
+==== Standalone way
   
   p = proxy_for [3, 2, 1], 
     :avoid_original_execution => true,
@@ -213,21 +344,39 @@ Default is false.
       :empty? => lambda {|obj| obj.sort!}
     }
     
-  p.empty? => nil
-  p.original_object => [1, 2, 3]
+  p.empty? # => nil
+  p.original_object # => [1, 2, 3]
+
+==== Class way
+
+  class MyClass
+    # ...
+    auto_proxy do
+      avoid_original_execution true
+    end
+    # ...
+  end
                       
 === Trying it in irb
 
   irb
   require 'proxy_machine'
+  
   proxy_for...
   
+  class XYZ
+    auto_proxy do
+      ...
+    end
+    ...
+  end
+  
 === Other ways:
 
 1º - Creates a proxy for the informed object
 
   p = Proxy.new [1,2,3]
-  p.size => 3
+  p.size # => 3
 
 2º - A proxy with a before callback.
 
@@ -235,8 +384,8 @@ Default is false.
     :size => lambda {|obj| puts "before: #{obj.inspect}"}
   }
   
-  p.size => before: [1, 2, 3]
-            3
+  p.size # => before: [1, 2, 3]
+              3
                   
 3º - A proxy with a after callback
 
@@ -244,8 +393,8 @@ Default is false.
     :size => lambda {|obj, result| puts "after: #{obj.inspect}: result => #{result}"}
   }
 
-  p.size => after: [1, 2, 3]: result => 3
-            3
+  p.size # => after: [1, 2, 3]: result => 3
+              3
                  
 4º - Both
 
@@ -258,4 +407,4 @@ Default is false.
 
 == Copyright
 
-Copyright (c) 2010 Túlio Ornelas. See LICENSE for details.                
+Copyright (c) 2010, 2011 Túlio Ornelas. See LICENSE for details.                

data/Rakefile

@@ -14,4 +14,19 @@ begin
   Jeweler::GemcutterTasks.new
 rescue LoadError
   puts "Jeweler not available. Install it with: gem install jeweler"
-end
+end
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+  spec.rspec_opts = '-c --format documentation'
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+  spec.rspec_opts = '-c --format documentation'
+end
+
+task :default => :spec

data/VERSION

@@ -1 +1 @@
-0.0.5
+0.0.6

data/lib/kernel.rb

@@ -3,7 +3,18 @@ require 'proxy_machine'
 module Kernel
   
   def proxy_for object, callbacks = nil
-    Proxy.new object, callbacks
+    ProxyMachine::Proxy.new object, callbacks
+  end
+  
+  def auto_proxy &block
+    @proxy_machine_config = ProxyMachine::Config.new
+    @proxy_machine_config.apply!(&block)
+    
+    def self.new(*args)
+      obj = allocate
+      obj.send(:initialize, *args)
+      proxy_for obj, @proxy_machine_config.callbacks
+    end
   end
   
 end

data/lib/proxy_machine.rb

@@ -10,4 +10,5 @@ require 'kernel'
 require 'object'
 require 'symbol'                            
 require 'proxy_machine/proxy'
+require 'proxy_machine/config'
 include ProxyMachine

data/lib/proxy_machine/config.rb

@@ -0,0 +1,38 @@
+module ProxyMachine
+  class Config
+    
+    attr_reader :callbacks
+    def initialize
+      @callbacks = {}
+    end
+    
+    def apply! &block
+      instance_exec(&block)
+    end
+    
+    def allow_dinamic boolean
+      @callbacks[:allow_dinamic] = boolean
+    end
+    
+    def avoid_original_execution boolean
+      @callbacks[:avoid_original_execution] = boolean
+    end
+    
+    def before hash
+      @callbacks[:before] = hash
+    end
+    
+    def before_all params = nil, &block
+      @callbacks[:before_all] = params ? params : block
+    end
+    
+    def after hash
+      @callbacks[:after] = hash
+    end
+    
+    def after_all params = nil, &block
+      @callbacks[:after_all] = params ? params : block
+    end
+    
+  end
+end

data/proxy_machine.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{proxy_machine}
-  s.version = "0.0.5"
+  s.version = "0.0.6"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["T\303\272lio Ornelas"]
-  s.date = %q{2010-11-02}
+  s.date = %q{2011-03-23}
   s.description = %q{A cool proxy implementation pattern in ruby}
   s.email = %q{ornelas.tulio@gmail.com}
   s.extra_rdoc_files = [
@@ -26,23 +26,24 @@ Gem::Specification.new do |s|
      "lib/kernel.rb",
      "lib/object.rb",
      "lib/proxy_machine.rb",
+     "lib/proxy_machine/config.rb",
      "lib/proxy_machine/proxy.rb",
      "lib/symbol.rb",
      "proxy_machine.gemspec",
      "script/console",
-     "spec/proxy_spec.rb"
+     "spec/proxy_spec.rb",
+     "spec/spec_helper.rb"
   ]
   s.homepage = %q{http://github.com/tulios/proxy_machine}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.7}
+  s.rubygems_version = %q{1.4.1}
   s.summary = %q{A cool proxy implementation pattern in ruby}
   s.test_files = [
     "spec/proxy_spec.rb"
   ]
 
   if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then

data/spec/proxy_spec.rb

@@ -1,6 +1,6 @@
-require 'proxy_machine'
+require 'spec_helper'
 
-describe Proxy do
+describe "proxy_machine" do
                              
   it 'should create a proxy object from the given one' do
     array = [1, 2, 3]
@@ -128,7 +128,7 @@ describe Proxy do
     
   end
   
-  context 'for kernel method' do
+  context 'for kernel method proxy_for' do
     
     it 'should call proxy' do
       array = [1, 2, 3]
@@ -415,6 +415,268 @@ describe Proxy do
     end
 
   end
+  
+  context 'for kernel method auto_proxy' do
+    class ProxiedConstructor
+      attr_accessor :name, :count
+      def initialize; @count = 0 end
+    end
+    
+    context 'when generate a object already proxied' do
+      
+      it 'should work even if the class have a parametrized initialize' do
+        class ProxiedConstructorWithArgs
+          attr_accessor :var1, :var2
+          def initialize(v1, v2); @var1 = v1; @var2 = v2; end
+          auto_proxy { before :var1 => lambda {|obj, args| obj.var1 = 'proxied' if obj.var1 == 1} }
+        end
+        
+        obj = ProxiedConstructorWithArgs.new(1,2)
+        obj.proxied?.should be_true
+        obj.send(:var1).should eql(1) # by passing proxy_machine
+        obj.var1.should eql('proxied')
+        obj.var2.should eql(2)
+        
+        obj = ProxiedConstructorWithArgs.new('a', 'b')
+        obj.proxied?.should be_true
+        obj.var1.should eql('a')
+        obj.var2.should eql('b')
+      end
+      
+      context 'for a certain method' do
+        
+        it 'should add a callbefore' do
+          class ProxiedConstructor
+            auto_proxy { before :name => lambda {|obj, args| obj.name = "#{obj.name}-2"} }
+          end  
+          
+          obj = ProxiedConstructor.new
+          obj.proxied?.should be_true
+          obj.name.should eql("-2")
+          obj.name = "house"
+          obj.name.should eql("house-2")
+        end
+      
+        it 'should add a callafter' do
+          class ProxiedConstructor
+            auto_proxy { after :name => lambda {|obj, result, args| result.chars.to_a.sort.to_s} }
+          end
+          
+          obj = ProxiedConstructor.new
+          obj.proxied?.should be_true
+          obj.name = "tulio"
+          obj.name.should eql("ilotu")
+          obj.name = "proxy"
+          obj.name.should eql("oprxy")
+        end
+        
+      end
+      
+      context 'for all methods' do
+        
+        it 'should add a callbefore' do
+          class ProxiedConstructor
+            auto_proxy { before_all {|obj, method, args| obj.count+=1} }
+          end
+          
+          obj = ProxiedConstructor.new
+          obj.proxied?.should be_true
+          obj.count.should eql(1)
+          obj.to_s
+          obj.count.should eql(3)
+          obj.display
+          obj.count.should eql(5)
+        end
+        
+        it 'should add a callafter' do
+          class ProxiedConstructor
+            auto_proxy { after_all {|obj, method, args| obj.count-=1} }
+          end
+          
+          obj = ProxiedConstructor.new
+          obj.proxied?.should be_true
+          obj.count.should eql(-1)
+          obj.to_s
+          obj.count.should eql(-3)
+          obj.display
+          obj.count.should eql(-5)
+        end
+        
+      end
+      
+      context 'filtering methods by regex' do
+        class MyRegexMethodsProxiedConstructor                    
+          attr_accessor :value
+          def get_value1; @value ? @value : 'get' end
+          def get_value2; @value ? @value : 'get' end
+          def another_method; @value ? @value : 'another' end
+          def crazy_one; @value ? @value : 'crazy' end
+        end
+        
+        it 'should affect just the matched methods on callbefore' do
+          class MyRegexMethodsProxiedConstructor
+            auto_proxy do
+              before_all [
+                [/^get_/, lambda {|obj, method, args| obj.value = 'gotcha!' }],
+                [/method$/, lambda {|obj, method, args| obj.value = 'another gotcha!' }]
+              ]
+            end
+          end
+          
+          obj = MyRegexMethodsProxiedConstructor.new
+          obj.proxied?.should be_true
+
+          obj.original_object.value = nil
+          obj.get_value1.should == 'gotcha!'
+
+          obj.original_object.value = nil
+          obj.get_value2.should == 'gotcha!'
+
+          obj.original_object.value = nil
+          obj.another_method.should == 'another gotcha!'
+
+          obj.original_object.value = nil
+          obj.crazy_one.should == 'crazy'
+        end
+        
+        it 'should affect just the matched methods on callafter' do
+          class MyRegexMethodsProxiedConstructor
+            auto_proxy do
+              after_all [
+                [/^get_/, lambda {|obj, result, method, args| obj.value = 'gotcha!' }],
+                [/method$/, lambda {|obj, result, method, args| obj.value = 'another gotcha!'}]
+              ]
+            end
+          end
+            
+          obj = MyRegexMethodsProxiedConstructor.new
+          obj.proxied?.should be_true
+
+          obj.original_object.value = nil
+          obj.get_value1.should == 'gotcha!'
+
+          obj.original_object.value = nil
+          obj.get_value2.should == 'gotcha!'
+
+          obj.original_object.value = nil
+          obj.another_method.should == 'another gotcha!'
+
+          obj.original_object.value = nil
+          obj.crazy_one.should == 'crazy'
+        end
+        
+      end
+      
+    end
+    
+    context 'with dinamic methods' do
+      class MyClassProxiedConstructed
+        attr_accessor :value
+        auto_proxy do
+          allow_dinamic true
+          before :crazy_method => lambda {|obj, args| obj.value = "proxied value!" }
+        end
+        def method_missing(symbol, *args); @value; end
+      end
+
+      it 'should allow dinamic methods' do
+        obj = MyClassProxiedConstructed.new
+        obj.proxied?.should be_true
+        
+        obj.value = "Crazy Value"
+        obj.value.should == "Crazy Value"
+        obj.crazy_method.should == "proxied value!"
+        obj.value.should == "proxied value!"
+      end
+    end
+    
+    context 'avoiding original execution' do
+      class AvoidOriginalProxiedConstructed
+        attr_accessor :value
+        auto_proxy do
+          avoid_original_execution true
+          after_all {|obj, result, method, args| "avoided"}
+        end
+        def do_something; @value = "original" end
+      end
+
+      it 'should happen' do
+        obj = AvoidOriginalProxiedConstructed.new
+        obj.proxied?.should be_true
+        
+        obj.do_something.should == "avoided"
+        obj.original_object.value.should be_nil
+      end
+    end
+    
+    context 'when registering a class' do
+      class CounterPerformer
+        def initialize object, result = nil, method = nil, args = nil
+          @object = object; @result = result; @method = method, @args = args
+        end
+      
+        def call; @object.count = @object.count ? @object.count+1 : 0 end
+      end
+      class RegisteredProxiedConstructed; attr_accessor :count; end
+      
+      it 'should use a instance of the registered class for a callbefore' do
+        class RegisteredProxiedConstructed
+          auto_proxy {before :to_s => CounterPerformer}
+        end
+        
+        obj = RegisteredProxiedConstructed.new
+        obj.proxied?.should be_true
+        obj.count.should eql(nil)
+        obj.to_s
+        obj.count.should eql(0)
+        obj.to_s
+        obj.count.should eql(1)
+      end
+  
+      it 'should use a instance of the registered class for a callafter' do
+        class RegisteredProxiedConstructed
+          auto_proxy {after :to_s => CounterPerformer}
+        end
+        
+        obj = RegisteredProxiedConstructed.new
+        obj.proxied?.should be_true
+        obj.count.should eql(nil)
+        obj.to_s
+        obj.count.should eql(0)
+        obj.to_s
+        obj.count.should eql(1)
+      end
+  
+      it 'should use a instance of the registered class for callbefore_all' do
+        class RegisteredProxiedConstructed
+          auto_proxy {before_all CounterPerformer}
+        end
+        
+        obj = RegisteredProxiedConstructed.new
+        obj.proxied?.should be_true
+        obj.count.should eql(0)
+        obj.to_s
+        obj.count.should eql(2)
+        obj.display
+        obj.count.should eql(4)
+      end
+  
+      it 'should use a instance of the registered class for callafter_all' do
+        class RegisteredProxiedConstructed
+          auto_proxy {after_all CounterPerformer}
+        end
+        
+        obj = RegisteredProxiedConstructed.new
+        obj.proxied?.should be_true
+        obj.count.should eql(0)
+        obj.to_s
+        obj.count.should eql(2)
+        obj.display
+        obj.count.should eql(4)
+      end
+  
+    end
+  end
 
 end
 

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'rspec'
+require 'proxy_machine'
+
+RSpec.configure do |config|
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: proxy_machine
 version: !ruby/object:Gem::Version 
-  hash: 21
-  prerelease: false
+  hash: 19
+  prerelease: 
   segments: 
   - 0
   - 0
-  - 5
-  version: 0.0.5
+  - 6
+  version: 0.0.6
 platform: ruby
 authors: 
 - "T\xC3\xBAlio Ornelas"
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-02 00:00:00 -02:00
+date: 2011-03-23 00:00:00 -03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -69,11 +69,13 @@ files:
 - lib/kernel.rb
 - lib/object.rb
 - lib/proxy_machine.rb
+- lib/proxy_machine/config.rb
 - lib/proxy_machine/proxy.rb
 - lib/symbol.rb
 - proxy_machine.gemspec
 - script/console
 - spec/proxy_spec.rb
+- spec/spec_helper.rb
 has_rdoc: true
 homepage: http://github.com/tulios/proxy_machine
 licenses: []
@@ -104,7 +106,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.4.1
 signing_key: 
 specification_version: 3
 summary: A cool proxy implementation pattern in ruby