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:

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

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 <<-WARNING if Pry.config.windows_console_warning
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.
      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

Private Instance Methods

ensure_correct_encoding!(val) click to toggle source

Force `eval_string` into the encoding of `val`. [Issue #284]

# File lib/pry/pry_instance.rb, line 388
def ensure_correct_encoding!(val)
  if @eval_string.empty? &&
      val.respond_to?(:encoding) &&
      val.encoding != @eval_string.encoding
    @eval_string.force_encoding(val.encoding)
  end
end
generate_prompt(prompt_proc, conf) click to toggle source
# File lib/pry/pry_instance.rb, line 558
def generate_prompt(prompt_proc, conf)
  if prompt_proc.arity == 1
    prompt_proc.call(conf)
  else
    prompt_proc.call(conf.object, conf.nesting_level, conf._pry_)
  end
end
handle_line(line, options) click to toggle source
# File lib/pry/pry_instance.rb, line 259
def handle_line(line, options)
  if line.nil?
    config.control_d_handler.call(@eval_string, self)
    return
  end

  ensure_correct_encoding!(line)
  Pry.history << line unless options[:generated]

  @suppress_output = false
  inject_sticky_locals!
  begin
    if !process_command_safely(line.lstrip)
      @eval_string << "#{line.chomp}\n" if !line.empty? || !@eval_string.empty?
    end
  rescue RescuableException => e
    self.last_exception = e
    result = e

    Pry.critical_section do
      show_result(result)
    end
    return
  end

  # This hook is supposed to be executed after each line of ruby code
  # has been read (regardless of whether eval_string is yet a complete expression)
  exec_hook :after_read, eval_string, self

  begin
    complete_expr = Pry::Code.complete_expression?(@eval_string)
  rescue SyntaxError => e
    output.puts "SyntaxError: #{e.message.sub(/.*syntax error, */m, '')}"
    reset_eval_string
  end

  if complete_expr
    if @eval_string =~ /;\Z/ || @eval_string.empty? || @eval_string =~ /\A *#.*\n\z/
      @suppress_output = true
    end

    # A bug in jruby makes java.lang.Exception not rescued by
    # `rescue Pry::RescuableException` clause.
    #
    # * https://github.com/pry/pry/issues/854
    # * https://jira.codehaus.org/browse/JRUBY-7100
    #
    # Until that gets fixed upstream, treat java.lang.Exception
    # as an additional exception to be rescued explicitly.
    #
    # This workaround has a side effect: java exceptions specified
    # in `Pry.config.exception_whitelist` are ignored.
    jruby_exceptions = []
    if Pry::Helpers::BaseHelpers.jruby?
      jruby_exceptions << Java::JavaLang::Exception
    end

    begin
      # Reset eval string, in case we're evaluating Ruby that does something
      # like open a nested REPL on this instance.
      eval_string = @eval_string
      reset_eval_string

      result = evaluate_ruby(eval_string)
    rescue RescuableException, *jruby_exceptions => e
      # Eliminate following warning:
      # warning: singleton on non-persistent Java type X
      # (http://wiki.jruby.org/Persistence)
      if Pry::Helpers::BaseHelpers.jruby? && e.class.respond_to?('__persistent__')
        e.class.__persistent__ = true
      end
      self.last_exception = e
      result = e
    end

    Pry.critical_section do
      show_result(result)
    end
  end

  throw(:breakout) if current_binding.nil?
end
prompt_stack() click to toggle source

the array that the prompt stack is stored in

# File lib/pry/pry_instance.rb, line 568
def prompt_stack
  @prompt_stack ||= Array.new
end