class Pry - pry-0.10.1 Documentation

# class Pry

PP subclass for streaming inspect output in color.

Pry is a powerful alternative to the standard IRB shell for Ruby. It features syntax highlighting, a flexible plugin architecture, runtime invocation and source and documentation browsing.

Pry can be started similar to other command line utilities by simply running the following command:

    pry

Once inside Pry you can invoke the help message:

    help

This will show a list of available commands and their usage. For more information about Pry you can refer to the following resources:

- pry.github.com/

- github.com/pry/pry

- the IRC channel, which is pry on the Freenode network

### Constants

BINDING_METHOD_IMPL

  @return [Array] Code of the method used when implementing Pry’s

      __binding__, along with line indication to be used with instance_eval (and
      friends).

  @see Object#__binding__

CLIPPED_PRINT

  useful when playing with truly enormous objects

Commands

  Default commands used by Pry.

DEFAULT_CONTROL_D_HANDLER

  Deal with the ^D key being pressed. Different behaviour in different cases:

      1. In an expression behave like `!` command.
      2. At top-level session behave like `exit` command.
      3. In a nested session behave like `cd ..`.

DEFAULT_EXCEPTION_HANDLER

  Will only show the first line of the backtrace

DEFAULT_EXCEPTION_WHITELIST

  Don’t catch these exceptions

DEFAULT_HOOKS

  The default hooks - display messages when beginning and ending Pry sessions.

DEFAULT_PRINT

  The default print

DEFAULT_PROMPT

  The default prompt; includes the target and nesting level

DEFAULT_PROMPT_NAME
DEFAULT_PROMPT_SAFE_OBJECTS
DEFAULT_SYSTEM
EMPTY_COMPLETIONS
HOME_RC_FILE
INITIAL_PWD

  Store the current working directory. This allows show-source etc. to work if your process has changed directory since boot. [Issue #675]

LOCAL_RC_FILE
NAV_PROMPT

  A prompt that includes the full object path as well as input/output (in and out) information. Good for navigation.

NO_PROMPT
SHELL_PROMPT
SIMPLE_PRINT

  may be convenient when working with enormous objects and pretty_print is too slow

SIMPLE_PROMPT

  A simple prompt - doesn’t display target or nesting level

VERSION

### Attributes

cli[RW]
config[RW]
current_line[RW]
custom_completions[RW]
eval_path[RW]
history[W]
last_internal_error[RW]
line_buffer[RW]
quiet[RW]
backtrace[RW]
binding_stack[RW]
command_state[R]
config[R]
custom_completions[RW]
eval_string[RW]
exit_value[R]
input_array[R]
last_dir[RW]
last_exception[R]
last_file[RW]
last_result[RW]
output_array[R]
suppress_output[RW]

### Public Class Methods

Code(obj) click to toggle source

Convert the given object into an instance of `Pry::Code`, if it isn’t already one.

@param [Code, Method, UnboundMethod, Proc, Pry::Method, String, Array,

    IO] obj

    # File lib/pry/code.rb, line 12
    def Code(obj)
      case obj
      when Code
        obj
      when ::Method, UnboundMethod, Proc, Pry::Method
        Code.from_method(obj)
      else
        Code.new(obj)
      end
    end

Method(obj) click to toggle source

If the given object is a `Pry::Method`, return it unaltered. If it’s anything else, return it wrapped in a `Pry::Method` instance.

    # File lib/pry/method.rb, line 7
    def Method(obj)
      if obj.is_a? Pry::Method
        obj
      else
        Pry::Method.new(obj)
      end
    end

WrappedModule(obj) click to toggle source

If the given object is a `Pry::WrappedModule`, return it unaltered. If it’s anything else, return it wrapped in a `Pry::WrappedModule` instance.

    # File lib/pry/wrapped_module.rb, line 7
    def WrappedModule(obj)
      if obj.is_a? Pry::WrappedModule
        obj
      else
        Pry::WrappedModule.new(obj)
      end
    end

auto_resize!() click to toggle source

    # File lib/pry/pry_class.rb, line 275
      def self.auto_resize!
        Pry.config.input # by default, load Readline

        if !defined?(Readline) || Pry.config.input != Readline
          warn "Sorry, you must be using Readline for Pry.auto_resize! to work."
          return
        end

        if Readline::VERSION =~ /edit/i
          warn <<-EOT
    Readline version #{Readline::VERSION} detected - will not auto_resize! correctly.
      For the fix, use GNU Readline instead:
      https://github.com/guard/guard/wiki/Add-proper-Readline-support-to-Ruby-on-Mac-OS-X
          EOT
          return
        end

        trap :WINCH do
          begin
            Readline.set_screen_size(*Terminal.size!)
          rescue => e
            warn "\nPry.auto_resize!'s Readline.set_screen_size failed: #{e}"
          end
          begin
            Readline.refresh_line
          rescue => e
            warn "\nPry.auto_resize!'s Readline.refresh_line failed: #{e}"
          end
        end
      end

binding_for(target) click to toggle source

Return a `Binding` object for `target` or return `target` if it is already a `Binding`. In the case where `target` is top-level then return `TOPLEVEL_BINDING` @param [Object] target The object to get a `Binding` object for. @return [Binding] The `Binding` object.

    # File lib/pry/pry_class.rb, line 328
    def self.binding_for(target)
      if Binding === target
        target
      else
        if Pry.main == target
          TOPLEVEL_BINDING
        else
          target.__binding__
        end
      end
    end

critical_section() { || ... } click to toggle source

    # File lib/pry/pry_class.rb, line 366
    def self.critical_section(&block)
      Thread.current[:pry_critical_section] ||= 0
      Thread.current[:pry_critical_section] += 1
      yield
    ensure
      Thread.current[:pry_critical_section] -= 1
    end

current() click to toggle source

@return [Pry::Config]

    Returns a value store for an instance of Pry running on the current thread.

    # File lib/pry/pry_class.rb, line 49
    def self.current
      Thread.current[:__pry__] ||= Pry::Config.from_hash({}, nil)
    end

default_editor_for_platform() click to toggle source

    # File lib/pry/pry_class.rb, line 263
    def self.default_editor_for_platform
      return ENV['VISUAL'] if ENV['VISUAL'] and not ENV['VISUAL'].empty?
      return ENV['EDITOR'] if ENV['EDITOR'] and not ENV['EDITOR'].empty?
      if Helpers::BaseHelpers.windows?
        'notepad'
      else
        %w(editor nano vi).detect do |editor|
          system("which #{editor} > /dev/null 2>&1")
        end
      end
    end

history() click to toggle source

    # File lib/pry/pry_class.rb, line 32
    def history
      @history ||= History.new
    end

in_critical_section?() click to toggle source

    # File lib/pry/pry_class.rb, line 361
    def self.in_critical_section?
      Thread.current[:pry_critical_section] ||= 0
      Thread.current[:pry_critical_section] > 0
    end

init() click to toggle source

Basic initialization.

    # File lib/pry/pry_class.rb, line 317
    def self.init
      @plugin_manager ||= PluginManager.new
      reset_defaults
      locate_plugins
    end

initial_session?() click to toggle source

@return [Boolean] Whether this is the first time a Pry session has

    been started since loading the Pry class.

    # File lib/pry/pry_class.rb, line 227
    def self.initial_session?
      @initial_session
    end

initial_session_setup() click to toggle source

Do basic setup for initial session. Including: loading .pryrc, loading plugins, loading requires, and loading history.

    # File lib/pry/pry_class.rb, line 120
    def self.initial_session_setup
      return unless initial_session?
      @initial_session = false

      # note these have to be loaded here rather than in pry_instance as
      # we only want them loaded once per entire Pry lifetime.
      load_rc_files
      load_plugins if Pry.config.should_load_plugins
      load_requires if Pry.config.should_load_requires
      load_history if Pry.config.history.should_load
      load_traps if Pry.config.should_trap_interrupts
      load_win32console if Pry::Helpers::BaseHelpers.windows? && !Pry::Helpers::BaseHelpers.windows_ansi?
    end

load_file_at_toplevel(file) click to toggle source

Load the given file in the context of `Pry.toplevel_binding` @param [String] file The unexpanded file path.

    # File lib/pry/pry_class.rb, line 55
    def self.load_file_at_toplevel(file)
      toplevel_binding.eval(File.read(file), file)
    rescue RescuableException => e
      puts "Error loading #{file}: #{e}\n#{e.backtrace.first}"
    end

load_file_through_repl(file_name) click to toggle source

Execute the file through the REPL loop, non-interactively. @param [String] file_name File name to load through the REPL.

    # File lib/pry/pry_class.rb, line 177
    def self.load_file_through_repl(file_name)
      require "pry/repl_file_loader"
      REPLFileLoader.new(file_name).load
    end

load_history() click to toggle source

Load Readline history if required.

    # File lib/pry/pry_class.rb, line 221
    def self.load_history
      Pry.history.load
    end

load_rc_files() click to toggle source

Load HOME_RC_FILE and LOCAL_RC_FILE if appropriate This method can also be used to reload the files if they have changed.

    # File lib/pry/pry_class.rb, line 63
    def self.load_rc_files
      rc_files_to_load.each do |file|
        critical_section do
          load_file_at_toplevel(file)
        end
      end
    end

load_requires() click to toggle source

Load any Ruby files specified with the -r flag on the command line.

    # File lib/pry/pry_class.rb, line 89
    def self.load_requires
      Pry.config.requires.each do |file|
        require file
      end
    end

load_traps() click to toggle source

Trap interrupts on jruby, and make them behave like MRI so we can catch them.

    # File lib/pry/pry_class.rb, line 97
    def self.load_traps
      trap('INT'){ raise Interrupt }
    end

load_win32console() click to toggle source

    # File lib/pry/pry_class.rb, line 101
      def self.load_win32console
        begin
          require 'win32console'
          # The mswin and mingw versions of pry require win32console, so this should
          # only fail on jruby (where win32console doesn't work).
          # Instead we'll recommend ansicon, which does.
        rescue LoadError
          warn "For a better Pry experience on Windows, please use ansicon:
      https://github.com/adoxa/ansicon
    If you use an alternative to ansicon and don't want to see this warning again,
    you can add "Pry.config.windows_console_warning = false" to your .pryrc.
    " if Pry.config.windows_console_warning
        end
      end

main() click to toggle source

@return [main]

    returns the special instance of Object, "main".

    # File lib/pry/pry_class.rb, line 41
    def self.main
      @main ||= TOPLEVEL_BINDING.eval "self"
    end

new(options={}) click to toggle source

Create a new {Pry} instance. @param [Hash] options @option options [#readline] :input

    The object to use for input.

@option options [#puts] :output

    The object to use for output.

@option options [Pry::CommandBase] :commands

    The object to use for commands.

@option options [Hash] :hooks

    The defined hook Procs.

@option options [Array<Proc>] :prompt

    The array of Procs to use for prompts.

@option options [Proc] :print

    The Proc to use for printing return values.

@option options [Boolean] :quiet

    Omit the `whereami` banner when starting.

@option options [Array<String>] :backtrace

    The backtrace of the session's `binding.pry` line, if applicable.

@option options [Object] :target

    The initial context for this session.

    # File lib/pry/pry_instance.rb, line 64
    def initialize(options={})
      @binding_stack = []
      @indent        = Pry::Indent.new
      @command_state = {}
      @eval_string   = ""
      @backtrace     = options.delete(:backtrace) || caller
      target = options.delete(:target)
      @config = Pry::Config.new
      config.merge!(options)
      push_prompt(config.prompt)
      @input_array  = Pry::HistoryArray.new config.memory_size
      @output_array = Pry::HistoryArray.new config.memory_size
      @custom_completions = config.command_completions
      set_last_result nil
      @input_array << nil
      push_initial_binding(target)
      exec_hook(:when_started, target, options, self)
    end

orig_reset_defaults()
Alias for: reset_defaults
prompt() click to toggle source

    # File lib/pry/pry_class.rb, line 28
    def prompt
      config.prompt
    end

prompt=(value) click to toggle source

    # File lib/pry/pry_class.rb, line 24
    def prompt=(value)
      config.prompt = value
    end

rc_files_to_load() click to toggle source

Load the local RC file (./.pryrc)

    # File lib/pry/pry_class.rb, line 72
    def self.rc_files_to_load
      files = []
      files << HOME_RC_FILE if Pry.config.should_load_rc
      files << LOCAL_RC_FILE if Pry.config.should_load_local_rc
      files.map { |file| real_path_to(file) }.compact.uniq
    end

real_path_to(file) click to toggle source

Expand a file to its canonical name (following symlinks as appropriate)

    # File lib/pry/pry_class.rb, line 80
    def self.real_path_to(file)
      expanded = Pathname.new(File.expand_path(file)).realpath.to_s
      # For rbx 1.9 mode [see rubinius issue #2165]
      File.exist?(expanded) ? expanded : nil
    rescue Errno::ENOENT
      nil
    end

reset_defaults() click to toggle source

Set all the configurable options back to their default values

    # File lib/pry/pry_class.rb, line 307
    def self.reset_defaults
      @initial_session = true
      self.config = Pry::Config.new Pry::Config::Default.new
      self.cli = false
      self.current_line = 1
      self.line_buffer = [""]
      self.eval_path = "(pry)"
    end

Also aliased as: orig_reset_defaults
run_command(command_string, options={}) click to toggle source

Run a Pry command from outside a session. The commands available are those referenced by `Pry.config.commands` (the default command set). @param [String] command_string The Pry command (including arguments,

    if any).

@param [Hash] options Optional named parameters. @return [Object] The return value of the Pry command. @option options [Object, Binding] :target The object to run the

    command under. Defaults to `TOPLEVEL_BINDING` (main).

@option options [Boolean] :show_output Whether to show command

    output. Defaults to true.

@example Run at top-level with no output.

    Pry.run_command "ls"

@example Run under Pry class, returning only public methods.

    Pry.run_command "ls -m", :target => Pry

@example Display command output.

    Pry.run_command "ls -av", :show_output => true

    # File lib/pry/pry_class.rb, line 247
    def self.run_command(command_string, options={})
      options = {
        :target => TOPLEVEL_BINDING,
        :show_output => true,
        :output => Pry.config.output,
        :commands => Pry.config.commands
      }.merge!(options)

      # :context for compatibility with <= 0.9.11.4
      target = options[:context] || options[:target]
      output = options[:show_output] ? options[:output] : StringIO.new

      pry = Pry.new(:output   => output, :target   => target, :commands => options[:commands])
      pry.eval command_string
    end

start(target=nil, options={}) click to toggle source

Start a Pry REPL. This method also loads `~/.pryrc` and `./.pryrc` as necessary the first time it is invoked. @param [Object, Binding] target The receiver of the Pry session @param [Hash] options @option options (see Pry#initialize) @example

    Pry.start(Object.new, :input => MyInput.new)

    # File lib/pry/pry_class.rb, line 142
    def self.start(target=nil, options={})
      return if ENV['DISABLE_PRY']
      options = options.to_hash

      if in_critical_section?
        output.puts "ERROR: Pry started inside Pry."
        output.puts "This can happen if you have a binding.pry inside a #to_s or #inspect function."
        return
      end

      options[:target] = Pry.binding_for(target || toplevel_binding)
      options[:hooks] = Pry::Hooks.from_hash options.delete(:hooks) if options.key?(:hooks)
      initial_session_setup

      # Unless we were given a backtrace, save the current one
      if options[:backtrace].nil?
        options[:backtrace] = caller

        # If Pry was started via `binding.pry`, elide that from the backtrace
        if options[:backtrace].first =~ /pry.*core_extensions.*pry/
          options[:backtrace].shift
        end
      end

      driver = options[:driver] || Pry::REPL

      # Enter the matrix
      driver.start(options)
    rescue Pry::TooSafeException
      puts "ERROR: Pry cannot work with $SAFE > 0"
      raise
    end

toplevel_binding() click to toggle source

    # File lib/pry/pry_class.rb, line 340
    def self.toplevel_binding
      unless defined?(@toplevel_binding) && @toplevel_binding
        # Grab a copy of the TOPLEVEL_BINDING without any local variables.
        # This binding has a default definee of Object, and new methods are
        # private (just as in TOPLEVEL_BINDING).
        TOPLEVEL_BINDING.eval <<-RUBY
          def self.__pry__
            binding
          end
          Pry.toplevel_binding = __pry__
          class << self; undef __pry__; end
        RUBY
      end
      @toplevel_binding.eval('private')
      @toplevel_binding
    end

toplevel_binding=(binding) click to toggle source

    # File lib/pry/pry_class.rb, line 357
    def self.toplevel_binding=(binding)
      @toplevel_binding = binding
    end

view_clip(obj, options = {}) click to toggle source

An inspector that clips the output to `max_length` chars. In case of > `max_length` chars the `#<Object…> notation is used.

@param [Object] obj

    The object to view.

@param [Hash] options @option options [Integer] :max_length (60)

    The maximum number of chars before clipping occurs.

@option options [Boolean] :id (false)

    Boolean to indicate whether or not a hex reprsentation of the object ID
    is attached to the return value when the length of inspect is greater than
    value of `:max_length`.

@return [String]

    The string representation of `obj`.

    # File lib/pry/pry_class.rb, line 201
    def self.view_clip(obj, options = {})
      max = options.fetch :max_length, 60
      id = options.fetch :id, false
      if obj.kind_of?(Module) && obj.name.to_s != "" && obj.name.to_s.length <= max
        obj.name.to_s
      elsif Pry.main == obj
        # special-case to support jruby.
        # fixed as of https://github.com/jruby/jruby/commit/d365ebd309cf9df3dde28f5eb36ea97056e0c039
        # we can drop in the future.
        obj.to_s
      elsif Pry.config.prompt_safe_objects.any? { |v| v === obj } && obj.inspect.length <= max
        obj.inspect
      else
        id == true ? "#<#{obj.class}:0x%x>" % (obj.object_id << 1) : "#<#{obj.class}>"
      end
    rescue RescuableException
      "unknown"
    end

### Public Instance Methods

add_sticky_local(name, &block) click to toggle source

Add a sticky local to this Pry instance. A sticky local is a local that persists between all bindings in a session. @param [Symbol] name The name of the sticky local. @yield The block that defines the content of the local. The local

    will be refreshed at each tick of the repl loop.

    # File lib/pry/pry_instance.rb, line 194
    def add_sticky_local(name, &block)
      config.extra_sticky_locals[name] = block
    end

complete(str) click to toggle source

Generate completions.

@param [String] input

    What the user has typed so far

@return [Array<String>]

    Possible completions

    # File lib/pry/pry_instance.rb, line 132
    def complete(str)
      return EMPTY_COMPLETIONS unless config.completer
      Pry.critical_section do
        completer = config.completer.new(config.input, self)
        completer.call str, target: current_binding, custom_completions: custom_completions.call.push(*sticky_locals.keys)
      end
    end

current_binding() click to toggle source

The currently active `Binding`. @return [Binding] The currently active `Binding` for the session.

    # File lib/pry/pry_instance.rb, line 111
    def current_binding
      binding_stack.last
    end

Also aliased as: current_context
current_context()
Alias for: current_binding
eval(line, options={}) click to toggle source

Pass a line of input to Pry.

This is the equivalent of `Binding#eval` but with extra Pry!

In particular:

1. Pry commands will be executed immediately if the line matches.

2. Partial lines of input will be queued up until a complete expression has been accepted.

3. Output is written to `#output` in pretty colours, not returned.

Once this method has raised an exception or returned false, this instance is no longer usable. {#exit_value} will return the session’s breakout value if applicable.

@param [String?] line The line of input; `nil` if the user types `<Ctrl-D>` @option options [Boolean] :generated Whether this line was generated automatically.

    Generated lines are not stored in history.

@return [Boolean] Is Pry ready to accept more input? @raise [Exception] If the user uses the `raise-up` command, this method

    will raise that exception.

    # File lib/pry/pry_instance.rb, line 236
    def eval(line, options={})
      return false if @stopped

      exit_value = nil
      exception = catch(:raise_up) do
        exit_value = catch(:breakout) do
          handle_line(line, options)
          # We use 'return !@stopped' here instead of 'return true' so that if
          # handle_line has stopped this pry instance (e.g. by opening _pry_.repl and
          # then popping all the bindings) we still exit immediately.
          return !@stopped
        end
        exception = false
      end

      @stopped = true
      @exit_value = exit_value

      # TODO: make this configurable?
      raise exception if exception
      return false
    end

evaluate_ruby(code) click to toggle source

    # File lib/pry/pry_instance.rb, line 350
    def evaluate_ruby(code)
      inject_sticky_locals!
      exec_hook :before_eval, code, self

      result = current_binding.eval(code, Pry.eval_path, Pry.current_line)
      set_last_result(result, code)
    ensure
      update_input_history(code)
      exec_hook :after_eval, result, self
    end

exec_hook(name, *args, &block) click to toggle source

Execute the specified hook. @param [Symbol] name The hook name to execute @param [*Object] args The arguments to pass to the hook @return [Object, Exception] The return value of the hook or the exception raised

If executing a hook raises an exception, we log that and then continue sucessfully. To debug such errors, use the global variable $pry_hook_error, which is set as a result.

    # File lib/pry/pry_instance.rb, line 464
    def exec_hook(name, *args, &block)
      e_before = hooks.errors.size
      hooks.exec_hook(name, *args, &block).tap do
        hooks.errors[e_before..-1].each do |e|
          output.puts "#{name} hook failed: #{e.class}: #{e.message}"
          output.puts "#{e.backtrace.first}"
          output.puts "(see _pry_.hooks.errors to debug)"
        end
      end
    end

inject_local(name, value, b) click to toggle source

Injects a local variable into the provided binding.

@param [String] name

    The name of the local to inject.

@param [Object] value

    The value to set the local to.

@param [Binding] b

    The binding to set the local on.

@return [Object]

    The value the local was set to.

    # File lib/pry/pry_instance.rb, line 155
    def inject_local(name, value, b)
      value = Proc === value ? value.call : value
      if b.respond_to?(:local_variable_set)
        b.local_variable_set name, value
      else # < 2.1
        begin
          Pry.current[:pry_local] = value
          b.eval "#{name} = ::Pry.current[:pry_local]"
        ensure
          Pry.current[:pry_local] = nil
        end
      end
    end

inject_sticky_locals!() click to toggle source

Inject all the sticky locals into the current binding.

    # File lib/pry/pry_instance.rb, line 183
    def inject_sticky_locals!
      sticky_locals.each_pair do |name, value|
        inject_local(name, value, current_binding)
      end
    end

last_exception=(e) click to toggle source

Set the last exception for a session.

@param [Exception] e

    the last exception.

    # File lib/pry/pry_instance.rb, line 492
    def last_exception=(e)
      last_exception = Pry::LastException.new(e)
      @last_result_is_exception = true
      @output_array << last_exception
      @last_exception = last_exception
    end

last_result_is_exception?() click to toggle source

@return [Boolean] True if the last result is an exception that was raised,

    as opposed to simply an instance of Exception (like the result of
    Exception.new)

    # File lib/pry/pry_instance.rb, line 514
    def last_result_is_exception?
      @last_result_is_exception
    end

memory_size() click to toggle source

@return [Integer] The maximum amount of objects remembered by the inp and

    out arrays. Defaults to 100.

    # File lib/pry/pry_instance.rb, line 172
    def memory_size
      @output_array.max_size
    end

memory_size=(size) click to toggle source

    # File lib/pry/pry_instance.rb, line 177
    def memory_size=(size)
      @input_array  = Pry::HistoryArray.new(size)
      @output_array = Pry::HistoryArray.new(size)
    end

output() click to toggle source

Returns an output device @example

    _pry_.output.puts "ohai!"

    # File lib/pry/pry_instance.rb, line 612
    def output
      Pry::Output.new(self)
    end

pager() click to toggle source

Returns the currently configured pager @example

    _pry_.pager.page text

    # File lib/pry/pry_instance.rb, line 604
    def pager
      Pry::Pager.new(self)
    end

pop_prompt() click to toggle source

Pops the current prompt off of the prompt stack. If the prompt you are popping is the last prompt, it will not be popped. Use this to restore the previous prompt. @return [Array<Proc>] Prompt being popped. @example

    prompt1 = [ proc { '>' }, proc { '>>' } ]
    prompt2 = [ proc { '$' }, proc { '>' } ]
    pry = Pry.new :prompt => prompt1
    pry.push_prompt(prompt2)
    pry.pop_prompt # => prompt2
    pry.pop_prompt # => prompt1
    pry.pop_prompt # => prompt1

    # File lib/pry/pry_instance.rb, line 596
    def pop_prompt
      prompt_stack.size > 1 ? prompt_stack.pop : prompt
    end

process_command(val) click to toggle source

If the given line is a valid command, process it in the context of the current `eval_string` and binding. @param [String] val The line to process. @return [Boolean] `true` if `val` is a command, `false` otherwise

    # File lib/pry/pry_instance.rb, line 401
    def process_command(val)
      val = val.chomp
      result = commands.process_line(val,
        :target => current_binding,
        :output => output,
        :eval_string => @eval_string,
        :pry_instance => self
      )

      # set a temporary (just so we can inject the value we want into eval_string)
      Pry.current[:pry_cmd_result] = result

      # note that `result` wraps the result of command processing; if a
      # command was matched and invoked then `result.command?` returns true,
      # otherwise it returns false.
      if result.command?
        if !result.void_command?
          # the command that was invoked was non-void (had a return value) and so we make
          # the value of the current expression equal to the return value
          # of the command.
          @eval_string.replace "::Pry.current[:pry_cmd_result].retval\n"
        end
        true
      else
        false
      end
    end

process_command_safely(val) click to toggle source

Same as #process_command, but outputs exceptions to `#output` instead of raising. @param [String] val The line to process. @return [Boolean] `true` if `val` is a command, `false` otherwise

    # File lib/pry/pry_instance.rb, line 433
    def process_command_safely(val)
      process_command(val)
    rescue CommandError, Slop::InvalidOptionError, MethodSource::SourceNotFoundError => e
      Pry.last_internal_error = e
      output.puts "Error: #{e.message}"
      true
    end

prompt() click to toggle source

The current prompt. This is the prompt at the top of the prompt stack.

@example

    self.prompt = Pry::SIMPLE_PROMPT
    self.prompt # => Pry::SIMPLE_PROMPT

@return [Array<Proc>] Current prompt.

    # File lib/pry/pry_instance.rb, line 91
    def prompt
      prompt_stack.last
    end

prompt=(new_prompt) click to toggle source

    # File lib/pry/pry_instance.rb, line 95
    def prompt=(new_prompt)
      if prompt_stack.empty?
        push_prompt new_prompt
      else
        prompt_stack[-1] = new_prompt
      end
    end

push_binding(object) click to toggle source

Push a binding for the given object onto the stack. If this instance is currently stopped, mark it as usable again.

    # File lib/pry/pry_instance.rb, line 118
    def push_binding(object)
      @stopped = false
      binding_stack << Pry.binding_for(object)
    end

push_initial_binding(target=nil) click to toggle source

Initialize this instance by pushing its initial context into the binding stack. If no target is given, start at the top level.

    # File lib/pry/pry_instance.rb, line 105
    def push_initial_binding(target=nil)
      push_binding(target || Pry.toplevel_binding)
    end

push_prompt(new_prompt) click to toggle source

Pushes the current prompt onto a stack that it can be restored from later. Use this if you wish to temporarily change the prompt. @param [Array<Proc>] new_prompt @return [Array<Proc>] new_prompt @example

    new_prompt = [ proc { '>' }, proc { '>>' } ]
    push_prompt(new_prompt) # => new_prompt

    # File lib/pry/pry_instance.rb, line 580
    def push_prompt(new_prompt)
      prompt_stack.push new_prompt
    end

quiet?() click to toggle source

Convenience accessor for the `quiet` config key. @return [Boolean]

    # File lib/pry/pry_instance.rb, line 660
    def quiet?
      config.quiet
    end

raise_up(*args) click to toggle source

    # File lib/pry/pry_instance.rb, line 655
    def raise_up(*args); raise_up_common(false, *args); end

raise_up!(*args) click to toggle source

    # File lib/pry/pry_instance.rb, line 656
    def raise_up!(*args); raise_up_common(true, *args); end

raise_up_common(force, *args) click to toggle source

Raise an exception out of Pry.

See Kernel#raise for documentation of parameters. See rb_make_exception for the inbuilt implementation.

This is necessary so that the raise-up command can tell the difference between an exception the user has decided to raise, and a mistake in specifying that exception.

(i.e. raise-up RunThymeError.new should not be the same as

    raise-up NameError, "unititialized constant RunThymeError")

    # File lib/pry/pry_instance.rb, line 628
    def raise_up_common(force, *args)
      exception = if args == []
                    last_exception || RuntimeError.new
                  elsif args.length == 1 && args.first.is_a?(String)
                    RuntimeError.new(args.first)
                  elsif args.length > 3
                    raise ArgumentError, "wrong number of arguments"
                  elsif !args.first.respond_to?(:exception)
                    raise TypeError, "exception class/object expected"
                  elsif args.length === 1
                    args.first.exception
                  else
                    args.first.exception(args[1])
                  end

      raise TypeError, "exception object expected" unless exception.is_a? Exception

      exception.set_backtrace(args.length === 3 ? args[2] : caller(1))

      if force || binding_stack.one?
        binding_stack.clear
        throw :raise_up, exception
      else
        binding_stack.pop
        raise exception
      end
    end

repl(target = nil) click to toggle source

Potentially deprecated — Use `Pry::REPL.new(pry, :target => target).start` (If nested sessions are going to exist, this method is fine, but a goal is to come up with an alternative to nested sessions altogether.)

    # File lib/pry/pry_instance.rb, line 346
    def repl(target = nil)
      Pry::REPL.new(self, :target => target).start
    end

reset_eval_string() click to toggle source

Reset the current eval string. If the user has entered part of a multiline expression, this discards that input.

    # File lib/pry/pry_instance.rb, line 212
    def reset_eval_string
      @eval_string = ""
    end

run_command(val) click to toggle source

Run the specified command. @param [String] val The command (and its params) to execute. @return [Pry::Command::VOID_VALUE] @example

    pry_instance.run_command("ls -m")

    # File lib/pry/pry_instance.rb, line 446
    def run_command(val)
      commands.process_line(val,
        :eval_string => @eval_string,
        :target => current_binding,
        :pry_instance => self,
        :output => output
      )
      Pry::Command::VOID_VALUE
    end

select_prompt() click to toggle source

Returns the appropriate prompt to use. @return [String] The prompt.

    # File lib/pry/pry_instance.rb, line 527
    def select_prompt
      object = current_binding.eval('self')

      open_token = @indent.open_delimiters.any? ? @indent.open_delimiters.last :
        @indent.stack.last

      c = Pry::Config.from_hash({
                         :object         => object,
                         :nesting_level  => binding_stack.size - 1,
                         :open_token     => open_token,
                         :session_line   => Pry.history.session_line_count + 1,
                         :history_line   => Pry.history.history_line_count + 1,
                         :expr_number    => input_array.count,
                         :_pry_          => self,
                         :binding_stack  => binding_stack,
                         :input_array    => input_array,
                         :eval_string    => @eval_string,
                         :cont           => !@eval_string.empty?})

      Pry.critical_section do
        # If input buffer is empty then use normal prompt
        if eval_string.empty?
          generate_prompt(Array(prompt).first, c)

        # Otherwise use the wait prompt (indicating multi-line expression)
        else
          generate_prompt(Array(prompt).last, c)
        end
      end
    end

set_last_result(result, code="") click to toggle source

Set the last result of an eval. This method should not need to be invoked directly. @param [Object] result The result. @param [String] code The code that was run.

    # File lib/pry/pry_instance.rb, line 479
    def set_last_result(result, code="")
      @last_result_is_exception = false
      @output_array << result

      self.last_result = result unless code =~ /\A\s*\z/
    end

should_print?() click to toggle source

Whether the print proc should be invoked. Currently only invoked if the output is not suppressed. @return [Boolean] Whether the print proc should be invoked.

    # File lib/pry/pry_instance.rb, line 521
    def should_print?
      !@suppress_output
    end

show_result(result) click to toggle source

Output the result or pass to an exception handler (if result is an exception).

    # File lib/pry/pry_instance.rb, line 362
    def show_result(result)
      if last_result_is_exception?
        exception_handler.call(output, result, self)
      elsif should_print?
        print.call(output, result, self)
      else
        # nothin'
      end
    rescue RescuableException => e
      # Being uber-paranoid here, given that this exception arose because we couldn't
      # serialize something in the user's program, let's not assume we can serialize
      # the exception either.
      begin
        output.puts "(pry) output error: #{e.inspect}"
      rescue RescuableException => e
        if last_result_is_exception?
          output.puts "(pry) output error: failed to show exception"
        else
          output.puts "(pry) output error: failed to show result"
        end
      end
    ensure
      output.flush if output.respond_to?(:flush)
    end

sticky_locals() click to toggle source

    # File lib/pry/pry_instance.rb, line 198
    def sticky_locals
      { _in_: input_array,
        _out_: output_array,
        _pry_: self,
        _ex_: last_exception && last_exception.wrapped_exception,
        _file_: last_file,
        _dir_: last_dir,
        _: proc { last_result },
        __: proc { output_array[-2] }
      }.merge(config.extra_sticky_locals)
    end

update_input_history(code) click to toggle source

Update Pry’s internal state after evalling code. This method should not need to be invoked directly. @param [String] code The code we just eval’d

    # File lib/pry/pry_instance.rb, line 502
    def update_input_history(code)
      # Always push to the @input_array as the @output_array is always pushed to.
      @input_array << code
      if code
        Pry.line_buffer.push(*code.each_line)
        Pry.current_line += code.lines.count
      end
    end