Is there some sort of ‘python -i’ equivalent for ruby or irb? I can’t
seem to find it. I know you can ‘load’ or ‘require’ a module, but I need
to load the file into the current scope. Currently all I seem to be able
to do is either code and run file, or copy and paste into irb if I
wanted the ‘-i’ functionality. I’d really like to “enter interactive
mode after executing the script or the command” as the python man page
puts it. It’ll be enormously useful for testing and stuff. Sorry if it’s
a rather n00b or repeated question, I couldn’t search since the function
is “disabled due to technical problems”.
As mentioned you can use breakpoint (excellect tool) and irb -r, also
don’t forget you can use require and/or load from within irb as well
to load (and execute) a script.
eval() won’t create local variables - it will update one if it already
exists however:
$ cat eval-test.rb
a = 42
$ cat eval-scope.rb
eval(File.read(“eval-test.rb”))
p a
$ ruby eval-scope.rb
eval-scope.rb:2: undefined local variable or method `a’ for
main:Object (NameError)
$ cat eval-scope2.rb
a = nil
eval(File.read(“eval-test.rb”))
p a
$ ruby eval-scope2.rb
42
I think he wants to be able to have a file with abc=4 in it, and then be
able to load the file and have the local variable abc be in scope.
Neither of these solutions do that.
eval-scope.rb:2: undefined local variable or method `a’ for
Regards,
hi
You’re right - another one of those little quirks of irb
(I’m too abashed to admit I missed the point)
Regards,
Sean
It’s not really a little quirk of irb, it’s the same quirk you
noted of eval (Since irb uses #eval to well, evaluate ).
e.g.:
% cat demo_eval.rb
puts eval(“x = 1”)
puts begin
x
rescue
“At parse time, x has not been declared as a local variable (by
assigning to it.)\n” +
“This means it will raise an exception when it gets evaluated here.”
end
puts eval(“x”) # But x does indeed exist.
% ruby demo_eval.rb
1
At parse time, x has not been declared as a local variable (by
assigning to it.)
This means it will raise an exception when it gets evaluated here.
1
eval(File.read(‘blah.rb’)) in irb does the trick! Though it is rather a
quirky way things are handled:) I’ve moved over from python and I’m
wondering how people do without this simple feature? I find it
invaluable in test-running my app since I can run it as a whole, still
inspect things, and modify things live as the app is being run. The
alternative to use irb as interactive ruby is great, but it doesn’t
allow me to import existing code easily (until now:) and I must retype
everything if I wanted to test it. It’s not necessarily for debugging an
app (ruby’s got a cool debugger for that:), but testing out features and
functions interactively (what an interactive shell prompt allows us to
do) without having to retype everything into irb. What do you guys use
normally for something like this?
I think ruby/irb -r debug also works but how do I get it to stop
executing after the last line? I can’t quite set a breakpoint there.
Will have a look at ruby-breakpoint too thanks!
~dingsi
eval(File.read(“eval-test.rb”))
42
a = 1
Which I think will work for what the OP wanted?
rescue
At parse time, x has not been declared as a local variable (by
assigning to it.)
This means it will raise an exception when it gets evaluated here.
1
It’s even quirkier than that even
(ruby-talk 202571)
puts eval(“x = 1”)
puts begin
x
rescue
“At parse time, x has not been declared as a local variable (by
assigning to it.)\n” +
“This means it will raise an exception when it gets evaluated here.”
end
puts “But x does indeed exist.”
puts eval(“x”)
begin
puts x
rescue
puts “or does it?”
end
p local_variables END
1
At parse time, x has not been declared as a local variable (by
assigning to it.)
This means it will raise an exception when it gets evaluated here.
1
or does it?
[“x”]
My point was that eval won’t introduce local variables into the
current scope (which irb does because of the tricks it plays with
bindings). It appears that when eval is called without a binding, it
temporarily pushes the current frame, re-uses the binding in effect
when the eval was called, then pops the current frame back again which
I guess has the effect of erasing changes to local variables (but
someone should tell the local_variables method!). This creates the
effect of a kind of binding that persists between calls to eval but
which is inaccessible to the local scope (except via eval). At least,
that’s how it seems to me. I’d be grateful for a definitive
explanation of what’s going on in eval.c:6500ff.
Regards,
Sean
This forum is not affiliated to the Ruby language, Ruby on Rails framework, nor any Ruby applications discussed here.
