Class: IRB::Context (Ruby 2.4.2)
Description: Class : IRB::Context - Ruby 2.4.2

Support for the Ruby 2.4 series has ended. See here for reference.

### Home Classes Methods

### In Files

- irb/context.rb
- irb/ext/change-ws.rb
- irb/ext/history.rb
- irb/ext/math-mode.rb
- irb/ext/save-history.rb
- irb/ext/tracer.rb
- irb/ext/use-loader.rb
- irb/ext/workspaces.rb

### Parent

Object

### Methods

- ::new
- #__exit__
- #_set_last_value
- #change_workspace
- #debug?
- #debug_level=
- #eval_history=
- #exit
- #file_input?
- #history_file
- #history_file=
- #home_workspace
- #inspect?
- #inspect_mode=
- #irb_level
- #main
- #math_mode=
- #pop_workspace
- #prompt_mode=
- #prompting?
- #push_workspace
- #save_history
- #save_history=
- #set_last_value
- #use_loader
- #use_loader=
- #use_loader?
- #use_readline=
- #use_tracer=
- #verbose?
- #workspaces

### Class/Module Index

Quicksearch

- IRB::Abort
- IRB::Context
- IRB::ContextExtender
- IRB::ExtendCommandBundle
- IRB::FileInputMethod
- IRB::Frame
- IRB::InputMethod
- IRB::Inspector
- IRB::Irb
- IRB::IrbLoader
- IRB::JobManager
- IRB::LoadAbort
- IRB::MethodExtender
- IRB::Notifier
- IRB::Notifier::AbstractNotifier
- IRB::Notifier::CompositeNotifier
- IRB::Notifier::LeveledNotifier
- IRB::Notifier::NoMsgNotifier
- IRB::OutputMethod
- IRB::ReadlineInputMethod
- IRB::StdioInputMethod
- IRB::StdioOutputMethod
- IRB::WorkSpace
- Object
- XMP
- XMP::StringInputMethod

No matching classes.

# IRB::Context

A class that wraps the current state of the irb session, including the configuration of `IRB.conf`.

### Attributes

ap_name[RW]

A copy of the default `IRB.conf[:AP_NAME]`

auto_indent_mode[RW]

Can be either the default `IRB.conf[:AUTO_INDENT]`, or the mode set by `prompt_mode=`

To enable auto-indentation in irb:

    IRB.conf[:AUTO_INDENT] = true

or

    irb_context.auto_indent_mode = true

or

    IRB.CurrentContext.auto_indent_mode = true

See Configuration at `IRB` for more information.

back_trace_limit[RW]

The limit of backtrace lines displayed as top `n` and tail `n`.

The default value is 16.

Can also be set using the `--back-trace-limit` command line option.

See Command line options at `IRB` for more command line options.

debug_level[R]

The debug level of irb

See `debug_level=` for more information.

echo[RW]

Whether to echo the return value to output or not.

Uses `IRB.conf` if available, or defaults to `true`.

    puts "hello"
    # hello
    #=> nil
    IRB.CurrentContext.echo = false
    puts "omg"
    # omg

echo?[RW]

Whether to echo the return value to output or not.

Uses `IRB.conf` if available, or defaults to `true`.

    puts "hello"
    # hello
    #=> nil
    IRB.CurrentContext.echo = false
    puts "omg"
    # omg

eval_history[R]

The command result history limit.

ignore_eof[RW]

Whether `^D` (`control-d`) will be ignored or not.

If set to `false`, `^D` will quit irb.

ignore_eof?[RW]

Whether `^D` (`control-d`) will be ignored or not.

If set to `false`, `^D` will quit irb.

ignore_sigint[RW]

Whether `^C` (`control-c`) will be ignored or not.

If set to `false`, `^C` will quit irb.

If set to `true`,

- during input: cancel input then return to top level.

- during execute: abandon current execution.

ignore_sigint?[RW]

Whether `^C` (`control-c`) will be ignored or not.

If set to `false`, `^C` will quit irb.

If set to `true`,

- during input: cancel input then return to top level.

- during execute: abandon current execution.

inspect_mode[R]

A copy of the default `IRB.conf[:INSPECT_MODE]`

io[RW]

The current input method

Can be either `StdioInputMethod`, `ReadlineInputMethod`, `FileInputMethod` or other specified when the context is created. See `::new` for more information on `input_method`.

irb[RW]

Current irb session

irb_name[RW]

Can be either name from `IRB.conf[:IRB_NAME]`, or the number of the current job set by `JobManager`, such as `irb#2`

irb_path[RW]

Can be either the `irb_name` surrounded by parenthesis, or the `input_method` passed to `Context.new`

last_value[R]

The return value of the last statement evaluated.

load_modules[RW]

A copy of the default `IRB.conf[:LOAD_MODULES]`

math?[R]

Returns whether bc mode is enabled.

See `math_mode=`

math_mode[R]

Returns whether bc mode is enabled.

See `math_mode=`

prompt_c[RW]

IRB prompt for continuated statement (e.g. immediately after an `if`)

See IRB for more information.

prompt_i[RW]

Standard IRB prompt

See IRB for more information.

prompt_mode[R]

A copy of the default `IRB.conf[:PROMPT_MODE]`

prompt_n[RW]

See Customizing the IRB Prompt at `IRB` for more information.

prompt_s[RW]

IRB prompt for continuated strings

See IRB for more information.

rc[RW]

A copy of the default `IRB.conf[:RC]`

rc?[RW]

A copy of the default `IRB.conf[:RC]`

return_format[RW]

The format of the return statement, set by `prompt_mode=` using the `:RETURN` of the `mode` passed to set the current `prompt_mode`.

thread[R]

The current thread in this context

use_readline[R]

Whether `Readline` is enabled or not.

A copy of the default `IRB.conf[:USE_READLINE]`

See `use_readline=` for more information.

use_readline?[R]

Whether `Readline` is enabled or not.

A copy of the default `IRB.conf[:USE_READLINE]`

See `use_readline=` for more information.

use_tracer[R]

Whether Tracer is used when evaluating statements in this context.

See `lib/tracer.rb` for more information.

use_tracer?[R]

Whether Tracer is used when evaluating statements in this context.

See `lib/tracer.rb` for more information.

verbose[RW]

Whether verbose messages are displayed or not.

A copy of the default `IRB.conf[:VERBOSE]`

workspace[RW]

`WorkSpace` in the current context

workspace_home[R]

The toplevel workspace, see `home_workspace`

### Public Class Methods

new(irb, workspace = nil, input_method = nil, output_method = nil) click to toggle source

Creates a new IRB context.

The optional `input_method` argument:

`nil`

  uses stdin or Readline

`String`

  uses a File

`other`

  uses this as `InputMethod`

                   # File irb/context.rb, line 27
    def initialize(irb, workspace = nil, input_method = nil, output_method = nil)
      @irb = irb
      if workspace
        @workspace = workspace
      else
        @workspace = WorkSpace.new
      end
      @thread = Thread.current if defined? Thread

      # copy of default configuration
      @ap_name = IRB.conf[:AP_NAME]
      @rc = IRB.conf[:RC]
      @load_modules = IRB.conf[:LOAD_MODULES]

      @use_readline = IRB.conf[:USE_READLINE]
      @verbose = IRB.conf[:VERBOSE]
      @io = nil

      self.inspect_mode = IRB.conf[:INSPECT_MODE]
      self.math_mode = IRB.conf[:MATH_MODE] if IRB.conf[:MATH_MODE]
      self.use_tracer = IRB.conf[:USE_TRACER] if IRB.conf[:USE_TRACER]
      self.use_loader = IRB.conf[:USE_LOADER] if IRB.conf[:USE_LOADER]
      self.eval_history = IRB.conf[:EVAL_HISTORY] if IRB.conf[:EVAL_HISTORY]

      @ignore_sigint = IRB.conf[:IGNORE_SIGINT]
      @ignore_eof = IRB.conf[:IGNORE_EOF]

      @back_trace_limit = IRB.conf[:BACK_TRACE_LIMIT]

      self.prompt_mode = IRB.conf[:PROMPT_MODE]

      if IRB.conf[:SINGLE_IRB] or !defined?(IRB::JobManager)
        @irb_name = IRB.conf[:IRB_NAME]
      else
        @irb_name = IRB.conf[:IRB_NAME]+"#"+IRB.JobManager.n_jobs.to_s
      end
      @irb_path = "(" + @irb_name + ")"

      case input_method
      when nil
        case use_readline?
        when nil
          if (defined?(ReadlineInputMethod) && STDIN.tty? &&
              IRB.conf[:PROMPT_MODE] != :INF_RUBY)
            @io = ReadlineInputMethod.new
          else
            @io = StdioInputMethod.new
          end
        when false
          @io = StdioInputMethod.new
        when true
          if defined?(ReadlineInputMethod)
            @io = ReadlineInputMethod.new
          else
            @io = StdioInputMethod.new
          end
        end

      when String
        @io = FileInputMethod.new(input_method)
        @irb_name = File.basename(input_method)
        @irb_path = input_method
      else
        @io = input_method
      end
      self.save_history = IRB.conf[:SAVE_HISTORY] if IRB.conf[:SAVE_HISTORY]

      if output_method
        @output_method = output_method
      else
        @output_method = StdioOutputMethod.new
      end

      @echo = IRB.conf[:ECHO]
      if @echo.nil?
        @echo = true
      end
      self.debug_level = IRB.conf[:DEBUG_LEVEL]
    end

### Public Instance Methods

__exit__(ret = 0) click to toggle source
Alias for: exit
_set_last_value(value) click to toggle source

See `set_last_value`

Alias for: set_last_value
change_workspace(*_main) click to toggle source

Changes the current workspace to given object or binding.

If the optional argument is omitted, the workspace will be `home_workspace` which is inherited from `TOPLEVEL_BINDING` or the main object, `IRB.conf[:MAIN_CONTEXT]` when irb was initialized.

See `IRB::WorkSpace.new` for more information.

                   # File irb/ext/change-ws.rb, line 32
    def change_workspace(*_main)
      if _main.empty?
        @workspace = home_workspace
        return main
      end

      @workspace = WorkSpace.new(_main[0])

      if !(class<<main;ancestors;end).include?(ExtendCommandBundle)
        main.extend ExtendCommandBundle
      end
    end

debug?() click to toggle source

Whether or not debug mode is enabled, see `debug_level=`.

                   # File irb/context.rb, line 375
    def debug?
      @debug_level > 0
    end

debug_level=(value) click to toggle source

Sets the debug level of irb

Can also be set using the `--irb_debug` command line option.

See Command line options at `IRB` for more command line options.

                   # File irb/context.rb, line 369
    def debug_level=(value)
      @debug_level = value
      RubyLex.debug_level = value
    end

eval_history=(no) click to toggle source

Sets command result history limit.

`no` is an Integer or `nil`.

Returns `no` of history items if greater than 0.

If `no` is 0, the number of history items is unlimited.

If `no` is `nil`, execution result history isn't used (default).

                   # File irb/ext/history.rb, line 44
    def eval_history=(no)
      if no
        if defined?(@eval_history) && @eval_history
          @eval_history_values.size(no)
        else
          @eval_history_values = History.new(no)
          IRB.conf[:__TMP__EHV__] = @eval_history_values
          @workspace.evaluate(self, "__ = IRB.conf[:__TMP__EHV__]")
          IRB.conf.delete(:__TMP_EHV__)
        end
      else
        @eval_history_values = nil
      end
      @eval_history = no
    end

exit(ret = 0) click to toggle source

Exits the current session, see `IRB.irb_exit`

                   # File irb/context.rb, line 390
    def exit(ret = 0)
      IRB.irb_exit(@irb, ret)
    end

Also aliased as: __exit__
file_input?() click to toggle source

Whether `io` uses a File for the `input_method` passed when creating the current context, see `::new`

                   # File irb/context.rb, line 293
    def file_input?
      @io.class == FileInputMethod
    end

history_file() click to toggle source

A copy of the default `IRB.conf[:HISTORY_FILE]`

                   # File irb/ext/save-history.rb, line 50
    def history_file
      IRB.conf[:HISTORY_FILE]
    end

history_file=(hist) click to toggle source

Set `IRB.conf[:HISTORY_FILE]` to the given `hist`.

                   # File irb/ext/save-history.rb, line 55
    def history_file=(hist)
      IRB.conf[:HISTORY_FILE] = hist
    end

home_workspace() click to toggle source

Inherited from `TOPLEVEL_BINDING`.

                   # File irb/ext/change-ws.rb, line 17
    def home_workspace
      if defined? @home_workspace
        @home_workspace
      else
        @home_workspace = @workspace
      end
    end

inspect?() click to toggle source

Whether `inspect_mode` is set or not, see `inspect_mode=` for more detail.

                   # File irb/context.rb, line 287
    def inspect?
      @inspect_mode.nil? or @inspect_mode
    end

inspect_mode=(opt) click to toggle source

Specifies the inspect mode with `opt`:

`true`

  display `inspect`

`false`

  display `to_s`

`nil`

  inspect mode in non-math mode, non-inspect mode in math mode

See `IRB::Inspector` for more information.

Can also be set using the `--inspect` and `--noinspect` command line options.

See Command line options at `IRB` for more command line options.

                   # File irb/context.rb, line 310
    def inspect_mode=(opt)

      if i = Inspector::INSPECTORS[opt]
        @inspect_mode = opt
        @inspect_method = i
        i.init
      else
        case opt
        when nil
          if Inspector.keys_with_inspector(Inspector::INSPECTORS[true]).include?(@inspect_mode)
            self.inspect_mode = false
          elsif Inspector.keys_with_inspector(Inspector::INSPECTORS[false]).include?(@inspect_mode)
            self.inspect_mode = true
          else
            puts "Can't switch inspect mode."
            return
          end
        when /^\s*\{.*\}\s*$/
          begin
            inspector = eval "proc#{opt}"
          rescue Exception
            puts "Can't switch inspect mode(#{opt})."
            return
          end
          self.inspect_mode = inspector
        when Proc
          self.inspect_mode = IRB::Inspector(opt)
        when Inspector
          prefix = "usr%d"
          i = 1
          while Inspector::INSPECTORS[format(prefix, i)]; i += 1; end
          @inspect_mode = format(prefix, i)
          @inspect_method = opt
          Inspector.def_inspector(format(prefix, i), @inspect_method)
        else
          puts "Can't switch inspect mode(#{opt})."
          return
        end
      end
      print "Switch to#{unless @inspect_mode; ' non';end} inspect mode.\n" if verbose?
      @inspect_mode
    end

irb_level() click to toggle source

Size of the current `WorkSpace` stack

                   # File irb/ext/workspaces.rb, line 17
    def irb_level
      workspace_stack.size
    end

main() click to toggle source

The top-level workspace, see `WorkSpace#main`

                   # File irb/context.rb, line 108
    def main
      @workspace.main
    end

math_mode=(opt) click to toggle source

Sets bc mode, which loads `lib/mathn.rb` so fractions or matrix are available.

Also available as the `-m` command line option.

See Command line options at `IRB` and the unix manpage `bc(1)` for more information.

                   # File irb/ext/math-mode.rb, line 30
    def math_mode=(opt)
      if @math_mode == true && !opt
        IRB.fail CantReturnToNormalMode
        return
      end

      @math_mode = opt
      if math_mode
        main.extend Math
        print "start math mode\n" if verbose?
      end
    end

pop_workspace() click to toggle source

Removes the last element from the current `workspaces` stack and returns it, or `nil` if the current workspace stack is empty.

Also, see `push_workspace`.

                   # File irb/ext/workspaces.rb, line 58
    def pop_workspace
      if workspaces.empty?
        print "workspace stack empty\n"
        return
      end
      @workspace = workspaces.pop
    end

prompt_mode=(mode) click to toggle source

Sets the `mode` of the prompt in this context.

See Customizing the IRB Prompt at `IRB` for more information.

                   # File irb/context.rb, line 271
    def prompt_mode=(mode)
      @prompt_mode = mode
      pconf = IRB.conf[:PROMPT][mode]
      @prompt_i = pconf[:PROMPT_I]
      @prompt_s = pconf[:PROMPT_S]
      @prompt_c = pconf[:PROMPT_C]
      @prompt_n = pconf[:PROMPT_N]
      @return_format = pconf[:RETURN]
      if ai = pconf.include?(:AUTO_INDENT)
        @auto_indent_mode = ai
      else
        @auto_indent_mode = IRB.conf[:AUTO_INDENT]
      end
    end

prompting?() click to toggle source

Whether `verbose?` is `true`, and `input_method` is either `StdioInputMethod` or `ReadlineInputMethod`, see `io` for more information.

                   # File irb/context.rb, line 253
    def prompting?
      verbose? || (STDIN.tty? && @io.kind_of?(StdioInputMethod) ||
                   (defined?(ReadlineInputMethod) && @io.kind_of?(ReadlineInputMethod)))
    end

push_workspace(*_main) click to toggle source

Creates a new workspace with the given object or binding, and appends it onto the current `workspaces` stack.

See `IRB::Context#change_workspace` and `IRB::WorkSpace.new` for more information.

                   # File irb/ext/workspaces.rb, line 35
    def push_workspace(*_main)
      if _main.empty?
        if workspaces.empty?
          print "No other workspace\n"
          return nil
        end
        ws = workspaces.pop
        workspaces.push @workspace
        @workspace = ws
        return workspaces
      end

      workspaces.push @workspace
      @workspace = WorkSpace.new(@workspace.binding, _main[0])
      if !(class<<main;ancestors;end).include?(ExtendCommandBundle)
        main.extend ExtendCommandBundle
      end
    end

save_history() click to toggle source

A copy of the default `IRB.conf[:SAVE_HISTORY]`

                   # File irb/ext/save-history.rb, line 26
    def save_history
      IRB.conf[:SAVE_HISTORY]
    end

save_history=(val) click to toggle source

Sets `IRB.conf[:SAVE_HISTORY]` to the given `val` and calls init_save_history with this context.

Will store the number of `val` entries of history in the `history_file`

Add the following to your `.irbrc` to change the number of history entries stored to 1000:

    IRB.conf[:SAVE_HISTORY] = 1000

                   # File irb/ext/save-history.rb, line 40
    def save_history=(val)
      IRB.conf[:SAVE_HISTORY] = val
      if val
        main_context = IRB.conf[:MAIN_CONTEXT]
        main_context = self unless main_context
        main_context.init_save_history
      end
    end

set_last_value(value) click to toggle source

Sets the return value from the last statement evaluated in this context to `last_value`.

                   # File irb/context.rb, line 263
    def set_last_value(value)
      @last_value = value
      @workspace.evaluate self, "_ = IRB.CurrentContext.last_value"
    end

Also aliased as: _set_last_value
use_loader() click to toggle source

Returns whether `irb`'s own file reader method is used by `load`/`require` or not.

This mode is globally affected (irb-wide).

                   # File irb/ext/use-loader.rb, line 41
    def use_loader
      IRB.conf[:USE_LOADER]
    end

Also aliased as: use_loader?
use_loader=(opt) click to toggle source

Sets `IRB.conf`

See `use_loader` for more information.

                   # File irb/ext/use-loader.rb, line 50
    def use_loader=(opt)

      if IRB.conf[:USE_LOADER] != opt
        IRB.conf[:USE_LOADER] = opt
        if opt
          if !$".include?("irb/cmd/load")
          end
          (class<<@workspace.main;self;end).instance_eval {
            alias_method :load, :irb_load
            alias_method :require, :irb_require
          }
        else
          (class<<@workspace.main;self;end).instance_eval {
            alias_method :load, :__original__load__IRB_use_loader__
            alias_method :require, :__original__require__IRB_use_loader__
          }
        end
      end
      print "Switch to load/require#{unless use_loader; ' non';end} trace mode.\n" if verbose?
      opt
    end

use_loader?() click to toggle source
Alias for: use_loader
use_readline=(opt) click to toggle source

Obsolete method.

Can be set using the `--noreadline` and `--readline` command line options.

See Command line options at `IRB` for more command line options.

                   # File irb/context.rb, line 359
    def use_readline=(opt)
      print "This method is obsolete."
      print "Do nothing."
    end

use_tracer=(opt) click to toggle source

Sets whether or not to use the Tracer library when evaluating statements in this context.

See `lib/tracer.rb` for more information.

                   # File irb/ext/tracer.rb, line 37
    def use_tracer=(opt)
      if opt
        Tracer.set_get_line_procs(@irb_path) {
          |line_no, *rests|
          @io.line(line_no)
        }
      elsif !opt && @use_tracer
        Tracer.off
      end
      @use_tracer=opt
    end

verbose?() click to toggle source

Returns whether messages are displayed or not.

                   # File irb/context.rb, line 237
    def verbose?
      if @verbose.nil?
        if defined?(ReadlineInputMethod) && @io.kind_of?(ReadlineInputMethod)
          false
        elsif !STDIN.tty? or @io.kind_of?(FileInputMethod)
          true
        else
          false
        end
      else
        @verbose
      end
    end

workspaces() click to toggle source

WorkSpaces in the current stack

                   # File irb/ext/workspaces.rb, line 22
    def workspaces
      if defined? @workspaces
        @workspaces
      else
        @workspaces = []
      end
    end