È possibile codice di valutazione nel contesto di un chiamante in Ruby?

Question

In sostanza mi chiedo se the following può essere fatto in Ruby.

Così, per esempio:

def bar(symbol) 
    # magic code goes here, it outputs "a = 100" 
end 

def foo 
    a = 100 
    bar(:a) 
end 

Answer 1

Non v'è alcun incorporato in modo da far legare i chiamanti ing in Ruby in 1.8.X o 1.9.X.

È possibile utilizzare https://github.com/banister/binding_of_caller per aggirare.

In risonanza magnetica 2.0 è possibile utilizzare RubyVM :: DebugInspector, vedi: campione Lavorare https://github.com/banister/binding_of_caller/blob/master/lib/binding_of_caller/mri2.rb

in MRI 2.0:

require 'debug_inspector' 

def bar(symbol) 
    RubyVM::DebugInspector.open do |inspector| 
    val = eval(symbol.to_s, inspector.frame_binding(2)) 
    puts "#{symbol}: #{val}" 
    end 
end 

def foo 
    a = 100 
    bar(:a) 
end 

foo 
# a: 100 

Answer 2

check out articolo Variable Bindings in Ruby

class Reference 
    def initialize(var_name, vars) 
    @getter = eval "lambda { #{var_name} }", vars 
    @setter = eval "lambda { |v| #{var_name} = v }", vars 
    end 
    def value 
    @getter.call 
    end 
    def value=(new_value) 
    @setter.call(new_value) 
    end 
end 

def ref(&block) 
    Reference.new(block.call, block.binding) 
end 

def bar(ref) 
    # magic code goes here, it outputs "a = 100" 
    p ref.value 
end 

def foo 
    a = 100 
    bar(ref{:a}) 
end 

foo 

Answer 3

Devi passare foo 's contesto bar:

def foo 
    a = 100 
    bar(:a, binding) 
end 
def bar(sym, b) 
    puts "#{sym} is #{eval(sym.to_s, b)}" 
end 

Answer 4

Proprio A proposito, ecco un "modo hacky". Questa è la mia (ri) attuazione ppp.rb noto:.

#!/usr/bin/ruby 
# 
# better ppp.rb 
# 

require 'continuation' if RUBY_VERSION >= '1.9.0' 

def ppp(*sym) 
    cc = nil 
    ok = false 

    set_trace_func lambda {|event, file, lineno, id, binding, klass| 
    if ok 
     set_trace_func nil 
     cc.call(binding) 
    else 
     ok = event == "return" 
    end 
    } 
    return unless bb = callcc{|c| cc = c; nil } 

    sym.map{|s| v = eval(s.to_s, bb); puts "#{s.inspect} = #{v}"; v } 
end 

a = 1 
s = "hello" 
ppp :a, :s 

exit 0 

Questo attualmente non riesce e 1.9 [012] a causa di un bug in set_trace_func di Ruby.

Answer 5

Ecco un hack sintassi più semplice, con un passato nel blocco vincolante:

def loginfo &block 
    what = yield.to_s 
    evaled = eval(what, block.binding) 
    Rails.logger.info "#{what} = #{evaled.inspect}" 
    end 

chiamati in questo modo:

x = 1 
    loginfo{ :x } 

sarà disconnettersi:

x = 1