Class: Pry

Inherits:
Object show all
Extended by:
Config::Convenience, Forwardable
Defined in:
lib/pry/pager.rb,
lib/pry.rb,
lib/pry/cli.rb,
lib/pry/code.rb,
lib/pry/repl.rb,
lib/pry/ring.rb,
lib/pry/hooks.rb,
lib/pry/config.rb,
lib/pry/editor.rb,
lib/pry/indent.rb,
lib/pry/method.rb,
lib/pry/prompt.rb,
lib/pry/command.rb,
lib/pry/history.rb,
lib/pry/plugins.rb,
lib/pry/rubygem.rb,
lib/pry/version.rb,
lib/pry/code/loc.rb,
lib/pry/platform.rb,
lib/pry/pry_class.rb,
lib/pry/exceptions.rb,
lib/pry/input_lock.rb,
lib/pry/code_object.rb,
lib/pry/command_set.rb,
lib/pry/commands/cd.rb,
lib/pry/commands/ls.rb,
lib/pry/commands/ri.rb,
lib/pry/forwardable.rb,
lib/pry/object_path.rb,
lib/pry/commands/cat.rb,
lib/pry/commands/wtf.rb,
lib/pry/helpers/text.rb,
lib/pry/pry_instance.rb,
lib/pry/color_printer.rb,
lib/pry/commands/bang.rb,
lib/pry/commands/edit.rb,
lib/pry/commands/exit.rb,
lib/pry/commands/gist.rb,
lib/pry/commands/help.rb,
lib/pry/commands/hist.rb,
lib/pry/commands/play.rb,
lib/pry/commands/stat.rb,
lib/pry/helpers/table.rb,
lib/pry/code/code_file.rb,
lib/pry/commands/reset.rb,
lib/pry/config/default.rb,
lib/pry/method/patcher.rb,
lib/pry/wrapped_module.rb,
lib/pry/code/code_range.rb,
lib/pry/commands/gem_cd.rb,
lib/pry/config/behavior.rb,
lib/pry/core_extensions.rb,
lib/pry/method/disowned.rb,
lib/pry/commands/jump_to.rb,
lib/pry/commands/ls/grep.rb,
lib/pry/commands/nesting.rb,
lib/pry/helpers/platform.rb,
lib/pry/repl_file_loader.rb,
lib/pry/commands/bang_pry.rb,
lib/pry/commands/exit_all.rb,
lib/pry/commands/gem_list.rb,
lib/pry/commands/gem_open.rb,
lib/pry/commands/raise_up.rb,
lib/pry/commands/show_doc.rb,
lib/pry/commands/whereami.rb,
lib/pry/commands/save_file.rb,
lib/pry/commands/show_info.rb,
lib/pry/commands/switch_to.rb,
lib/pry/config/convenience.rb,
lib/pry/config/memoization.rb,
lib/pry/commands/amend_line.rb,
lib/pry/commands/fix_indent.rb,
lib/pry/commands/import_set.rb,
lib/pry/commands/ls/globals.rb,
lib/pry/commands/ls/methods.rb,
lib/pry/commands/shell_mode.rb,
lib/pry/commands/show_input.rb,
lib/pry/commands/disable_pry.rb,
lib/pry/commands/easter_eggs.rb,
lib/pry/commands/find_method.rb,
lib/pry/commands/gem_install.rb,
lib/pry/commands/pry_version.rb,
lib/pry/commands/reload_code.rb,
lib/pry/commands/show_source.rb,
lib/pry/commands/exit_program.rb,
lib/pry/commands/ls/constants.rb,
lib/pry/commands/ls/formatter.rb,
lib/pry/commands/ls/ls_entity.rb,
lib/pry/commands/toggle_color.rb,
lib/pry/commands/ls/local_vars.rb,
lib/pry/commands/pry_backtrace.rb,
lib/pry/commands/shell_command.rb,
lib/pry/commands/code_collector.rb,
lib/pry/commands/ls/local_names.rb,
lib/pry/helpers/command_helpers.rb,
lib/pry/helpers/options_helpers.rb,
lib/pry/commands/install_command.rb,
lib/pry/commands/ls/self_methods.rb,
lib/pry/wrapped_module/candidate.rb,
lib/pry/commands/ls/instance_vars.rb,
lib/pry/commands/watch_expression.rb,
lib/pry/commands/cat/file_formatter.rb,
lib/pry/method/weird_method_locator.rb,
lib/pry/helpers/documentation_helpers.rb,
lib/pry/commands/cat/abstract_formatter.rb,
lib/pry/commands/edit/exception_patcher.rb,
lib/pry/commands/cat/exception_formatter.rb,
lib/pry/commands/edit/file_and_line_locator.rb,
lib/pry/commands/watch_expression/expression.rb,
lib/pry/commands/cat/input_expression_formatter.rb

Overview

PP subclass for streaming inspect output in color.

Defined Under Namespace

Modules: ExtendCommandBundle, Forwardable, FrozenObjectException, Helpers, Platform, Prompt, RescuableException, Rubygem, Testable, TooSafeException, UserError Classes: BasicObject, BlockCommand, CLI, ClassCommand, Code, CodeFile, CodeObject, ColorPrinter, Command, CommandError, CommandSet, Config, Editor, History, Hooks, Indent, InputCompleter, InputLock, Inspector, LastException, Method, MethodNotFound, NoCommandError, ObjectPath, ObsoleteError, Output, Pager, PluginManager, REPL, REPLFileLoader, Result, Ring, Slop, Terminal, WrappedModule

Constant Summary collapse

DEFAULT_HOOKS =

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

Pry::Hooks.new.add_hook(:before_session, :default) do |out, target, _pry_|
  next if _pry_.quiet?

  _pry_.run_command("whereami --quiet")
end
DEFAULT_PRINT =

The default print

proc do |output, value, _pry_|
  _pry_.pager.open do |pager|
    pager.print _pry_.config.output_prefix
    Pry::ColorPrinter.pp(value, pager, Pry::Terminal.width! - 1)
  end
end
SIMPLE_PRINT =

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

proc do |output, value|
  begin
    output.puts value.inspect
  rescue RescuableException
    output.puts "unknown"
  end
end
CLIPPED_PRINT =

useful when playing with truly enormous objects

proc do |output, value|
  output.puts Pry.view_clip(value, id: true)
end
DEFAULT_EXCEPTION_HANDLER =

Will only show the first line of the backtrace

proc do |output, exception, _|
  if UserError === exception && SyntaxError === exception
    output.puts "SyntaxError: #{exception.message.sub(/.*syntax error, */m, '')}"
  else
    output.puts "#{exception.class}: #{exception.message}"
    output.puts "from #{exception.backtrace.first}"

    if exception.respond_to? :cause
      cause = exception.cause
      while cause
        output.puts "Caused by #{cause.class}: #{cause}\n"
        output.puts "from #{cause.backtrace.first}"
        cause = cause.cause
      end
    end
  end
end
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 ..`.

proc do |eval_string, _pry_|
  if !eval_string.empty?
    eval_string.replace('') # Clear input buffer.
  elsif _pry_.binding_stack.one?
    _pry_.binding_stack.clear
    throw(:breakout)
  else
    # Otherwise, saves current binding stack as old stack and pops last
    # binding out of binding stack (the old stack still has that binding).
    _pry_.command_state["cd"] ||= Pry::Config.from_hash({}) # FIXME
    _pry_.command_state['cd'].old_stack = _pry_.binding_stack.dup
    _pry_.binding_stack.pop
  end
end
DEFAULT_SYSTEM = 
proc do |output, cmd, _|
  if !system(cmd)
    output.puts "Error: there was a problem executing system command: #{cmd}"
  end
end
VERSION = 
'0.12.2'.freeze
Commands =

Default commands used by Pry.

Pry::CommandSet.new
HOME_RC_FILE = 
if ENV.key?('PRYRC')
  ENV['PRYRC']
elsif File.exist?(File.expand_path('~/.pryrc'))
  '~/.pryrc'
elsif ENV.key?('XDG_CONFIG_HOME') && ENV['XDG_CONFIG_HOME'] != ''
  # See XDG Base Directory Specification at
  # https://standards.freedesktop.org/basedir-spec/basedir-spec-0.8.html
  ENV['XDG_CONFIG_HOME'] + '/pry/pryrc'
else
  '~/.config/pry/pryrc'
end
LOCAL_RC_FILE = 
"./.pryrc"
DEFAULT_EXCEPTION_WHITELIST =

Don’t catch these exceptions

[SystemExit,
SignalException,
Pry::TooSafeException]
EMPTY_COMPLETIONS = 
[].freeze
BINDING_METHOD_IMPL =

Returns Code of the method used when implementing Pry’s __binding__, along with line indication to be used with instance_eval (and friends).

Returns:

  • (Array) —

    Code of the method used when implementing Pry’s __binding__, along with line indication to be used with instance_eval (and friends).

See Also:

[<<-METHOD, __FILE__, __LINE__ + 1]
  # Get a binding with 'self' set to self, and no locals.
  #
  # The default definee is determined by the context in which the
  # definition is eval'd.
  #
  # Please don't call this method directly, see {__binding__}.
  #
  # @return [Binding]
  def __pry__
    binding
  end
METHOD

Constants included from Config::Convenience

Config::Convenience::SHORTCUTS

Class Attribute Summary collapse

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Forwardable

def_private_delegators

Methods included from Config::Convenience

config_shortcut

Constructor Details

#initialize(options = {}) ⇒ Pry

Create a new Pry instance.

Parameters:

  • options (Hash) (defaults to: {})

Options Hash (options):

  • :input (#readline) —

    The object to use for input.

  • :output (#puts) —

    The object to use for output.

  • :commands (Pry::CommandBase) —

    The object to use for commands.

  • :hooks (Hash) —

    The defined hook Procs.

  • :prompt (Array<Proc>) —

    The array of Procs to use for prompts.

  • :print (Proc) —

    The Proc to use for printing return values.

  • :quiet (Boolean) —

    Omit the ‘whereami` banner when starting.

  • :backtrace (Array<String>) —

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

  • :target (Object) —

    The initial context for this session.



71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
 
# File 'lib/pry/pry_instance.rb', line 71

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_ring = Pry::Ring.new(config.memory_size)
  @output_ring = Pry::Ring.new(config.memory_size)
  @custom_completions = config.command_completions
  set_last_result nil
  @input_ring << nil
  push_initial_binding(target)
  exec_hook(:when_started, target, options, self)
end

Class Attribute Details

.cli ⇒ Object

Returns the value of attribute cli.



22
23
24
 
# File 'lib/pry/pry_class.rb', line 22

def cli
  @cli
end

.config ⇒ Object

Returns the value of attribute config.



25
26
27
 
# File 'lib/pry/pry_class.rb', line 25

def config
  @config
end

.current_line ⇒ Object

Returns the value of attribute current_line.



19
20
21
 
# File 'lib/pry/pry_class.rb', line 19

def current_line
  @current_line
end

.custom_completions ⇒ Object

Returns the value of attribute custom_completions.



18
19
20
 
# File 'lib/pry/pry_class.rb', line 18

def custom_completions
  @custom_completions
end

.eval_path ⇒ Object

Returns the value of attribute eval_path.



21
22
23
 
# File 'lib/pry/pry_class.rb', line 21

def eval_path
  @eval_path
end

.history ⇒ Object 



41
42
43
 
# File 'lib/pry/pry_class.rb', line 41

def history
  @history ||= History.new
end

.last_internal_error ⇒ Object

Returns the value of attribute last_internal_error.



24
25
26
 
# File 'lib/pry/pry_class.rb', line 24

def last_internal_error
  @last_internal_error
end

.line_buffer ⇒ Object

Returns the value of attribute line_buffer.



20
21
22
 
# File 'lib/pry/pry_class.rb', line 20

def line_buffer
  @line_buffer
end

.quiet ⇒ Object

Returns the value of attribute quiet.



23
24
25
 
# File 'lib/pry/pry_class.rb', line 23

def quiet
  @quiet
end

Instance Attribute Details

#backtrace ⇒ Object

Returns the value of attribute backtrace.



29
30
31
 
# File 'lib/pry/pry_instance.rb', line 29

def backtrace
  @backtrace
end

#binding_stack ⇒ Object

Returns the value of attribute binding_stack.



26
27
28
 
# File 'lib/pry/pry_instance.rb', line 26

def binding_stack
  @binding_stack
end

#command_state ⇒ Object (readonly)

Returns the value of attribute command_state.



36
37
38
 
# File 'lib/pry/pry_instance.rb', line 36

def command_state
  @command_state
end

#config ⇒ Object (readonly)

Returns the value of attribute config.



45
46
47
 
# File 'lib/pry/pry_instance.rb', line 45

def config
  @config
end

#custom_completions ⇒ Object

Returns the value of attribute custom_completions.



27
28
29
 
# File 'lib/pry/pry_instance.rb', line 27

def custom_completions
  @custom_completions
end

#eval_string ⇒ Object

Returns the value of attribute eval_string.



28
29
30
 
# File 'lib/pry/pry_instance.rb', line 28

def eval_string
  @eval_string
end

#exit_value ⇒ Object (readonly)

Returns the value of attribute exit_value.



37
38
39
 
# File 'lib/pry/pry_instance.rb', line 37

def exit_value
  @exit_value
end

#input_ring ⇒ Object (readonly)

Since:

  • v0.12.0



40
41
42
 
# File 'lib/pry/pry_instance.rb', line 40

def input_ring
  @input_ring
end

#last_dir ⇒ Object

Returns the value of attribute last_dir.



33
34
35
 
# File 'lib/pry/pry_instance.rb', line 33

def last_dir
  @last_dir
end

#last_exception ⇒ Object

Returns the value of attribute last_exception.



35
36
37
 
# File 'lib/pry/pry_instance.rb', line 35

def last_exception
  @last_exception
end

#last_file ⇒ Object

Returns the value of attribute last_file.



32
33
34
 
# File 'lib/pry/pry_instance.rb', line 32

def last_file
  @last_file
end

#last_result ⇒ Object

Returns the value of attribute last_result.



31
32
33
 
# File 'lib/pry/pry_instance.rb', line 31

def last_result
  @last_result
end

#output_ring ⇒ Object (readonly)

Since:

  • v0.12.0



43
44
45
 
# File 'lib/pry/pry_instance.rb', line 43

def output_ring
  @output_ring
end

#suppress_output ⇒ Object

Returns the value of attribute suppress_output.



30
31
32
 
# File 'lib/pry/pry_instance.rb', line 30

def suppress_output
  @suppress_output
end

Class Method Details

.auto_resize! ⇒ Object 



305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
 
# File 'lib/pry/pry_class.rb', line 305

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) ⇒ Binding

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`

Parameters:

  • target (Object) —

    The object to get a ‘Binding` object for.

Returns:

  • (Binding) —

    The ‘Binding` object.



360
361
362
363
364
365
366
367
368
369
370
 
# File 'lib/pry/pry_class.rb', line 360

def self.binding_for(target)
  if Binding === target
    target
  else
    if Pry.main == target
      TOPLEVEL_BINDING
    else
      target.__binding__
    end
  end
end

.Code(obj) ⇒ Object

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

Parameters:



12
13
14
15
16
17
18
19
20
21
 
# 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

.configure {|config| ... } ⇒ Object

Examples:

Pry.configure do |config|
   config.eager_load! # optional
   config.input =     # ..
   config.foo = 2
end

Yields:



56
57
58
 
# File 'lib/pry/pry_class.rb', line 56

def configure
  yield config
end

.critical_section ⇒ Object 



398
399
400
401
402
403
404
 
# File 'lib/pry/pry_class.rb', line 398

def self.critical_section
  Thread.current[:pry_critical_section] ||= 0
  Thread.current[:pry_critical_section] += 1
  yield
ensure
  Thread.current[:pry_critical_section] -= 1
end

.current ⇒ Pry::Config

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

Returns:

  • (Pry::Config) —

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



73
74
75
 
# File 'lib/pry/pry_class.rb', line 73

def self.current
  Thread.current[:__pry__] ||= Pry::Config.from_hash({}, nil)
end

.default_editor_for_platform ⇒ Object 



295
296
297
298
299
300
301
302
303
 
# File 'lib/pry/pry_class.rb', line 295

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?
  return 'notepad' if Helpers::Platform.windows?

  %w(editor nano vi).detect do |editor|
    system("which #{editor} > /dev/null 2>&1")
  end
end

.final_session_setup ⇒ Object 



151
152
153
154
155
156
157
158
159
160
 
# File 'lib/pry/pry_class.rb', line 151

def self.final_session_setup
  return if @session_finalized

  @session_finalized = true
  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 Helpers::Platform.windows? && !Helpers::Platform.windows_ansi?
end

.in_critical_section? ⇒ Boolean

Returns:

  • (Boolean) 


393
394
395
396
 
# File 'lib/pry/pry_class.rb', line 393

def self.in_critical_section?
  Thread.current[:pry_critical_section] ||= 0
  Thread.current[:pry_critical_section] > 0
end

.init ⇒ Object

Basic initialization.



349
350
351
352
353
 
# File 'lib/pry/pry_class.rb', line 349

def self.init
  @plugin_manager ||= PluginManager.new
  reset_defaults
  locate_plugins
end

.initial_session? ⇒ Boolean

Returns Whether this is the first time a Pry session has been started since loading the Pry class.

Returns:

  • (Boolean) —

    Whether this is the first time a Pry session has been started since loading the Pry class.



258
259
260
 
# File 'lib/pry/pry_class.rb', line 258

def self.initial_session?
  @initial_session
end

.initial_session_setup ⇒ Object

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



141
142
143
144
145
146
147
148
149
 
# File 'lib/pry/pry_class.rb', line 141

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
end

.lazy(&block) ⇒ #call

Wraps a block in a named block called ‘Pry::Config::Lazy`. This is used for dynamic config values, which are calculated every time Pry::Config::Lazy#call is called.

Examples:

# pryrc
Pry.config.prompt_name = Pry.lazy { rand(100) }

# Session
[1] 96(main)>
[2] 19(main)>
[3] 80(main)>

Returns:

  • (#call) 


420
421
422
 
# File 'lib/pry/pry_class.rb', line 420

def self.lazy(&block)
  Pry::Config::Lazy.new(&block)
end

.load_file_at_toplevel(file) ⇒ Object

Load the given file in the context of ‘Pry.toplevel_binding`

Parameters:

  • file (String) —

    The unexpanded file path.



79
80
81
82
83
 
# File 'lib/pry/pry_class.rb', line 79

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) ⇒ Object

Execute the file through the REPL loop, non-interactively.

Parameters:

  • file_name (String) —

    File name to load through the REPL.



208
209
210
211
 
# File 'lib/pry/pry_class.rb', line 208

def self.load_file_through_repl(file_name)
  require "pry/repl_file_loader"
  REPLFileLoader.new(file_name).load
end

.load_history ⇒ Object

Load Readline history if required.



252
253
254
 
# File 'lib/pry/pry_class.rb', line 252

def self.load_history
  Pry.history.load
end

.load_rc_files ⇒ Object

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



87
88
89
90
91
92
93
 
# File 'lib/pry/pry_class.rb', line 87

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 ⇒ Object

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



111
112
113
114
115
 
# File 'lib/pry/pry_class.rb', line 111

def self.load_requires
  Pry.config.requires.each do |file|
    require file
  end
end

.load_traps ⇒ Object

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



119
120
121
 
# File 'lib/pry/pry_class.rb', line 119

def self.load_traps
  trap('INT') { raise Interrupt }
end

.load_win32console ⇒ Object 



123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
 
# File 'lib/pry/pry_class.rb', line 123

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 ⇒ main

Returns the special instance of Object, “main”.

Returns:

  • (main) —

    returns the special instance of Object, “main”.



65
66
67
 
# File 'lib/pry/pry_class.rb', line 65

def self.main
  @main ||= TOPLEVEL_BINDING.eval "self"
end

.Method(obj) ⇒ Object

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



7
8
9
10
11
12
13
 
# File 'lib/pry/method.rb', line 7

def Method(obj)
  if obj.is_a? Pry::Method
    obj
  else
    Pry::Method.new(obj)
  end
end

.prompt ⇒ Object 



37
38
39
 
# File 'lib/pry/pry_class.rb', line 37

def prompt
  config.prompt
end

.prompt=(value) ⇒ Object 



33
34
35
 
# File 'lib/pry/pry_class.rb', line 33

def prompt=(value)
  config.prompt = value
end

.rc_files_to_load ⇒ Object

Load the local RC file (./.pryrc)



96
97
98
99
100
101
 
# File 'lib/pry/pry_class.rb', line 96

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) ⇒ Object

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



104
105
106
107
108
 
# File 'lib/pry/pry_class.rb', line 104

def self.real_path_to(file)
  Pathname.new(File.expand_path(file)).realpath.to_s
rescue Errno::ENOENT, Errno::EACCES
  nil
end

.reset_defaults ⇒ Object

Set all the configurable options back to their default values



337
338
339
340
341
342
343
344
345
346
 
# File 'lib/pry/pry_class.rb', line 337

def self.reset_defaults
  @initial_session = true
  @session_finalized = nil

  self.config = Pry::Config.new Pry::Config::Default.new
  self.cli = false
  self.current_line = 1
  self.line_buffer = [""]
  self.eval_path = "(pry)"
end

.run_command(command_string, options = {}) ⇒ nil

Run a Pry command from outside a session. The commands available are those referenced by ‘Pry.config.commands` (the default command set).

Examples:

Run at top-level with no output.

Pry.run_command "ls"

Run under Pry class, returning only public methods.

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

Display command output.

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

Parameters:

  • command_string (String) —

    The Pry command (including arguments, if any).

  • options (Hash) (defaults to: {}) —

    Optional named parameters.

Options Hash (options):

  • :target (Object, Binding) —

    The object to run the command under. Defaults to ‘TOPLEVEL_BINDING` (main).

  • :show_output (Boolean) —

    Whether to show command output. Defaults to true.

Returns:

  • (nil) 


278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
 
# File 'lib/pry/pry_class.rb', line 278

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
  nil
end

.start(target = nil, options = {}) ⇒ Object

Start a Pry REPL. This method also loads ‘pryrc` as necessary the first time it is invoked.

Examples:

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

Parameters:

  • target (Object, Binding) (defaults to: nil) —

    The receiver of the Pry session

  • options (Hash) (defaults to: {})

Options Hash (options):

  • :input (#readline) —

    The object to use for input.

  • :output (#puts) —

    The object to use for output.

  • :commands (Pry::CommandBase) —

    The object to use for commands.

  • :hooks (Hash) —

    The defined hook Procs.

  • :prompt (Array<Proc>) —

    The array of Procs to use for prompts.

  • :print (Proc) —

    The Proc to use for printing return values.

  • :quiet (Boolean) —

    Omit the ‘whereami` banner when starting.

  • :backtrace (Array<String>) —

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

  • :target (Object) —

    The initial context for this session.



169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
 
# File 'lib/pry/pry_class.rb', line 169

def self.start(target = nil, options = {})
  return if ENV['DISABLE_PRY']
  if ENV['FAIL_PRY']
    raise 'You have FAIL_PRY set to true, which results in Pry calls failing'
  end

  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)
  initial_session_setup
  final_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 ⇒ Object 



372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
 
# File 'lib/pry/pry_class.rb', line 372

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) ⇒ Object 



389
390
391
 
# File 'lib/pry/pry_class.rb', line 389

def self.toplevel_binding=(binding)
  @toplevel_binding = binding
end

.view_clip(obj, options = {}) ⇒ String

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

Parameters:

  • obj (Object) —

    The object to view.

  • options (Hash) (defaults to: {})

Options Hash (options):

  • :max_length (Integer) — default: 60 —

    The maximum number of chars before clipping occurs.

  • :id (Boolean) — default: 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`.

Returns:

  • (String) —

    The string representation of ‘obj`.



232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
 
# File 'lib/pry/pry_class.rb', line 232

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_contexts.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

.WrappedModule(obj) ⇒ Object

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



7
8
9
10
11
12
13
 
# 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

Instance Method Details

#add_sticky_local(name) { ... } ⇒ Object

Add a sticky local to this Pry instance. A sticky local is a local that persists between all bindings in a session.

Parameters:

  • name (Symbol) —

    The name of the sticky local.

Yields:

  • The block that defines the content of the local. The local will be refreshed at each tick of the repl loop.



226
227
228
 
# File 'lib/pry/pry_instance.rb', line 226

def add_sticky_local(name, &block)
  config.extra_sticky_locals[name] = block
end

#complete(str) ⇒ Array<String>

Generate completions.

Parameters:

  • str (String) —

    What the user has typed so far

Returns:

  • (Array<String>) —

    Possible completions



163
164
165
166
167
168
169
170
 
# File 'lib/pry/pry_instance.rb', line 163

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 ⇒ Binding Also known as: current_context

The currently active ‘Binding`.

Returns:

  • (Binding) —

    The currently active ‘Binding` for the session.



142
143
144
 
# File 'lib/pry/pry_instance.rb', line 142

def current_binding
  binding_stack.last
end

#eval(line, options = {}) ⇒ Boolean

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.

Parameters:

  • line (String?) —

    The line of input; ‘nil` if the user types `<Ctrl-D>`

  • options (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (options):

  • :generated (Boolean) —

    Whether this line was generated automatically. Generated lines are not stored in history.

Returns:

  • (Boolean) —

    Is Pry ready to accept more input?

Raises:

  • (Exception) —

    If the user uses the ‘raise-up` command, this method will raise that exception.



268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
 
# File 'lib/pry/pry_instance.rb', line 268

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) ⇒ Object 



383
384
385
386
387
388
389
390
391
392
 
# File 'lib/pry/pry_instance.rb', line 383

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) ⇒ Object, Exception

Execute the specified hook. 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.

Parameters:

  • name (Symbol) —

    The hook name to execute

  • args (*Object) —

    The arguments to pass to the hook

Returns:

  • (Object, Exception) —

    The return value of the hook or the exception raised



499
500
501
502
503
504
505
506
507
508
 
# File 'lib/pry/pry_instance.rb', line 499

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) ⇒ Object

Injects a local variable into the provided binding.

Parameters:

  • name (String) —

    The name of the local to inject.

  • value (Object) —

    The value to set the local to.

  • b (Binding) —

    The binding to set the local on.

Returns:

  • (Object) —

    The value the local was set to.



187
188
189
190
191
192
193
194
195
196
197
198
199
 
# File 'lib/pry/pry_instance.rb', line 187

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! ⇒ Object

Inject all the sticky locals into the current binding.



215
216
217
218
219
 
# File 'lib/pry/pry_instance.rb', line 215

def inject_sticky_locals!
  sticky_locals.each_pair do |name, value|
    inject_local(name, value, current_binding)
  end
end

#input_array ⇒ Object

Deprecated.

Use #input_ring instead.



92
93
94
95
96
97
98
99
100
101
102
103
 
# File 'lib/pry/pry_instance.rb', line 92

def input_array
  unless @input_array_warn
    loc = caller_locations(1..1).first
    warn(
      "#{loc.path}:#{loc.lineno}: warning: method #{self.class}##{__method__} " \
      "is deprecated. Use #{self.class}#input_ring instead"
    )
    @input_array_warn = true
  end

  @input_ring
end

#last_result_is_exception? ⇒ Boolean

Returns 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).

Returns:

  • (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)



549
550
551
 
# File 'lib/pry/pry_instance.rb', line 549

def last_result_is_exception?
  @last_result_is_exception
end

#memory_size ⇒ Integer

Returns The maximum amount of objects remembered by the inp and out arrays. Defaults to 100.

Returns:

  • (Integer) —

    The maximum amount of objects remembered by the inp and out arrays. Defaults to 100.



204
205
206
 
# File 'lib/pry/pry_instance.rb', line 204

def memory_size
  @output_ring.max_size
end

#memory_size=(size) ⇒ Object 



209
210
211
212
 
# File 'lib/pry/pry_instance.rb', line 209

def memory_size=(size)
  @input_ring = Pry::Ring.new(size)
  @output_ring = Pry::Ring.new(size)
end

#output ⇒ Object

Returns an output device

Examples:

_pry_.output.puts "ohai!"


645
646
647
 
# File 'lib/pry/pry_instance.rb', line 645

def output
  Pry::Output.new(self)
end

#output_array ⇒ Object

Deprecated.

Use #output_ring instead.



107
108
109
110
111
112
113
114
115
116
117
118
 
# File 'lib/pry/pry_instance.rb', line 107

def output_array
  unless @output_array_warn
    loc = caller_locations(1..1).first
    warn(
      "#{loc.path}:#{loc.lineno}: warning: method #{self.class}##{__method__} " \
      "is deprecated. Use #{self.class}#output_ring instead"
    )
    @output_array_warn = true
  end

  @output_ring
end

#pager ⇒ Object

Returns the currently configured pager

Examples:

_pry_.pager.page text


637
638
639
 
# File 'lib/pry/pry_instance.rb', line 637

def pager
  Pry::Pager.new(self)
end

#pop_prompt ⇒ Array<Proc>

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.

Examples:

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

Returns:

  • (Array<Proc>) —

    Prompt being popped.



629
630
631
 
# File 'lib/pry/pry_instance.rb', line 629

def pop_prompt
  prompt_stack.size > 1 ? prompt_stack.pop : prompt
end

#process_command(val) ⇒ Boolean

If the given line is a valid command, process it in the context of the current ‘eval_string` and binding.

Parameters:

  • val (String) —

    The line to process.

Returns:

  • (Boolean) —

    ‘true` if `val` is a command, `false` otherwise



434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
 
# File 'lib/pry/pry_instance.rb', line 434

def process_command(val)
  val = val.lstrip if /^\s\S/ !~ val
  val = val.chomp
  result = commands.process_line(val,
    target: current_binding,
    output: output,
    eval_string: @eval_string,
    pry_instance: self,
    hooks: hooks
  )

  # 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) ⇒ Boolean

Same as process_command, but outputs exceptions to ‘#output` instead of raising.

Parameters:

  • val (String) —

    The line to process.

Returns:

  • (Boolean) —

    ‘true` if `val` is a command, `false` otherwise



468
469
470
471
472
473
474
 
# File 'lib/pry/pry_instance.rb', line 468

def process_command_safely(val)
  process_command(val)
rescue CommandError, Pry::Slop::InvalidOptionError, MethodSource::SourceNotFoundError => e
  Pry.last_internal_error = e
  output.puts "Error: #{e.message}"
  true
end

#prompt ⇒ Array<Proc>

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

Returns:

  • (Array<Proc>) —

    the current prompt



122
123
124
 
# File 'lib/pry/pry_instance.rb', line 122

def prompt
  prompt_stack.last
end

#prompt=(new_prompt) ⇒ Object 



126
127
128
129
130
131
132
 
# File 'lib/pry/pry_instance.rb', line 126

def prompt=(new_prompt)
  if prompt_stack.empty?
    push_prompt new_prompt
  else
    prompt_stack[-1] = new_prompt
  end
end

#push_binding(object) ⇒ Object

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



149
150
151
152
 
# File 'lib/pry/pry_instance.rb', line 149

def push_binding(object)
  @stopped = false
  binding_stack << Pry.binding_for(object)
end

#push_initial_binding(target = nil) ⇒ Object

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



136
137
138
 
# File 'lib/pry/pry_instance.rb', line 136

def push_initial_binding(target = nil)
  push_binding(target || Pry.toplevel_binding)
end

#push_prompt(new_prompt) ⇒ Array<Proc>

Pushes the current prompt onto a stack that it can be restored from later. Use this if you wish to temporarily change the prompt.

Examples:

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

Parameters:

  • new_prompt (Array<Proc>)

Returns:

  • (Array<Proc>) —

    new_prompt



613
614
615
 
# File 'lib/pry/pry_instance.rb', line 613

def push_prompt(new_prompt)
  prompt_stack.push new_prompt
end

#quiet? ⇒ Boolean

Convenience accessor for the ‘quiet` config key.

Returns:

  • (Boolean) 


695
696
697
 
# File 'lib/pry/pry_instance.rb', line 695

def quiet?
  config.quiet
end

#raise_up(*args) ⇒ Object 



689
 
# File 'lib/pry/pry_instance.rb', line 689

def raise_up(*args); raise_up_common(false, *args); end

#raise_up!(*args) ⇒ Object 



691
 
# File 'lib/pry/pry_instance.rb', line 691

def raise_up!(*args); raise_up_common(true, *args); end

#raise_up_common(force, *args) ⇒ Object

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")

Raises:

  • (TypeError) 


661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
 
# File 'lib/pry/pry_instance.rb', line 661

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) ⇒ Object

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.)



379
380
381
 
# File 'lib/pry/pry_instance.rb', line 379

def repl(target = nil)
  Pry::REPL.new(self, target: target).start
end

#reset_eval_string ⇒ Object

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



244
245
246
 
# File 'lib/pry/pry_instance.rb', line 244

def reset_eval_string
  @eval_string = ""
end

#run_command(val) ⇒ Pry::Command::VOID_VALUE

Run the specified command.

Examples:

pry_instance.run_command("ls -m")

Parameters:

  • val (String) —

    The command (and its params) to execute.

Returns:



481
482
483
484
485
486
487
488
489
 
# File 'lib/pry/pry_instance.rb', line 481

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 ⇒ String

Returns the appropriate prompt to use.

Returns:

  • (String) —

    The prompt.



562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
 
# File 'lib/pry/pry_instance.rb', line 562

def select_prompt
  object = current_binding.eval('self')
  open_token = @indent.open_delimiters.last || @indent.stack.last

  c = Pry::Config.assign({
      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_ring.count,
      _pry_: self,
      binding_stack: binding_stack,
      input_ring: input_ring,
      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 = "") ⇒ Object

Set the last result of an eval. This method should not need to be invoked directly.

Parameters:

  • result (Object) —

    The result.

  • code (String) (defaults to: "") —

    The code that was run.



514
515
516
517
518
519
 
# File 'lib/pry/pry_instance.rb', line 514

def set_last_result(result, code = "")
  @last_result_is_exception = false
  @output_ring << result

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

#should_print? ⇒ Boolean

Whether the print proc should be invoked. Currently only invoked if the output is not suppressed.

Returns:

  • (Boolean) —

    Whether the print proc should be invoked.



556
557
558
 
# File 'lib/pry/pry_instance.rb', line 556

def should_print?
  !@suppress_output
end

#show_result(result) ⇒ Object

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



395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
 
# File 'lib/pry/pry_instance.rb', line 395

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}\n#{e.backtrace.join("\n")}"
  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 ⇒ Object 



230
231
232
233
234
235
236
237
238
239
240
 
# File 'lib/pry/pry_instance.rb', line 230

def sticky_locals
  { _in_: input_ring,
    _out_: output_ring,
    _pry_: self,
    _ex_: last_exception && last_exception.wrapped_exception,
    _file_: last_file,
    _dir_: last_dir,
    _: proc { last_result },
    __: proc { output_ring[-2] }
  }.merge(config.extra_sticky_locals)
end

#update_input_history(code) ⇒ Object

Update Pry’s internal state after evalling code. This method should not need to be invoked directly.

Parameters:

  • code (String) —

    The code we just eval’d



537
538
539
540
541
542
543
544
 
# File 'lib/pry/pry_instance.rb', line 537

def update_input_history(code)
  # Always push to the @input_ring as the @output_ring is always pushed to.
  @input_ring << code
  if code
    Pry.line_buffer.push(*code.each_line)
    Pry.current_line += code.lines.count
  end
end