pry 0.9.12.6-java → 0.10.0-java

data/lib/pry/rbx_path.rb

@@ -2,7 +2,7 @@ class Pry
   module RbxPath
     module_function
     def is_core_path?(path)
-      path.start_with?("kernel") || path.start_with?("lib")
+      Pry::Helpers::BaseHelpers.rbx? && (path.start_with?("kernel") || path.start_with?("lib")) && File.exist?(convert_path_to_full(path))
     end
 
     def convert_path_to_full(path)

data/lib/pry/repl.rb

@@ -0,0 +1,202 @@
+require 'forwardable'
+
+class Pry
+  class REPL
+    extend Forwardable
+    def_delegators :@pry, :input, :output
+
+    # @return [Pry] The instance of {Pry} that the user is controlling.
+    attr_accessor :pry
+
+    # Instantiate a new {Pry} instance with the given options, then start a
+    # {REPL} instance wrapping it.
+    # @option options See {Pry#initialize}
+    def self.start(options)
+      new(Pry.new(options)).start
+    end
+
+    # Create an instance of {REPL} wrapping the given {Pry}.
+    # @param [Pry] pry The instance of {Pry} that this {REPL} will control.
+    # @param [Hash] options Options for this {REPL} instance.
+    # @option options [Object] :target The initial target of the session.
+    def initialize(pry, options = {})
+      @pry    = pry
+      @indent = Pry::Indent.new
+
+      if options[:target]
+        @pry.push_binding options[:target]
+      end
+    end
+
+    # Start the read-eval-print loop.
+    # @return [Object?] If the session throws `:breakout`, return the value
+    #   thrown with it.
+    # @raise [Exception] If the session throws `:raise_up`, raise the exception
+    #   thrown with it.
+    def start
+      prologue
+      Pry::InputLock.for(:all).with_ownership { repl }
+    ensure
+      epilogue
+    end
+
+    private
+
+    # Set up the repl session.
+    # @return [void]
+    def prologue
+      pry.exec_hook :before_session, pry.output, pry.current_binding, pry
+
+      # Clear the line before starting Pry. This fixes issue #566.
+      if pry.config.correct_indent
+        Kernel.print Pry::Helpers::BaseHelpers.windows_ansi? ? "\e[0F" : "\e[0G"
+      end
+    end
+
+    # The actual read-eval-print loop.
+    #
+    # The {REPL} instance is responsible for reading and looping, whereas the
+    # {Pry} instance is responsible for evaluating user input and printing
+    # return values and command output.
+    #
+    # @return [Object?] If the session throws `:breakout`, return the value
+    #   thrown with it.
+    # @raise [Exception] If the session throws `:raise_up`, raise the exception
+    #   thrown with it.
+    def repl
+      loop do
+        case val = read
+        when :control_c
+          output.puts ""
+          pry.reset_eval_string
+        when :no_more_input
+          output.puts "" if output.tty?
+          break
+        else
+          output.puts "" if val.nil? && output.tty?
+          return pry.exit_value unless pry.eval(val)
+        end
+      end
+    end
+
+    # Clean up after the repl session.
+    # @return [void]
+    def epilogue
+      pry.exec_hook :after_session, pry.output, pry.current_binding, pry
+    end
+
+    # Read a line of input from the user.
+    # @return [String] The line entered by the user.
+    # @return [nil] On `<Ctrl-D>`.
+    # @return [:control_c] On `<Ctrl+C>`.
+    # @return [:no_more_input] On EOF.
+    def read
+      @indent.reset if pry.eval_string.empty?
+      current_prompt = pry.select_prompt
+      indentation = pry.config.auto_indent ? @indent.current_prefix : ''
+
+      val = read_line("#{current_prompt}#{indentation}")
+
+      # Return nil for EOF, :no_more_input for error, or :control_c for <Ctrl-C>
+      return val unless String === val
+
+      if pry.config.auto_indent
+        original_val = "#{indentation}#{val}"
+        indented_val = @indent.indent(val)
+
+        if output.tty? && pry.config.correct_indent && Pry::Helpers::BaseHelpers.use_ansi_codes?
+          output.print @indent.correct_indentation(
+            current_prompt, indented_val,
+            original_val.length - indented_val.length
+          )
+          output.flush
+        end
+      else
+        indented_val = val
+      end
+
+      indented_val
+    end
+
+    # Manage switching of input objects on encountering `EOFError`s.
+    # @return [Object] Whatever the given block returns.
+    # @return [:no_more_input] Indicates that no more input can be read.
+    def handle_read_errors
+      should_retry = true
+      exception_count = 0
+
+      begin
+        yield
+      rescue EOFError
+        pry.config.input = Pry.config.input
+        if !should_retry
+          output.puts "Error: Pry ran out of things to read from! " \
+            "Attempting to break out of REPL."
+          return :no_more_input
+        end
+        should_retry = false
+        retry
+
+      # Handle <Ctrl+C> like Bash: empty the current input buffer, but don't
+      # quit.  This is only for MRI 1.9; other versions of Ruby don't let you
+      # send Interrupt from within Readline.
+      rescue Interrupt
+        return :control_c
+
+      # 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"
+        return :no_more_input
+      end
+    end
+
+    # Returns the next line of input to be sent to the {Pry} instance.
+    # @param [String] current_prompt The prompt to use for input.
+    # @return [String?] The next line of input, or `nil` on <Ctrl-D>.
+    def read_line(current_prompt)
+      handle_read_errors do
+        if defined? Coolline and input.is_a? Coolline
+          input.completion_proc = proc do |cool|
+            completions = @pry.complete cool.completed_word
+            completions.compact
+          end
+        elsif input.respond_to? :completion_proc=
+          input.completion_proc = proc do |input|
+            @pry.complete input
+          end
+        end
+
+        if defined?(Readline) and 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
+
+    def input_readline(*args)
+      Pry::InputLock.for(:all).interruptible_region do
+        input.readline(*args)
+      end
+    end
+  end
+end

data/lib/pry/repl_file_loader.rb

@@ -15,29 +15,40 @@ class Pry
       full_name = File.expand_path(file_name)
       raise RuntimeError, "No such file: #{full_name}" if !File.exists?(full_name)
 
-      @content = StringIO.new(File.read(full_name))
+      define_additional_commands
+      @content = File.read(full_name)
     end
 
     # Switch to interactive mode, i.e take input from the user
     # and use the regular print and exception handlers.
     # @param [Pry] _pry_ the Pry instance to make interactive.
     def interactive_mode(_pry_)
-      _pry_.input = Pry.config.input
-      _pry_.print = Pry.config.print
-      _pry_.exception_handler = Pry.config.exception_handler
+      _pry_.config.input = Pry.config.input
+      _pry_.config.print = Pry.config.print
+      _pry_.config.exception_handler = Pry.config.exception_handler
+      Pry::REPL.new(_pry_).start
     end
 
     # Switch to non-interactive mode. Essentially
     # this means there is no result output
     # and that the session becomes interactive when an exception is encountered.
     # @param [Pry] _pry_ the Pry instance to make non-interactive.
-    def non_interactive_mode(_pry_)
+    def non_interactive_mode(_pry_, content)
       _pry_.print = proc {}
-      _pry_.exception_handler = proc do |o, e, _pry_|
-        _pry_.run_command "cat --ex"
+      _pry_.exception_handler = proc do |o, e, _p_|
+        _p_.run_command "cat --ex"
         o.puts "...exception encountered, going interactive!"
         interactive_mode(_pry_)
       end
+
+      content.lines.each do |line|
+        break unless _pry_.eval line, :generated => true
+      end
+
+      unless _pry_.eval_string.empty?
+        _pry_.output.puts "#{_pry_.eval_string}...exception encountered, going interactive!"
+        interactive_mode(_pry_)
+      end
     end
 
     # Define a few extra commands useful for flipping back & forth
@@ -46,35 +57,18 @@ class Pry
       s = self
 
       Pry::Commands.command "make-interactive", "Make the session interactive" do
-        _pry_.input_stack.push _pry_.input
         s.interactive_mode(_pry_)
       end
 
-      Pry::Commands.command "make-non-interactive", "Make the session non-interactive" do
-        _pry_.input = _pry_.input_stack.pop
-        s.non_interactive_mode(_pry_)
-      end
-
       Pry::Commands.command "load-file", "Load another file through the repl" do |file_name|
-        content = StringIO.new(File.read(File.expand_path(file_name)))
-        _pry_.input_stack.push(_pry_.input)
-        _pry_.input = content
+        s.non_interactive_mode(_pry_, File.read(File.expand_path(file_name)))
       end
     end
 
     # Actually load the file through the REPL by setting file content
     # as the REPL input stream.
     def load
-      Pry.initial_session_setup
-      define_additional_commands
-
-      Pry.config.hooks.add_hook(:when_started, :start_non_interactively) do |o, t, _pry_|
-        non_interactive_mode(_pry_)
-      end
-
-      Pry.start(Pry.toplevel_binding,
-                :input => @content,
-                :input_stack => [StringIO.new("exit-all\n")])
+      non_interactive_mode(Pry.new, @content)
     end
   end
 end

data/lib/pry/rubygem.rb

@@ -23,9 +23,9 @@ class Pry
                   Gem.source_index.find_name(name)
                 end
 
-        spec = specs.sort_by{ |spec| Gem::Version.new(spec.version) }.first
+        first_spec = specs.sort_by{ |spec| Gem::Version.new(spec.version) }.last
 
-        spec or raise CommandError, "Gem `#{name}` not found"
+        first_spec or raise CommandError, "Gem `#{name}` not found"
       end
 
       # List gems matching a pattern.
@@ -57,14 +57,22 @@ class Pry
       # @param [String] name
       # @return [void]
       def install(name)
-        destination = File.writable?(Gem.dir) ? Gem.dir : Gem.user_dir
+        gemrc_opts = Gem.configuration['gem'].split(' ')
+        destination = if gemrc_opts.include?('--user-install')
+                        Gem.user_dir
+                      elsif File.writable?(Gem.dir)
+                        Gem.dir
+                      else
+                        Gem.user_dir
+                      end
         installer = Gem::DependencyInstaller.new(:install_dir => destination)
         installer.install(name)
       rescue Errno::EACCES
         raise CommandError,
-          "Insufficient permissions to install `#{ text.green(name) }`."
+          "Insufficient permissions to install #{ Pry::Helpers::Text.green(name) }."
       rescue Gem::GemNotFoundException
-        raise CommandError, "Gem `#{ text.green(name) }` not found."
+        raise CommandError,
+          "Gem #{ Pry::Helpers::Text.green(name) } not found. Aborting installation."
       else
         Gem.refresh
       end

data/lib/pry/terminal.rb

@@ -44,7 +44,8 @@ class Pry::Terminal
       require 'io/console'
       $stdout.winsize if $stdout.tty? and $stdout.respond_to?(:winsize)
     rescue LoadError
-      # They're probably on 1.8 without the io-console gem. We'll keep trying.
+      # They probably don't have the io/console stdlib or the io-console gem.
+      # We'll keep trying.
     end
 
     def screen_size_according_to_env

data/lib/pry/test/helper.rb

@@ -7,14 +7,14 @@ class << Pry
   def reset_defaults
     orig_reset_defaults
 
-    Pry.color = false
-    Pry.pager = false
+    Pry.config.color = false
+    Pry.config.pager = false
     Pry.config.should_load_rc      = false
     Pry.config.should_load_local_rc= false
     Pry.config.should_load_plugins = false
     Pry.config.history.should_load = false
     Pry.config.history.should_save = false
-    Pry.config.auto_indent         = false
+    Pry.config.correct_indent      = false
     Pry.config.hooks               = Pry::Hooks.new
     Pry.config.collision_warning   = false
   end
@@ -47,10 +47,6 @@ module PryTestHelpers
     end
   end
 
-  def mri18_and_no_real_source_location?
-    Pry::Helpers::BaseHelpers.mri_18? && !(Method.instance_method(:source_location).owner == Method)
-  end
-
   # Open a temp file and yield it to the block, closing it after
   # @return [String] The path of the temp file
   def temp_file(ext='.rb')
@@ -67,16 +63,15 @@ module PryTestHelpers
 
   def mock_command(cmd, args=[], opts={})
     output = StringIO.new
-    ret = cmd.new(opts.merge(:output => output)).call_safely(*args)
+    pry = Pry.new(output: output)
+    ret = cmd.new(opts.merge(pry_instance: pry, :output => output)).call_safely(*args)
     Struct.new(:output, :return).new(output.string, ret)
   end
 
   def mock_exception(*mock_backtrace)
-    e = StandardError.new("mock exception")
-    (class << e; self; end).class_eval do
-      define_method(:backtrace) { mock_backtrace }
+    StandardError.new.tap do |e|
+      e.define_singleton_method(:backtrace) { mock_backtrace }
     end
-    e
   end
 end
 
@@ -101,18 +96,17 @@ def pry_eval(*eval_strs)
 end
 
 class PryTester
+  extend Forwardable
+
   attr_reader :pry, :out
 
-  def initialize(context = TOPLEVEL_BINDING, options = {})
-    @pry = Pry.new(options)
+  def_delegators :@pry, :eval_string, :eval_string=
 
-    if context
-      target = Pry.binding_for(context)
-      @pry.binding_stack << target
-      @pry.inject_sticky_locals(target)
-    end
+  def initialize(target = TOPLEVEL_BINDING, options = {})
+    @pry = Pry.new(options.merge(:target => target))
+    @history = options[:history]
 
-    @pry.input_array << nil # TODO: shouldn't need this
+    @pry.inject_sticky_locals!
     reset_output
   end
 
@@ -122,6 +116,8 @@ class PryTester
 
     strs.flatten.each do |str|
       str = "#{str.strip}\n"
+      @history.push str if @history
+
       if @pry.process_command(str)
         result = last_command_result_or_output
       else
@@ -132,43 +128,32 @@ class PryTester
     result
   end
 
-  def context=(context)
-    @pry.binding_stack << Pry.binding_for(context)
-  end
-
-  # TODO: eliminate duplication with Pry#repl
-  def simulate_repl
-    didnt_exit = nil
-    break_data = nil
-
-    didnt_exit = catch(:didnt_exit) do
-      break_data = catch(:breakout) do
-        yield self
-        throw(:didnt_exit, true)
-      end
-      nil
+  def push(*lines)
+    Array(lines).flatten.each do |line|
+      @pry.eval(line)
     end
+  end
 
-    raise "Failed to exit REPL" if didnt_exit
-    break_data
+  def push_binding(context)
+    @pry.push_binding context
   end
 
   def last_output
     @out.string if @out
   end
 
-  def process_command(command_str, eval_str = '')
-    @pry.process_command(command_str, eval_str) or raise "Not a valid command"
+  def process_command(command_str)
+    @pry.process_command(command_str) or raise "Not a valid command"
     last_command_result_or_output
   end
 
-  protected
-
   def last_command_result
     result = Pry.current[:pry_cmd_result]
     result.retval if result
   end
 
+  protected
+
   def last_command_result_or_output
     result = last_command_result
     if result != Pry::Command::VOID_VALUE