bindable_block 0.0.5.1 → 0.0.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5b1c8b49ff2472deebf4c6d9e551166d037b1b8a
+  data.tar.gz: df827455f3cd67f49550b331849fcda641ca48d3
+SHA512:
+  metadata.gz: fe81548ae86dc946d2dbe42c3f21ecf9401877eabbec57a1da4183456dc46bc6d7a629f14b3be2c76bfeb47df1e253f39f49a163f388434157173612e8c4a653
+  data.tar.gz: 30b47e2b53ab657136bead810544a145b1d57b25235ff31256b7fe9458068319a01bd2821a47576de54b8ae79cad29f2fbd47532e8c2c37c0bf098b55b9a0112

data/README.md

@@ -1,16 +1,56 @@
 # BindableBlock
 
-`instance_exec` can't take block arguments. Get around that with BindableProc
+`instance_exec` can't take block arguments. Get around that with BindableProc (also provides optional `BasicObject#instance_exec_b`)
+
+If you understand that previous statement, then I probably can't dissuade you from using this.
+If you don't, then a word of warning: This is probably the wrong solution.
+`instance_exec` is probably the wrong solution too.
+Metaprogramming is almost never merited.
+It's lighting your way by setting yourself on fire.
+Your problem will be simpler if you don't use it.
+It will be more comprehensible.
+You'll waste less time later trying to figure out how to get it to do what you want.
+95% of the times I've used metaprogramming, I've later regretted it.
+The whole use-case that led to the creation of this gem was wrong,
+it was unnecessary, it added tremendous complexity to the implementation.
+Think Rails moving from `find_by_name(name)` to `find_by(name: name)`,
+and how much better that was.
+
+BUT! If I still can't convince you, then read on:
+
 
 ```ruby
 require 'bindable_block'
 
 User = Struct.new :name
-greeter = BindableBlock.new(User) { "Welcome, #{name}" }
+greeter = BindableBlock.new { "Welcome, #{name}" }
 greeter.bind(User.new "Josh").call # => "Welcome, Josh"
 ```
 
+```ruby
+require 'bindable_block/instance_exec_b'
+
+# http://rdoc.info/stdlib/core/BasicObject:instance_exec
+class KlassWithSecret
+  def initialize
+    @secret = 99
+  end
+end
+k           = KlassWithSecret.new
+sum         = 10
+sum_updater = lambda { |to_add| sum += to_add }
+result      = k.instance_exec_b(5, sum_updater) { |x, &b| b.call(@secret+x) } # => 114
+sum # => 114
+```
+
 [Here](https://github.com/JoshCheek/surrogate/blob/eb1d7f98a148c032f6d3ef1d8df8b703386f286d/lib/surrogate/options.rb#L32-34) is an example.
+Note that it is the old-style where users had to submit the class that could be bound to.
+
+## Possible advances in usefulness
+
+It just occurred to me that if we bound it to BasicObject
+then it could be used on any class without the user needing to
+specify which class they want to bind it to.
 
 ## Where the abstraction leaks
 

data/README.mountain_berry_fields.md

@@ -1,18 +1,60 @@
 # BindableBlock
 
-`instance_exec` can't take block arguments. Get around that with BindableProc
+`instance_exec` can't take block arguments. Get around that with BindableProc (also provides optional `BasicObject#instance_exec_b`)
+
+If you understand that previous statement, then I probably can't dissuade you from using this.
+If you don't, then a word of warning: This is probably the wrong solution.
+`instance_exec` is probably the wrong solution too.
+Metaprogramming is almost never merited.
+It's lighting your way by setting yourself on fire.
+Your problem will be simpler if you don't use it.
+It will be more comprehensible.
+You'll waste less time later trying to figure out how to get it to do what you want.
+95% of the times I've used metaprogramming, I've later regretted it.
+The whole use-case that led to the creation of this gem was wrong,
+it was unnecessary, it added tremendous complexity to the implementation.
+Think Rails moving from `find_by_name(name)` to `find_by(name: name)`,
+and how much better that was.
+
+BUT! If I still can't convince you, then read on:
+
 
 ```ruby
 <% test 'example', with: :magic_comments do %>
 require 'bindable_block'
 
 User = Struct.new :name
-greeter = BindableBlock.new(User) { "Welcome, #{name}" }
+greeter = BindableBlock.new { "Welcome, #{name}" }
 greeter.bind(User.new "Josh").call # => "Welcome, Josh"
 <% end %>
 ```
 
+```ruby
+<% test 'example', with :magic_comments do %>
+require 'bindable_block/instance_exec_b'
+
+# http://rdoc.info/stdlib/core/BasicObject:instance_exec
+class KlassWithSecret
+  def initialize
+    @secret = 99
+  end
+end
+k           = KlassWithSecret.new
+sum         = 10
+sum_updater = lambda { |to_add| sum += to_add }
+result      = k.instance_exec_b(5, sum_updater) { |x, &b| b.call(@secret+x) } # => 114
+sum # => 114
+<% end %>
+```
+
 [Here](https://github.com/JoshCheek/surrogate/blob/eb1d7f98a148c032f6d3ef1d8df8b703386f286d/lib/surrogate/options.rb#L32-34) is an example.
+Note that it is the old-style where users had to submit the class that could be bound to.
+
+## Possible advances in usefulness
+
+It just occurred to me that if we bound it to BasicObject
+then it could be used on any class without the user needing to
+specify which class they want to bind it to.
 
 ## Where the abstraction leaks
 

data/bindable_block.gemspec

@@ -4,7 +4,7 @@ require File.expand_path('../lib/bindable_block/version', __FILE__)
 Gem::Specification.new do |gem|
   gem.authors       = ["Josh Cheek"]
   gem.email         = ["josh.cheek@gmail.com"]
-  gem.description   = %q{instance_exec can't pass block arguments through. Use a bindable block instead.}
+  gem.description   = %q{instance_exec can't pass block arguments through. Use a bindable block instead (there is also an optional core extension instance_exec_b, which will mimic the instance_exec interface, but also allow you to pass the block).}
   gem.summary       = %q{Allows you to bind procs to instances of classes}
 
   gem.homepage      = "https://github.com/JoshCheek/bindable_block"
@@ -15,4 +15,8 @@ Gem::Specification.new do |gem|
   gem.name          = "bindable_block"
   gem.require_paths = ["lib"]
   gem.version       = BindableBlock::VERSION
+
+  gem.required_ruby_version = '~> 2.1'
+
+  gem.add_development_dependency 'rspec', '>= 3.0.0', '~> 3.0'
 end

data/lib/bindable_block.rb

@@ -1,69 +1,70 @@
 require "bindable_block/version"
+require 'bindable_block/bound_block'
 
-class BindableBlock
+class BindableBlock < Proc
 
   # match args to arity, since instance_method has lambda properties
-  class ArgAligner
-    def initialize(args, instance_method)
-      @result, @args, @parameters = [], args, instance_method.parameters.map(&:first)
-      take num :req
-      take [num(:opt), args.size].min
-      take args.size if has? :rest
-    end
-
-    def call
-      result
-    end
 
-    private
-
-    attr_reader :args, :parameters, :result
-
-    def has?(type)
-      parameters.any? { |param| param == type }
-    end
-
-    def num(type)
-      parameters.count { |param| param == type }
-    end
-
-    def take(n)
-      n.times { result << args.shift }
-    end
-  end
-
-
-  def initialize(klass, &block)
+  def initialize(klass=BasicObject, &block)
+    @klass           = klass
     @original_block  = block
-
-    klass.__send__ :define_method, method_name, &block
-    @instance_method = klass.instance_method method_name
-    klass.__send__ :remove_method, method_name
+    if curried_values = block.instance_variable_get(:@curried_values)
+      @original_block = curried_values[:original_block]
+      @curried_args   = curried_values[:curried_args]
+      @uncurried_size = curried_values[:uncurried_size]
+    end
+    @instance_method = block_to_method klass, @original_block
   end
 
-  attr_reader :instance_method, :original_block
-
   def bind(target)
-    Proc.new do |*args, &block|
-      instance_method.bind(target).call(*align(args), &block)
+    bound = BoundBlock.new @original_block, &@instance_method.bind(target)
+    if @curried_args then bound.curry(@uncurried_size)[*@curried_args]
+    else                  bound
     end
   end
 
   def call(*args, &block)
-    original_block.call(*args, &block)
+    @original_block.call(*args, &block)
   end
 
-  def to_proc
-    method(:call).to_proc
+  def arity
+    @original_block.arity
   end
 
-  private
-
-  def align(args)
-    ArgAligner.new(args, instance_method).call
+  def curry(arity=nil)
+    arity ||= @instance_method.parameters.count { |type, _| type == :req }
+    original_block     = @original_block # can't use the imeth, because it's unbound, so no curry
+    bindable_blk_class = self.class
+    klass              = @klass
+
+    proc_maker = lambda do |curried_args, uncurried_size|
+      p = Proc.new do |*args, &block|
+        actual_args = curried_args + args
+        if uncurried_size <= actual_args.size
+          original_block.call(*actual_args, &block)
+        else
+          curried = proc_maker.call actual_args, uncurried_size
+          bindable_blk_class.new klass, &curried
+        end
+      end
+      p.instance_variable_set :@curried_values, {
+        original_block: original_block,
+        curried_args:   curried_args,
+        uncurried_size: arity,
+      }
+      p
+    end
+    curried = proc_maker.call [], arity
+    BindableBlock.new klass, &curried
   end
 
-  def method_name
-    @method_name ||= "bindable_block_#{Time.now.to_i}_#{$$}_#{rand 1000000}"
+  private
+
+  def block_to_method(klass, block)
+    temp_method_name = "bindable_block_#{Time.now.to_i}_#{$$}_#{rand 1_000_0000}"
+    @klass.__send__(:define_method, temp_method_name, &block)
+    @klass.instance_method(temp_method_name)
+  ensure
+    @klass.__send__(:remove_method, temp_method_name)
   end
 end

data/lib/bindable_block/arg_aligner.rb

@@ -0,0 +1,30 @@
+class BindableBlock < Proc
+  class ArgAligner
+    def initialize(args, instance_method)
+      @result, @args, @parameters = [], args, instance_method.parameters.map(&:first)
+      take num :req
+      take [num(:opt), args.size].min
+      take args.size if has? :rest
+    end
+
+    def call
+      result
+    end
+
+    private
+
+    attr_reader :args, :parameters, :result
+
+    def has?(type)
+      parameters.any? { |param| param == type }
+    end
+
+    def num(type)
+      parameters.count { |param| param == type }
+    end
+
+    def take(n)
+      n.times { result << args.shift }
+    end
+  end
+end

data/lib/bindable_block/bound_block.rb

@@ -0,0 +1,61 @@
+require 'bindable_block/arg_aligner'
+
+class BindableBlock < Proc
+  class BoundBlock < Proc
+    def initialize(original_block, &method)
+      f, ln, *               = caller[2].split(':')
+      self.bound_file        = f
+      self.bound_line_number = ln.to_i
+      self.original_block    = original_block
+      self.method            = method
+    end
+
+    def call(*args, &block)
+      method.call(*align(args), &block)
+    end
+
+    def lambda?
+      original_block.lambda?
+    end
+
+    def bound_location
+      [bound_file.dup, bound_line_number]
+    end
+
+    def parameters
+      original_block.parameters
+    end
+
+    def inspect
+      original_block.to_s.gsub(/^#<\w*/, "#<#{self.class.name}")
+    end
+    alias to_s inspect
+
+
+    def binding
+      raise NotImplementedError, <<-SADFACE.gsub(/^\s*/, '')
+        I legit tried to figure this out, and can't :(
+
+        * Can't just ask, it's private on most objects
+        * Can't use `__send__` b/c it's like "the binding at the top of the callstack", which would not be the binding of the obj you're invoking it on
+        * Can't `instance_eval { binding }`, because BasicObject doesn't have a binding method
+        * Can't `Kernel.instance_method(:binding).bind(obj).instance_eval { binding }` because if obj is a BasicObject, then Kernel isn't an ancestor and thus won't bind to it
+        * Tried all manner of adding temp methods, subclassing the singleton class, etc. In the end, I think it's just not doable.
+
+        This is your friendly reminder that whatever you're using this method for is probably bullshit.
+      SADFACE
+    end
+
+    private
+
+    attr_accessor :bound_file, :bound_line_number, :original_block, :method
+
+    def align(args)
+      if original_block.lambda?
+        args
+      else
+        ArgAligner.new(args, method).call
+      end
+    end
+  end
+end

data/lib/bindable_block/instance_exec_b.rb

@@ -0,0 +1,16 @@
+require 'bindable_block'
+
+class BasicObject
+  def instance_exec_b(*args, argument_block, &instance_block)
+    if argument_block.nil?
+      instance_exec(*args, &instance_block)
+    elsif argument_block.respond_to?(:call) && argument_block.respond_to?(:to_proc)
+      ::BindableBlock
+        .new(self.singleton_class, &instance_block)
+        .bind(self)
+        .call(*args, &argument_block)
+    else
+      ::Kernel.raise ::ArgumentError, "Last argument to instance_exec_b must be blocky (respond to #call and #to_proc), or nil"
+    end
+  end
+end

data/lib/bindable_block/version.rb

@@ -1,3 +1,3 @@
-class BindableBlock
-  VERSION = "0.0.5.1"
+class BindableBlock < Proc
+  VERSION = "0.0.7"
 end

data/spec/bindable_block_spec.rb

@@ -1,101 +1,401 @@
 require 'bindable_block'
 
+# TODO: when created with a lambda, args should match like lambda args
+
 describe BindableBlock do
+  let(:name)         { 'Unbound Name' }
   let(:default_name) { "Carmen" }
   let(:klass)        { Struct.new :name }
   let(:instance)     { klass.new default_name }
 
-  it 'can be bound to instances of the target' do
-    block = BindableBlock.new(klass) { self }
-    block.bind(instance).call.should equal instance
+  # minitest style, b/c otherwise the levels of things being passed around gets to be a bit much
+  def assert_equal(a, b)
+    expect(b).to eq a
   end
-
-  it 'can be rebound' do
-    block = BindableBlock.new(klass) { name }
-    block.bind(klass.new 'Josh').call.should == 'Josh'
-    block.bind(klass.new 'Mei').call.should == 'Mei'
+  def assert_same(a, b)
+    expect(b).to equal a
+  end
+  def assert(val)
+    expect(val).to be_truthy
   end
+  def refute(val)
+    expect(val).to_not be_truthy
+  end
+
+
+  describe 'binding' do
+    it 'can be bound to any object' do
+      block = BindableBlock.new { self }
+      assert_same block.bind(instance).call, instance
+    end
+
+    it 'can be bound to a BasicObject' do
+      o = BasicObject.new
+      o.instance_eval { @a = 1 }
+      assert_equal 1, BindableBlock.new { @a }.bind(o).call
+    end
+
+    it 'can be rebound' do
+      block = BindableBlock.new { name }
+      assert_equal 'Josh', block.bind(klass.new 'Josh').call
+      assert_equal 'Mei',  block.bind(klass.new 'Mei').call
+    end
+
+    it 'can be rebound to instances of different classes' do
+      klass1 = Class.new { def m; 1; end }
+      klass2 = Class.new { def m; 2; end }
+      block  = BindableBlock.new { m }
+      assert_equal 1, block.bind(klass1.new).call
+      assert_equal 2, block.bind(klass2.new).call
+    end
 
-  it 'can also just be invoked without being bound' do
-    def self.a() 1 end
-    b = 2
-    block = BindableBlock.new(klass) { |c, &d| a + b + c + d.call }
-    block.call(3){4}.should == 10
+    it 'can scope the class of objects it can be bound to' do
+      klass1 = Class.new
+      klass2 = Class.new
+      block = BindableBlock.new(klass1) {}
+      block.bind(klass1.new).call
+      expect { block.bind(klass2.new).call }.to raise_error TypeError, /instance of/
+    end
   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
-
-    # sadly this part doesn't work, I think it unwraps the block from the proc, then re-wraps it in a new one, losing the singleton method
-    # binder = lambda { |&block| block.bind(instance).call }
-    # binder.call(&BindableBlock.new(klass) { name }).should == default_name
-    #
-    # This was my attempted to_proc implementation
-    # bindable_block = self
-    # proc = method(:call).to_proc
-    # proc.define_singleton_method(:bind) { |target| bindable_block.bind target }
-    # proc
+  describe 'as a block' do
+    it 'can be passed in the block slot to methods and shit' do
+      doubler = lambda { |&block| block.call + '!' }
+      assert_equal 'Unbound Name!', doubler.call(&BindableBlock.new { name })
+      assert_equal 'Carmen!',       doubler.call(&BindableBlock.new { name }.bind(instance))
+    end
+
+    it 'can be invoked without being bound, in which case self is that of the scope it was defined in' do
+      def self.a() 1 end
+      @b = 2
+      c = 3
+      block = BindableBlock.new { |d, &e| a + @b + c + d + e.call }
+      assert_equal 15, block.call(4){5}
+    end
+
+    it 'retains it\'s bindability after being passed through a method' do
+      block = BindableBlock.new { name }
+      def m(&bindable_block)
+        bindable_block.bind(instance).call
+      end
+      assert_equal default_name, m(&block)
+    end
+
+    it 'has a #bound_location to complement #source_location' do
+      unbound = BindableBlock.new { }
+      bound   = unbound.bind(instance)
+      assert_equal bound.bound_location, [__FILE__, __LINE__-1]
+    end
+
+    specify '#bound_location isn\'t susceptible to mutation of returned value' do
+      bound = BindableBlock.new { }.bind(instance)
+      bound.bound_location.first.replace ""  # mutate the string
+      bound.bound_location.replace []        # mutate the array
+      assert_equal bound.bound_location, [__FILE__, __LINE__-3]
+    end
+
+    context 'Proc instance methods' do
+      let(:args_and_name) { BindableBlock.new { |arg| [arg, name] } }
+
+      example '#[]' do
+        assert_equal [1, 'Unbound Name'], args_and_name[1]
+        assert_equal [1, 'Carmen'],       args_and_name.bind(instance)[1]
+      end
+
+      example '#===' do
+        assert_equal [1, 'Unbound Name'], args_and_name === 1
+        assert_equal [1, 'Carmen'],       args_and_name.bind(instance) === 1
+      end
+
+      example '#yield' do
+        assert_equal [1, 'Unbound Name'], args_and_name.yield(1)
+        assert_equal [1, 'Carmen'],       args_and_name.bind(instance).yield(1)
+      end
+
+      example '#arity' do
+        p = Proc.new { |a, b, c=1, d=2, *e, f| [a,b,c,d,e,f] }
+        b = BindableBlock.new(&p)
+        assert_equal p.arity, b.arity
+        assert_equal p.arity, b.bind(instance).arity
+
+        l = Proc.new { |a, b, c=1, d=2, *e, f| [a,b,c,d,e,f] }
+        b = BindableBlock.new(&l)
+        assert_equal l.arity, b.arity
+        assert_equal l.arity, b.bind(instance).arity
+      end
+
+      example '#binding' do
+        a = 1
+        b = BindableBlock.new { }
+
+        assert_equal 1,        b.binding.eval('a')
+        assert_equal self,     b.binding.eval('self')
+
+        pending "If anyone can solve this, I'll be so impressed"
+        assert_equal 1,        b.bind(instance).binding.eval('a')
+        assert_equal instance, b.bind(instance).binding.eval('self')
+      end
+
+      example '#clone' do
+        assert_equal [1, 'Unbound Name'], args_and_name.clone.call(1)
+        assert_equal [1, 'Carmen'],       args_and_name.bind(instance).clone.call(1)
+      end
+
+      example '#dup' do
+        assert_equal [1, 'Unbound Name'], args_and_name.dup.call(1)
+        assert_equal [1, 'Carmen'],       args_and_name.bind(instance).dup.call(1)
+      end
+
+      example '#curry without being bound' do
+        b    = BindableBlock.new { |a, b, c, &d| [a, b, c, d.call, name] }
+        four = lambda { 4 }
+
+        assert_equal [1, 2, 3, 4, 'Unbound Name'], b.curry[1, 2, 3, &four]
+        assert_equal [1, 2, 3, 4, 'Unbound Name'], b.curry[1][2][3, &four]
+        assert_equal [1, 2, 3, 4, 'Unbound Name'], b.curry[1, 2][3, &four]
+      end
+
+      example '#curry after being bound' do
+        b    = BindableBlock.new { |a, b, c, &d| [a, b, c, d.call, name] }.bind(instance)
+        four = lambda { 4 }
+        assert_equal [1, 2, 3, 4, 'Carmen'], b.curry[1][2][3, &four]
+        assert_equal [1, 2, 3, 4, 'Carmen'], b.curry[1, 2][3, &four]
+      end
+
+      example '#curry before being bound' do
+        b = BindableBlock.new { |a, b, c, &d| [a, b, c, d.call, name] }
+        four = lambda { 4 }
+        assert_equal [1, 2, 3, 4, 'Carmen'], b.curry[1].bind(instance).curry[2][3, &four]
+        assert_equal [1, 2, 3, 4, 'Carmen'], b.curry[1, 2].bind(instance).curry[3, &four]
+        assert_equal [1, 2, 3, 4, 'Carmen'], b.curry[1][2].bind(instance).curry[3, &four]
+        assert_equal [1, 2, 3, 4, 'Carmen'], b.curry[1][2].bind(instance).curry[3, &four]
+      end
+
+      example '#hash' do
+        raise pending 'punting on this, b/c I really don\'t know what it should do here'
+      end
+
+      example '#lambda?' do
+        refute BindableBlock.new {}.lambda?
+        refute BindableBlock.new {}.bind(instance).lambda?
+
+        assert BindableBlock.new(&lambda {}).lambda?
+        assert BindableBlock.new(&lambda {}).bind(instance).lambda?
+      end
+
+      example '#parameters' do
+        b = BindableBlock.new { |a, b=1, *c, d, e:, **f, &g| }
+        assert_equal [[:opt, :a], [:opt, :b], [:rest, :c], [:opt, :d], [:keyreq, :e], [:keyrest, :f], [:block, :g]], b.parameters
+        assert_equal [[:opt, :a], [:opt, :b], [:rest, :c], [:opt, :d], [:keyreq, :e], [:keyrest, :f], [:block, :g]], b.bind(instance).parameters
+
+        b = BindableBlock.new(&lambda { |a, b=1, *c, d, e:, **f, &g| })
+        assert_equal [[:req, :a], [:opt, :b], [:rest, :c], [:req, :d], [:keyreq, :e], [:keyrest, :f], [:block, :g]], b.parameters
+        assert_equal [[:req, :a], [:opt, :b], [:rest, :c], [:req, :d], [:keyreq, :e], [:keyrest, :f], [:block, :g]], b.bind(instance).parameters
+      end
+
+      example '#source_location' do
+        b, f, l = BindableBlock.new { }, __FILE__, __LINE__
+        assert_equal [f, l], b.source_location
+        assert_equal [f, l], b.bind(instance).source_location
+      end
+
+      example '#to_proc' do
+        unbound = BindableBlock.new {}
+        assert_same unbound, unbound.to_proc
+
+        bound = unbound.bind(instance)
+        assert_same bound, bound.to_proc
+      end
+
+      example '#to_s and #inspect have the source file and line' do
+        # proc
+        unbound, f, l = BindableBlock.new {}, __FILE__, __LINE__
+        expect(unbound.to_s).to include "#{f}:#{l}"
+        expect(unbound.to_s).to include "BindableBlock"
+
+        bound = unbound.bind(instance)
+        expect(bound.to_s).to include "#{f}:#{l}"
+        expect(bound.to_s).to include "BindableBlock::BoundBlock"
+
+        # lambda
+        unbound, f, l = BindableBlock.new(&lambda {}), __FILE__, __LINE__
+        expect(unbound.to_s).to include "#{f}:#{l}"
+        expect(unbound.to_s).to include "BindableBlock"
+
+        bound = unbound.bind(instance)
+        expect(bound.to_s).to include "#{f}:#{l}"
+        expect(bound.to_s).to include "BindableBlock::BoundBlock"
+      end
+
+      specify '#to_s and #inspect should not have lambda in them' do
+        # proc
+        unbound = BindableBlock.new {}
+        expect(unbound.to_s).to_not include 'lambda'
+        expect(unbound.inspect).to_not include 'lambda'
+
+        bound = unbound.bind instance
+        expect(bound.to_s).to_not include 'lambda'
+        expect(bound.inspect).to_not include 'lambda'
+
+        # lambda
+        unbound = BindableBlock.new(&lambda {})
+        expect(unbound.to_s).to include 'lambda'
+        expect(unbound.inspect).to include 'lambda'
+
+        bound = unbound.bind instance
+        expect(bound.to_s).to include 'lambda'
+        expect(bound.inspect).to include 'lambda'
+      end
+    end
   end
 
+
   describe 'arguments' do
+    def assert_same_error(b1, b2)
+      e1 = b1.call rescue $!
+      e2 = b2.call rescue $!
+      expect(e1).to be_an Exception
+      expect(e2).to be_an Exception
+      assert_equal e1.class,   e2.class
+      assert_equal e1.message, e2.message
+    end
+
+    it 'matches them lambda-style if initialized with a lambda' do
+      l     = lambda { |a| a }
+      block = BindableBlock.new(&l)
+      assert_equal 1, block.call(1)
+      assert_equal 1, block.bind(instance).call(1)
+      assert_same_error lambda { block.call                     }, lambda { l.call      }
+      assert_same_error lambda { block.call 1, 2                }, lambda { l.call 1, 2 }
+      assert_same_error lambda { block.bind(instance).call      }, lambda { l.call      }
+      assert_same_error lambda { block.bind(instance).call 1, 2 }, lambda { l.call 1, 2 }
+    end
+
+    it 'matches them proc-style if initialized with a proc' do
+      p     = Proc.new { |a| a }
+      block = BindableBlock.new(&p)
+      assert_equal 1,            block.call(1)
+      assert_equal p.call,       block.call
+      assert_equal p.call(1),    block.call(1)
+      assert_equal p.call(1, 2), block.call(1, 2)
+
+      assert_equal 1,            block.bind(instance).call(1)
+      assert_equal p.call,       block.bind(instance).call
+      assert_equal p.call(1),    block.bind(instance).call(1)
+      assert_equal p.call(1, 2), block.bind(instance).call(1, 2)
+    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]
+      block = BindableBlock.new { |a, &b| [a, (b&&b.call)] }.bind(instance)
+      assert_equal [1, nil], block.call(1)
+      assert_equal [1, 2],   block.call(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]
+      block = BindableBlock.new { |a| [a] }.bind(instance)
+      assert_equal [nil], block.call
+      assert_equal [1],   block.call(1)
+      assert_equal [1],   block.call(1, 2)
     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]
+      block = BindableBlock.new { |a, b=1, c=2| [a, b, c] }.bind(instance)
+      assert_equal [nil, 1, 2]  , block.call
+      assert_equal [:a, 1, 2]   , block.call(:a)
+      assert_equal [:a, :b, 2]  , block.call(:a, :b)
+      assert_equal [:a, :b, :c] , block.call(:a, :b, :c)
+      assert_equal [:a, :b, :c] , block.call(:a, :b, :c, :d)
     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]]
+      block = BindableBlock.new { |a, *rest| [a, rest] }.bind(instance)
+      assert_equal [nil, []]   , block.call
+      assert_equal [1, []]     , block.call(1)
+      assert_equal [1, [2]]    , block.call(1, 2)
+      assert_equal [1, [2, 3]] , block.call(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 { |*a, b, &c| [a, b] }.bind(instance)
+      assert_equal [[], nil]   , block.call
+      assert_equal [[], 1]     , block.call(1)
+      assert_equal [[1], 2]    , block.call(1,2)
+      assert_equal [[1, 2], 3] , block.call(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]
+      block = BindableBlock.new { |a=:a, b, c| [a, b, c] }.bind(instance)
+      assert_equal [:a, nil, nil] , block.call
+      assert_equal [:a, 1, nil]   , block.call(1)
+      assert_equal [:a, 1, 2]     , block.call(1, 2)
+      assert_equal [1, 2, 3]      , block.call(1, 2, 3)
+      assert_equal [1, 2, 3]      , block.call(1, 2, 3, 4)
     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)
+      block = BindableBlock.new(&proc).bind(instance)
+      assert_equal proc.call                       , block.call
+      assert_equal proc.call(:a)                   , block.call(:a)
+      assert_equal proc.call(:a,:b)                , block.call(:a,:b)
+      assert_equal proc.call(:a,:b,:c)             , block.call(:a,:b,:c)
+      assert_equal proc.call(:a,:b,:c,:d)          , block.call(:a,:b,:c,:d)
+      assert_equal proc.call(:a,:b,:c,:d,:e)       , block.call(:a,:b,:c,:d,:e)
+      assert_equal proc.call(:a,:b,:c,:d,:e,:f)    , block.call(:a,:b,:c,:d,:e,:f)
+      assert_equal proc.call(:a,:b,:c,:d,:e,:f,:g) , block.call(:a,:b,:c,:d,:e,:f,:g)
+    end
+  end
+
+  describe 'instance_exec_b' do
+    it 'is only available if you require the file explicitly, since it monkey patches BasicObject' do
+      expect { method :instance_exec_b }.to raise_error NameError
+      require 'bindable_block/instance_exec_b'
+      method :instance_exec_b
+    end
+
+    it 'is on wherever instance_exec is on (BasicObject)' do
+      expect(method(:instance_exec_b).owner).to equal method(:instance_exec).owner
+    end
+
+    it 'provides an instance_exec like method, whose last argument is a block' do
+      a, b = 1, 2
+      result = instance.instance_exec_b(a, lambda { b }) { |ordinal, &block| "#{name}#{ordinal}#{block.call}" }
+      assert_equal "Carmen12", result
+    end
+
+    it 'passes no block if the last param is nil'  do
+      a, b = 1, 2
+      result = instance.instance_exec_b(a, nil) { |ordinal, &block| "#{name}#{ordinal}#{!!block}" }
+      assert_equal "Carmen1false", result
+    end
+
+    it 'the block can be blocky things (can be called and put into the block slot), otherwise raises an ArgumentError' do
+      expect { instance.instance_exec_b(1) { |*| } }.to raise_error ArgumentError, /block/
+      expect { instance.instance_exec_b(1, :abc) { |*| } }.to raise_error ArgumentError, /block/ # has to_proc, but not call
+      o = Object.new
+      def o.call(*)
+        2
+      end
+      expect { instance.instance_exec_b(1, o) { |*| } }.to raise_error ArgumentError, /block/ # has call, but not to_proc
+      def o.to_proc
+        Proc.new { 3 }
+      end
+      assert_equal 4, instance.instance_exec_b(1, o) { |n, &b| n + b.call }
+    end
+
+    it 'doesn\'t need ordinal args' do
+      assert instance.instance_exec_b(lambda {}) { |&block| !!block }
+      refute instance.instance_exec_b(nil)       { |&block| !!block }
+    end
+
+    it 'Doesn\'t define methods on the class' do
+      class BasicObject
+        old_method_added = singleton_class.method(:method_added)
+        def self.method_added(method_name)
+          raise "METHOD ADDED: #{method_name}"
+        end
+        instance_exec_b(lambda {}) { }
+        define_singleton_method(:method_added, &old_method_added)
+      end
     end
   end
 end

metadata

@@ -1,57 +1,78 @@
 --- !ruby/object:Gem::Specification
 name: bindable_block
 version: !ruby/object:Gem::Version
-  version: 0.0.5.1
-  prerelease: 
+  version: 0.0.7
 platform: ruby
 authors:
 - Josh Cheek
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-18 00:00:00.000000000 Z
-dependencies: []
+date: 2014-07-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 description: instance_exec can't pass block arguments through. Use a bindable block
-  instead.
+  instead (there is also an optional core extension instance_exec_b, which will mimic
+  the instance_exec interface, but also allow you to pass the block).
 email:
 - josh.cheek@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
 - Gemfile
 - LICENSE
 - README.md
 - README.mountain_berry_fields.md
-- Rakefile
 - bindable_block.gemspec
 - lib/bindable_block.rb
+- lib/bindable_block/arg_aligner.rb
+- lib/bindable_block/bound_block.rb
+- lib/bindable_block/instance_exec_b.rb
 - lib/bindable_block/version.rb
 - spec/bindable_block_spec.rb
 homepage: https://github.com/JoshCheek/bindable_block
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - "~>"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.11
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Allows you to bind procs to instances of classes
 test_files:
 - spec/bindable_block_spec.rb

data/Rakefile

@@ -1,2 +0,0 @@
-#!/usr/bin/env rake
-require "bundler/gem_tasks"