¿Cómo puedo llamar a un Proc que toma un bloque en un contexto diferente?

Question

Tome este ejemplo Proc:

proc = Proc.new {|x,y,&block| block.call(x,y,self.instance_method)} 

Se toma dos argumentos, x e y, y también un bloque.

Quiero ejecutar ese bloque usando diferentes valores para mí mismo. Algo así casi funciona:

some_object.instance_exec("x arg", "y arg", &proc) 

Sin embargo, eso no le permite pasar en un bloque. Esto también no funciona

some_object.instance_exec("x arg", "y arg", another_proc, &proc) 

tampoco

some_object.instance_exec("x arg", "y arg", &another_proc, &proc) 

No estoy seguro de qué otra cosa podría trabajar aquí. ¿Es esto posible y, de ser así, cómo lo haces?

Editar: Básicamente si puede obtener este archivo rspec para pasar cambiando el método change_scope_of_proc, ha resuelto mi problema.

require 'rspec' 

class SomeClass 
    def instance_method(x) 
    "Hello #{x}" 
    end 
end 

class AnotherClass 
    def instance_method(x) 
    "Goodbye #{x}" 
    end 

    def make_proc 
    Proc.new do |x, &block| 
     instance_method(block.call(x)) 
    end 
    end 
end 

def change_scope_of_proc(new_self, proc) 
    # TODO fix me!!! 
    proc 
end 

describe "change_scope_of_proc" do 
    it "should change the instance method that is called" do 
    some_class = SomeClass.new 
    another_class = AnotherClass.new 
    proc = another_class.make_proc 
    fixed_proc = change_scope_of_proc(some_class, proc) 
    result = fixed_proc.call("Wor") do |x| 
     "#{x}ld" 
    end 

    result.should == "Hello World" 
    end 
end 

Answer 1

Para solucionar esto, debe volver a vincular el Proc a la nueva clase.

Aquí es su solución, aprovechando un buen código de Rails core_ext:

require 'rspec' 

# Same as original post 

class SomeClass 
    def instance_method(x) 
    "Hello #{x}" 
    end 
end 

# Same as original post 

class AnotherClass 
    def instance_method(x) 
    "Goodbye #{x}" 
    end 

    def make_proc 
    Proc.new do |x, &block| 
     instance_method(block.call(x)) 
    end 
    end 
end 

### SOLUTION ### 

# From activesupport lib/active_support/core_ext/kernel/singleton_class.rb 

module Kernel 
    # Returns the object's singleton class. 
    def singleton_class 
    class << self 
     self 
    end 
    end unless respond_to?(:singleton_class) # exists in 1.9.2 

    # class_eval on an object acts like singleton_class.class_eval. 
    def class_eval(*args, &block) 
    singleton_class.class_eval(*args, &block) 
    end 
end 

# From activesupport lib/active_support/core_ext/proc.rb 

class ProC#:nodoc: 
    def bind(object) 
    block, time = self, Time.now 
    object.class_eval do 
     method_name = "__bind_#{time.to_i}_#{time.usec}" 
     define_method(method_name, &block) 
     method = instance_method(method_name) 
     remove_method(method_name) 
     method 
    end.bind(object) 
    end 
end 

# Here's the method you requested 

def change_scope_of_proc(new_self, proc) 
    return proc.bind(new_self) 
end 

# Same as original post 

describe "change_scope_of_proc" do 
    it "should change the instance method that is called" do 
    some_class = SomeClass.new 
    another_class = AnotherClass.new 
    proc = another_class.make_proc 
    fixed_proc = change_scope_of_proc(some_class, proc) 
    result = fixed_proc.call("Wor") do |x| 
     "#{x}ld" 
    end 
    result.should == "Hello World" 
    end 
end 

Answer 2

No creo que pueda hacer esto, y el problema no está en pasar varios bloques. Proc y bloques son cierres y capturan sus enlaces en el punto de creación. self es parte de esa unión, por lo que incluso si cambia uno mismo con instance_eval, cuando call el proc/Bloque se ejecuta en su unión, con el yo que se cerró sobre: ​​

$ irb 
irb(main):001:0> class Foo; def mkproc; Proc.new { puts "#{self.class}:#{object_id}" }; end; end 
=> nil 
irb(main):002:0> p = Foo.new.mkproc 
=> #<Proc:0x00000001b04338@(irb):1> 
irb(main):003:0> p.call 
Foo:14164520 
=> nil 
irb(main):004:0> 'bar'.instance_exec { puts "#{self.class}:#{object_id}"; p.call } 
String:16299940 
Foo:14164520 

Ruby que le permite capturar un cierre de Binding con Kernel#binding, pero no ofrece ninguna forma de establecer el enlace asociado con un Proc. Puede especificar un enlace para la versión de cadena de Kernel#eval, pero eso aún no le permite cambiar el enlace de un proceso al que llame.

irb(main):005:0> class BindMe; def get_binding(p=nil); binding; end; end 
=> nil 
irb(main):006:0> b = BindMe.new.get_binding(p) 
=> #<Binding:0x00000001f58e48> 
irb(main):007:0> eval '"#{self.class}:#{object_id}"', b 
=> "BindMe:14098300" 
irb(main):008:0> eval '"#{self.class}:#{object_id}"', p.binding 
=> "Foo:14164520" 
irb(main):009:0> eval "p.call", b 
Foo:14164520