# File lib/pry/pry_class.rb, line 41 def self.main @main ||= TOPLEVEL_BINDING.eval "self" end
PP subclass for streaming inspect output in color.
Pry is a powerful alternative to the standard IRB shell for Ruby. It features syntax highlighting, a flexible plugin architecture, runtime invocation and source and documentation browsing.
Pry can be started similar to other command line utilities by simply running the following command:
pry
Once inside Pry you can invoke the help message:
help
This will show a list of available commands and their usage. For more information about Pry you can refer to the following resources:
the IRC channel, which is pry on the Freenode network
@return [Array] Code of the method used when implementing Pry’s
__binding__, along with line indication to be used with instance_eval (and friends).
@see Object#__binding__
useful when playing with truly enormous objects
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 ..`.
Will only show the first line of the backtrace
Don’t catch these exceptions
The default hooks - display messages when beginning and ending Pry sessions.
The default print
The default prompt; includes the target and nesting level
Store the current working directory. This allows show-source etc. to work if your process has changed directory since boot. [Issue #675]
A prompt that includes the full object path as well as input/output (in and out) information. Good for navigation.
may be convenient when working with enormous objects and pretty_print is too slow
A simple prompt - doesn’t display target or nesting level
Convert the given object into an instance of `Pry::Code`, if it isn’t already one.
@param [Code, Method, UnboundMethod, Proc, Pry::Method, String, Array,
IO] obj
# File lib/pry/code.rb, line 12 def Code(obj) case obj when Code obj when ::Method, UnboundMethod, Proc, Pry::Method Code.from_method(obj) else Code.new(obj) end end
If the given object is a `Pry::Method`, return it unaltered. If it’s anything else, return it wrapped in a `Pry::Method` instance.
# File lib/pry/method.rb, line 7 def Method(obj) if obj.is_a? Pry::Method obj else Pry::Method.new(obj) end end
If the given object is a `Pry::WrappedModule`, return it unaltered. If it’s anything else, return it wrapped in a `Pry::WrappedModule` instance.
# File lib/pry/wrapped_module.rb, line 7 def WrappedModule(obj) if obj.is_a? Pry::WrappedModule obj else Pry::WrappedModule.new(obj) end end
# File lib/pry/pry_class.rb, line 275 def self.auto_resize! Pry.config.input # by default, load Readline if !defined?(Readline) || Pry.config.input != Readline warn "Sorry, you must be using Readline for Pry.auto_resize! to work." return end if Readline::VERSION =~ /edit/ 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
Return a `Binding` object for `target` or return `target` if it is already a `Binding`. In the case where `target` is top-level then return `TOPLEVEL_BINDING` @param [Object] target The object to get a `Binding` object for. @return [Binding] The `Binding` object.
# File lib/pry/pry_class.rb, line 328 def self.binding_for(target) if Binding === target target else if Pry.main == target TOPLEVEL_BINDING else target.__binding__ end end end
# File lib/pry/pry_class.rb, line 366 def self.critical_section(&block) Thread.current[:pry_critical_section] ||= 0 Thread.current[:pry_critical_section] += 1 yield ensure Thread.current[:pry_critical_section] -= 1 end
@return [Pry::Config]
Returns a value store for an instance of Pry running on the current thread.
# File lib/pry/pry_class.rb, line 49 def self.current Thread.current[:__pry__] ||= Pry::Config.from_hash({}, nil) end
# File lib/pry/pry_class.rb, line 263 def self.default_editor_for_platform return ENV['VISUAL'] if ENV['VISUAL'] and not ENV['VISUAL'].empty? return ENV['EDITOR'] if ENV['EDITOR'] and not ENV['EDITOR'].empty? if Helpers::BaseHelpers.windows? 'notepad' else %w(editor nano vi).detect do |editor| system("which #{editor} > /dev/null 2>&1") end end end
# File lib/pry/pry_class.rb, line 32 def history @history ||= History.new end
# File lib/pry/pry_class.rb, line 361 def self.in_critical_section? Thread.current[:pry_critical_section] ||= 0 Thread.current[:pry_critical_section] > 0 end
Basic initialization.
# File lib/pry/pry_class.rb, line 317 def self.init @plugin_manager ||= PluginManager.new reset_defaults locate_plugins end
@return [Boolean] Whether this is the first time a Pry session has
been started since loading the Pry class.
# File lib/pry/pry_class.rb, line 227 def self.initial_session? @initial_session end
Do basic setup for initial session. Including: loading .pryrc, loading plugins, loading requires, and loading history.
# File lib/pry/pry_class.rb, line 120 def self.initial_session_setup return unless initial_session? @initial_session = false # note these have to be loaded here rather than in pry_instance as # we only want them loaded once per entire Pry lifetime. load_rc_files load_plugins if Pry.config.should_load_plugins load_requires if Pry.config.should_load_requires load_history if Pry.config.history.should_load load_traps if Pry.config.should_trap_interrupts load_win32console if Pry::Helpers::BaseHelpers.windows? && !Pry::Helpers::BaseHelpers.windows_ansi? end
Load the given file in the context of `::toplevel_binding` @param [String] file The unexpanded file path.
# File lib/pry/pry_class.rb, line 55 def self.load_file_at_toplevel(file) toplevel_binding.eval(File.read(file), file) rescue RescuableException => e puts "Error loading #{file}: #{e}\n#{e.backtrace.first}" end
Load Readline history if required.
# File lib/pry/pry_class.rb, line 221 def self.load_history Pry.history.load end
Load HOME_RC_FILE and LOCAL_RC_FILE if appropriate This method can also be used to reload the files if they have changed.
# File lib/pry/pry_class.rb, line 63 def self.load_rc_files rc_files_to_load.each do |file| critical_section do load_file_at_toplevel(file) end end end
Load any Ruby files specified with the -r flag on the command line.
# File lib/pry/pry_class.rb, line 89 def self.load_requires Pry.config.requires.each do |file| require file end end
Trap interrupts on jruby, and make them behave like MRI so we can catch them.
# File lib/pry/pry_class.rb, line 97 def self.load_traps trap('INT'){ raise Interrupt } end
# File lib/pry/pry_class.rb, line 101 def self.load_win32console begin require 'win32console' # The mswin and mingw versions of pry require win32console, so this should # only fail on jruby (where win32console doesn't work). # Instead we'll recommend ansicon, which does. rescue LoadError warn "For a better Pry experience on Windows, please use ansicon: https://github.com/adoxa/ansicon If you use an alternative to ansicon and don't want to see this warning again, you can add "Pry.config.windows_console_warning = false" to your .pryrc. " if Pry.config.windows_console_warning end end
@return [main]
returns the special instance of Object, "main".
# File lib/pry/pry_class.rb, line 41 def self.main @main ||= TOPLEVEL_BINDING.eval "self" end
Create a new {Pry} instance. @param [Hash] options @option options [readline] :input
The object to use for input.
@option options [puts] :output
The object to use for output.
@option options [Pry::CommandBase] :commands
The object to use for commands.
@option options [Hash] :hooks
The defined hook Procs.
@option options [Array<Proc>] :prompt
The array of Procs to use for prompts.
@option options [Proc] :print
The Proc to use for printing return values.
@option options [Boolean] :quiet
Omit the `whereami` banner when starting.
@option options [Array<String>] :backtrace
The backtrace of the session's `binding.pry` line, if applicable.
@option options [Object] :target
The initial context for this session.
# File lib/pry/pry_instance.rb, line 64 def initialize(options={}) @binding_stack = [] @indent = Pry::Indent.new @command_state = {} @eval_string = "" @backtrace = options.delete(:backtrace) || caller target = options.delete(:target) @config = Pry::Config.new config.merge!(options) push_prompt(config.prompt) @input_array = Pry::HistoryArray.new config.memory_size @output_array = Pry::HistoryArray.new config.memory_size @custom_completions = config.command_completions set_last_result nil @input_array << nil push_initial_binding(target) exec_hook(:when_started, target, options, self) end
# File lib/pry/pry_class.rb, line 28 def prompt config.prompt end
# File lib/pry/pry_class.rb, line 24 def prompt=(value) config.prompt = value end
Load the local RC file (./.pryrc)
# File lib/pry/pry_class.rb, line 72 def self.rc_files_to_load files = [] files << HOME_RC_FILE if Pry.config.should_load_rc files << LOCAL_RC_FILE if Pry.config.should_load_local_rc files.map { |file| real_path_to(file) }.compact.uniq end
Expand a file to its canonical name (following symlinks as appropriate)
# File lib/pry/pry_class.rb, line 80 def self.real_path_to(file) expanded = Pathname.new(File.expand_path(file)).realpath.to_s # For rbx 1.9 mode [see rubinius issue #2165] File.exist?(expanded) ? expanded : nil rescue Errno::ENOENT nil end
Set all the configurable options back to their default values
# File lib/pry/pry_class.rb, line 307 def self.reset_defaults @initial_session = true self.config = Pry::Config.new Pry::Config::Default.new self.cli = false self.current_line = 1 self.line_buffer = [""] self.eval_path = "(pry)" end
Run a Pry command from outside a session. The commands available are those referenced by `::config.commands` (the default command set). @param [String] command_string The Pry command (including arguments,
if any).
@param [Hash] options Optional named parameters. @return [Object] The return value of the Pry command. @option options [Object, Binding] :target The object to run the
command under. Defaults to `TOPLEVEL_BINDING` (main).
@option options [Boolean] :show_output Whether to show command
output. Defaults to true.
@example Run at top-level with no output.
Pry.run_command "ls"
@example Run under Pry class, returning only public methods.
Pry.run_command "ls -m", :target => Pry
@example Display command output.
Pry.run_command "ls -av", :show_output => true
# File lib/pry/pry_class.rb, line 247 def self.run_command(command_string, options={}) options = { :target => TOPLEVEL_BINDING, :show_output => true, :output => Pry.config.output, :commands => Pry.config.commands }.merge!(options) # :context for compatibility with <= 0.9.11.4 target = options[:context] || options[:target] output = options[:show_output] ? options[:output] : StringIO.new pry = Pry.new(:output => output, :target => target, :commands => options[:commands]) pry.eval command_string end
Start a Pry REPL. This method also loads `~/.pryrc` and `./.pryrc` as necessary the first time it is invoked. @param [Object, Binding] target The receiver of the Pry session @param [Hash] options @option options (see Pry#initialize) @example
Pry.start(Object.new, :input => MyInput.new)
# File lib/pry/pry_class.rb, line 142 def self.start(target=nil, options={}) return if ENV['DISABLE_PRY'] options = options.to_hash if in_critical_section? output.puts "ERROR: Pry started inside Pry." output.puts "This can happen if you have a binding.pry inside a #to_s or #inspect function." return end options[:target] = Pry.binding_for(target || toplevel_binding) options[:hooks] = Pry::Hooks.from_hash options.delete(:hooks) if options.key?(:hooks) initial_session_setup # Unless we were given a backtrace, save the current one if options[:backtrace].nil? options[:backtrace] = caller # If Pry was started via `binding.pry`, elide that from the backtrace if options[:backtrace].first =~ /pry.*core_extensions.*pry/ options[:backtrace].shift end end driver = options[:driver] || Pry::REPL # Enter the matrix driver.start(options) rescue Pry::TooSafeException puts "ERROR: Pry cannot work with $SAFE > 0" raise end
# File lib/pry/pry_class.rb, line 340 def self.toplevel_binding unless defined?(@toplevel_binding) && @toplevel_binding # Grab a copy of the TOPLEVEL_BINDING without any local variables. # This binding has a default definee of Object, and new methods are # private (just as in TOPLEVEL_BINDING). TOPLEVEL_BINDING.eval <<-RUBY def self.__pry__ binding end Pry.toplevel_binding = __pry__ class << self; undef __pry__; end RUBY end @toplevel_binding.eval('private') @toplevel_binding end
# File lib/pry/pry_class.rb, line 357 def self.toplevel_binding=(binding) @toplevel_binding = binding end
An inspector that clips the output to `max_length` chars. In case of > `max_length` chars the `#<Object…> notation is used.
@param [Object] obj
The object to view.
@param [Hash] options @option options [Integer] :max_length (60)
The maximum number of chars before clipping occurs.
@option options [Boolean] :id (false)
Boolean to indicate whether or not a hex reprsentation of the object ID is attached to the return value when the length of inspect is greater than value of `:max_length`.
@return [String]
The string representation of `obj`.
# File lib/pry/pry_class.rb, line 201 def self.view_clip(obj, options = {}) max = options.fetch :max_length, 60 id = options.fetch :id, false if obj.kind_of?(Module) && obj.name.to_s != "" && obj.name.to_s.length <= max obj.name.to_s elsif Pry.main == obj # special-case to support jruby. # fixed as of https://github.com/jruby/jruby/commit/d365ebd309cf9df3dde28f5eb36ea97056e0c039 # we can drop in the future. obj.to_s elsif Pry.config.prompt_safe_objects.any? { |v| v === obj } && obj.inspect.length <= max obj.inspect else id == true ? "#<#{obj.class}:0x%x>" % (obj.object_id << 1) : "#<#{obj.class}>" end rescue RescuableException "unknown" end
Add a sticky local to this Pry instance. A sticky local is a local that persists between all bindings in a session. @param [Symbol] name The name of the sticky local. @yield The block that defines the content of the local. The local
will be refreshed at each tick of the repl loop.
# File lib/pry/pry_instance.rb, line 194 def add_sticky_local(name, &block) config.extra_sticky_locals[name] = block end
Generate completions.
@param [String] input
What the user has typed so far
@return [Array<String>]
Possible completions
# File lib/pry/pry_instance.rb, line 132 def complete(str) return EMPTY_COMPLETIONS unless config.completer Pry.critical_section do completer = config.completer.new(config.input, self) completer.call str, target: current_binding, custom_completions: custom_completions.call.push(*sticky_locals.keys) end end
The currently active `Binding`. @return [Binding] The currently active `Binding` for the session.
# File lib/pry/pry_instance.rb, line 111 def current_binding binding_stack.last end
Pass a line of input to Pry.
This is the equivalent of `Binding#eval` but with extra Pry!
In particular:
Pry commands will be executed immediately if the line matches.
Partial lines of input will be queued up until a complete expression has been accepted.
Output is written to `output` in pretty colours, not returned.
Once this method has raised an exception or returned false, this instance is no longer usable. {exit_value} will return the session’s breakout value if applicable.
@param [String?] line The line of input; `nil` if the user types `<Ctrl-D>` @option options [Boolean] :generated Whether this line was generated automatically.
Generated lines are not stored in history.
@return [Boolean] Is Pry ready to accept more input? @raise [Exception] If the user uses the `raise-up` command, this method
will raise that exception.
# File lib/pry/pry_instance.rb, line 236 def eval(line, options={}) return false if @stopped exit_value = nil exception = catch(:raise_up) do exit_value = catch(:breakout) do handle_line(line, options) # We use 'return !@stopped' here instead of 'return true' so that if # handle_line has stopped this pry instance (e.g. by opening _pry_.repl and # then popping all the bindings) we still exit immediately. return !@stopped end exception = false end @stopped = true @exit_value = exit_value # TODO: make this configurable? raise exception if exception return false end
# File lib/pry/pry_instance.rb, line 350 def evaluate_ruby(code) inject_sticky_locals! exec_hook :before_eval, code, self result = current_binding.eval(code, Pry.eval_path, Pry.current_line) set_last_result(result, code) ensure update_input_history(code) exec_hook :after_eval, result, self end
Execute the specified hook. @param [Symbol] name The hook name to execute @param [*Object] args The arguments to pass to the hook @return [Object, Exception] The return value of the hook or the exception raised
If executing a hook raises an exception, we log that and then continue sucessfully. To debug such errors, use the global variable $pry_hook_error, which is set as a result.
# File lib/pry/pry_instance.rb, line 464 def exec_hook(name, *args, &block) e_before = hooks.errors.size hooks.exec_hook(name, *args, &block).tap do hooks.errors[e_before..-1].each do |e| output.puts "#{name} hook failed: #{e.class}: #{e.message}" output.puts "#{e.backtrace.first}" output.puts "(see _pry_.hooks.errors to debug)" end end end
Injects a local variable into the provided binding.
@param [String] name
The name of the local to inject.
@param [Object] value
The value to set the local to.
@param [Binding] b
The binding to set the local on.
@return [Object]
The value the local was set to.
# File lib/pry/pry_instance.rb, line 155 def inject_local(name, value, b) value = Proc === value ? value.call : value if b.respond_to?(:local_variable_set) b.local_variable_set name, value else # < 2.1 begin Pry.current[:pry_local] = value b.eval "#{name} = ::Pry.current[:pry_local]" ensure Pry.current[:pry_local] = nil end end end
Inject all the sticky locals into the current binding.
# File lib/pry/pry_instance.rb, line 183 def inject_sticky_locals! sticky_locals.each_pair do |name, value| inject_local(name, value, current_binding) end end
Set the last exception for a session.
@param [Exception] e
the last exception.
# File lib/pry/pry_instance.rb, line 492 def last_exception=(e) last_exception = Pry::LastException.new(e) @last_result_is_exception = true @output_array << last_exception @last_exception = last_exception end
@return [Boolean] True if the last result is an exception that was raised,
as opposed to simply an instance of Exception (like the result of Exception.new)
# File lib/pry/pry_instance.rb, line 514 def last_result_is_exception? @last_result_is_exception end
@return [Integer] The maximum amount of objects remembered by the inp and
out arrays. Defaults to 100.
# File lib/pry/pry_instance.rb, line 172 def memory_size @output_array.max_size end
# File lib/pry/pry_instance.rb, line 177 def memory_size=(size) @input_array = Pry::HistoryArray.new(size) @output_array = Pry::HistoryArray.new(size) end
Returns an output device @example
_pry_.output.puts "ohai!"
# File lib/pry/pry_instance.rb, line 612 def output Pry::Output.new(self) end
Returns the currently configured pager @example
_pry_.pager.page text
# File lib/pry/pry_instance.rb, line 604 def pager Pry::Pager.new(self) end
Pops the current prompt off of the prompt stack. If the prompt you are popping is the last prompt, it will not be popped. Use this to restore the previous prompt. @return [Array<Proc>] Prompt being popped. @example
prompt1 = [ proc { '>' }, proc { '>>' } ] prompt2 = [ proc { '$' }, proc { '>' } ] pry = Pry.new :prompt => prompt1 pry.push_prompt(prompt2) pry.pop_prompt # => prompt2 pry.pop_prompt # => prompt1 pry.pop_prompt # => prompt1
# File lib/pry/pry_instance.rb, line 596 def pop_prompt prompt_stack.size > 1 ? prompt_stack.pop : prompt end
If the given line is a valid command, process it in the context of the current `#eval_string` and binding. @param [String] val The line to process. @return [Boolean] `true` if `val` is a command, `false` otherwise
# File lib/pry/pry_instance.rb, line 401 def process_command(val) val = val.chomp result = commands.process_line(val, :target => current_binding, :output => output, :eval_string => @eval_string, :pry_instance => self ) # set a temporary (just so we can inject the value we want into eval_string) Pry.current[:pry_cmd_result] = result # note that `result` wraps the result of command processing; if a # command was matched and invoked then `result.command?` returns true, # otherwise it returns false. if result.command? if !result.void_command? # the command that was invoked was non-void (had a return value) and so we make # the value of the current expression equal to the return value # of the command. @eval_string.replace "::Pry.current[:pry_cmd_result].retval\n" end true else false end end
Same as #process_command, but outputs exceptions to `output` instead of raising. @param [String] val The line to process. @return [Boolean] `true` if `val` is a command, `false` otherwise
# File lib/pry/pry_instance.rb, line 433 def process_command_safely(val) process_command(val) rescue CommandError, Slop::InvalidOptionError, MethodSource::SourceNotFoundError => e Pry.last_internal_error = e output.puts "Error: #{e.message}" true end
The current prompt. This is the prompt at the top of the prompt stack.
@example
self.prompt = Pry::SIMPLE_PROMPT self.prompt # => Pry::SIMPLE_PROMPT
@return [Array<Proc>] Current prompt.
# File lib/pry/pry_instance.rb, line 91 def prompt prompt_stack.last end
# File lib/pry/pry_instance.rb, line 95 def prompt=(new_prompt) if prompt_stack.empty? push_prompt new_prompt else prompt_stack[-1] = new_prompt end end
Push a binding for the given object onto the stack. If this instance is currently stopped, mark it as usable again.
# File lib/pry/pry_instance.rb, line 118 def push_binding(object) @stopped = false binding_stack << Pry.binding_for(object) end
Initialize this instance by pushing its initial context into the binding stack. If no target is given, start at the top level.
# File lib/pry/pry_instance.rb, line 105 def push_initial_binding(target=nil) push_binding(target || Pry.toplevel_binding) end
Pushes the current prompt onto a stack that it can be restored from later. Use this if you wish to temporarily change the prompt. @param [Array<Proc>] new_prompt @return [Array<Proc>] new_prompt @example
new_prompt = [ proc { '>' }, proc { '>>' } ] push_prompt(new_prompt) # => new_prompt
# File lib/pry/pry_instance.rb, line 580 def push_prompt(new_prompt) prompt_stack.push new_prompt end
Convenience accessor for the `quiet` config key. @return [Boolean]
# File lib/pry/pry_instance.rb, line 660 def quiet? config.quiet end
# File lib/pry/pry_instance.rb, line 655 def raise_up(*args); raise_up_common(false, *args); end
# File lib/pry/pry_instance.rb, line 656 def raise_up!(*args); raise_up_common(true, *args); end
Raise an exception out of Pry.
See Kernel#raise for documentation of parameters. See rb_make_exception for the inbuilt implementation.
This is necessary so that the raise-up command can tell the difference between an exception the user has decided to raise, and a mistake in specifying that exception.
(i.e. raise-up RunThymeError.new should not be the same as
raise-up NameError, "unititialized constant RunThymeError")
# File lib/pry/pry_instance.rb, line 628 def raise_up_common(force, *args) exception = if args == [] last_exception || RuntimeError.new elsif args.length == 1 && args.first.is_a?(String) RuntimeError.new(args.first) elsif args.length > 3 raise ArgumentError, "wrong number of arguments" elsif !args.first.respond_to?(:exception) raise TypeError, "exception class/object expected" elsif args.length === 1 args.first.exception else args.first.exception(args[1]) end raise TypeError, "exception object expected" unless exception.is_a? Exception exception.set_backtrace(args.length === 3 ? args[2] : caller(1)) if force || binding_stack.one? binding_stack.clear throw :raise_up, exception else binding_stack.pop raise exception end end
Potentially deprecated — Use `Pry::REPL.new(pry, :target => target).start` (If nested sessions are going to exist, this method is fine, but a goal is to come up with an alternative to nested sessions altogether.)
# File lib/pry/pry_instance.rb, line 346 def repl(target = nil) Pry::REPL.new(self, :target => target).start end
Reset the current eval string. If the user has entered part of a multiline expression, this discards that input.
# File lib/pry/pry_instance.rb, line 212 def reset_eval_string @eval_string = "" end
Run the specified command. @param [String] val The command (and its params) to execute. @return [Pry::Command::VOID_VALUE] @example
pry_instance.run_command("ls -m")
# File lib/pry/pry_instance.rb, line 446 def run_command(val) commands.process_line(val, :eval_string => @eval_string, :target => current_binding, :pry_instance => self, :output => output ) Pry::Command::VOID_VALUE end
Returns the appropriate prompt to use. @return [String] The prompt.
# File lib/pry/pry_instance.rb, line 527 def select_prompt object = current_binding.eval('self') open_token = @indent.open_delimiters.any? ? @indent.open_delimiters.last : @indent.stack.last c = Pry::Config.from_hash({ :object => object, :nesting_level => binding_stack.size - 1, :open_token => open_token, :session_line => Pry.history.session_line_count + 1, :history_line => Pry.history.history_line_count + 1, :expr_number => input_array.count, :_pry_ => self, :binding_stack => binding_stack, :input_array => input_array, :eval_string => @eval_string, :cont => !@eval_string.empty?}) Pry.critical_section do # If input buffer is empty then use normal prompt if eval_string.empty? generate_prompt(Array(prompt).first, c) # Otherwise use the wait prompt (indicating multi-line expression) else generate_prompt(Array(prompt).last, c) end end end
Set the last result of an eval. This method should not need to be invoked directly. @param [Object] result The result. @param [String] code The code that was run.
# File lib/pry/pry_instance.rb, line 479 def set_last_result(result, code="") @last_result_is_exception = false @output_array << result self.last_result = result unless code =~ /\A\s*\z/ end
Whether the print proc should be invoked. Currently only invoked if the output is not suppressed. @return [Boolean] Whether the print proc should be invoked.
# File lib/pry/pry_instance.rb, line 521 def should_print? !@suppress_output end
Output the result or pass to an exception handler (if result is an exception).
# File lib/pry/pry_instance.rb, line 362 def show_result(result) if last_result_is_exception? exception_handler.call(output, result, self) elsif should_print? print.call(output, result, self) else # nothin' end rescue RescuableException => e # Being uber-paranoid here, given that this exception arose because we couldn't # serialize something in the user's program, let's not assume we can serialize # the exception either. begin output.puts "(pry) output error: #{e.inspect}" rescue RescuableException => e if last_result_is_exception? output.puts "(pry) output error: failed to show exception" else output.puts "(pry) output error: failed to show result" end end ensure output.flush if output.respond_to?(:flush) end
# File lib/pry/pry_instance.rb, line 198 def sticky_locals { _in_: input_array, _out_: output_array, _pry_: self, _ex_: last_exception && last_exception.wrapped_exception, _file_: last_file, _dir_: last_dir, _: proc { last_result }, __: proc { output_array[-2] } }.merge(config.extra_sticky_locals) end
Update Pry’s internal state after evalling code. This method should not need to be invoked directly. @param [String] code The code we just eval’d
# File lib/pry/pry_instance.rb, line 502 def update_input_history(code) # Always push to the @input_array as the @output_array is always pushed to. @input_array << code if code Pry.line_buffer.push(*code.each_line) Pry.current_line += code.lines.count end end