module IRB

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.

Usage¶ ↑

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.

Command line options¶ ↑

Usage:  irb.rb [options] [programfile] [arguments]
  -f                Don't initialize from configuration file.
  -d                Set $DEBUG and $VERBOSE to true (same as 'ruby -d').
  -r load-module    Require load-module (same as 'ruby -r').
  -I path           Specify $LOAD_PATH directory (same as 'ruby -I').
  -U                Set external and internal encodings to UTF-8.
  -E ex[:in]        Set default external (ex) and internal (in) encodings
                    (same as 'ruby -E').
  -w                Suppress warnings (same as 'ruby -w').
  -W[level=2]       Set warning level: 0=silence, 1=medium, 2=verbose
                    (same as 'ruby -W').
  --context-mode n  Set n[0-4] to method to create Binding Object,
                    when new workspace was created.
  --extra-doc-dir   Add an extra doc dir for the doc dialog.
  --echo            Show result (default).
  --noecho          Don't show result.
  --echo-on-assignment
                    Show result on assignment.
  --noecho-on-assignment
                    Don't show result on assignment.
  --truncate-echo-on-assignment
                    Show truncated result on assignment (default).
  --inspect         Use 'inspect' for output.
  --noinspect       Don't use 'inspect' for output.
  --multiline       Use multiline editor module (default).
  --nomultiline     Don't use multiline editor module.
  --singleline      Use single line editor module.
  --nosingleline    Don't use single line editor module (default).
  --colorize        Use color-highlighting (default).
  --nocolorize      Don't use color-highlighting.
  --autocomplete    Use auto-completion (default).
  --noautocomplete  Don't use auto-completion.
  --prompt prompt-mode, --prompt-mode prompt-mode
                    Set prompt mode. Pre-defined prompt modes are:
                    'default', 'classic', 'simple', 'inf-ruby', 'xmp', 'null'.
  --inf-ruby-mode   Use prompt appropriate for inf-ruby-mode on emacs.
                    Suppresses --multiline and --singleline.
  --sample-book-mode, --simple-prompt
                    Set prompt mode to 'simple'.
  --noprompt        Don't output prompt.
  --script          Script mode (default, treat first argument as script)
  --noscript        No script mode (leave arguments in argv)
  --single-irb      Share self with sub-irb.
  --tracer          Show stack trace for each command.
  --back-trace-limit n[=16]
                    Display backtrace top n and bottom n.
  --verbose         Show details.
  --noverbose       Don't show details.
  -v, --version     Print the version of irb.
  -h, --help        Print help.
  --                Separate options of irb from the list of command-line args.

Commands¶ ↑

The following commands are available on IRB.

cwws
- Show the current workspace.
cb, cws, chws
- Change the current workspace to an object.
bindings, workspaces
- Show workspaces.
pushb, pushws
- Push an object to the workspace stack.
popb, popws
- Pop a workspace from the workspace stack.
load
- Load a Ruby file.
require
- Require a Ruby file.
source
- Loads a given file in the current session.
irb
- Start a child IRB.
jobs
- List of current sessions.
fg
- Switches to the session of the given number.
kill
- Kills the session with the given number.
help
- Enter the mode to look up RI documents.
irb_info
- Show information about IRB.
ls
- Show methods, constants, and variables. -g [query] or -G [query] allows you to filter out the output.
measure
- measure enables the mode to measure processing time. measure :off disables it.
$, show_source
- Show the source code of a given method or constant.
@, whereami
- Show the source code around binding.irb again.
debug
- Start the debugger of debug.gem.
break, delete, next, step, continue, finish, backtrace, info, catch
- Start the debugger of debug.gem and run the command on it.

Configuration¶ ↑

IRB reads a personal initialization file when it’s invoked. IRB searches a file in the following order and loads the first one found.

$IRBRC (if $IRBRC is set)
$XDG_CONFIG_HOME/irb/irbrc (if $XDG_CONFIG_HOME is set)
~/.irbrc
.config/irb/irbrc
.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[:USE_AUTOCOMPLETE] = true
IRB.conf[:IGNORE_SIGINT] = true
IRB.conf[:IGNORE_EOF] = false
IRB.conf[:PROMPT_MODE] = :DEFAULT
IRB.conf[:PROMPT] = {...}

Auto indentation¶ ↑

To disable auto-indent mode in irb, add the following to your .irbrc:

IRB.conf[:AUTO_INDENT] = false

Autocompletion¶ ↑

To disable autocompletion for irb, add the following to your .irbrc:

IRB.conf[:USE_AUTOCOMPLETE] = false

History¶ ↑

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 EvalHistory class. The history of command results is not permanently saved in any file.

Customizing the `IRB` Prompt¶ ↑

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> ",
  :PROMPT_S => "%N(%m):%03n%l ",
  :PROMPT_C => "%N(%m):%03n* ",
  :RETURN => "%s\n" # used to printf
}

irb comes with a number of available modes:

# :NULL:
#   :PROMPT_I:
#   :PROMPT_S:
#   :PROMPT_C:
#   :RETURN: |
#     %s
# :DEFAULT:
#   :PROMPT_I: ! '%N(%m):%03n> '
#   :PROMPT_S: ! '%N(%m):%03n%l '
#   :PROMPT_C: ! '%N(%m):%03n* '
#   :RETURN: |
#     => %s
# :CLASSIC:
#   :PROMPT_I: ! '%N(%m):%03n:%i> '
#   :PROMPT_S: ! '%N(%m):%03n:%i%l '
#   :PROMPT_C: ! '%N(%m):%03n:%i* '
#   :RETURN: |
#     %s
# :SIMPLE:
#   :PROMPT_I: ! '>> '
#   :PROMPT_S:
#   :PROMPT_C: ! '?> '
#   :RETURN: |
#     => %s
# :INF_RUBY:
#   :PROMPT_I: ! '%N(%m):%03n> '
#   :PROMPT_S:
#   :PROMPT_C:
#   :RETURN: |
#     %s
#   :AUTO_INDENT: true
# :XMP:
#   :PROMPT_I:
#   :PROMPT_S:
#   :PROMPT_C:
#   :RETURN: |2
#         ==>%s

Restrictions¶ ↑

Because irb evaluates input immediately after it is syntactically complete, the results may be slightly different than directly using Ruby.

`IRB` Sessions¶ ↑

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.

Commands¶ ↑

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.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 IrbLoader#source_file
irb_load: Loads the given file similarly to Kernel#load, see IrbLoader#irb_load
irb_require: Loads the given file similarly to Kernel#require

Configuration¶ ↑

The command line options, or IRB.conf, specify the default behavior of Irb.irb.

On the other hand, each conf in Command line options at IRB is used to individually configure IRB.irb.

If a proc is set for IRB.conf[:IRB_RC], 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.

Session variables¶ ↑

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.

Example using `IRB` Sessions¶ ↑

# 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

nop.rb -

by Keiju ISHITSUKA(keiju@ruby-lang.org)

irb/multi-irb.rb - multiple irb module

by Keiju ISHITSUKA(keiju@ruby-lang.org)

frame.rb -

by Keiju ISHITSUKA(Nihon Rational Software Co.,Ltd)

irb/help.rb - print usage module

by Keiju ISHITSUKA(keiju@ishitsuka.com)

irb/lc/error.rb -

by Keiju ISHITSUKA(keiju@ruby-lang.org)

irb/lc/ja/error.rb -

by Keiju ISHITSUKA(keiju@ruby-lang.org)

output-method.rb - output methods used by irb

by Keiju ISHITSUKA(keiju@ruby-lang.org)

Constants

TOPLEVEL_BINDING

Public Class Methods

CurrentContext() click to toggle source

The current IRB::Context of the session, see IRB.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 393
def IRB.CurrentContext
  IRB.conf[:MAIN_CONTEXT]
end

JobManager() click to toggle source

The current JobManager in the session

# File irb/ext/multi-irb.rb, line 169
def IRB.JobManager
  @JobManager
end

conf() click to toggle source

Displays current configuration.

Modifying the configuration is achieved by sending a message to IRB.conf.

See Configuration at IRB for more information.

# File irb.rb, line 376
def IRB.conf
  @CONF
end

initialize_tracer() click to toggle source

initialize tracing function

# File irb/ext/tracer.rb, line 24
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

irb(file = nil, *main) click to toggle source

Creates a new IRB session, see Irb.new.

The optional file argument is given to Context.new, along with the workspace created with the remaining arguments, see WorkSpace.new

# File irb/ext/multi-irb.rb, line 182
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

irb_abort(irb, exception = Abort) click to toggle source

Aborts then interrupts irb.

Will raise an Abort exception, or the given exception.

# File irb.rb, line 420
def IRB.irb_abort(irb, exception = Abort)
  irb.context.thread.raise exception, "abort then interrupt!"
end

irb_exit(irb, ret) click to toggle source

Quits irb

# File irb.rb, line 413
def IRB.irb_exit(irb, ret)
  throw :IRB_EXIT, ret
end

print_usage() click to toggle source

Outputs the irb help message, see Command line options at IRB.

# File irb/help.rb, line 9
def IRB.print_usage
  lc = IRB.conf[:LC_MESSAGES]
  path = lc.find("irb/help-message")
  space_line = false
  File.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

start(ap_path = nil) click to toggle source

Initializes IRB and creates a new Irb.irb object at the TOPLEVEL_BINDING

# File irb.rb, line 398
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

version() click to toggle source

Returns the current version of IRB, including release version and last updated date.

# File irb.rb, line 382
def IRB.version
  if v = @CONF[:VERSION] then return v end

  @CONF[:VERSION] = format("irb %s (%s)", @RELEASE_VERSION, @LAST_UPDATE_DATE)
end

Private Class Methods

easter_egg(type = nil) click to toggle source

# File irb/easter-egg.rb, line 101
        def easter_egg(type = nil)
  type ||= [:logo, :dancing].sample
  case type
  when :logo
    File.open(File.join(__dir__, 'ruby_logo.aa')) do |f|
      require "rdoc"
      RDoc::RI::Driver.new.page do |io|
        IO.copy_stream(f, io)
      end
    end
  when :dancing
    begin
      canvas = Canvas.new(Reline.get_screen_size)
      Reline::IOGate.set_winch_handler do
        canvas = Canvas.new(Reline.get_screen_size)
      end
      ruby_model = RubyModel.new
      print "\e[?1049h"
      0.step do |i| # TODO (0..).each needs Ruby 2.6 or later
        buff = canvas.draw do
          ruby_model.render_frame(i) do |p1, p2|
            canvas.line(p1, p2)
          end
        end
        buff[0, 20] = "\e[0mPress Ctrl+C to stop\e[31m\e[1m"
        print "\e[H" + buff
        sleep 0.05
      end
    rescue Interrupt
    ensure
      print "\e[0m\e[?1049l"
    end
  end
end

module IRB

Usage¶ ↑

Command line options¶ ↑

Commands¶ ↑

Configuration¶ ↑

Auto indentation¶ ↑

Autocompletion¶ ↑

History¶ ↑

Customizing the IRB Prompt¶ ↑

Restrictions¶ ↑

IRB Sessions¶ ↑

Commands¶ ↑

Configuration¶ ↑

Session variables¶ ↑

Example using IRB Sessions¶ ↑

Customizing the `IRB` Prompt¶ ↑

`IRB` Sessions¶ ↑

Example using `IRB` Sessions¶ ↑