Class: Pry

Inherits:
Object show all
Extended by:
Forwardable
Defined in:
lib/pry/completion.rb,
lib/pry.rb,
lib/pry/cli.rb,
lib/pry/code.rb,
lib/pry/hooks.rb,
lib/pry/method.rb,
lib/pry/indent.rb,
lib/pry/editor.rb,
lib/pry/config.rb,
lib/pry/history.rb,
lib/pry/version.rb,
lib/pry/plugins.rb,
lib/pry/rubygem.rb,
lib/pry/command.rb,
lib/pry/code/loc.rb,
lib/pry/rbx_path.rb,
lib/pry/pry_class.rb,
lib/pry/rbx_method.rb,
lib/pry/code_object.rb,
lib/pry/commands/ri.rb,
lib/pry/commands/ls.rb,
lib/pry/command_set.rb,
lib/pry/commands/cd.rb,
lib/pry/helpers/text.rb,
lib/pry/commands/wtf.rb,
lib/pry/pry_instance.rb,
lib/pry/commands/cat.rb,
lib/pry/commands/gist.rb,
lib/pry/commands/exit.rb,
lib/pry/commands/stat.rb,
lib/pry/commands/help.rb,
lib/pry/history_array.rb,
lib/pry/commands/bang.rb,
lib/pry/helpers/table.rb,
lib/pry/commands/play.rb,
lib/pry/commands/edit.rb,
lib/pry/commands/hist.rb,
lib/pry/wrapped_module.rb,
lib/pry/commands/reset.rb,
lib/pry/core_extensions.rb,
lib/pry/commands/gem_cd.rb,
lib/pry/code/code_range.rb,
lib/pry/module_candidate.rb,
lib/pry/repl_file_loader.rb,
lib/pry/commands/nesting.rb,
lib/pry/commands/jump_to.rb,
lib/pry/commands/gem_open.rb,
lib/pry/commands/gem_list.rb,
lib/pry/commands/bang_pry.rb,
lib/pry/commands/show_doc.rb,
lib/pry/commands/exit_all.rb,
lib/pry/commands/whereami.rb,
lib/pry/commands/raise_up.rb,
lib/pry/commands/switch_to.rb,
lib/pry/commands/save_file.rb,
lib/pry/commands/show_info.rb,
lib/pry/custom_completions.rb,
lib/pry/commands/import_set.rb,
lib/pry/commands/shell_mode.rb,
lib/pry/commands/fix_indent.rb,
lib/pry/commands/show_input.rb,
lib/pry/commands/amend_line.rb,
lib/pry/commands/gem_install.rb,
lib/pry/commands/find_method.rb,
lib/pry/commands/pry_version.rb,
lib/pry/commands/easter_eggs.rb,
lib/pry/commands/disable_pry.rb,
lib/pry/helpers/base_helpers.rb,
lib/pry/commands/reload_code.rb,
lib/pry/commands/show_source.rb,
lib/pry/commands/toggle_color.rb,
lib/pry/commands/exit_program.rb,
lib/pry/commands/simple_prompt.rb,
lib/pry/commands/shell_command.rb,
lib/pry/commands/pry_backtrace.rb,
lib/pry/helpers/options_helpers.rb,
lib/pry/helpers/command_helpers.rb,
lib/pry/commands/code_collector.rb,
lib/pry/commands/install_command.rb,
lib/pry/commands/cat/file_formatter.rb,
lib/pry/commands/edit/method_patcher.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/cat/input_expression_formatter.rb

Overview

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:

Defined Under Namespace

Modules: BondCompleter, ExtendCommandBundle, Helpers, InputCompleter, RbxMethod, RbxPath, RescuableException, Rubygem, TooSafeException, UserError Classes: BlockCommand, CLI, ClassCommand, Code, CodeObject, Command, CommandError, CommandSet, Config, Editor, History, HistoryArray, Hooks, Indent, Method, MethodNotFound, NoCommandError, ObsoleteError, Pager, PluginManager, REPLFileLoader, Result, TerminalInfo, WrappedModule

Constant Summary

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", "", target)
end
DEFAULT_PRINT =

The default print

proc do |output, value|
  output_with_default_format(output, value, :hashrocket => true)
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)
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}"
  end
end
DEFAULT_PROMPT_NAME =
'pry'
DEFAULT_PROMPT =

The default prompt; includes the target and nesting level

[
 proc { |target_self, nest_level, pry|
   "[#{pry.input_array.size}] #{Pry.config.prompt_name}(#{Pry.view_clip(target_self)})#{":#{nest_level}" unless nest_level.zero?}> "
 },

 proc { |target_self, nest_level, pry|
   "[#{pry.input_array.size}] #{Pry.config.prompt_name}(#{Pry.view_clip(target_self)})#{":#{nest_level}" unless nest_level.zero?}* "
 }
]
SIMPLE_PROMPT =

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

[proc { ">> " }, proc { " | " }]
SHELL_PROMPT =
[
 proc { |target_self, _, _| "#{Pry.config.prompt_name} #{Pry.view_clip(target_self)}:#{Dir.pwd} $ " },
 proc { |target_self, _, _| "#{Pry.config.prompt_name} #{Pry.view_clip(target_self)}:#{Dir.pwd} * " }
]
[
 proc do |conf|
   tree = conf.binding_stack.map { |b| Pry.view_clip(b.eval("self")) }.join " / "
   "[#{conf.expr_number}] (#{Pry.config.prompt_name}) #{tree}: #{conf.nesting_level}> "
 end,
 proc do |conf|
   tree = conf.binding_stack.map { |b| Pry.view_clip(b.eval("self")) }.join " / "
   "[#{conf.expr_number}] (#{ Pry.config.prompt_name}) #{tree}: #{conf.nesting_level}* "
 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
    # Store the entire binding stack before popping. Useful for `cd -`.
    if _pry_.command_state['cd'].nil?
      _pry_.command_state['cd'] = OpenStruct.new
    end
    _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
INITIAL_PWD =

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

Dir.pwd
DEFAULT_EXCEPTION_WHITELIST =

Don't catch these exceptions

[SystemExit, SignalException, Pry::TooSafeException]
VERSION =
"0.9.11.1"
HOME_RC_FILE =

The RC Files to load.

"~/.pryrc"
LOCAL_RC_FILE =
"./.pryrc"
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
DEFAULT_CUSTOM_COMPLETIONS =

This proc will be instance_eval's against the active Pry instance

proc { commands.commands.keys }
FILE_COMPLETIONS =
proc { commands.commands.keys + Dir.entries('.') }

Class Attribute Summary (collapse)

Instance Attribute Summary (collapse)

Class Method Summary (collapse)

Instance Method Summary (collapse)

Constructor Details

- (Pry) initialize(options = {})

Create a new Pry object.

Parameters:

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

    The optional configuration parameters.

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 the prompts.

  • :print (Proc)

    The Proc to use for the 'print'

  • :quiet (Boolean)

    If true, omit the whereami banner when starting. component of the REPL. (see print.rb)



83
84
85
86
87
88
89
# File 'lib/pry/pry_instance.rb', line 83

def initialize(options={})
  refresh(options)

  @binding_stack = []
  @indent        = Pry::Indent.new
  @command_state = {}
end

Class Attribute Details

+ (Boolean) cli

Returns Whether Pry was activated from the command line.

Returns:

  • (Boolean)

    Whether Pry was activated from the command line.



50
51
52
# File 'lib/pry/pry_class.rb', line 50

def cli
  @cli
end

+ (OpenStruct) config

Return Pry's config object.

Returns:

  • (OpenStruct)

    Return Pry's config object.



44
45
46
# File 'lib/pry/pry_class.rb', line 44

def config
  @config
end

+ (Fixnum) current_line

Returns The current input line.

Returns:

  • (Fixnum)

    The current input line.



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

def current_line
  @current_line
end

+ (Proc) custom_completions

Get/Set the Proc that defines extra Readline completions (on top of the ones defined for IRB).

Examples:

Add file names to completion list

Pry.custom_completions = proc { Dir.entries('.') }

Returns:

  • (Proc)

    The Proc that defines extra Readline completions (on top



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

def custom_completions
  @custom_completions
end

+ (String) eval_path

Returns The FILE for the eval(). Should be "(pry)" by default.

Returns:

  • (String)

    The FILE for the eval(). Should be "(pry)" by default.



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

def eval_path
  @eval_path
end

+ (History) history

Return Pry's line history object.

Returns:

  • (History)

    Return Pry's line history object.



47
48
49
# File 'lib/pry/pry_class.rb', line 47

def history
  @history
end

+ (Array) line_buffer

Returns The Array of evaluated expressions.

Returns:

  • (Array)

    The Array of evaluated expressions.



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

def line_buffer
  @line_buffer
end

+ (Boolean) quiet

Returns Whether Pry sessions are quiet by default.

Returns:

  • (Boolean)

    Whether Pry sessions are quiet by default.



53
54
55
# File 'lib/pry/pry_class.rb', line 53

def quiet
  @quiet
end

+ (Binding) toplevel_binding

Returns A top level binding with no local variables

Returns:

  • (Binding)

    A top level binding with no local variables



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

def toplevel_binding
  @toplevel_binding
end

Instance Attribute Details

- (Object) backtrace

Returns the value of attribute backtrace



48
49
50
# File 'lib/pry/pry_instance.rb', line 48

def backtrace
  @backtrace
end

- (Object) binding_stack

Returns the value of attribute binding_stack



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

def binding_stack
  @binding_stack
end

- (Object) command_state (readonly)

This is exposed via Pry::Command#state.



55
56
57
# File 'lib/pry/pry_instance.rb', line 55

def command_state
  @command_state
end

- (Object) commands

Returns the value of attribute commands



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

def commands
  @commands
end

- (Object) custom_completions

Returns the value of attribute custom_completions



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

def custom_completions
  @custom_completions
end

- (Object) exception_handler

Returns the value of attribute exception_handler



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

def exception_handler
  @exception_handler
end

- (Object) extra_sticky_locals

Returns the value of attribute extra_sticky_locals



50
51
52
# File 'lib/pry/pry_instance.rb', line 50

def extra_sticky_locals
  @extra_sticky_locals
end

- (Object) hooks

Special treatment for hooks as we want to alert people of the changed API



59
60
61
# File 'lib/pry/pry_instance.rb', line 59

def hooks
  @hooks
end

- (Object) input

Returns the value of attribute input



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

def input
  @input
end

- (Object) input_array (readonly)

Returns the value of attribute input_array



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

def input_array
  @input_array
end

- (Object) input_stack

Returns the value of attribute input_stack



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

def input_stack
  @input_stack
end

- (Object) last_dir

Returns the value of attribute last_dir



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

def last_dir
  @last_dir
end

- (Object) last_exception

Returns the value of attribute last_exception



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

def last_exception
  @last_exception
end

- (Object) last_file

Returns the value of attribute last_file



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

def last_file
  @last_file
end

- (Object) last_result

Returns the value of attribute last_result



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

def last_result
  @last_result
end

- (Object) output

Returns the value of attribute output



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

def output
  @output
end

- (Object) output_array (readonly)

Returns the value of attribute output_array



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

def output_array
  @output_array
end

Returns the value of attribute print



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

def print
  @print
end

- (Object) quiet Also known as: quiet?

Returns the value of attribute quiet



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

def quiet
  @quiet
end

- (Object) suppress_output

Returns the value of attribute suppress_output



52
53
54
# File 'lib/pry/pry_instance.rb', line 52

def suppress_output
  @suppress_output
end

Class Method Details

+ (Binding) binding_for(target)

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.



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

def self.binding_for(target)
  if Binding === target
    target
  else
    if TOPLEVEL_BINDING.eval('self') == target
      TOPLEVEL_BINDING
    else
      target.__binding__
    end
  end
end

+ (Object) Code(obj)

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

Parameters:



11
12
13
14
15
16
17
18
19
20
# File 'lib/pry/code.rb', line 11

def Code(obj)
  case obj
  when Code
    obj
  when ::Method, UnboundMethod, Proc, Pry::Method
    Code.from_method(obj)
  else
    Code.new(obj)
  end
end

+ (Object) critical_section(&block)



431
432
433
434
435
436
# File 'lib/pry/pry_class.rb', line 431

def self.critical_section(&block)
  @critical_section = @critical_section.to_i + 1
  yield
ensure
  @critical_section -= 1
end

+ (Hash) current

Returns Pry's Thread.current hash

Returns:

  • (Hash)

    Pry's Thread.current hash



12
13
14
# File 'lib/pry/pry_class.rb', line 12

def self.current
  Thread.current[:__pry__] ||= {}
end

+ (Object) default_editor_for_platform



245
246
247
248
249
250
251
252
253
254
255
256
# File 'lib/pry/pry_class.rb', line 245

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

+ (Object) delegate_accessors(delagatee, *names)

convenience method



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

def self.delegate_accessors(delagatee, *names)
  def_delegators delagatee, *names
  def_delegators delagatee, *names.map { |v| "#{v}=" }
end

+ (Object) fix_coderay_colors

To avoid mass-confusion, we change the default colour of "white" to "blue" enabling global legibility



367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
# File 'lib/pry/pry_class.rb', line 367

def self.fix_coderay_colors
    to_fix = if (CodeRay::Encoders::Terminal::TOKEN_COLORS rescue nil)
               # CodeRay 1.0.0
               CodeRay::Encoders::Terminal::TOKEN_COLORS
             else
               # CodeRay 0.9
               begin
                 require 'coderay/encoders/term'
                 CodeRay::Encoders::Term::TOKEN_COLORS
               rescue
               end
             end

    to_fix[:comment] = "0;34" if to_fix
end

+ (Boolean) in_critical_section?

Returns:

  • (Boolean)


427
428
429
# File 'lib/pry/pry_class.rb', line 427

def self.in_critical_section?
  @critical_section.to_i > 0
end

+ (Object) init

Basic initialization.



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

def self.init
  @plugin_manager ||= PluginManager.new
  self.config ||= Config.new
  self.history ||= History.new

  reset_defaults
  locate_plugins
end

+ (Boolean) initial_session?

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.



212
213
214
# File 'lib/pry/pry_class.rb', line 212

def self.initial_session?
  @initial_session
end

+ (Object) initial_session_setup

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



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

def self.initial_session_setup

  return if !initial_session?

  # 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 if Pry.config.should_load_rc
  load_local_rc if Pry.config.should_load_local_rc
  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

  @initial_session = false
end

+ (Object) load_file_at_toplevel(file_name)

Load the given file in the context of Pry.toplevel_binding

Parameters:

  • file_name (String)

    The unexpanded file path.



67
68
69
70
71
72
73
74
# File 'lib/pry/pry_class.rb', line 67

def self.load_file_at_toplevel(file_name)
  full_name = File.expand_path(file_name)
  begin
    toplevel_binding.eval(File.read(full_name), full_name) if File.exists?(full_name)
  rescue RescuableException => e
    puts "Error loading #{file_name}: #{e}\n#{e.backtrace.first}"
  end
end

+ (Object) load_file_through_repl(file_name)

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

Parameters:

  • file_name (String)

    File name to load through the REPL.



174
175
176
177
# File 'lib/pry/pry_class.rb', line 174

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

+ (Object) load_history

Load Readline history if required.



201
202
203
# File 'lib/pry/pry_class.rb', line 201

def self.load_history
  Pry.history.load
end

+ (Object) load_local_rc

Load the local RC file (./.pryrc)



83
84
85
86
87
# File 'lib/pry/pry_class.rb', line 83

def self.load_local_rc
  unless File.expand_path(HOME_RC_FILE) == File.expand_path(LOCAL_RC_FILE)
    load_file_at_toplevel(LOCAL_RC_FILE)
  end
end

+ (Object) load_rc

Load the rc files given in the Pry::RC_FILES array. This method can also be used to reload the files if they have changed.



78
79
80
# File 'lib/pry/pry_class.rb', line 78

def self.load_rc
  load_file_at_toplevel(HOME_RC_FILE)
end

+ (Object) load_requires

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



90
91
92
93
94
# File 'lib/pry/pry_class.rb', line 90

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

+ (Object) load_traps

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



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

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

+ (Object) Method(obj)

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



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

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

+ (Object) orig_reset_defaults

Set all the configurable options back to their default values



6
7
8
9
10
11
12
13
14
15
16
17
18
# File 'lib/pry/test/helper.rb', line 6

def self.reset_defaults
  set_config_defaults

  @initial_session = true

  self.custom_completions = DEFAULT_CUSTOM_COMPLETIONS
  self.cli = false
  self.current_line = 1
  self.line_buffer = [""]
  self.eval_path = "(pry)"

  fix_coderay_colors
end

+ (Object) output_with_default_format(output, value, options = {})



21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
# File 'lib/pry.rb', line 21

def self.output_with_default_format(output, value, options = {})
  stringified = begin
                  value.pretty_inspect
                rescue RescuableException
                  nil
                end

  unless String === stringified
    # Read the class name off of the singleton class to provide a default
    # inspect.
    klass = (class << value; self; end).ancestors.first
    stringified = "#<#{klass}:0x#{value.__id__.to_s(16)}>"
  end

  nonce = rand(0x100000000).to_s(16) # whatever

  stringified.gsub!(/#</, "%<#{nonce}")
  # Don't recolorize output with color (for cucumber, looksee, etc.) [Issue #751]
  colorized = if stringified =~ /\e\[/
                stringified
              else
                Helpers::BaseHelpers.colorize_code(stringified)
              end

  # avoid colour-leak from CodeRay and any of the users' previous output
  colorized = colorized.sub(/(\n*)\z/, "\e[0m\\1") if Pry.color

  result = colorized.gsub(/%<(.*?)#{nonce}/, '#<\1')
  result = "=> #{result}"if options[:hashrocket]
  Helpers::BaseHelpers.stagger_output(result, output)
end

+ (Object) reset_defaults

Set all the configurable options back to their default values



351
352
353
354
355
356
357
358
359
360
361
362
363
# File 'lib/pry/pry_class.rb', line 351

def self.reset_defaults
  set_config_defaults

  @initial_session = true

  self.custom_completions = DEFAULT_CUSTOM_COMPLETIONS
  self.cli = false
  self.current_line = 1
  self.line_buffer = [""]
  self.eval_path = "(pry)"

  fix_coderay_colors
end

+ (Object) run_command(command_string, options = {})

Run a Pry command from outside a session. The commands available are those referenced by Pry.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", :context => 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):

  • :context (Object, Binding)

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

  • :show_output (Boolean)

    Whether to show command output. Defaults to true.

Returns:

  • (Object)

    The return value of the Pry command.



232
233
234
235
236
237
238
239
240
241
242
243
# File 'lib/pry/pry_class.rb', line 232

def self.run_command(command_string, options={})
  options = {
    :context => TOPLEVEL_BINDING,
    :show_output => true,
    :output => Pry.output,
    :commands => Pry.commands
  }.merge!(options)

  output = options[:show_output] ? options[:output] : StringIO.new

  Pry.new(:output => output, :input => StringIO.new(command_string), :commands => options[:commands], :prompt => proc {""}, :hooks => Pry::Hooks.new).rep(options[:context])
end

+ (Object) save_history

Save new lines of Readline history if required.



206
207
208
# File 'lib/pry/pry_class.rb', line 206

def self.save_history
  Pry.history.save
end

+ (Object) set_config_defaults



258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
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
335
336
337
338
339
340
341
342
343
344
345
346
347
348
# File 'lib/pry/pry_class.rb', line 258

def self.set_config_defaults
  config.input = Readline
  config.output = $stdout
  config.commands = Pry::Commands
  config.prompt_name = DEFAULT_PROMPT_NAME
  config.prompt = DEFAULT_PROMPT
  config.print = DEFAULT_PRINT
  config.exception_handler = DEFAULT_EXCEPTION_HANDLER
  config.exception_whitelist = DEFAULT_EXCEPTION_WHITELIST
  config.default_window_size = 5
  config.hooks = DEFAULT_HOOKS
  config.input_stack = []
  config.color = Helpers::BaseHelpers.use_ansi_codes?
  config.pager = true
  config.system = DEFAULT_SYSTEM
  config.editor = default_editor_for_platform
  config.should_load_rc = true
  config.should_load_local_rc = true
  config.should_trap_interrupts = Helpers::BaseHelpers.jruby?
  config.disable_auto_reload = false
  config.command_prefix = ""
  config.auto_indent = Helpers::BaseHelpers.use_ansi_codes?
  config.correct_indent = true
  config.collision_warning = false
  config.output_prefix = "=> "

  if defined?(Bond) && Readline::VERSION !~ /editline/i
    config.completer = Pry::BondCompleter
  else
    config.completer = Pry::InputCompleter
  end

  config.gist ||= OpenStruct.new
  config.gist.inspecter = proc(&:pretty_inspect)

  config.should_load_plugins = true

  config.requires ||= []
  config.should_load_requires = true

  config.history ||= OpenStruct.new
  config.history.should_save = true
  config.history.should_load = true
  config.history.file = File.expand_path("~/.pry_history") rescue nil

  if config.history.file.nil?
    config.should_load_rc = false
    config.history.should_save = false
    config.history.should_load = false
  end

  config.control_d_handler = DEFAULT_CONTROL_D_HANDLER

  config.memory_size = 100

  config.extra_sticky_locals = {}

  config.ls ||= OpenStruct.new({
    :heading_color            => :default,

    :public_method_color      => :default,
    :private_method_color     => :green,
    :protected_method_color   => :yellow,
    :method_missing_color     => :bright_red,

    :local_var_color          => :yellow,
    :pry_var_color            => :default,         # e.g. _, _pry_, _file_

    :instance_var_color       => :blue,        # e.g. @foo
    :class_var_color          => :bright_blue, # e.g. @@foo

    :global_var_color         => :default,     # e.g. $CODERAY_DEBUG, $eventmachine_library
    :builtin_global_color     => :cyan,        # e.g. $stdin, $-w, $PID
    :pseudo_global_color      => :cyan,        # e.g. $~, $1..$9, $LAST_MATCH_INFO

    :constant_color           => :default,     # e.g. VERSION, ARGF
    :class_constant_color     => :blue,        # e.g. Object, Kernel
    :exception_constant_color => :magenta,     # e.g. Exception, RuntimeError
    :unloaded_constant_color  => :yellow,      # Any constant that is still in .autoload? state

    # What should separate items listed by ls? (TODO: we should allow a columnar layout)
    :separator                => "  ",

    # Any methods defined on these classes, or modules included into these classes, will not
    # be shown by ls unless the -v flag is used.
    # A user of Rails may wih to add ActiveRecord::Base to the list.
    # add the following to your .pryrc:
    # Pry.config.ls.ceiling << ActiveRecord::Base if defined? ActiveRecordBase
    :ceiling                  => [Object, Module, Class]
  })
end

+ (Object) start(target = nil, options = {})

Start a Pry REPL. This method also loads the ~/.pryrc and ./.pryrc as necessary 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 the prompts.

  • :print (Proc)

    The Proc to use for the 'print'

  • :quiet (Boolean)

    If true, omit the whereami banner when starting. component of the REPL. (see print.rb)



129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
# File 'lib/pry/pry_class.rb', line 129

def self.start(target=nil, options={})
  return if ENV['DISABLE_PRY']

  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

  target = Pry.binding_for(target || toplevel_binding)
  initial_session_setup

  # create the Pry instance to manage the session
  pry_instance = new(options)

  # save backtrace
  pry_instance.backtrace = caller

  # if Pry was started via binding.pry, elide that from the backtrace.
  pry_instance.backtrace.shift if pry_instance.backtrace.first =~ /pry.*core_extensions.*pry/

  # yield the binding_stack to the hook for modification
  pry_instance.exec_hook(:when_started, target, options, pry_instance)

  if !pry_instance.binding_stack.empty?
    head = pry_instance.binding_stack.pop
  else
    head = target
  end

  # Clear the line before starting Pry. This fixes the issue discussed here:
  # https://github.com/pry/pry/issues/566
  if Pry.config.auto_indent
    Kernel.print Pry::Helpers::BaseHelpers.windows_ansi? ? "\e[0F" : "\e[0G"
  end

  # Enter the matrix
  pry_instance.repl(head)
rescue Pry::TooSafeException
  puts "ERROR: Pry cannot work with $SAFE > 0"
  raise
end

+ (String) view_clip(obj, max_length = 60)

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

Parameters:

  • obj

    The object to view.

  • max_length (defaults to: 60)

    The maximum number of chars before clipping occurs.

Returns:

  • (String)

    The string representation of obj.



184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
# File 'lib/pry/pry_class.rb', line 184

def self.view_clip(obj, max_length = 60)
  if obj.kind_of?(Module) && obj.name.to_s != "" && obj.name.to_s.length <= max_length
    obj.name.to_s
  elsif TOPLEVEL_BINDING.eval('self') == obj
    # special case for 'main' object :)
    obj.to_s
  elsif [String, Numeric, Symbol, nil, true, false].any? { |v| v === obj } && obj.inspect.length <= max_length
    obj.inspect
  else
    "#<#{obj.class}>"#:%x>"# % (obj.object_id << 1)
  end

rescue RescuableException
  "unknown"
end

+ (Object) WrappedModule(obj)

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

- (Object) add_sticky_local(name) { ... }

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.



178
179
180
# File 'lib/pry/pry_instance.rb', line 178

def add_sticky_local(name, &block)
  sticky_locals[name] = block
end

- (Binding) current_context

The currently active Binding.

Returns:

  • (Binding)

    The currently active Binding for the session.



118
119
120
# File 'lib/pry/pry_instance.rb', line 118

def current_context
  binding_stack.last
end

- (Object) evaluate_ruby(code, target = binding_stack.last)



322
323
324
325
326
327
328
329
330
331
332
# File 'lib/pry/pry_instance.rb', line 322

def evaluate_ruby(code, target = binding_stack.last)
  target = Pry.binding_for(target)
  inject_sticky_locals(target)
  exec_hook :before_eval, code, self

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

- (Object, Exception) exec_hook(name, *args, &block)

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



493
494
495
496
497
498
499
500
501
502
# File 'lib/pry/pry_instance.rb', line 493

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

- (Object) generate_prompt(prompt_proc, conf) (private)



676
677
678
679
680
681
682
# File 'lib/pry/pry_instance.rb', line 676

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

- (Object) handle_read_errors (private)

Manage switching of input objects on encountering EOFErrors



559
560
561
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
590
591
592
593
594
595
596
597
598
599
600
# File 'lib/pry/pry_instance.rb', line 559

def handle_read_errors
  should_retry = true
  exception_count = 0
  begin
    yield
  rescue EOFError
    if input_stack.empty?
      self.input = Pry.config.input
      if !should_retry
        output.puts "Error: Pry ran out of things to read from! Attempting to break out of REPL."
        throw(:breakout)
      end
      should_retry = false
    else
      self.input = input_stack.pop
    end

    retry

  # Interrupts are handled in r() because they need to tweak eval_string
  # TODO: Refactor this baby.
  rescue Interrupt
    raise

  # If we get a random error when trying to read a line we don't want to automatically
  # retry, as the user will see a lot of error messages scroll past and be unable to do
  # anything about it.
  rescue RescuableException => e
    puts "Error: #{e.message}"
    output.puts e.backtrace
    exception_count += 1
    if exception_count < 5
      retry
    end
    puts "FATAL: Pry failed to get user input using `#{input}`."
    puts "To fix this you may be able to pass input and output file descriptors to pry directly. e.g."
    puts "  Pry.config.input = STDIN"
    puts "  Pry.config.output = STDOUT"
    puts "  binding.pry"
    throw(:breakout)
  end
end

- (Object) inject_local(name, value, b)

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.



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

def inject_local(name, value, b)
  Pry.current[:pry_local] = value.is_a?(Proc) ? value.call : value
  b.eval("#{name} = ::Pry.current[:pry_local]")
ensure
  Pry.current[:pry_local] = nil
end

- (Object) inject_sticky_locals(target)

Inject all the sticky locals into the target binding.

Parameters:

  • target (Binding)


167
168
169
170
171
# File 'lib/pry/pry_instance.rb', line 167

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

- (Boolean) last_result_is_exception?

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)



554
555
556
# File 'lib/pry/pry_instance.rb', line 554

def last_result_is_exception?
  @last_result_is_exception
end

- (Integer) memory_size

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.



156
157
158
# File 'lib/pry/pry_instance.rb', line 156

def memory_size
  @output_array.max_size
end

- (Object) memory_size=(size)



160
161
162
163
# File 'lib/pry/pry_instance.rb', line 160

def memory_size=(size)
  @input_array  = Pry::HistoryArray.new(size)
  @output_array = Pry::HistoryArray.new(size)
end

- (Array<Proc>) pop_prompt

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.



714
715
716
# File 'lib/pry/pry_instance.rb', line 714

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

- (Boolean) process_command(val, eval_string = '', target = binding_stack.last)

If the given line is a valid command, process it in the context of the current eval_string and context. This method should not need to be invoked directly.

Parameters:

  • val (String)

    The line to process.

  • eval_string (String) (defaults to: '')

    The cumulative lines of input.

  • target (Binding) (defaults to: binding_stack.last)

    The target of the Pry session.

Returns:

  • (Boolean)

    true if val is a command, false otherwise



440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
# File 'lib/pry/pry_instance.rb', line 440

def process_command(val, eval_string = '', target = binding_stack.last)
  val = val.chomp
  result = commands.process_line(val, {
    :target => target,
    :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

- (Array<Proc>) prompt

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

Examples:

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

Returns:

  • (Array<Proc>)

    Current prompt.



130
131
132
# File 'lib/pry/pry_instance.rb', line 130

def prompt
  prompt_stack.last
end

- (Object) prompt=(new_prompt)



134
135
136
137
138
139
140
# File 'lib/pry/pry_instance.rb', line 134

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

- (Object) prompt_stack (private)

the array that the prompt stack is stored in



686
687
688
# File 'lib/pry/pry_instance.rb', line 686

def prompt_stack
  @prompt_stack ||= Array.new
end

- (Array<Proc>) push_prompt(new_prompt)

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



698
699
700
# File 'lib/pry/pry_instance.rb', line 698

def push_prompt(new_prompt)
  prompt_stack.push new_prompt
end

- (String) r(target = TOPLEVEL_BINDING, eval_string = "")

Perform a read. If no parameter is given, default to top-level (main). This is a multi-line read; so the read continues until a valid Ruby expression is received. Pry commands are also accepted here and operate on the target.

Examples:

Pry.new.r(Object.new)

Parameters:

  • target (Object, Binding) (defaults to: TOPLEVEL_BINDING)

    The receiver of the read.

  • eval_string (String) (defaults to: "")

    Optionally Prime eval_string with a start value.

Returns:

  • (String)

    The Ruby expression.



294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
# File 'lib/pry/pry_instance.rb', line 294

def r(target=TOPLEVEL_BINDING, eval_string="")
  target = Pry.binding_for(target)
  @suppress_output = false

  loop do
    begin
      # eval_string will probably be mutated by this method
      retrieve_line(eval_string, target)
    rescue CommandError, Slop::InvalidOptionError, MethodSource::SourceNotFoundError => e
      output.puts "Error: #{e.message}"
    end

    begin
      break if Pry::Code.complete_expression?(eval_string)
    rescue SyntaxError => e
      exception_handler.call(output, e.extend(UserError), self)
      eval_string = ""
    end
  end

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

  exec_hook :after_read, eval_string, self
  eval_string
end

- (Object) raise_up(*args)



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

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

- (Object) raise_up!(*args)



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

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

- (Object) raise_up_common(force, *args)

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)


730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
# File 'lib/pry/pry_instance.rb', line 730

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

- (Object) re(target = TOPLEVEL_BINDING)

Perform a read-eval If no parameter is given, default to top-level (main).

Examples:

Pry.new.re(Object.new)

Parameters:

  • target (Object, Binding) (defaults to: TOPLEVEL_BINDING)

    The receiver of the read-eval-print

Returns:

  • (Object)

    The result of the eval or an Exception object in case of error. In the latter case, you can check whether the exception was raised or is just the result of the expression using #last_result_is_exception?



269
270
271
272
273
274
275
276
277
278
279
280
281
282
# File 'lib/pry/pry_instance.rb', line 269

def re(target=TOPLEVEL_BINDING)
  target = Pry.binding_for(target)

  # It's not actually redundant to inject them continually as we may have
  # moved into the scope of a new Binding (e.g the user typed `cd`).
  inject_sticky_locals(target)

  code = r(target)

  evaluate_ruby(code, target)
rescue RescuableException => e
  self.last_exception = e
  e
end

- (String) readline(current_prompt = "> ", completion_proc = nil)

Returns the next line of input to be used by the pry instance. This method should not need to be invoked directly.

Parameters:

  • current_prompt (String) (defaults to: "> ")

    The prompt to use for input.

Returns:

  • (String)

    The next line of input.



607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
# File 'lib/pry/pry_instance.rb', line 607

def readline(current_prompt="> ", completion_proc=nil)
  handle_read_errors do

    if defined? Coolline and input.is_a? Coolline
      input.completion_proc = proc do |cool|
        completions = completion_proc.call cool.completed_word
        completions.compact
      end
    elsif input.respond_to? :completion_proc=
      input.completion_proc = completion_proc
    end

    if input == Readline
      input.readline(current_prompt, false) # false since we'll add it manually
    elsif defined? Coolline and input.is_a? Coolline
      input.readline(current_prompt)
    else
      if input.method(:readline).arity == 1
        input.readline(current_prompt)
      else
        input.readline
      end
    end
  end
end

- (Object) refresh(options = {})

Refresh the Pry instance settings from the Pry class. Allows options to be specified to override settings from Pry class.

Parameters:

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

    The options to override Pry class settings for this instance.



95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
# File 'lib/pry/pry_instance.rb', line 95

def refresh(options={})
  defaults   = {}
  attributes = [
                 :input, :output, :commands, :print, :quiet,
                 :exception_handler, :hooks, :custom_completions,
                 :prompt, :memory_size, :extra_sticky_locals
               ]

  attributes.each do |attribute|
    defaults[attribute] = Pry.send attribute
  end

  defaults[:input_stack] = Pry.input_stack.dup

  defaults.merge!(options).each do |key, value|
    send("#{key}=", value) if respond_to?("#{key}=")
  end

  true
end

- (Object) rep(target = TOPLEVEL_BINDING)

Perform a read-eval-print. If no parameter is given, default to top-level (main).

Examples:

Pry.new.rep(Object.new)

Parameters:

  • target (Object, Binding) (defaults to: TOPLEVEL_BINDING)

    The receiver of the read-eval-print



252
253
254
255
256
257
258
259
# File 'lib/pry/pry_instance.rb', line 252

def rep(target=TOPLEVEL_BINDING)
  target = Pry.binding_for(target)
  result = re(target)

  Pry.critical_section do
    show_result(result)
  end
end

- (Object) repl(target = TOPLEVEL_BINDING)

Start a read-eval-print-loop. If no parameter is given, default to top-level (main).

Examples:

Pry.new.repl(Object.new)

Parameters:

  • target (Object, Binding) (defaults to: TOPLEVEL_BINDING)

    The receiver of the Pry session

Returns:

  • (Object)

    The target of the Pry session or an explictly given return value. If given return value is nil or no return value is specified then target will be returned.



224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
# File 'lib/pry/pry_instance.rb', line 224

def repl(target=TOPLEVEL_BINDING)
  target = Pry.binding_for(target)

  repl_prologue(target)

  break_data = nil
  exception = catch(:raise_up) do
    break_data = catch(:breakout) do
      loop do
        throw(:breakout) if binding_stack.empty?
        rep(binding_stack.last)
      end
    end
    exception = false
  end

  raise exception if exception

  break_data
ensure
  repl_epilogue(target)
end

- (Object) repl_epilogue(target)

Clean-up after the repl session.

Parameters:

  • target (Binding)

    The target binding for the session.



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

def repl_epilogue(target)
  exec_hook :after_session, output, target, self

  binding_stack.pop
  Pry.save_history if Pry.config.history.should_save
end

- (Object) repl_prologue(target)

Initialize the repl session.

Parameters:

  • target (Binding)

    The target binding for the session.



198
199
200
201
202
203
204
205
# File 'lib/pry/pry_instance.rb', line 198

def repl_prologue(target)
  exec_hook :before_session, output, target, self
  set_last_result(nil, target)

  @input_array << nil # add empty input so _in_ and _out_ match

  binding_stack.push target
end

- (String) retrieve_line(eval_string, target)

Read and process a line of input -- check for ^D, determine which prompt to use, rewrite the indentation if Pry.config.auto_indent is enabled, and, if the line is a command, process it and alter the eval_string accordingly. This method should not need to be invoked directly.

Parameters:

  • eval_string (String)

    The cumulative lines of input.

  • target (Binding)

    The target of the session.

Returns:

  • (String)

    The line received.



371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
# File 'lib/pry/pry_instance.rb', line 371

def retrieve_line(eval_string, target)
  @indent.reset if eval_string.empty?

  current_prompt = select_prompt(eval_string, target)
  completion_proc = Pry.config.completer.build_completion_proc(target, self,
                                                      instance_eval(&custom_completions))

  safe_completion_proc = proc{ |*a| Pry.critical_section{ completion_proc.call(*a) } }

  indentation = Pry.config.auto_indent ? @indent.current_prefix : ''

  begin
    val = readline("#{current_prompt}#{indentation}", safe_completion_proc)

  # Handle <Ctrl+C> like Bash, empty the current input buffer but do not quit.
  # This is only for ruby-1.9; other versions of ruby do not let you send Interrupt
  # from within Readline.
  rescue Interrupt
    output.puts ""
    eval_string.replace("")
    return
  end

  # invoke handler if we receive EOF character (^D)
  if !val
    output.puts ""
    Pry.config.control_d_handler.call(eval_string, self)
    return
  end

  # Change the eval_string into the input encoding (Issue 284)
  # TODO: This wouldn't be necessary if the eval_string was constructed from
  # input strings only.
  if should_force_encoding?(eval_string, val)
    eval_string.force_encoding(val.encoding)
  end

  if Pry.config.auto_indent && !input.is_a?(StringIO)
    original_val = "#{indentation}#{val}"
    indented_val = @indent.indent(val)

    if output.tty? && Pry::Helpers::BaseHelpers.use_ansi_codes? && Pry.config.correct_indent
      output.print @indent.correct_indentation(current_prompt, indented_val, original_val.length - indented_val.length)
      output.flush
    end
  else
    indented_val = val
  end

  # Check this before processing the line, because a command might change
  # Pry's input.
  interactive = !input.is_a?(StringIO)

  begin
    if !process_command(val, eval_string, target)
      eval_string << "#{indented_val.chomp}\n" unless val.empty?
    end
  ensure
    Pry.history << indented_val if interactive
  end
end

- (Pry::Command::VOID_VALUE) run_command(val, eval_string = "", target = binding_stack.last)

Run the specified command.

Examples:

pry_instance.run_command("ls -m")

Parameters:

  • val (String)

    The command (and its params) to execute.

  • eval_string (String) (defaults to: "")

    The current input buffer.

  • target (Binding) (defaults to: binding_stack.last)

    The binding to use..

Returns:



475
476
477
478
479
480
481
482
483
# File 'lib/pry/pry_instance.rb', line 475

def run_command(val, eval_string = "", target = binding_stack.last)
  commands.process_line(val,
    :eval_string => eval_string,
    :target => target,
    :pry_instance => self,
    :output => output
  )
  Pry::Command::VOID_VALUE
end

- (String) select_prompt(eval_string, target)

Returns the appropriate prompt to use. This method should not need to be invoked directly.

Parameters:

  • eval_string (String)

    The current input buffer.

  • target (Binding)

    The target Binding of the Pry session.

Returns:

  • (String)

    The prompt.



645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
# File 'lib/pry/pry_instance.rb', line 645

def select_prompt(eval_string, target)
  target_self = target.eval('self')

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

  c = OpenStruct.new(
                     :object         => target_self,
                     :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

- (Object) set_last_result(result, target, code = "")

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

Parameters:

  • result (Object)

    The result.

  • target (Binding)

    The binding to set _ on.

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

    The code that was run.



509
510
511
512
513
514
# File 'lib/pry/pry_instance.rb', line 509

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

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

- (Boolean) should_force_encoding?(eval_string, val) (private)

Returns:

  • (Boolean)


358
359
360
# File 'lib/pry/pry_instance.rb', line 358

def should_force_encoding?(eval_string, val)
  eval_string.empty? && val.respond_to?(:encoding) && val.encoding != eval_string.encoding
end

- (Boolean) should_print?

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.



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

def should_print?
  !@suppress_output
end

- (Object) show_result(result)

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



335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
# File 'lib/pry/pry_instance.rb', line 335

def show_result(result)
  if last_result_is_exception?
    exception_handler.call(output, result, self)
  elsif should_print?
    print.call(output, result)
  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
end

- (Hash) sticky_locals

Returns The currently defined sticky locals.

Returns:

  • (Hash)

    The currently defined sticky locals.



183
184
185
186
187
188
189
190
191
192
193
194
# File 'lib/pry/pry_instance.rb', line 183

def sticky_locals
  @sticky_locals ||= {
    :_in_   => proc { @input_array },
    :_out_  => proc { @output_array },
    :_pry_  => self,
    :_ex_   => proc { last_exception },
    :_file_ => proc { last_file },
    :_dir_  => proc { last_dir },
    :_      => proc { last_result },
    :__     => proc { @output_array[-2] }
  }.merge(extra_sticky_locals)
end

- (Object) update_input_history(code)

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



542
543
544
545
546
547
548
549
# File 'lib/pry/pry_instance.rb', line 542

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.each_line.count
  end
end