bindable_block 0.0.2 → 0.0.3

data/lib/bindable_block/version.rb

@@ -1,3 +1,3 @@
 class BindableBlock
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/lib/bindable_block.rb

@@ -1,6 +1,54 @@
 require "bindable_block/version"
 
 class BindableBlock
+
+  # match args to arity, since instance_method has lambda properties
+  class ArgAligner
+    def self.align(args, instance_method)
+      new(args, instance_method).call
+    end
+
+    private
+
+    attr_reader :args, :parameters, :result
+
+    def initialize(args, instance_method)
+      @result, @args, @parameters = [], args, instance_method.parameters.map(&:first)
+      track_if_has_rest
+      parameters.delete :rest
+      remove_block
+      take num_required
+      parameters.delete :req
+      take 1 while parameters.shift && args.any?
+      take args.size if has_rest?
+    end
+
+    def num_required
+      parameters.count { |param| param == :req }
+    end
+
+    def take(n)
+      n.times { result << args.shift }
+    end
+
+    def remove_block
+      parameters.pop if parameters.last == :block
+    end
+
+    def track_if_has_rest
+      @has_splat = parameters.any? { |param| param == :rest }
+    end
+
+    def has_rest?
+      @has_splat
+    end
+
+    def call
+      result
+    end
+  end
+
+
   def initialize(klass, &block)
     @original_block  = block
 
@@ -9,25 +57,11 @@ class BindableBlock
     klass.__send__ :remove_method, method_name
   end
 
-  def method_name
-    @method_name ||= "bindable_block_#{Time.now.to_i}_#{$$}_#{rand 1000000}"
-  end
-
-  def arg_size
-    instance_method.arity
-  end
-
   attr_reader :instance_method, :original_block
 
   def bind(target)
     Proc.new do |*args, &block|
-      # match args to arity, since instance_method has lambda properties
-      if args.size >= arg_size
-        args = args.take arg_size
-      else
-        args[arg_size-1] = nil
-      end
-      instance_method.bind(target).call(*args, &block)
+      instance_method.bind(target).call(*align(args), &block)
     end
   end
 
@@ -38,4 +72,14 @@ class BindableBlock
   def to_proc
     method(:call).to_proc
   end
+
+  private
+
+  def align(args)
+    ArgAligner.align args, instance_method
+  end
+
+  def method_name
+    @method_name ||= "bindable_block_#{Time.now.to_i}_#{$$}_#{rand 1000000}"
+  end
 end

data/spec/bindable_block_spec.rb

@@ -23,19 +23,6 @@ describe BindableBlock do
     block.call(3){4}.should == 10
   end
 
-  it "doesn't care about arity" do
-    block = BindableBlock.new(klass) { |a| [a] }.bind(instance)
-    block.call.should == [nil]
-    block.call(1).should == [1]
-    block.call(1, 2).should == [1]
-  end
-
-  it 'can take a block' do
-    block = BindableBlock.new(klass) { |a, &b| [a, (b&&b.call)] }.bind(instance)
-    block.call(1).should == [1, nil]
-    block.call(1){2}.should == [1, 2]
-  end
-
   it 'can be passed to methods and shit' do
     doubler = lambda { |&block| block.call + block.call }
     doubler.call(&BindableBlock.new(klass) { 12 }).should == 24
@@ -50,4 +37,65 @@ describe BindableBlock do
     # proc.define_singleton_method(:bind) { |target| bindable_block.bind target }
     # proc
   end
+
+  describe 'arguments' do
+    it 'can take a block' do
+      block = BindableBlock.new(klass) { |a, &b| [a, (b&&b.call)] }.bind(instance)
+      block.call(1).should == [1, nil]
+      block.call(1){2}.should == [1, 2]
+    end
+
+    specify "when given ordinal arguments at the start, it doesn't care about arity" do
+      block = BindableBlock.new(klass) { |a| [a] }.bind(instance)
+      block.call.should == [nil]
+      block.call(1).should == [1]
+      block.call(1, 2).should == [1]
+    end
+
+    specify 'when given optional args, it matches them up correctly' do
+      block = BindableBlock.new(klass) { |a, b=1, c=2| [a, b, c] }.bind(instance)
+      block.call.should == [nil, 1, 2]
+      block.call(:a).should == [:a, 1, 2]
+      block.call(:a, :b).should == [:a, :b, 2]
+      block.call(:a, :b, :c).should == [:a, :b, :c]
+      block.call(:a, :b, :c, :d).should == [:a, :b, :c]
+    end
+
+    specify 'splat acts as a catch all' do
+      block = BindableBlock.new(klass) { |a, *rest| [a, rest] }.bind(instance)
+      block.call.should == [nil, []]
+      block.call(1).should == [1, []]
+      block.call(1, 2).should == [1, [2]]
+      block.call(1, 2, 3).should == [1, [2, 3]]
+    end
+
+    specify "when given ordinal arguments at the end, it doesn't care about arity" do
+      block = BindableBlock.new(klass) { |*a, b, &c| [a, b] }.bind(instance)
+      block.call.should == [[], nil]
+      block.call(1).should == [[], 1]
+      block.call(1,2).should == [[1], 2]
+      block.call(1,2,3).should == [[1, 2], 3]
+
+      block = BindableBlock.new(klass) { |a=:a, b, c| [a, b, c] }.bind(instance)
+      block.call.should == [:a, nil, nil]
+      block.call(1).should == [:a, 1, nil]
+      block.call(1, 2).should == [:a, 1, 2]
+      block.call(1, 2, 3).should == [1, 2, 3]
+      block.call(1, 2, 3, 4).should == [1, 2, 3]
+    end
+
+
+    specify "when given complex arguments, it matches that shit up right" do
+      proc  = Proc.new { |a, b, c=1, d=2, *e, f| [a,b,c,d,e,f] }
+      block = BindableBlock.new(klass, &proc).bind(instance)
+      block.call.should == proc.call
+      block.call(:a).should == proc.call(:a)
+      block.call(:a,:b).should == proc.call(:a,:b)
+      block.call(:a,:b,:c).should == proc.call(:a,:b,:c)
+      block.call(:a,:b,:c,:d).should == proc.call(:a,:b,:c,:d)
+      block.call(:a,:b,:c,:d,:e).should == proc.call(:a,:b,:c,:d,:e)
+      block.call(:a,:b,:c,:d,:e,:f).should == proc.call(:a,:b,:c,:d,:e,:f)
+      block.call(:a,:b,:c,:d,:e,:f,:g).should == proc.call(:a,:b,:c,:d,:e,:f,:g)
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bindable_block
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-03 00:00:00.000000000 Z
+date: 2012-06-05 00:00:00.000000000 Z
 dependencies: []
 description: instance_exec can't pass block arguments through. Use a bindable block
   instead.