123456789_123456789_123456789_123456789_123456789_

Module: IRB

Overview

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 Readline extension module can be used with irb. Use of Readline is default if it's installed.

Command line options

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
  --readline        Use Readline extension module
  --noreadline      Don't use Readline extension module
  --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 --readline.
  --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.
  --irb_debug n     Set internal debug level to n (not for popular use)
  -v, --version     Print the version of irb

Configuration

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_READLINE] = nil
IRB.conf[:USE_TRACER] = false
IRB.conf[:IGNORE_SIGINT] = true
IRB.conf[:IGNORE_EOF] = false
IRB.conf[:PROMPT_MODE] = :DEFAULT
IRB.conf[:PROMPT] = {...}
IRB.conf[:DEBUG_LEVEL]=0

Auto indentation

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

IRB.conf[:AUTO_INDENT] = true

Autocompletion

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

require 'irb/completion'

History

By default, irb disables history and will not store any commands you used.

If you want to enable history, add the following to your .irbrc:

IRB.conf[:SAVE_HISTORY] = 1000

This will now store the last 1000 commands in ~/.irb_history.

See Context#save_history= for more information.

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 => true,           # enables 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_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

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_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 .conf, specify the default behavior of Irb.irb.

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

If a proc is set for IRB.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.

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

__[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 sesssion
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

Constant Summary

Class Method Summary

Class Method Details

.conf

Displays current configuration.

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

See IRB@Configuration for more information.

[ GitHub ] 

  


# File 'lib/irb.rb', line 348



def IRB.conf
  @CONF
end


  








  

    CurrentContext  
  



  

    

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"



See additional method definition at file lib/irb.rb line 367.


  



  [ GitHub ]


  

  


# File 'lib/irb/ext/multi-irb.rb', line 181



def IRB.CurrentContext
  IRB.conf[:MAIN_CONTEXT]
end


  








  

    .default_src_encoding  
  

  [ GitHub ]


  

  


# File 'lib/irb/src_encoding.rb', line 4



def self.default_src_encoding
  return __ENCODING__
end


  








  

    .delete_caller  
  

  [ GitHub ]


  

  


# File 'lib/irb/workspace.rb', line 132



def IRB.delete_caller
end


  








  

    .init_config(ap_path)  
  

  

    This method is for internal use only.
  

  [ GitHub ]


  

  


# File 'lib/irb/init.rb', line 29



def IRB.init_config(ap_path)
  # class instance variables
  @TRACER_INITIALIZED = false

  # default configurations
  unless ap_path and @CONF[:AP_NAME]
    ap_path = File.join(File.dirname(File.dirname(__FILE__)), "irb.rb")
  end
  @CONF[:AP_NAME] = File::basename(ap_path, ".rb")

  @CONF[:IRB_NAME] = "irb"
  @CONF[:IRB_LIB_PATH] = File.dirname(__FILE__)

  @CONF[:RC] = true
  @CONF[:LOAD_MODULES] = []
  @CONF[:IRB_RC] = nil

  @CONF[:USE_READLINE] = false unless defined?(ReadlineInputMethod)
  @CONF[:INSPECT_MODE] = true
  @CONF[:USE_TRACER] = false
  @CONF[:USE_LOADER] = false
  @CONF[:IGNORE_SIGINT] = true
  @CONF[:IGNORE_EOF] = false
  @CONF[:ECHO] = nil
  @CONF[:VERBOSE] = nil

  @CONF[:EVAL_HISTORY] = nil
  @CONF[:SAVE_HISTORY] = nil

  @CONF[:BACK_TRACE_LIMIT] = 16

  @CONF[:PROMPT] = {
    :NULL => {
      :PROMPT_I => nil,
      :PROMPT_N => nil,
      :PROMPT_S => nil,
      :PROMPT_C => nil,
      :RETURN => "%s\n"
    },
    :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"
    },
    :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\n"
    },
    :SIMPLE => {
      :PROMPT_I => ">> ",
      :PROMPT_N => ">> ",
      :PROMPT_S => nil,
      :PROMPT_C => "?> ",
      :RETURN => "=> %s\n"
    },
    :INF_RUBY => {
      :PROMPT_I => "%N(%m):%03n:%i> ",
      :PROMPT_N => nil,
      :PROMPT_S => nil,
      :PROMPT_C => nil,
      :RETURN => "%s\n",
      :AUTO_INDENT => true
    },
    :XMP => {
      :PROMPT_I => nil,
      :PROMPT_N => nil,
      :PROMPT_S => nil,
      :PROMPT_C => nil,
      :RETURN => "    ==>%s\n"
    }
  }

  @CONF[:PROMPT_MODE] = (STDIN.tty? ? :DEFAULT : :NULL)
  @CONF[:AUTO_INDENT] = false

  @CONF[:CONTEXT_MODE] = 3 # use binding in function on TOPLEVEL_BINDING
  @CONF[:SINGLE_IRB] = false

  @CONF[:LC_MESSAGES] = Locale.new

  @CONF[:AT_EXIT] = []

  @CONF[:DEBUG_LEVEL] = 0
end


  








  

    .init_error  
  

  

    This method is for internal use only.
  

  [ GitHub ]


  

  


# File 'lib/irb/init.rb', line 119



def IRB.init_error
  @CONF[:LC_MESSAGES].load("irb/error.rb")
end


  








  

    .initialize_tracer  
  



  

    

initialize tracing function


  



  [ GitHub ]


  

  


# File 'lib/irb/ext/tracer.rb', line 17



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


  








  

    .inspect  
  

  [ GitHub ]


  

  


# File 'lib/irb.rb', line 687



def @CONF.inspect
  IRB.version unless self[:VERSION]

  array = []
  for k, v in sort{|a1, a2| a1[0].id2name <=> a2[0].id2name}
    case k
    when :MAIN_CONTEXT, :__TMP__EHV__
      array.push format("CONF[:%s]=...myself...", k.id2name)
    when :PROMPT
      s = v.collect{
        |kk, vv|
        ss = vv.collect{|kkk, vvv| ":#{kkk.id2name}=>#{vvv.inspect}"}
        format(":%s=>{%s}", kk.id2name, ss.join(", "))
      }
      array.push format("CONF[:%s]={%s}", k.id2name, s.join(", "))
    else
      array.push format("CONF[:%s]=%s", k.id2name, v.inspect)
    end
  end
  array.join("\n")
end


  








  

    Inspector(inspect, init = nil)  
  

  

    This method is for internal use only.
  



  

    

Convenience method to create a new ::IRB::Inspector, using the given .inspect proc, and optional init proc and passes them to Inspector.new



irb(main):001:0> ins = IRB::Inspector(proc{ |v| "omg! #{v}" })
irb(main):001:0> IRB.CurrentContext.inspect_mode = ins # => omg! #<IRB::Inspector:0x007f46f7ba7d28>
irb(main):001:0> "what?" #=> omg! what?


  



  [ GitHub ]


  

  


# File 'lib/irb/inspector.rb', line 24



def IRB::Inspector(inspect, init = nil)
  Inspector.new(inspect, init)
end


  








  

    .irb(file = nil, *main)  
  



  

    

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


  



  [ GitHub ]


  

  


# File 'lib/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


  








  

    .irb_abort(irb, exception = Abort)  
  



  

    

Aborts then interrupts irb.



Will raise an ::IRB::Abort exception, or the given exception.


  



  [ GitHub ]


  

  


# File 'lib/irb.rb', line 399



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


  








  

    .irb_at_exit  
  



  

    

Calls each event hook of IRB.conf when the current session quits.


  



  [ GitHub ]


  

  


# File 'lib/irb.rb', line 387



def IRB.irb_at_exit
  @CONF[:AT_EXIT].each{|hook| hook.call}
end


  








  

    .irb_exit(irb, ret)  
  



  

    

Quits irb


  



  [ GitHub ]


  

  


# File 'lib/irb.rb', line 392



def IRB.irb_exit(irb, ret)
  throw :IRB_EXIT, ret
end


  








  

    JobManager  
  



  

    

The current ::IRB::JobManager in the session


  



  [ GitHub ]


  

  


# File 'lib/irb/ext/multi-irb.rb', line 176



def IRB.JobManager
  @JobManager
end


  








  

    .load_modules  
  

  

    This method is for internal use only.
  



  

    

loading modules


  



  [ GitHub ]


  

  


# File 'lib/irb/init.rb', line 275



def IRB.load_modules
  for m in @CONF[:LOAD_MODULES]
    begin
      require m
    rescue LoadError => err
      warn "#{err.class}: #{err}", uplevel: 0
    end
  end
end


  








  

    .parse_opts(argv: ::ARGV)  
  

  

    This method is for internal use only.
  



  

    

option analyzing


  



  [ GitHub ]


  

  


# File 'lib/irb/init.rb', line 124



def IRB.parse_opts(argv: ::ARGV)
  load_path = []
  while opt = argv.shift
    case opt
    when "-f"
      @CONF[:RC] = false
    when "-d"
      $DEBUG = true
      $VERBOSE = true
    when "-w"
      $VERBOSE = true
    when /^-W(.+)?/
      opt = $1 || argv.shift
      case opt
      when "0"
        $VERBOSE = nil
      when "1"
        $VERBOSE = false
      else
        $VERBOSE = true
      end
    when /^-r(.+)?/
      opt = $1 || argv.shift
      @CONF[:LOAD_MODULES].push opt if opt
    when /^-I(.+)?/
      opt = $1 || argv.shift
      load_path.concat(opt.split(File::PATH_SEPARATOR)) if opt
    when '-U'
      set_encoding("UTF-8", "UTF-8")
    when /^-E(.+)?/, /^--encoding(?:=(.+))?/
      opt = $1 || argv.shift
      set_encoding(*opt.split(':', 2))
    when "--inspect"
      if /^-/ !~ argv.first
        @CONF[:INSPECT_MODE] = argv.shift
      else
        @CONF[:INSPECT_MODE] = true
      end
    when "--noinspect"
      @CONF[:INSPECT_MODE] = false
    when "--readline"
      @CONF[:USE_READLINE] = true
    when "--noreadline"
      @CONF[:USE_READLINE] = false
    when "--echo"
      @CONF[:ECHO] = true
    when "--noecho"
      @CONF[:ECHO] = false
    when "--verbose"
      @CONF[:VERBOSE] = true
    when "--noverbose"
      @CONF[:VERBOSE] = false
    when /^--prompt-mode(?:=(.+))?/, /^--prompt(?:=(.+))?/
      opt = $1 || argv.shift
      prompt_mode = opt.upcase.tr("-", "_").intern
      @CONF[:PROMPT_MODE] = prompt_mode
    when "--noprompt"
      @CONF[:PROMPT_MODE] = :NULL
    when "--inf-ruby-mode"
      @CONF[:PROMPT_MODE] = :INF_RUBY
    when "--sample-book-mode", "--simple-prompt"
      @CONF[:PROMPT_MODE] = :SIMPLE
    when "--tracer"
      @CONF[:USE_TRACER] = true
    when /^--back-trace-limit(?:=(.+))?/
      @CONF[:BACK_TRACE_LIMIT] = ($1 || argv.shift).to_i
    when /^--context-mode(?:=(.+))?/
      @CONF[:CONTEXT_MODE] = ($1 || argv.shift).to_i
    when "--single-irb"
      @CONF[:SINGLE_IRB] = true
    when /^--irb_debug(?:=(.+))?/
      @CONF[:DEBUG_LEVEL] = ($1 || argv.shift).to_i
    when "-v", "--version"
      print IRB.version, "\n"
      exit 0
    when "-h", "--help"
      require "irb/help"
      IRB.print_usage
      exit 0
    when "--"
      if opt = argv.shift
        @CONF[:SCRIPT] = opt
        $0 = opt
      end
      break
    when /^-/
      IRB.fail UnrecognizedSwitch, opt
    else
      @CONF[:SCRIPT] = opt
      $0 = opt
      break
    end
  end
  load_path.collect! do |path|
    /\A\.\// =~ path ? path : File.expand_path(path)
  end
  $LOAD_PATH.unshift(*load_path)

end


  










  

    .rc_file(ext = IRBRC_EXT)  
  

  

    This method is for internal use only.
  

  [ GitHub ]


  

  


# File 'lib/irb/init.rb', line 241



def IRB.rc_file(ext = IRBRC_EXT)
  if !@CONF[:RC_NAME_GENERATOR]
    rc_file_generators do |rcgen|
      @CONF[:RC_NAME_GENERATOR] ||= rcgen
      if File.exist?(rcgen.call(IRBRC_EXT))
        @CONF[:RC_NAME_GENERATOR] = rcgen
        break
      end
    end
  end
  case rc_file = @CONF[:RC_NAME_GENERATOR].call(ext)
  when String
    return rc_file
  else
    IRB.fail IllegalRCNameGenerator
  end
end


  








  

    .rc_file_generators {|proc{|rc| home+"/.irb#{rc}"}| ... } 
  

  

    This method is for internal use only.
  



  

    

enumerate possible rc-file base name generators


  





  
Yields:


    
  
  • 
    (proc{|rc| home+"/.irb#{rc}"})
  
    • 





  [ GitHub ]


  

  


# File 'lib/irb/init.rb', line 260



def IRB.rc_file_generators
  if irbrc = ENV["IRBRC"]
    yield proc{|rc| rc == "rc" ? irbrc : irbrc+rc}
  end
  if home = ENV["HOME"]
    yield proc{|rc| home+"/.irb#{rc}"}
  end
  home = Dir.pwd
  yield proc{|rc| home+"/.irb#{rc}"}
  yield proc{|rc| home+"/irb#{rc.sub(/\A_?/, '.')}"}
  yield proc{|rc| home+"/_irb#{rc}"}
  yield proc{|rc| home+"/$irb#{rc}"}
end


  








  

    .run_config  
  

  

    This method is for internal use only.
  



  

    

running config


  



  [ GitHub ]


  

  


# File 'lib/irb/init.rb', line 225



def IRB.run_config
  if @CONF[:RC]
    begin
      load rc_file
    rescue LoadError, Errno::ENOENT
    rescue # StandardError, ScriptError
      print "load error: #{rc_file}\n"
      print $!.class, ": ", $!, "\n"
      for err in $@[0, $@.size - 2]
        print "\t", err, "\n"
      end
    end
  end
end


  








  

    .set_encoding(extern, intern = nil)   (private)
  

  

    This method is for internal use only.
  

  [ GitHub ]


  

  


# File 'lib/irb/init.rb', line 289



def set_encoding(extern, intern = nil)
  verbose, $VERBOSE = $VERBOSE, nil
  Encoding.default_external = extern unless extern.nil? || extern.empty?
  Encoding.default_internal = intern unless intern.nil? || intern.empty?
  @CONF[:ENCODINGS] = IRB::DefaultEncodings.new(extern, intern)
  [$stdin, $stdout, $stderr].each do |io|
    io.set_encoding(extern, intern)
  end
  @CONF[:LC_MESSAGES].instance_variable_set(:@encoding, extern)
ensure
  $VERBOSE = verbose
end


  








  

    .setup(ap_path, argv: ::ARGV)  
  

  

    This method is for internal use only.
  



  

    

initialize config


  



  [ GitHub ]


  

  


# File 'lib/irb/init.rb', line 16



def IRB.setup(ap_path, argv: ::ARGV)
  IRB.init_config(ap_path)
  IRB.init_error
  IRB.parse_opts(argv: argv)
  IRB.run_config
  IRB.load_modules

  unless @CONF[:PROMPT][@CONF[:PROMPT_MODE]]
    IRB.fail(UndefinedPromptMode, @CONF[:PROMPT_MODE])
  end
end


  








  

    .start(ap_path = nil)  
  



  

    

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


  



  [ GitHub ]


  

  


# File 'lib/irb.rb', line 372



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  
  



  

    

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


  



  [ GitHub ]


  

  


# File 'lib/irb.rb', line 354



def IRB.version
  if v = @CONF[:VERSION] then return v end

  require "irb/version"
  rv = @RELEASE_VERSION.sub(/\.0/, "")
  @CONF[:VERSION] = format("irb %s(%s)", rv, @LAST_UPDATE_DATE)
end