Extended maintenance of Ruby 1.9.3 ended on February 23, 2015. Read more

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

IRB::Context

Attributes

ap_name[RW]
auto_indent_mode[RW]
back_trace_limit[RW]
debug_level[R]
echo[RW]
echo?[RW]
eval_history[R]
ignore_eof[RW]
ignore_eof?[RW]
ignore_sigint[RW]
ignore_sigint?[RW]
inspect_mode[R]
io[RW]
irb[RW]
irb_name[RW]
irb_path[RW]
last_value[R]
load_modules[RW]
math?[R]
math_mode[R]
prompt_c[RW]
prompt_i[RW]
prompt_mode[R]
prompt_n[RW]
prompt_s[RW]
rc[RW]
rc?[RW]
return_format[RW]
thread[R]
use_readline[R]
use_readline?[R]
use_tracer[R]
use_tracer?[R]
verbose[RW]
workspace[RW]
workspace_home[R]

Public Class Methods

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

Arguments:

input_method: nil -- stdin or readline
              String -- File
              other -- using this as InputMethod
 
               # File irb/context.rb, line 22
    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
#      @irb_level = 0

      # 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?(JobManager)
        @irb_name = IRB.conf[:IRB_NAME]
      else
        @irb_name = "irb#"+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
      @debug_level = IRB.conf[:DEBUG_LEVEL]
    end

Public Instance Methods

__exit__(ret = 0) click to toggle source
Alias for: exit
__inspect__() click to toggle source
Alias for: inspect
__to_s__() click to toggle source
Alias for: to_s
_set_last_value(value) click to toggle source
Alias for: set_last_value
change_workspace(*_main) click to toggle source 
 
               # File irb/ext/change-ws.rb, line 23
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 
 
               # File irb/context.rb, line 248
def debug?
  @debug_level > 0
end
debug_level=(value) click to toggle source 
 
               # File irb/context.rb, line 242
def debug_level=(value)
  @debug_level = value
  RubyLex.debug_level = value
  SLex.debug_level = value
end
eval_history=(no) click to toggle source 
 
               # File irb/ext/history.rb, line 33
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
evaluate(line, line_no) click to toggle source 
 
               # File irb/context.rb, line 252
    def evaluate(line, line_no)
      @line_no = line_no
      set_last_value(@workspace.evaluate(self, line, irb_path, line_no))
#      @workspace.evaluate("_ = IRB.conf[:MAIN_CONTEXT]._")
#      @_ = @workspace.evaluate(line, irb_path, line_no)
    end
exit(ret = 0) click to toggle source 
 
               # File irb/context.rb, line 264
def exit(ret = 0)
  IRB.irb_exit(@irb, ret)
end
Also aliased as: __exit__
file_input?() click to toggle source 
 
               # File irb/context.rb, line 189
def file_input?
  @io.class == FileInputMethod
end
history_file() click to toggle source 
 
               # File irb/ext/save-history.rb, line 38
def history_file
  IRB.conf[:HISTORY_FILE]
end
history_file=(hist) click to toggle source 
 
               # File irb/ext/save-history.rb, line 42
def history_file=(hist)
  IRB.conf[:HISTORY_FILE] = hist
end
home_workspace() click to toggle source 
 
               # File irb/ext/change-ws.rb, line 15
def home_workspace
  if defined? @home_workspace
    @home_workspace
  else
    @home_workspace = @workspace
  end
end
init_save_history() click to toggle source 
 
               # File irb/ext/save-history.rb, line 19
def init_save_history
  unless (class<<@io;self;end).include?(HistorySavingAbility)
    @io.extend(HistorySavingAbility)
  end
end
inspect() click to toggle source 
 
               # File irb/context.rb, line 273
def inspect
  array = []
  for ivar in instance_variables.sort{|e1, e2| e1 <=> e2}
    ivar = ivar.to_s
    name = ivar.sub(/^@(.*)$/, '\1')
    val = instance_eval(ivar)
    case ivar
    when *NOPRINTING_IVARS
      array.push format("conf.%s=%s", name, "...")
    when *NO_INSPECTING_IVARS
      array.push format("conf.%s=%s", name, val.to_s)
    when *IDNAME_IVARS
      array.push format("conf.%s=:%s", name, val.id2name)
    else
      array.push format("conf.%s=%s", name, val.inspect)
    end
  end
  array.join("\n")
end
Also aliased as: __inspect__, to_s
inspect?() click to toggle source 
 
               # File irb/context.rb, line 185
def inspect?
  @inspect_mode.nil? or @inspect_mode
end
inspect_last_value() click to toggle source 
 
               # File irb/context.rb, line 259
def inspect_last_value
  @inspect_method.inspect_value(@last_value)
end
inspect_mode=(opt) click to toggle source 
 
               # File irb/context.rb, line 193
def inspect_mode=(opt)

  if i = INSPECTORS[opt]
    @inspect_mode = opt
    @inspect_method = i
    i.init
  else
    case opt
    when nil
      if INSPECTORS.keys_with_inspector(INSPECTORS[true]).include?(@inspect_mode)
        self.inspect_mode = false
      elsif INSPECTORS.keys_with_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 INSPECTORS[format(prefix, i)]; i += 1; end
      @inspect_mode = format(prefix, i)
      @inspect_method = opt
      INSPECTORS.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 
 
               # File irb/ext/workspaces.rb, line 15
def irb_level
  workspace_stack.size
end
main() click to toggle source 
 
               # File irb/context.rb, line 103
def main
  @workspace.main
end
math_mode=(opt) click to toggle source 
 
               # File irb/ext/math-mode.rb, line 18
def math_mode=(opt)
  if @math_mode == true && opt == false
    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 
 
               # File irb/ext/workspaces.rb, line 46
def pop_workspace
  if workspaces.empty?
    print "workspace stack empty\n"
    return
  end
  @workspace = workspaces.pop
end
prompt_mode=(mode) click to toggle source 
 
               # File irb/context.rb, line 170
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 
 
               # File irb/context.rb, line 158
def prompting?
  verbose? || (STDIN.tty? && @io.kind_of?(StdioInputMethod) ||
            (defined?(ReadlineInputMethod) && @io.kind_of?(ReadlineInputMethod)))
end
push_workspace(*_main) click to toggle source 
 
               # File irb/ext/workspaces.rb, line 27
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 
 
               # File irb/ext/save-history.rb, line 25
def save_history
  IRB.conf[:SAVE_HISTORY]
end
save_history=(val) click to toggle source 
 
               # File irb/ext/save-history.rb, line 29
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 
 
               # File irb/context.rb, line 165
def set_last_value(value)
  @last_value = value
  @workspace.evaluate self, "_ = IRB.CurrentContext.last_value"
end
Also aliased as: _set_last_value
to_s() click to toggle source
Also aliased as: __to_s__
Alias for: inspect
use_loader() click to toggle source 
 
               # File irb/ext/use-loader.rb, line 34
def use_loader
  IRB.conf[:USE_LOADER]
end
Also aliased as: use_loader?
use_loader=(opt) click to toggle source 
 
               # File irb/ext/use-loader.rb, line 40
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 
 
               # File irb/context.rb, line 237
def use_readline=(opt)
  @use_readline = opt
  print "use readline module\n" if @use_readline
end
use_tracer=(opt) click to toggle source 
 
               # File irb/ext/tracer.rb, line 29
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 
 
               # File irb/context.rb, line 144
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 
 
               # File irb/ext/workspaces.rb, line 19
def workspaces
  if defined? @workspaces
    @workspaces
  else
    @workspaces = []
  end
end

Commenting is here to help enhance the documentation. For example, code samples, or clarification of the documentation.

If you have questions about Ruby or the documentation, please post to one of the Ruby mailing lists. You will get better, faster, help that way.

If you wish to post a correction of the docs, please do so, but also file bug report so that it can be corrected for the next release. Thank you.

If you want to help improve the Ruby documentation, please visit Documenting-ruby.org.