NAME¶

SYNOPSIS¶

DESCRIPTION¶

    $ jirb1.3
    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
    irb(main):007:0> 

And, Readline extesion module can be used with irb. Using Readline is the standard default action if Readline is installed.

OPTIONS¶

-f

suppress read ~/.irbrc

-m

bc mode (fraction or matrix are available)

-d

set $DEBUG to true (same as `ruby -d')

-r load-module

same as `ruby -r'

--inspect

uses `inspect' for output (the default except bc mode)

--noinspect

doesn't uses inspect for output

--readline

uses Readline extension module

--noreadline

doesn't use Readline extension module

--prompt prompt-mode

--prompt-mode prompt-mode

switches prompt mode. Pre-defined prompt modes are `default', `simple', `xmp' and `inf-ruby'

--inf-ruby-mode

uses prompt appreciate for inf-ruby-mode on emacs. Suppresses --readline.

--simple-prompt

simple prompt mode

--noprompt

no prompt

--tracer

display trace for each execution of commands.

--back-trace-limit n

displayes backtrace top n and tail n. The default value is 16.

--irb_debug n

sets internal debug level to n (It shouldn't be used)

-v, --version

prints the version of irb

CONFIGURATIONS¶

    IRB.conf[:IRB_NAME]="irb"
    IRB.conf[:MATH_MODE]=false
    IRB.conf[:USE_TRACER]=false
    IRB.conf[:USE_LOADER]=false
    IRB.conf[:IGNORE_SIGINT]=true
    IRB.conf[:IGNORE_EOF]=false
    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] = :DEFALUT
    IRB.conf[:PROMPT] = {...}
    IRB.conf[:DEBUG_LEVEL]=0
    IRB.conf[:VERBOSE]=true

Customizing prompt¶

    IRB.conf[:PROMPT]

For example, describe as follows in `.irbrc'.

    IRB.conf[:PROMPT][:MY_PROMPT] = { # name of prompt mode
      :PROMPT_I => nil,		  # normal prompt
      :PROMPT_S => nil,		  # prompt for continuated strings
      :PROMPT_C => nil,		  # prompt for continuated statement
      :RETURN => "    ==>%s\n"	  # format to return value
    }

Then, invoke irb with the above prompt mode by

    $ jirb1.3 --prompt my-prompt

Or add the following in `.irbrc'.

    IRB.conf[:PROMPT_MODE] = :MY_PROMPT

Constants PROMPT_I, PROMPT_S and PROMPT_C specifies 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 degits and means as same as printf("%NNd"). 
          It can be ommited
    %NNn	line number. 
    %%    %

PROMPT_I => "%N(%m):%03n:%i> ",

PROMPT_S => "%N(%m):%03n:%i%l ",

PROMPT_C => "%N(%m):%03n:%i* ",

RETURN => "%s\n"}

RETURN is used to printf.

Configurating subirb¶

Command¶

exit, quit, irb_exit

Quits (sub)irb. if you've done cb (see below), exit from the binding mode.

conf, irb_context

Displays current configuration. Modifing the configuration is achieved by sending message to `conf'.

conf.back_trace_limit

Sets display lines of backtrace as top n and tail n. The default value is 16.

conf.debug_level = N

Sets debug level of irb.

conf.ignore_eof = true/false

Whether ^D (control-d) will be ignored or not. If false is set, ^D means quit.

conf.ignore_sigint= true/false

Whether ^C (control-c) will be ignored or not. If false is set, ^D means quit. If true,

    during input:   cancel inputing then return to top level. 
    during execute: abondon current execution. 
    

conf.inf_ruby_mode = true/false

Whether inf-ruby-mode or not. The default value is false.

conf.inspect_mode = true/false/nil

Specifies inspect mode. true: display inspect false: display to_s nil: inspect mode in non math mode,

    non inspect mode in math mode. 
    

conf.irb_level

The level of cb.

conf.math_mode

Whether bc mode or not.

conf.use_loader = true/false

Whether irb's own file reader method is used when load/require or not. This mode is globaly affected (irb wide).

conf.prompt_c

prompt for a continuating statement (e.g, immediately after of `if')

conf.prompt_i

standard prompt

conf.prompt_s

prompt for a continuating string

conf.rc

Whether ~/.irbrc is read or not.

conf.use_prompt = true/false

Prompting or not.

conf.use_readline = true/false/nil

Whether readline is used or not. true: uses false: doen't use nil: intends to use readline except for inf-reuby-mode (default)

conf.verbose=T/F

Whether verbose messages are display or not.

cb, irb_change_binding [obj]

Enter new binding which has a distinct scope of local variables. If obj is given, obj will be self.

irb [obj]

Invoke subirb. If obj is given, obj will be self.

jobs, irb_jobs

List of subirb

fg n, irb_fg n

Switch into specified subirb. The following is candidates of n:

    irb number
    thhread
    irb object
    self(obj which is specified of irb obj)
    

kill n, irb_kill n

Kill subirb. The means of n is as same as the case of irb_fg.

System variable¶

_

The latest value of evaluation (it is local)

Session Example¶

    $ jirb1.3
    irb(main):001:0> irb                        # invoke subirb
    irb#1(main):001:0> jobs                     # list of subirbs
    #0->irb on main (#<Thread:0x400fb7e4> : stop)
    #1->irb#1 on main (#<Thread:0x40125d64> : running)
    nil
    irb#1(main):002:0> fg 0                     # switch job
    nil
    irb(main):002:0> class Foo;end
    nil
    irb(main):003:0> irb Foo                    # invoke subirb which has the 

    #              context of Foo

    irb#2(Foo):001:0> def foo                   # define Foo#foo
    irb#2(Foo):002:1>   print 1
    irb#2(Foo):003:1> end
    nil
    irb#2(Foo):004:0> fg 0                      # switch job
    nil
    irb(main):004:0> jobs                       # list of job
    #0->irb on main (#<Thread:0x400fb7e4> : running)
    #1->irb#1 on main (#<Thread:0x40125d64> : stop)
    #2->irb#2 on Foo (#<Thread:0x4011d54c> : stop)
    nil
    irb(main):005:0> Foo.instance_methods       # Foo#foo is defined asurely
    ["foo"]
    irb(main):006:0> fg 2                       # switch job
    nil
    irb#2(Foo):005:0> def bar                   # define Foo#bar
    irb#2(Foo):006:1>  print "bar"
    irb#2(Foo):007:1> end
    nil
    irb#2(Foo):010:0>  Foo.instance_methods
    ["bar", "foo"]
    irb#2(Foo):011:0> fg 0                      
    nil
    irb(main):007:0> f = Foo.new
    #<Foo:0x4010af3c>
    irb(main):008:0> irb f                      # invoke subirb which has the

    #  context of f (instance of Foo)

    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)
    nil
    irb#3(#<Foo:0x4010af3c>):002:0> foo         # evaluate f.foo
    1nil
    irb#3(#<Foo:0x4010af3c>):003:0> bar         # evaluate f.bar
    barnil
    irb#3(#<Foo:0x4010af3c>):004:0> kill 1, 2, 3# kill job
    nil
    irb(main):009:0> jobs
    #0->irb on main (#<Thread:0x400fb7e4> : running)
    nil
    irb(main):010:0> exit                       # exit

Restrictions¶

Declaration of the local variable¶

    eval "foo = 0"
    foo
    --
    -:2: undefined local variable or method `foo' for #<Object:0x40283118> (NameError)
    ---
    NameError

Though, the above will successfully done by irb.

    >> eval "foo = 0"

    => 0
    >> foo
    => 0

Ruby evaluates a code after reading entire of code and determination of the scope of local variables. On the other hand, irb do immediately. More precisely, irb evaluate at first

    evel "foo = 0" 

then foo is defined on this timing. It is because of this incompatibility. If you'd like to detect those differences, begin...end can be used:

    >> begin
    ?>   eval "foo = 0"
    >>   foo
    >> end
    NameError: undefined local variable or method `foo' for #<Object:0x4013d0f0>
    (irb):3
    (irb_local_binding):1:in `eval'

Here-document¶

Symbol¶