IRB stands for “interactive Ruby” and is a tool to interactively execute Ruby expressions read from the standard input.
The irb
command from your shell will start the interpreter.
Use of irb is easy if you know Ruby.
When executing irb, prompts are displayed as follows. Then, enter the Ruby expression. An input is executed when it is syntactically complete.
$ irb irb(main):001:0> 1+2 #=> 3 irb(main):002:0> class Foo irb(main):003:1> def foo irb(main):004:2> print 1 irb(main):005:2> end irb(main):006:1> end #=> nil
The singleline editor module or multiline editor module can be used with irb. Use of multiline editor is default if it’s installed.
Usage: irb.rb [options] [programfile] [arguments] -f Suppress read of ~/.irbrc -d Set $DEBUG to true (same as `ruby -d') -r load-module Same as `ruby -r' -I path Specify $LOAD_PATH directory -U Same as `ruby -U` -E enc Same as `ruby -E` -w Same as `ruby -w` -W[level=2] Same as `ruby -W` --inspect Use `inspect' for output (default except for bc mode) --noinspect Don't use inspect for output --multiline Use multiline editor module --nomultiline Don't use multiline editor module --singleline Use singleline editor module --nosingleline Don't use singleline editor module --colorize Use colorization --nocolorize Don't use colorization --prompt prompt-mode --prompt-mode prompt-mode Switch prompt mode. Pre-defined prompt modes are `default', `simple', `xmp' and `inf-ruby' --inf-ruby-mode Use prompt appropriate for inf-ruby-mode on emacs. Suppresses --multiline and --singleline. --simple-prompt Simple prompt mode --noprompt No prompt mode --tracer Display trace for each execution of commands. --back-trace-limit n Display backtrace top n and tail n. The default value is 16. -v, --version Print the version of irb
IRB reads from ~/.irbrc
when it’s invoked.
If ~/.irbrc
doesn’t exist, irb
will try to read
in the following order:
.irbrc
irb.rc
_irbrc
$irbrc
The following are alternatives to the command line options. To use them
type as follows in an irb
session:
IRB.conf[:IRB_NAME]="irb" IRB.conf[:INSPECT_MODE]=nil IRB.conf[:IRB_RC] = nil IRB.conf[:BACK_TRACE_LIMIT]=16 IRB.conf[:USE_LOADER] = false IRB.conf[:USE_MULTILINE] = nil IRB.conf[:USE_SINGLELINE] = nil IRB.conf[:USE_COLORIZE] = true IRB.conf[:USE_TRACER] = false IRB.conf[:IGNORE_SIGINT] = true IRB.conf[:IGNORE_EOF] = false IRB.conf[:PROMPT_MODE] = :DEFAULT IRB.conf[:PROMPT] = {...}
To disable auto-indent mode in irb, add the following to your
.irbrc
:
IRB.conf[:AUTO_INDENT] = false
To enable autocompletion for irb, add the following to your
.irbrc
:
require 'irb/completion'
By default, irb will store the last 1000 commands you used in
IRB.conf[:HISTORY_FILE]
(~/.irb_history
by
default).
If you want to disable history, add the following to your
.irbrc
:
IRB.conf[:SAVE_HISTORY] = nil
See IRB::Context#save_history= for more information.
The history of results of commands evaluated is not stored by
default, but can be turned on to be stored with this .irbrc
setting:
IRB.conf[:EVAL_HISTORY] = <number>
See IRB::Context#eval_history= and History class. The history of command results is not permanently saved in any file.
In order to customize the prompt, you can change the following Hash:
IRB.conf[:PROMPT]
This example can be used in your .irbrc
IRB.conf[:PROMPT][:MY_PROMPT] = { # name of prompt mode :AUTO_INDENT => false, # disables auto-indent mode :PROMPT_I => ">> ", # simple prompt :PROMPT_S => nil, # prompt for continuated strings :PROMPT_C => nil, # prompt for continuated statement :RETURN => " ==>%s\n" # format to return value } IRB.conf[:PROMPT_MODE] = :MY_PROMPT
Or, invoke irb with the above prompt mode by:
irb --prompt my-prompt
Constants PROMPT_I
, PROMPT_S
and
PROMPT_C
specify the format. In the prompt specification, some
special strings are available:
%N # command name which is running %m # to_s of main object (self) %M # inspect of main object (self) %l # type of string(", ', /, ]), `]' is inner %w[...] %NNi # indent level. NN is digits and means as same as printf("%NNd"). # It can be omitted %NNn # line number. %% # %
For instance, the default prompt mode is defined as follows:
IRB.conf[:PROMPT_MODE][:DEFAULT] = { :PROMPT_I => "%N(%m):%03n:%i> ", :PROMPT_N => "%N(%m):%03n:%i> ", :PROMPT_S => "%N(%m):%03n:%i%l ", :PROMPT_C => "%N(%m):%03n:%i* ", :RETURN => "%s\n" # used to printf }
irb comes with a number of available modes:
# :NULL: # :PROMPT_I: # :PROMPT_N: # :PROMPT_S: # :PROMPT_C: # :RETURN: | # %s # :DEFAULT: # :PROMPT_I: ! '%N(%m):%03n:%i> ' # :PROMPT_N: ! '%N(%m):%03n:%i> ' # :PROMPT_S: ! '%N(%m):%03n:%i%l ' # :PROMPT_C: ! '%N(%m):%03n:%i* ' # :RETURN: | # => %s # :CLASSIC: # :PROMPT_I: ! '%N(%m):%03n:%i> ' # :PROMPT_N: ! '%N(%m):%03n:%i> ' # :PROMPT_S: ! '%N(%m):%03n:%i%l ' # :PROMPT_C: ! '%N(%m):%03n:%i* ' # :RETURN: | # %s # :SIMPLE: # :PROMPT_I: ! '>> ' # :PROMPT_N: ! '>> ' # :PROMPT_S: # :PROMPT_C: ! '?> ' # :RETURN: | # => %s # :INF_RUBY: # :PROMPT_I: ! '%N(%m):%03n:%i> ' # :PROMPT_N: # :PROMPT_S: # :PROMPT_C: # :RETURN: | # %s # :AUTO_INDENT: true # :XMP: # :PROMPT_I: # :PROMPT_N: # :PROMPT_S: # :PROMPT_C: # :RETURN: |2 # ==>%s
Because irb evaluates input immediately after it is syntactically complete, the results may be slightly different than directly using Ruby.
IRB has a special feature, that allows you to manage many sessions at once.
You can create new sessions with Irb.irb, and get a list of current
sessions with the jobs
command in the prompt.
JobManager provides commands to handle the current sessions:
jobs # List of current sessions fg # Switches to the session of the given number kill # Kills the session with the given number
The exit
command, or ::irb_exit, will quit the current
session and call any exit hooks with ::irb_at_exit.
A few commands for loading files within the session are also available:
source
Loads a given file in the current session and displays the source lines, see IRB::IrbLoader#source_file
irb_load
Loads the given file similarly to Kernel#load, see IRB::IrbLoader#irb_load
irb_require
Loads the given file similarly to Kernel#require
The command line options, or ::conf, specify the default behavior of Irb.irb.
On the other hand, each conf in IRB is used to individually configure ::irb.
If a proc is set for ::conf, its will be invoked after execution of that proc with the context of the current session as its argument. Each session can be configured using this mechanism.
There are a few variables in every Irb session that can come in handy:
_
The value command executed, as a local variable
__
The history of evaluated commands. Available only if
IRB.conf[:EVAL_HISTORY]
is not nil
(which is the
default). See also IRB::Context#eval_history=
and IRB::History.
__[line_no]
Returns the evaluation value at the given line number,
line_no
. If line_no
is a negative, the return
value line_no
many lines before the most recent return value.
# invoke a new session irb(main):001:0> irb # list open sessions irb.1(main):001:0> jobs #0->irb on main (#<Thread:0x400fb7e4> : stop) #1->irb#1 on main (#<Thread:0x40125d64> : running) # change the active session irb.1(main):002:0> fg 0 # define class Foo in top-level session irb(main):002:0> class Foo;end # invoke a new session with the context of Foo irb(main):003:0> irb Foo # define Foo#foo irb.2(Foo):001:0> def foo irb.2(Foo):002:1> print 1 irb.2(Foo):003:1> end # change the active session irb.2(Foo):004:0> fg 0 # list open sessions irb(main):004:0> jobs #0->irb on main (#<Thread:0x400fb7e4> : running) #1->irb#1 on main (#<Thread:0x40125d64> : stop) #2->irb#2 on Foo (#<Thread:0x4011d54c> : stop) # check if Foo#foo is available irb(main):005:0> Foo.instance_methods #=> [:foo, ...] # change the active session irb(main):006:0> fg 2 # define Foo#bar in the context of Foo irb.2(Foo):005:0> def bar irb.2(Foo):006:1> print "bar" irb.2(Foo):007:1> end irb.2(Foo):010:0> Foo.instance_methods #=> [:bar, :foo, ...] # change the active session irb.2(Foo):011:0> fg 0 irb(main):007:0> f = Foo.new #=> #<Foo:0x4010af3c> # invoke a new session with the context of f (instance of Foo) irb(main):008:0> irb f # list open sessions irb.3(<Foo:0x4010af3c>):001:0> jobs #0->irb on main (#<Thread:0x400fb7e4> : stop) #1->irb#1 on main (#<Thread:0x40125d64> : stop) #2->irb#2 on Foo (#<Thread:0x4011d54c> : stop) #3->irb#3 on #<Foo:0x4010af3c> (#<Thread:0x4010a1e0> : running) # evaluate f.foo irb.3(<Foo:0x4010af3c>):002:0> foo #=> 1 => nil # evaluate f.bar irb.3(<Foo:0x4010af3c>):003:0> bar #=> bar => nil # kill jobs 1, 2, and 3 irb.3(<Foo:0x4010af3c>):004:0> kill 1, 2, 3 # list open sessions, should only include main session irb(main):009:0> jobs #0->irb on main (#<Thread:0x400fb7e4> : running) # quit irb irb(main):010:0> exit
frozen_string_literal: false
frame.rb - $Release Version: 0.9$ $Revision$ by Keiju ISHITSUKA(Nihon Rational Software Co.,Ltd)
–
frozen_string_literal: false
frozen_string_literal: false
output-method.rb - output methods used by irb $Release Version: 0.9.6$ $Revision$ by Keiju ISHITSUKA(keiju@ruby-lang.org)
–
frozen_string_literal: false DO NOT WRITE ANY MAGIC COMMENT HERE.
The current IRB::Context of the session, see ::conf
irb irb(main):001:0> IRB.CurrentContext.irb_name = "foo" foo(main):002:0> IRB.conf[:MAIN_CONTEXT].irb_name #=> "foo"
# File irb.rb, line 383 def IRB.CurrentContext IRB.conf[:MAIN_CONTEXT] end
The current JobManager in the session
# File irb/ext/multi-irb.rb, line 176 def IRB.JobManager @JobManager end
Displays current configuration.
Modifying the configuration is achieved by sending a message to ::conf.
See Configuration at IRB for more information.
# File irb.rb, line 366 def IRB.conf @CONF end
# File irb/src_encoding.rb, line 4 def self.default_src_encoding return __ENCODING__ end
# File irb/easter-egg.rb, line 55 def draw @data.each {|row| row.fill(0) } yield @data.map {|row| row.map {|n| " ',;"[n] }.join }.join("\n") end
initialize tracing function
# File irb/ext/tracer.rb, line 30 def IRB.initialize_tracer Tracer.verbose = false Tracer.add_filter { |event, file, line, id, binding, *rests| /^#{Regexp.quote(@CONF[:IRB_LIB_PATH])}/ !~ file and File::basename(file) != "irb.rb" } end
Creates a new IRB session, see IRB::Irb.new.
The optional file
argument is given to IRB::Context.new, along with the
workspace created with the remaining arguments, see IRB::WorkSpace.new
# File irb/ext/multi-irb.rb, line 189 def IRB.irb(file = nil, *main) workspace = WorkSpace.new(*main) parent_thread = Thread.current Thread.start do begin irb = Irb.new(workspace, file) rescue print "Subirb can't start with context(self): ", workspace.main.inspect, "\n" print "return to main irb\n" Thread.pass Thread.main.wakeup Thread.exit end @CONF[:IRB_RC].call(irb.context) if @CONF[:IRB_RC] @JobManager.insert(irb) @JobManager.current_job = irb begin system_exit = false catch(:IRB_EXIT) do irb.eval_input end rescue SystemExit system_exit = true raise #fail ensure unless system_exit @JobManager.delete(irb) if @JobManager.current_job == irb if parent_thread.alive? @JobManager.current_job = @JobManager.irb(parent_thread) parent_thread.run else @JobManager.current_job = @JobManager.main_irb @JobManager.main_thread.run end end end end end Thread.stop @JobManager.current_job = @JobManager.irb(Thread.current) end
Aborts then interrupts irb.
Will raise an Abort exception, or the given
exception
.
# File irb.rb, line 415 def IRB.irb_abort(irb, exception = Abort) if defined? Thread irb.context.thread.raise exception, "abort then interrupt!" else raise exception, "abort then interrupt!" end end
Calls each event hook of ::conf when the current session quits.
# File irb.rb, line 403 def IRB.irb_at_exit @CONF[:AT_EXIT].each{|hook| hook.call} end
Quits irb
# File irb.rb, line 408 def IRB.irb_exit(irb, ret) throw :IRB_EXIT, ret end
Outputs the irb help message, see Command line options at IRB.
# File irb/help.rb, line 17 def IRB.print_usage lc = IRB.conf[:LC_MESSAGES] path = lc.find("irb/help-message") space_line = false IRB::MagicFile.open(path){|f| f.each_line do |l| if /^\s*$/ =~ l lc.puts l unless space_line space_line = true next end space_line = false l.sub!(/#.*$/, "") next if /^\s*$/ =~ l lc.puts l end } end
Initializes IRB and creates a new Irb.irb object at the
TOPLEVEL_BINDING
# File irb.rb, line 388 def IRB.start(ap_path = nil) STDOUT.sync = true $0 = File::basename(ap_path, ".rb") if ap_path IRB.setup(ap_path) if @CONF[:SCRIPT] irb = Irb.new(nil, @CONF[:SCRIPT]) else irb = Irb.new end irb.run(@CONF) end