pry 0.10.3 → 0.12.2

data/lib/pry/pry_instance.rb

@@ -16,11 +16,12 @@
 # This will show a list of available commands and their usage. For more
 # information about Pry you can refer to the following resources:
 #
-# * http://pry.github.com/
+# * http://pryrepl.org/
 # * https://github.com/pry/pry
 # * the IRC channel, which is #pry on the Freenode network
 #
 
+# rubocop:disable Metrics/ClassLength
 class Pry
   attr_accessor :binding_stack
   attr_accessor :custom_completions
@@ -34,8 +35,13 @@ class Pry
   attr_reader :last_exception
   attr_reader :command_state
   attr_reader :exit_value
-  attr_reader :input_array
-  attr_reader :output_array
+
+  # @since v0.12.0
+  attr_reader :input_ring
+
+  # @since v0.12.0
+  attr_reader :output_ring
+
   attr_reader :config
 
   extend Pry::Config::Convenience
@@ -62,7 +68,7 @@ class Pry
   #   The backtrace of the session's `binding.pry` line, if applicable.
   # @option options [Object] :target
   #   The initial context for this session.
-  def initialize(options={})
+  def initialize(options = {})
     @binding_stack = []
     @indent        = Pry::Indent.new
     @command_state = {}
@@ -72,23 +78,47 @@ class Pry
     @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
+    @input_ring = Pry::Ring.new(config.memory_size)
+    @output_ring = Pry::Ring.new(config.memory_size)
     @custom_completions = config.command_completions
     set_last_result nil
-    @input_array << nil
+    @input_ring << nil
     push_initial_binding(target)
     exec_hook(:when_started, target, options, self)
   end
 
-  # The current prompt.
+  @input_array_warn = false
+  # @deprecated Use {#input_ring} instead.
+  def input_array
+    unless @input_array_warn
+      loc = caller_locations(1..1).first
+      warn(
+        "#{loc.path}:#{loc.lineno}: warning: method #{self.class}##{__method__} " \
+        "is deprecated. Use #{self.class}#input_ring instead"
+      )
+      @input_array_warn = true
+    end
+
+    @input_ring
+  end
+
+  @output_array_warn = false
+  # @deprecated Use {#output_ring} instead.
+  def output_array
+    unless @output_array_warn
+      loc = caller_locations(1..1).first
+      warn(
+        "#{loc.path}:#{loc.lineno}: warning: method #{self.class}##{__method__} " \
+        "is deprecated. Use #{self.class}#output_ring instead"
+      )
+      @output_array_warn = true
+    end
+
+    @output_ring
+  end
+
   # 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.
+  # @return [Array<Proc>] the current prompt
   def prompt
     prompt_stack.last
   end
@@ -103,7 +133,7 @@ class Pry
 
   # 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)
+  def push_initial_binding(target = nil)
     push_binding(target || Pry.toplevel_binding)
   end
 
@@ -124,7 +154,7 @@ class Pry
   #
   # Generate completions.
   #
-  # @param [String] input
+  # @param [String] str
   #   What the user has typed so far
   #
   # @return [Array<String>]
@@ -132,6 +162,7 @@ class Pry
   #
   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)
@@ -171,13 +202,13 @@ class Pry
   # @return [Integer] The maximum amount of objects remembered by the inp and
   #   out arrays. Defaults to 100.
   def memory_size
-    @output_array.max_size
+    @output_ring.max_size
   end
 
   undef :memory_size= if method_defined? :memory_size=
   def memory_size=(size)
-    @input_array  = Pry::HistoryArray.new(size)
-    @output_array = Pry::HistoryArray.new(size)
+    @input_ring = Pry::Ring.new(size)
+    @output_ring = Pry::Ring.new(size)
   end
 
   # Inject all the sticky locals into the current binding.
@@ -197,14 +228,14 @@ class Pry
   end
 
   def sticky_locals
-    { _in_: input_array,
-      _out_: output_array,
+    { _in_: input_ring,
+      _out_: output_ring,
       _pry_: self,
       _ex_: last_exception && last_exception.wrapped_exception,
       _file_: last_file,
       _dir_: last_dir,
       _: proc { last_result },
-      __: proc { output_array[-2] }
+      __: proc { output_ring[-2] }
     }.merge(config.extra_sticky_locals)
   end
 
@@ -234,7 +265,7 @@ class Pry
   # @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={})
+  def eval(line, options = {})
     return false if @stopped
 
     exit_value = nil
@@ -254,6 +285,7 @@ class Pry
 
     # TODO: make this configurable?
     raise exception if exception
+
     return false
   end
 
@@ -269,7 +301,7 @@ class Pry
     @suppress_output = false
     inject_sticky_locals!
     begin
-      if !process_command_safely(line.lstrip)
+      if !process_command_safely(line)
         @eval_string << "#{line.chomp}\n" if !line.empty? || !@eval_string.empty?
       end
     rescue RescuableException => e
@@ -310,7 +342,7 @@ class Pry
       # This workaround has a side effect: java exceptions specified
       # in `Pry.config.exception_whitelist` are ignored.
       jruby_exceptions = []
-      if Pry::Helpers::BaseHelpers.jruby?
+      if Helpers::Platform.jruby?
         jruby_exceptions << Java::JavaLang::Exception
       end
 
@@ -325,7 +357,7 @@ class Pry
         # 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__')
+        if Helpers::Platform.jruby? && e.class.respond_to?('__persistent__')
           e.class.__persistent__ = true
         end
         self.last_exception = e
@@ -345,7 +377,7 @@ class Pry
   # (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
+    Pry::REPL.new(self, target: target).start
   end
 
   def evaluate_ruby(code)
@@ -373,7 +405,7 @@ class Pry
     # 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}"
+      output.puts "(pry) output error: #{e.inspect}\n#{e.backtrace.join("\n")}"
     rescue RescuableException => e
       if last_result_is_exception?
         output.puts "(pry) output error: failed to show exception"
@@ -400,12 +432,14 @@ class Pry
   # @param [String] val The line to process.
   # @return [Boolean] `true` if `val` is a command, `false` otherwise
   def process_command(val)
+    val = val.lstrip if /^\s\S/ !~ val
     val = val.chomp
     result = commands.process_line(val,
-      :target => current_binding,
-      :output => output,
-      :eval_string => @eval_string,
-      :pry_instance => self
+      target: current_binding,
+      output: output,
+      eval_string: @eval_string,
+      pry_instance: self,
+      hooks: hooks
     )
 
     # set a temporary (just so we can inject the value we want into eval_string)
@@ -433,7 +467,7 @@ class Pry
   # @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
+  rescue CommandError, Pry::Slop::InvalidOptionError, MethodSource::SourceNotFoundError => e
     Pry.last_internal_error = e
     output.puts "Error: #{e.message}"
     true
@@ -446,10 +480,10 @@ class Pry
   #   pry_instance.run_command("ls -m")
   def run_command(val)
     commands.process_line(val,
-      :eval_string => @eval_string,
-      :target => current_binding,
-      :pry_instance => self,
-      :output => output
+      eval_string: @eval_string,
+      target: current_binding,
+      pry_instance: self,
+      output: output
     )
     Pry::Command::VOID_VALUE
   end
@@ -477,9 +511,9 @@ class Pry
   # This method should not need to be invoked directly.
   # @param [Object] result The result.
   # @param [String] code The code that was run.
-  def set_last_result(result, code="")
+  def set_last_result(result, code = "")
     @last_result_is_exception = false
-    @output_array << result
+    @output_ring << result
 
     self.last_result = result unless code =~ /\A\s*\z/
   end
@@ -493,7 +527,7 @@ class Pry
   def last_exception=(e)
     last_exception = Pry::LastException.new(e)
     @last_result_is_exception = true
-    @output_array << last_exception
+    @output_ring << last_exception
     @last_exception = last_exception
   end
 
@@ -501,8 +535,8 @@ class Pry
   # This method should not need to be invoked directly.
   # @param [String] code The code we just eval'd
   def update_input_history(code)
-    # Always push to the @input_array as the @output_array is always pushed to.
-    @input_array << code
+    # Always push to the @input_ring as the @output_ring is always pushed to.
+    @input_ring << code
     if code
       Pry.line_buffer.push(*code.each_line)
       Pry.current_line += code.lines.count
@@ -527,28 +561,26 @@ class Pry
   # @return [String] The prompt.
   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?})
+    open_token = @indent.open_delimiters.last || @indent.stack.last
+
+    c = Pry::Config.assign({
+        object: object,
+        nesting_level: binding_stack.size - 1,
+        open_token: open_token,
+        session_line: Pry.history.session_line_count + 1,
+        history_line: Pry.history.history_line_count + 1,
+        expr_number: input_ring.count,
+        _pry_: self,
+        binding_stack: binding_stack,
+        input_ring: input_ring,
+        eval_string: @eval_string,
+        cont: !@eval_string.empty?
+      })
 
     Pry.critical_section do
       # If input buffer is empty then use normal prompt
       if eval_string.empty?
         generate_prompt(Array(prompt).first, c)
-
       # Otherwise use the wait prompt (indicating multi-line expression)
       else
         generate_prompt(Array(prompt).last, c)
@@ -653,7 +685,9 @@ class Pry
       raise exception
     end
   end
+
   def raise_up(*args); raise_up_common(false, *args); end
+
   def raise_up!(*args); raise_up_common(true, *args); end
 
   # Convenience accessor for the `quiet` config key.
@@ -662,3 +696,4 @@ class Pry
     config.quiet
   end
 end
+# rubocop:enable Metrics/ClassLength

data/lib/pry/repl.rb

@@ -1,8 +1,6 @@
-require 'forwardable'
-
 class Pry
   class REPL
-    extend Forwardable
+    extend Pry::Forwardable
     def_delegators :@pry, :input, :output
 
     # @return [Pry] The instance of {Pry} that the user is controlling.
@@ -23,6 +21,8 @@ class Pry
       @pry    = pry
       @indent = Pry::Indent.new
 
+      @readline_output = nil
+
       if options[:target]
         @pry.push_binding options[:target]
       end
@@ -49,7 +49,7 @@ class 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"
+        Kernel.print(Helpers::Platform.windows_ansi? ? "\e[0F" : "\e[0G")
       end
     end
 
@@ -106,8 +106,9 @@ class Pry
 
         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
+            current_prompt,
+            indented_val,
+            calculate_overhang(current_prompt, original_val, indented_val)
           )
           output.flush
         end
@@ -168,20 +169,21 @@ class Pry
     # @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
+        if coolline_available?
           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
+          input.completion_proc = proc do |inp|
+            @pry.complete inp
           end
         end
 
-        if defined?(Readline) and input == Readline
+        if readline_available?
+          set_readline_output
           input_readline(current_prompt, false) # false since we'll add it manually
-        elsif defined? Coolline and input.is_a? Coolline
+        elsif coolline_available?
           input_readline(current_prompt)
         else
           if input.method(:readline).arity == 1
@@ -198,5 +200,62 @@ class Pry
         input.readline(*args)
       end
     end
+
+    def readline_available?
+      defined?(Readline) && input == Readline
+    end
+
+    def coolline_available?
+      defined?(Coolline) && input.is_a?(Coolline)
+    end
+
+    # If `$stdout` is not a tty, it's probably a pipe.
+    # @example
+    #   # `piping?` returns `false`
+    #   % pry
+    #   [1] pry(main)
+    #
+    #   # `piping?` returns `true`
+    #   % pry | tee log
+    def piping?
+      return false unless $stdout.respond_to?(:tty?)
+
+      !$stdout.tty? && $stdin.tty? && !Helpers::Platform.windows?
+    end
+
+    # @return [void]
+    def set_readline_output
+      return if @readline_output
+
+      if piping?
+        @readline_output = (Readline.output = Pry.config.output)
+      end
+    end
+
+    # Calculates correct overhang for current line. Supports vi Readline
+    # mode and its indicators such as "(ins)" or "(cmd)".
+    #
+    # @return [Integer]
+    # @note This doesn't calculate overhang for Readline's emacs mode with an
+    #   indicator because emacs is the default mode and it doesn't use
+    #   indicators in 99% of cases.
+    def calculate_overhang(current_prompt, original_val, indented_val)
+      overhang = original_val.length - indented_val.length
+
+      if readline_available? && Readline.respond_to?(:vi_editing_mode?)
+        begin
+          # rb-readline doesn't support this method:
+          # https://github.com/ConnorAtherton/rb-readline/issues/152
+          if Readline.vi_editing_mode?
+            overhang += current_prompt.length - indented_val.length
+          end
+        rescue NotImplementedError
+          # VI editing mode is unsupported on JRuby.
+          # https://github.com/pry/pry/issues/1840
+          nil
+        end
+      end
+      [0, overhang].max
+    end
   end
 end

data/lib/pry/repl_file_loader.rb

@@ -1,5 +1,4 @@
 class Pry
-
   # A class to manage the loading of files through the REPL loop.
   # This is an interesting trick as it processes your file as if it
   # was user input in an interactive session. As a result, all Pry
@@ -13,7 +12,7 @@ class Pry
   class REPLFileLoader
     def initialize(file_name)
       full_name = File.expand_path(file_name)
-      raise RuntimeError, "No such file: #{full_name}" if !File.exists?(full_name)
+      raise RuntimeError, "No such file: #{full_name}" if !File.exist?(full_name)
 
       define_additional_commands
       @content = File.read(full_name)
@@ -42,7 +41,7 @@ class Pry
       end
 
       content.lines.each do |line|
-        break unless _pry_.eval line, :generated => true
+        break unless _pry_.eval line, generated: true
       end
 
       unless _pry_.eval_string.empty?

data/lib/pry/ring.rb

@@ -0,0 +1,84 @@
+class Pry
+  # A ring is a thread-safe fixed-capacity array to which you can only add
+  # elements. Older entries are overwritten as you add new elements, so that the
+  # ring can never contain more than `max_size` elemens.
+  #
+  # @example
+  #   ring = Pry::Ring.new(3)
+  #   ring << 1 << 2 << 3
+  #   ring.to_a #=> [1, 2, 3]
+  #   ring << 4
+  #   ring.to_a #=> [2, 3, 4]
+  #
+  #   ring[0] #=> 2
+  #   ring[-1] #=> 4
+  #   ring.clear
+  #   ring[0] #=> nil
+  #
+  # @api public
+  # @since v0.12.0
+  class Ring
+    # @return [Integer] maximum buffer size
+    attr_reader :max_size
+
+    # @return [Integer] how many objects were added during the lifetime of the
+    #   ring
+    attr_reader :count
+    alias size count
+
+    # @param [Integer] max_size Maximum buffer size. The buffer will start
+    #   overwriting elements once its reaches its maximum capacity
+    def initialize(max_size)
+      @max_size = max_size
+      @mutex = Mutex.new
+      clear
+    end
+
+    # Push `value` to the current index.
+    #
+    # @param [Object] value
+    # @return [self]
+    def <<(value)
+      @mutex.synchronize do
+        @buffer[count % max_size] = value
+        @count += 1
+        self
+      end
+    end
+
+    # Read the value stored at `index`.
+    #
+    # @param [Integer, Range] index The element (if Integer) or elements
+    #   (if Range) associated with `index`
+    # @return [Object, Array<Object>, nil] element(s) at `index`, `nil` if none
+    #   exist
+    def [](index)
+      @mutex.synchronize do
+        return @buffer[(count + index) % max_size] if index.is_a?(Integer)
+        return @buffer[index] if count <= max_size
+
+        # Swap parts of array when the array turns page and starts overwriting
+        # from the beginning, then apply the range.
+        last_part = @buffer.slice([index.end, max_size - 1].min, count % max_size)
+        (last_part + (@buffer - last_part))[index]
+      end
+    end
+
+    # @return [Array<Object>] the buffer as unwinded array
+    def to_a
+      return @buffer.dup if count <= max_size
+
+      last_part = @buffer.slice(count % max_size, @buffer.size)
+      last_part + (@buffer - last_part)
+    end
+
+    # Clear the buffer and reset count.
+    # @return [void]
+    def clear
+      @mutex.synchronize do
+        @buffer = []
+        @count = 0
+      end
+    end
+  end
+end

data/lib/pry/rubygem.rb

@@ -23,7 +23,7 @@ class Pry
                   Gem.source_index.find_name(name)
                 end
 
-        first_spec = specs.sort_by{ |spec| Gem::Version.new(spec.version) }.last
+        first_spec = specs.sort_by { |spec| Gem::Version.new(spec.version) }.last
 
         first_spec or raise CommandError, "Gem `#{name}` not found"
       end
@@ -34,9 +34,9 @@ class Pry
       # @return [Array<Gem::Specification>]
       def list(pattern = /.*/)
         if Gem::Specification.respond_to?(:each)
-          Gem::Specification.select{|spec| spec.name =~ pattern }
+          Gem::Specification.select { |spec| spec.name =~ pattern }
         else
-          Gem.source_index.gems.values.select{|spec| spec.name =~ pattern }
+          Gem.source_index.gems.values.select { |spec| spec.name =~ pattern }
         end
       end
 
@@ -57,7 +57,9 @@ class Pry
       # @param [String] name
       # @return [void]
       def install(name)
-        gemrc_opts = Gem.configuration['gem'].split(' ')
+        require 'rubygems/dependency_installer'
+        gem_config = Gem.configuration['gem']
+        gemrc_opts = (gem_config.nil? ? "" : gem_config.split(' '))
         destination = if gemrc_opts.include?('--user-install')
                         Gem.user_dir
                       elsif File.writable?(Gem.dir)
@@ -65,14 +67,14 @@ class Pry
                       else
                         Gem.user_dir
                       end
-        installer = Gem::DependencyInstaller.new(:install_dir => destination)
+        installer = Gem::DependencyInstaller.new(install_dir: destination)
         installer.install(name)
       rescue Errno::EACCES
         raise CommandError,
-          "Insufficient permissions to install #{ Pry::Helpers::Text.green(name) }."
+          "Insufficient permissions to install #{green(name)}."
       rescue Gem::GemNotFoundException
         raise CommandError,
-          "Gem #{ Pry::Helpers::Text.green(name) } not found. Aborting installation."
+          "Gem #{green(name)} not found. Aborting installation."
       else
         Gem.refresh
       end

data/lib/pry/slop/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Lee Jarvis
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.