Asi se pueden hacer cosas bastante interesantes ejecutando codigo ingresado dinamicamente ^_^
No obstante es necesario conocer como sortear determinados obstaculos en la ejecucion de codigo dinamico
class Runner
def run(code)
eval(code)
end
end
runner = Runner.new
# ¡¡FAIL!! :(, no se puede definir classes desde adentro de un metodo (Runner#run)
runner.run("
class X
def foo
print \"hello world\n\"
end
end
x = X.new
x.foo
")
Lo que se intento hacer en el ejemplo anterior, para el interprete es equivalente a:
class Runner
def run(code)
# いけない！!!
# en ruby no esta permitido definir clases adentro de metodos
# (aunque si permite hacer otras cosas locas XD )
class X
def foo
print \"hello world\n\"
end
end
x = X.new
x.foo
end
end
Para poder hacerlo correctamente hay que pasarle un segundo parametro a eval que es el "binding", un binding representa el contexto en ruby de donde se llama el binding, que incluye las variables locales, etc... mejor verlo en el ejemplo que explicarlo:
class Runner
class << self
attr_accessor :runner_binding
end
def run(code)
# se especifica un binding al eval para definir el contexto
# en el que se ejecuta el codigo
eval(code, Runner.runner_binding)
end
end
# se copia el binding del contexto actual (fuera de cualquier clase o metodo)
Runner.runner_binding = binding
runner = Runner.new
# se puede definir clases en el codigo pasado a eval, porque el binding
# esta afuera de cualquier declaracion de clase o metodo y el eval se
# llama con ese binding
runner.run("
class X
def foo
print \"hello world\n\"
end
end
x = X.new
x.foo
")
Que para el interprete es lo mismo que reemplazar el codigo en donde se llama a binding en lugar de en donde se llama a eval:
class Runner
class << self
attr_accessor :runner_binding
end
def run(code)
# se especifica un binding al eval para definir el contexto
# en el que se ejecuta el codigo
eval(code, Runner.runner_binding)
end
end
# よろしい
# Runner.runner_binding = binding
class X
def foo
print \"hello world\n\"
end
end
x = X.new
x.foo
Y ya que estamos, les cuento que otra cosa tiene el eval para hacer
def bar
1/0 # ZeroDivisionError
end
def foo(code) # ¿porque siempre foo?
eval(code)
end
foo("bar") #
Resultado:
test.rb:6:in `foo': test.rb:2:in `/': divided by 0 (ZeroDivisionError)
from test.rb:2:in `bar'
from (eval):1:in `foo'
from test.rb:9:in `eval'
from test.rb:6:in `foo'
from test.rb:9
Mejor, pasarle unos argumentos adicionales a eval especificando el "archivo" y el numero de linea de donde viene el codigo evaluado
def bar
1/0 # ZeroDivisionError
end
def foo(code) # ¿porque siempre foo?
eval(code, binding, "foo_eval.rb", 1)
end
foo("bar") #
Resultado:
test.rb:2:in `/': divided by 0 (ZeroDivisionError)
from test.rb:2:in `bar'
from foo_eval.rb:1:in `foo'
from test.rb:6:in `foo'
from test.rb:9
Ahora se puede ver mejor en el backtrace de donde viene el codigo, con esto mejorada la trazabilidad cuando se usa eval.
