pry 0.12.2 → 0.13.0

data/lib/pry/method/disowned.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Pry
   class Method
     # A Disowned Method is one that's been removed from the class on which it was defined.
@@ -21,7 +23,8 @@ class Pry
       # @param [Object] receiver
       # @param [String] method_name
       def initialize(receiver, method_name)
-        @receiver, @name = receiver, method_name
+        @receiver = receiver
+        @name = method_name
         @method = nil
       end
 
@@ -45,10 +48,19 @@ class Pry
       end
 
       # Raise a more useful error message instead of trying to forward to nil.
-      def method_missing(meth_name, *args, &block)
-        raise "Cannot call '#{meth_name}' on an undef'd method." if method(:name).respond_to?(meth_name)
+      # rubocop:disable Style/MethodMissingSuper
+      def method_missing(method_name, *args, &block)
+        if method(:name).respond_to?(method_name)
+          raise "Cannot call '#{method_name}' on an undef'd method."
+        end
+
+        method = Object.instance_method(:method_missing).bind(self)
+        method.call(method_name, *args, &block)
+      end
+      # rubocop:enable Style/MethodMissingSuper
 
-        Object.instance_method(:method_missing).bind(self).call(meth_name, *args, &block)
+      def respond_to_missing?(method_name, include_private = false)
+        !method(:name).respond_to?(method_name) || super
       end
     end
   end

data/lib/pry/method/patcher.rb

@@ -1,9 +1,13 @@
+# frozen_string_literal: true
+
 class Pry
   class Method
     class Patcher
       attr_accessor :method
 
+      # rubocop:disable Style/ClassVars
       @@source_cache = {}
+      # rubocop:enable Style/ClassVars
 
       def initialize(method)
         @method = method
@@ -51,9 +55,12 @@ class Pry
           alias_method method.name, method.original_name
           alias_method method.original_name, temp_name
         end
-
       ensure
-        method.send(:remove_method, temp_name) rescue nil
+        begin
+          method.send(:remove_method, temp_name)
+        rescue StandardError
+          nil
+        end
       end
 
       # Update the definition line so that it can be eval'd directly on the Method's
@@ -72,7 +79,9 @@ class Pry
         if line =~ /\Adef (?:.*?\.)?#{Regexp.escape(method.original_name)}(?=[\(\s;]|$)/
           "def #{method.original_name}#{$'}"
         else
-          raise CommandError, "Could not find original `def #{method.original_name}` line to patch."
+          raise CommandError,
+                "Could not find original `def #{method.original_name}` line " \
+                "to patch."
         end
       end
 

data/lib/pry/method/weird_method_locator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Pry
   class Method
     # This class is responsible for locating the *real* `Pry::Method`
@@ -6,10 +8,11 @@ class Pry
     # Given a `Binding` from inside a method and a 'seed' Pry::Method object,
     # there are primarily two situations where the seed method doesn't match
     # the Binding:
-    # 1. The Pry::Method is from a subclass 2. The Pry::Method represents a method of the same name
-    # while the original was renamed to something else. For 1. we
-    # search vertically up the inheritance chain,
-    # and for 2. we search laterally along the object's method table.
+    # 1. The Pry::Method is from a subclass
+    # 2. The Pry::Method represents a method of the same name while the original
+    # was renamed to something else. For 1. we search vertically up the
+    # inheritance chain, and for 2. we search laterally along the object's
+    # method table.
     #
     # When we locate the method that matches the Binding we wrap it in
     # Pry::Method and return it, or return nil if we fail.
@@ -21,20 +24,25 @@ class Pry
         # must commence a search.
         #
         # @param [Pry::Method] method
-        # @param [Binding] b
+        # @param [Binding] binding
         # @return [Boolean]
-        def normal_method?(method, b)
-          if method and method.source_file and method.source_range
-            binding_file, binding_line = b.eval('__FILE__'), b.eval('__LINE__')
-            File.expand_path(method.source_file) == File.expand_path(binding_file) and
-            method.source_range.include?(binding_line)
+        def normal_method?(method, binding)
+          if method && method.source_file && method.source_range
+            if binding.respond_to?(:source_location)
+              binding_file, binding_line = binding.source_location
+            else
+              binding_file = binding.eval('__FILE__')
+              binding_line = binding.eval('__LINE__')
+            end
+            (File.expand_path(method.source_file) == File.expand_path(binding_file)) &&
+              method.source_range.include?(binding_line)
           end
-        rescue
+        rescue StandardError
           false
         end
 
-        def weird_method?(method, b)
-          not normal_method?(method, b)
+        def weird_method?(method, binding)
+          !normal_method?(method, binding)
         end
       end
 
@@ -45,12 +53,13 @@ class Pry
       # @param [Binding] target The Binding that captures the method
       #   we want to locate.
       def initialize(method, target)
-        @method, @target = method, target
+        @method = method
+        @target = target
       end
 
       # @return [Pry::Method, nil] The Pry::Method that matches the
       #   given binding.
-      def get_method
+      def find_method
         find_method_in_superclass || find_renamed_method
       end
 
@@ -58,7 +67,7 @@ class Pry
       #   This usually happens when the method captured by the Binding
       #   has been subsequently deleted.
       def lost_method?
-        !!(get_method.nil? && renamed_method_source_location)
+        !!(find_method.nil? && renamed_method_source_location)
       end
 
       private
@@ -77,47 +86,59 @@ class Pry
       end
 
       def target_file
-        pry_file? ? target.eval('__FILE__') : File.expand_path(target.eval('__FILE__'))
+        file =
+          if target.respond_to?(:source_location)
+            target.source_location.first
+          else
+            target.eval('__FILE__')
+          end
+        pry_file? ? file : File.expand_path(file)
       end
 
       def target_line
-        target.eval('__LINE__')
+        if target.respond_to?(:source_location)
+          target.source_location.last
+        else
+          target.eval('__LINE__')
+        end
       end
 
       def pry_file?
-        Pry.eval_path == target.eval('__FILE__')
+        file =
+          if target.respond_to?(:source_location)
+            target.source_location.first
+          else
+            target.eval('__FILE__')
+          end
+        Pry.eval_path == file
       end
 
-      # it's possible in some cases that the method we find by this approach is a sub-method of
-      # the one we're currently in, consider:
+      # it's possible in some cases that the method we find by this approach is
+      # a sub-method of the one we're currently in, consider:
       #
       # class A; def b; binding.pry; end; end
       # class B < A; def b; super; end; end
       #
-      # Given that we can normally find the source_range of methods, and that we know which
-      # __FILE__ and __LINE__ the binding is at, we can hope to disambiguate these cases.
+      # Given that we can normally find the source_range of methods, and that we
+      # know which __FILE__ and __LINE__ the binding is at, we can hope to
+      # disambiguate these cases.
       #
-      # This obviously won't work if the source is unavaiable for some reason, or if both
-      # methods have the same __FILE__ and __LINE__.
+      # This obviously won't work if the source is unavaiable for some reason,
+      # or if both methods have the same __FILE__ and __LINE__.
       #
       # @return [Pry::Method, nil] The Pry::Method representing the
       #   superclass method.
       def find_method_in_superclass
         guess = method
-        if skip_superclass_search?
-          return guess
-        end
+        return guess if skip_superclass_search?
 
         while guess
           # needs rescue if this is a Disowned method or a C method or something...
           # TODO: Fix up the exception handling so we don't need a bare rescue
-          if normal_method?(guess)
-            return guess
-          elsif guess != guess.super
-            guess = guess.super
-          else
-            break
-          end
+          return guess if normal_method?(guess)
+          break if guess == guess.super
+
+          guess = guess.super
         end
 
         # Uhoh... none of the methods in the chain had the right `__FILE__` and
@@ -133,22 +154,23 @@ class Pry
       # @return [Pry::Method, nil] The Pry::Method representing the
       #   renamed method
       def find_renamed_method
-        return if !valid_file?(target_file)
+        return unless valid_file?(target_file)
 
         alias_name = all_methods_for(target_self).find do |v|
-          expanded_source_location(target_self.method(v).source_location) == renamed_method_source_location
+          location = target_self.method(v).source_location
+          expanded_source_location(location) == renamed_method_source_location
         end
 
         alias_name && Pry::Method(target_self.method(alias_name))
       end
 
-      def expanded_source_location(sl)
-        return if !sl
+      def expanded_source_location(source_location)
+        return unless source_location
 
         if pry_file?
-          sl
+          source_location
         else
-          [File.expand_path(sl.first), sl.last]
+          [File.expand_path(source_location.first), source_location.last]
         end
       end
 
@@ -160,14 +182,16 @@ class Pry
       # @return [Array<String, Fixnum>] The `source_location` of the
       #   renamed method
       def renamed_method_source_location
-        return @original_method_source_location if defined?(@original_method_source_location)
+        if defined?(@original_method_source_location)
+          return @original_method_source_location
+        end
 
         source_index = lines_for_file(target_file)[0..(target_line - 1)].rindex do |v|
           Pry::Method.method_definition?(method.name, v)
         end
 
-        @original_method_source_location = source_index &&
-          [target_file, index_to_line_number(source_index)]
+        @original_method_source_location =
+          source_index && [target_file, index_to_line_number(source_index)]
       end
 
       def index_to_line_number(index)

data/lib/pry/object_path.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require 'strscan'
+
 class Pry
   # `ObjectPath` implements the resolution of "object paths", which are strings
   # that are similar to filesystem paths but meant for traversing Ruby objects.
@@ -11,7 +15,7 @@ class Pry
   # Object paths are mostly relevant in the context of the `cd` command.
   # @see https://github.com/pry/pry/wiki/State-navigation
   class ObjectPath
-    SPECIAL_TERMS = ["", "::", ".", ".."]
+    SPECIAL_TERMS = ["", "::", ".", ".."].freeze
 
     # @param [String] path_string The object path expressed as a string.
     # @param [Array<Binding>] current_stack The current state of the binding
@@ -27,36 +31,40 @@ class Pry
       scanner = StringScanner.new(@path_string.strip)
       stack   = @current_stack.dup
 
-      begin
-        next_segment = ""
+      loop do
+        begin
+          next_segment = ""
 
-        loop do
-          # Scan for as long as we don't see a slash
-          next_segment << scanner.scan(/[^\/]*/)
+          loop do
+            # Scan for as long as we don't see a slash
+            next_segment += scanner.scan(%r{[^/]*})
 
-          if complete?(next_segment) || scanner.eos?
-            scanner.getch # consume the slash
-            break
+            if complete?(next_segment) || scanner.eos?
+              scanner.getch # consume the slash
+              break
+            else
+              next_segment += scanner.getch # append the slash
+            end
+          end
+
+          case next_segment.chomp
+          when ""
+            stack = [stack.first]
+          when "::"
+            stack.push(TOPLEVEL_BINDING)
+          when "."
+            next
+          when ".."
+            stack.pop unless stack.size == 1
           else
-            next_segment << scanner.getch # append the slash
+            stack.push(Pry.binding_for(stack.last.eval(next_segment)))
           end
+        rescue RescuableException => e
+          return handle_failure(next_segment, e)
         end
 
-        case next_segment.chomp
-        when ""
-          stack = [stack.first]
-        when "::"
-          stack.push(TOPLEVEL_BINDING)
-        when "."
-          next
-        when ".."
-          stack.pop unless stack.size == 1
-        else
-          stack.push(Pry.binding_for(stack.last.eval(next_segment)))
-        end
-      rescue RescuableException => e
-        return handle_failure(next_segment, e)
-      end until scanner.eos?
+        break if scanner.eos?
+      end
 
       stack
     end

data/lib/pry/output.rb

@@ -1,50 +1,136 @@
-class Pry::Output
-  attr_reader :_pry_
+# frozen_string_literal: true
 
-  def initialize(_pry_)
-    @_pry_ = _pry_
-    @boxed_io = _pry_.config.output
-  end
+class Pry
+  class Output
+    # @return [Array<Integer>] default terminal screen size [rows, cols]
+    DEFAULT_SIZE = [27, 80].freeze
+
+    attr_reader :pry_instance
+
+    def initialize(pry_instance)
+      @output = pry_instance.config.output
+      @color = pry_instance.config.color
+    end
+
+    def puts(*objs)
+      return print "\n" if objs.empty?
+
+      objs.each do |obj|
+        if (ary = Array.try_convert(obj))
+          puts(*ary)
+        else
+          print "#{obj.to_s.chomp}\n"
+        end
+      end
+      nil
+    end
+
+    def print(*objs)
+      objs.each do |obj|
+        @output.print decolorize_maybe(obj.to_s)
+      end
+      nil
+    end
+    alias << print
+    alias write print
 
-  def puts(*objs)
-    return print "\n" if objs.empty?
+    def tty?
+      @output.respond_to?(:tty?) && @output.tty?
+    end
 
-    objs.each do |obj|
-      if (ary = Array.try_convert(obj))
-        puts(*ary)
+    def method_missing(method_name, *args, &block)
+      if @output.respond_to?(method_name)
+        @output.__send__(method_name, *args, &block)
       else
-        print "#{obj.to_s.chomp}\n"
+        super
       end
     end
-    nil
-  end
 
-  def print(*objs)
-    objs.each do |obj|
-      @boxed_io.print decolorize_maybe(obj.to_s)
+    def respond_to_missing?(method_name, include_private = false)
+      @output.respond_to?(method_name, include_private)
     end
-    nil
-  end
-  alias << print
-  alias write print
 
-  def tty?
-    @boxed_io.respond_to?(:tty?) and @boxed_io.tty?
-  end
+    def decolorize_maybe(str)
+      return str if @color
 
-  def method_missing(name, *args, &block)
-    @boxed_io.__send__(name, *args, &block)
-  end
+      Pry::Helpers::Text.strip_color(str)
+    end
 
-  def respond_to_missing?(m, include_all = false)
-    @boxed_io.respond_to?(m, include_all)
-  end
+    # @return [Array<Integer>] a pair of [rows, columns] which gives the size of
+    #   the window. If the window size cannot be determined, the default value.
+    def size
+      rows, cols = actual_screen_size
+      return [rows.to_i, cols.to_i] if rows.to_i != 0 && cols.to_i != 0
+
+      DEFAULT_SIZE
+    end
+
+    # Return a screen width or the default if that fails.
+    def width
+      size.last
+    end
+
+    # Return a screen height or the default if that fails.
+    def height
+      size.first
+    end
+
+    private
+
+    def actual_screen_size
+      # The best way, if possible (requires non-jruby >=1.9 or io-console gem).
+      io_console_size ||
+        # Fall back to the old standby, though it might be stale.
+        env_size ||
+        # Fall further back, though this one is also out of date without
+        # something calling Readline.set_screen_size.
+        readline_size ||
+        # Windows users can otherwise run ansicon and get a decent answer.
+        ansicon_env_size
+    end
+
+    def io_console_size
+      return if Pry::Helpers::Platform.jruby?
+
+      begin
+        require 'io/console'
+
+        begin
+          @output.winsize if tty? && @output.respond_to?(:winsize)
+        rescue Errno::EOPNOTSUPP # rubocop:disable Lint/HandleExceptions
+          # Output is probably a socket, which doesn't support #winsize.
+        end
+      rescue LoadError # rubocop:disable Lint/HandleExceptions
+        # They probably don't have the io/console stdlib or the io-console gem.
+        # We'll keep trying.
+      end
+    end
+
+    def env_size
+      size = [Pry::Env['LINES'] || Pry::Env['ROWS'], Pry::Env['COLUMNS']]
+      size if nonzero_column?(size)
+    end
+
+    def readline_size
+      return unless defined?(Readline) && Readline.respond_to?(:get_screen_size)
+
+      size = Readline.get_screen_size
+      size if nonzero_column?(size)
+    rescue Java::JavaLang::NullPointerException
+      # This rescue won't happen on jrubies later than:
+      #     https://github.com/jruby/jruby/pull/436
+      nil
+    end
+
+    def ansicon_env_size
+      return unless Pry::Env['ANSICON'] =~ /\((.*)x(.*)\)/
+
+      size = [Regexp.last_match(2), Regexp.last_match(1)]
+      size if nonzero_column?(size)
+    end
 
-  def decolorize_maybe(str)
-    if _pry_.config.color
-      str
-    else
-      Pry::Helpers::Text.strip_color str
+    def nonzero_column?(size)
+      size[1].to_i > 0
     end
   end
 end