Guardar y reutilizar el bloque para llamadas a métodos

Question

Llamo al método RestClient::Resource#get(additional_headers = {}, &block) varias veces con el mismo bloque pero en Recursos diferentes, me preguntaba si hay una forma de guardar el bloque en una variable o guardarlo en un Proc lo convierte en un bloque cada vez.

Editar:

hice lo siguiente:

resource = RestClient::Resource.new('https://foo.com') 
redirect = lambda do |response, request, result, &block| 
    if [301, 302, 307].include? response.code 
    response.follow_redirection(request, result, &block) 
    else 
     response.return!(request, result, &block) 
    end 
end 
@resp = resource.get (&redirect) 

me sale: Syntax error, unexpected tAMPER

Answer 1

foo = lambda do |a,b,c| 
    # your code here 
end 

bar.get(&foo) 
jim.get(&foo) 
jam.get(&foo) 

La colocación de un símbolo de unión frente a un elemento de una llamada a un método, por ejemplo, a.map!(&:to_i) llama al método to_proc en ese objeto y pasa el proceso resultante como un bloque. Algunas formas alternativas de la definición de su reutilizable bloque:

foo = Proc.new{ |a,b,c| ... } 
foo = proc{ |a,b,c| ... } 
foo = ->(a,b,c){ ... } 

Si está llamando a un método con un bloque y que desea guardar que bloque para su reutilización posterior, puede hacerlo mediante el uso de un signo en la definición del método para capturar el bloque como parámetro proc:

class DoMany 
    def initialize(*items,&block) 
    @a = items 
    @b = block # don't use an ampersand here 
    end 
    def do_first 
    # Invoke the saved proc directly 
    @b.call(@a.first) 
    end 
    def do_each 
    # Pass the saved proc as a block 
    @a.each(&@b) 
    end 
end 

d = DoMany.new("Bob","Doug"){ |item| puts "Hello, #{item}!" } 

d.do_first 
#=> Hello, Bob! 

d.do_each 
#=> Hello, Bob! 
#=> Hello, Doug!