pry 0.9.12.6-i386-mswin32 → 0.10.0-i386-mswin32

data/lib/pry/pry_instance.rb

@@ -1,5 +1,4 @@
-require "pry/indent"
-
+# -*- coding: utf-8 -*-
 ##
 # Pry is a powerful alternative to the standard IRB shell for Ruby. It
 # features syntax highlighting, a flexible plugin architecture, runtime
@@ -21,102 +20,65 @@ require "pry/indent"
 # * https://github.com/pry/pry
 # * the IRC channel, which is #pry on the Freenode network
 #
-class Pry
-
-  attr_accessor :input
-  attr_accessor :output
-  attr_accessor :commands
-  attr_accessor :print
-  attr_accessor :exception_handler
-  attr_accessor :input_stack
-  attr_accessor :quiet
-  alias :quiet? :quiet
-
-  attr_accessor :custom_completions
 
+class Pry
   attr_accessor :binding_stack
-
+  attr_accessor :custom_completions
+  attr_accessor :eval_string
+  attr_accessor :backtrace
+  attr_accessor :suppress_output
   attr_accessor :last_result
   attr_accessor :last_file
   attr_accessor :last_dir
 
   attr_reader :last_exception
-
+  attr_reader :command_state
+  attr_reader :exit_value
   attr_reader :input_array
   attr_reader :output_array
-
-  attr_accessor :backtrace
-
-  attr_accessor :extra_sticky_locals
-
-  attr_accessor :suppress_output
-
-  # This is exposed via Pry::Command#state.
-  attr_reader :command_state
-
-  # Special treatment for hooks as we want to alert people of the
-  # changed API
-  attr_reader :hooks
-
-  # FIXME:
-  # This is a hack to alert people of the new API.
-  # @param [Pry::Hooks] v Only accept `Pry::Hooks` now!
-  def hooks=(v)
-    if v.is_a?(Hash)
-      warn "Hash-based hooks are now deprecated! Use a `Pry::Hooks` object instead! http://rubydoc.info/github/pry/pry/master/Pry/Hooks"
-      @hooks = Pry::Hooks.from_hash(v)
-    else
-      @hooks = v
-    end
-  end
-
-  # Create a new `Pry` object.
-  # @param [Hash] options The optional configuration parameters.
-  # @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 the prompts.
-  # @option options [Proc] :print The Proc to use for the 'print'
-  # @option options [Boolean] :quiet If true, omit the whereami banner when starting.
-  #   component of the REPL. (see print.rb)
+  attr_reader :config
+
+  extend Pry::Config::Convenience
+  config_shortcut *Pry::Config.shortcuts
+  EMPTY_COMPLETIONS = [].freeze
+
+  # 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.
   def initialize(options={})
-    refresh(options)
-
     @binding_stack = []
     @indent        = Pry::Indent.new
     @command_state = {}
-  end
-
-  # Refresh the Pry instance settings from the Pry class.
-  # Allows options to be specified to override settings from Pry class.
-  # @param [Hash] options The options to override Pry class settings
-  #   for this instance.
-  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
-
-  # The currently active `Binding`.
-  # @return [Binding] The currently active `Binding` for the session.
-  def current_context
-    binding_stack.last
+    @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
 
   # The current prompt.
@@ -139,16 +101,70 @@ class Pry
     end
   end
 
+  # Initialize this instance by pushing its initial context into the binding
+  # stack. If no target is given, start at the top level.
+  def push_initial_binding(target=nil)
+    push_binding(target || Pry.toplevel_binding)
+  end
+
+  # The currently active `Binding`.
+  # @return [Binding] The currently active `Binding` for the session.
+  def current_binding
+    binding_stack.last
+  end
+  alias current_context current_binding # support previous API
+
+  # Push a binding for the given object onto the stack. If this instance is
+  # currently stopped, mark it as usable again.
+  def push_binding(object)
+    @stopped = false
+    binding_stack << Pry.binding_for(object)
+  end
+
+  #
+  # Generate completions.
+  #
+  # @param [String] input
+  #   What the user has typed so far
+  #
+  # @return [Array<String>]
+  #   Possible completions
+  #
+  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
+
+  #
   # 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.
+  #
+  # @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.
+  #
   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
+    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
 
   # @return [Integer] The maximum amount of objects remembered by the inp and
@@ -162,11 +178,10 @@ class Pry
     @output_array = Pry::HistoryArray.new(size)
   end
 
-  # Inject all the sticky locals into the `target` binding.
-  # @param [Binding] target
-  def inject_sticky_locals(target)
+  # Inject all the sticky locals into the current binding.
+  def inject_sticky_locals!
     sticky_locals.each_pair do |name, value|
-      inject_local(name, value, target)
+      inject_local(name, value, current_binding)
     end
   end
 
@@ -176,157 +191,167 @@ class Pry
   # @yield The block that defines the content of the local. The local
   #   will be refreshed at each tick of the repl loop.
   def add_sticky_local(name, &block)
-    sticky_locals[name] = block
+    config.extra_sticky_locals[name] = block
   end
 
-  # @return [Hash] The currently defined sticky locals.
   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)
+    { _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
 
-  # Initialize the repl session.
-  # @param [Binding] target The target binding for the session.
-  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
+  # Reset the current eval string. If the user has entered part of a multiline
+  # expression, this discards that input.
+  def reset_eval_string
+    @eval_string = ""
   end
 
-  # Clean-up after the repl session.
-  # @param [Binding] target The target binding for the session.
-  def repl_epilogue(target)
-    exec_hook :after_session, output, target, self
-
-    binding_stack.pop
-    Pry.save_history if Pry.config.history.should_save
-  end
-
-  # Start a read-eval-print-loop.
-  # If no parameter is given, default to top-level (main).
-  # @param [Object, Binding] target The receiver of the Pry session
-  # @return [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.
-  # @example
-  #   Pry.new.repl(Object.new)
-  def repl(target=TOPLEVEL_BINDING)
-    target = Pry.binding_for(target)
-
-    repl_prologue(target)
-
-    break_data = nil
+  # Pass a line of input to Pry.
+  #
+  # This is the equivalent of `Binding#eval` but with extra Pry!
+  #
+  # In particular:
+  # 1. Pry commands will be executed immediately if the line matches.
+  # 2. Partial lines of input will be queued up until a complete expression has
+  #    been accepted.
+  # 3. Output is written to `#output` in pretty colours, not returned.
+  #
+  # Once this method has raised an exception or returned false, this instance
+  # is no longer usable. {#exit_value} will return the session's breakout
+  # value if applicable.
+  #
+  # @param [String?] line The line of input; `nil` if the user types `<Ctrl-D>`
+  # @option options [Boolean] :generated Whether this line was generated automatically.
+  #   Generated lines are not stored in history.
+  # @return [Boolean] Is Pry ready to accept more input?
+  # @raise [Exception] If the user uses the `raise-up` command, this method
+  #   will raise that exception.
+  def eval(line, options={})
+    return false if @stopped
+
+    exit_value = nil
     exception = catch(:raise_up) do
-      break_data = catch(:breakout) do
-        loop do
-          throw(:breakout) if binding_stack.empty?
-          rep(binding_stack.last)
-        end
+      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
 
-    raise exception if exception
+    @stopped = true
+    @exit_value = exit_value
 
-    break_data
-  ensure
-    repl_epilogue(target)
+    # TODO: make this configurable?
+    raise exception if exception
+    return false
   end
 
-  # Perform a read-eval-print.
-  # If no parameter is given, default to top-level (main).
-  # @param [Object, Binding] target The receiver of the read-eval-print
-  # @example
-  #   Pry.new.rep(Object.new)
-  def rep(target=TOPLEVEL_BINDING)
-    target = Pry.binding_for(target)
-    result = re(target)
+  def handle_line(line, options)
+    if line.nil?
+      config.control_d_handler.call(@eval_string, self)
+      return
+    end
 
-    Pry.critical_section do
-      show_result(result)
+    ensure_correct_encoding!(line)
+    Pry.history << line unless options[:generated]
+
+    @suppress_output = false
+    inject_sticky_locals!
+    begin
+      if !process_command_safely(line.lstrip)
+        @eval_string << "#{line.chomp}\n" if !line.empty? || !@eval_string.empty?
+      end
+    rescue RescuableException => e
+      self.last_exception = e
+      result = e
+
+      Pry.critical_section do
+        show_result(result)
+      end
+      return
     end
-  end
 
-  # Perform a read-eval
-  # If no parameter is given, default to top-level (main).
-  # @param [Object, Binding] target The receiver of the read-eval-print
-  # @return [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?
-  # @example
-  #   Pry.new.re(Object.new)
-  def re(target=TOPLEVEL_BINDING)
-    target = Pry.binding_for(target)
+    # This hook is supposed to be executed after each line of ruby code
+    # has been read (regardless of whether eval_string is yet a complete expression)
+    exec_hook :after_read, eval_string, self
 
-    # 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)
+    begin
+      complete_expr = Pry::Code.complete_expression?(@eval_string)
+    rescue SyntaxError => e
+      output.puts "SyntaxError: #{e.message.sub(/.*syntax error, */m, '')}"
+      reset_eval_string
+    end
 
-    code = r(target)
+    if complete_expr
+      if @eval_string =~ /;\Z/ || @eval_string.empty? || @eval_string =~ /\A *#.*\n\z/
+        @suppress_output = true
+      end
 
-    evaluate_ruby(code, target)
-  rescue RescuableException => e
-    self.last_exception = e
-    e
-  end
-
-  # 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.
-  # @param [Object, Binding] target The receiver of the read.
-  # @param [String] eval_string Optionally Prime `eval_string` with a start value.
-  # @return [String] The Ruby expression.
-  # @example
-  #   Pry.new.r(Object.new)
-  def r(target=TOPLEVEL_BINDING, eval_string="")
-    target = Pry.binding_for(target)
-    @suppress_output = false
+      # A bug in jruby makes java.lang.Exception not rescued by
+      # `rescue Pry::RescuableException` clause.
+      #
+      # * https://github.com/pry/pry/issues/854
+      # * https://jira.codehaus.org/browse/JRUBY-7100
+      #
+      # Until that gets fixed upstream, treat java.lang.Exception
+      # as an additional exception to be rescued explicitly.
+      #
+      # This workaround has a side effect: java exceptions specified
+      # in `Pry.config.exception_whitelist` are ignored.
+      jruby_exceptions = []
+      if Pry::Helpers::BaseHelpers.jruby?
+        jruby_exceptions << Java::JavaLang::Exception
+      end
 
-    loop do
       begin
-        # eval_string will probably be mutated by this method
-        retrieve_line(eval_string, target)
-      rescue CommandError, Slop::InvalidOptionError, MethodSource::SourceNotFoundError => e
-        Pry.last_internal_error = e
-        output.puts "Error: #{e.message}"
+        # Reset eval string, in case we're evaluating Ruby that does something
+        # like open a nested REPL on this instance.
+        eval_string = @eval_string
+        reset_eval_string
+
+        result = evaluate_ruby(eval_string)
+      rescue RescuableException, *jruby_exceptions => e
+        # Eliminate following warning:
+        # warning: singleton on non-persistent Java type X
+        # (http://wiki.jruby.org/Persistence)
+        if Pry::Helpers::BaseHelpers.jruby? && e.class.respond_to?('__persistent__')
+          e.class.__persistent__ = true
+        end
+        self.last_exception = e
+        result = e
       end
 
-      begin
-        break if Pry::Code.complete_expression?(eval_string)
-      rescue SyntaxError => e
-        exception_handler.call(output, e.extend(UserError), self)
-        eval_string = ""
+      Pry.critical_section do
+        show_result(result)
       end
     end
 
-    if eval_string =~ /;\Z/ || eval_string.empty? || eval_string =~ /\A *#.*\n\z/
-      @suppress_output = true
-    end
+    throw(:breakout) if current_binding.nil?
+  end
+  private :handle_line
 
-    exec_hook :after_read, eval_string, self
-    eval_string
+  # 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.)
+  def repl(target = nil)
+    Pry::REPL.new(self, :target => target).start
   end
 
-  def evaluate_ruby(code, target = binding_stack.last)
-    target = Pry.binding_for(target)
-    inject_sticky_locals(target)
+  def evaluate_ruby(code)
+    inject_sticky_locals!
     exec_hook :before_eval, code, self
 
-    result = target.eval(code, Pry.eval_path, Pry.current_line)
-    set_last_result(result, target, code)
+    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
@@ -337,7 +362,7 @@ class Pry
     if last_result_is_exception?
       exception_handler.call(output, result, self)
     elsif should_print?
-      print.call(output, result)
+      print.call(output, result, self)
     else
       # nothin'
     end
@@ -354,100 +379,32 @@ class Pry
         output.puts "(pry) output error: failed to show result"
       end
     end
+  ensure
+    output.flush if output.respond_to?(:flush)
   end
 
-  def should_force_encoding?(eval_string, val)
-    eval_string.empty? && val.respond_to?(:encoding) && val.encoding != eval_string.encoding
-  end
-  private :should_force_encoding?
-
-  # 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.
-  #
-  # @param [String] eval_string The cumulative lines of input.
-  # @param [Binding] target The target of the session.
-  # @return [String] The line received.
-  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)
-        unless [val, eval_string].all?(&:empty?)
-          eval_string << "#{indented_val.chomp}\n"
-        end
-      end
-    ensure
-      Pry.history << indented_val if interactive
+  # Force `eval_string` into the encoding of `val`. [Issue #284]
+  def ensure_correct_encoding!(val)
+    if @eval_string.empty? &&
+        val.respond_to?(:encoding) &&
+        val.encoding != @eval_string.encoding
+      @eval_string.force_encoding(val.encoding)
     end
   end
+  private :ensure_correct_encoding!
 
   # 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.
+  # current `eval_string` and binding.
   # @param [String] val The line to process.
-  # @param [String] eval_string The cumulative lines of input.
-  # @param [Binding] target The target of the Pry session.
   # @return [Boolean] `true` if `val` is a command, `false` otherwise
-  def process_command(val, eval_string = '', target = binding_stack.last)
+  def process_command(val)
     val = val.chomp
-    result = commands.process_line(val, {
-      :target => target,
+    result = commands.process_line(val,
+      :target => current_binding,
       :output => output,
-      :eval_string => eval_string,
+      :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
@@ -460,7 +417,7 @@ class Pry
         # 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"
+        @eval_string.replace "::Pry.current[:pry_cmd_result].retval\n"
       end
       true
     else
@@ -468,17 +425,27 @@ class Pry
     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
+  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
+
   # Run the specified command.
   # @param [String] val The command (and its params) to execute.
-  # @param [String] eval_string The current input buffer.
-  # @param [Binding] target The binding to use..
   # @return [Pry::Command::VOID_VALUE]
   # @example
   #   pry_instance.run_command("ls -m")
-  def run_command(val, eval_string = "", target = binding_stack.last)
+  def run_command(val)
     commands.process_line(val,
-      :eval_string => eval_string,
-      :target => target,
+      :eval_string => @eval_string,
+      :target => current_binding,
       :pry_instance => self,
       :output => output
     )
@@ -507,36 +474,25 @@ class Pry
   # Set the last result of an eval.
   # This method should not need to be invoked directly.
   # @param [Object] result The result.
-  # @param [Binding] target The binding to set `_` on.
   # @param [String] code The code that was run.
-  def set_last_result(result, target, code="")
+  def set_last_result(result, code="")
     @last_result_is_exception = false
     @output_array << result
 
     self.last_result = result unless code =~ /\A\s*\z/
   end
 
+  #
   # Set the last exception for a session.
-  # @param [Exception] ex
-  def last_exception=(ex)
-    class << ex
-      attr_accessor :file, :line, :bt_index
-      def bt_source_location_for(index)
-        backtrace[index] =~ /(.*):(\d+)/
-        [$1, $2.to_i]
-      end
-
-      def inc_bt_index
-        @bt_index = (@bt_index + 1) % backtrace.size
-      end
-    end
-
-    ex.bt_index = 0
-    ex.file, ex.line = ex.bt_source_location_for(0)
-
+  #
+  # @param [Exception] e
+  #   the last exception.
+  #
+  def last_exception=(e)
+    last_exception = Pry::LastException.new(e)
     @last_result_is_exception = true
-    @output_array << ex
-    @last_exception = ex
+    @output_array << last_exception
+    @last_exception = last_exception
   end
 
   # Update Pry's internal state after evalling code.
@@ -558,84 +514,6 @@ class Pry
     @last_result_is_exception
   end
 
-  # Manage switching of input objects on encountering EOFErrors
-  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
-  private :handle_read_errors
-
-  # Returns the next line of input to be used by the pry instance.
-  # This method should not need to be invoked directly.
-  # @param [String] current_prompt The prompt to use for input.
-  # @return [String] The next line of input.
-  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 defined?(Readline) && input == Readline
-        if !$stdout.tty? && $stdin.tty? && !Pry::Helpers::BaseHelpers.windows?
-          Readline.output = File.open('/dev/tty', 'w')
-        end
-        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
-
   # 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.
@@ -644,18 +522,15 @@ class Pry
   end
 
   # Returns the appropriate prompt to use.
-  # This method should not need to be invoked directly.
-  # @param [String] eval_string The current input buffer.
-  # @param [Binding] target The target Binding of the Pry session.
   # @return [String] The prompt.
-  def select_prompt(eval_string, target)
-    target_self = target.eval('self')
+  def select_prompt
+    object = current_binding.eval('self')
 
     open_token = @indent.open_delimiters.any? ? @indent.open_delimiters.last :
       @indent.stack.last
 
-    c = OpenStruct.new(
-                       :object         => target_self,
+    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,
@@ -664,8 +539,8 @@ class Pry
                        :_pry_          => self,
                        :binding_stack  => binding_stack,
                        :input_array    => input_array,
-                       :eval_string    => eval_string,
-                       :cont           => !eval_string.empty?)
+                       :eval_string    => @eval_string,
+                       :cont           => !@eval_string.empty?})
 
     Pry.critical_section do
       # If input buffer is empty then use normal prompt
@@ -721,6 +596,20 @@ class Pry
     prompt_stack.size > 1 ? prompt_stack.pop : prompt
   end
 
+  # Returns the currently configured pager
+  # @example
+  #   _pry_.pager.page text
+  def pager
+    Pry::Pager.new(self)
+  end
+
+  # Returns an output device
+  # @example
+  #   _pry_.output.puts "ohai!"
+  def output
+    Pry::Output.new(self)
+  end
+
   # Raise an exception out of Pry.
   #
   # See Kernel#raise for documentation of parameters.