pry 0.10.4 → 0.14.2

data/lib/pry/last_exception.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 #
 # {Pry::LastException} is a proxy class who wraps an Exception object for
 # {Pry#last_exception}. it extends the exception object with methods that
@@ -6,56 +8,54 @@
 # the original exception object is not modified and method calls are forwarded
 # to the wrapped exception object.
 #
-class Pry::LastException < BasicObject
-  attr_accessor :bt_index
-
-  def initialize(e)
-    @e = e
-    @bt_index = 0
-    @file, @line = bt_source_location_for(0)
-  end
-
-  def method_missing(name, *args, &block)
-    if @e.respond_to?(name)
-      @e.public_send(name, *args, &block)
-    else
-      super
+class Pry
+  class LastException < BasicObject
+    attr_accessor :bt_index
+
+    def initialize(exception)
+      @exception = exception
+      @bt_index = 0
+      @file, @line = bt_source_location_for(0)
     end
-  end
-
-  def respond_to_missing?(name, include_private = false)
-    @e.respond_to?(name)
-  end
 
-  #
-  # @return [String]
-  #  returns the path to a file for the current backtrace. see {#bt_index}.
-  #
-  def file
-    @file
-  end
+    def method_missing(name, *args, &block)
+      if @exception.respond_to?(name)
+        @exception.public_send(name, *args, &block)
+      else
+        super
+      end
+    end
 
-  #
-  # @return [Fixnum]
-  #  returns the line for the current backtrace. see {#bt_index}.
-  #
-  def line
-    @line
-  end
+    def respond_to_missing?(name, include_all = false)
+      @exception.respond_to?(name, include_all)
+    end
 
-  # @return [Exception]
-  #   returns the wrapped exception
-  #
-  def wrapped_exception
-    @e
-  end
+    #
+    # @return [String]
+    #  returns the path to a file for the current backtrace. see {#bt_index}.
+    #
+    attr_reader :file
+
+    #
+    # @return [Fixnum]
+    #  returns the line for the current backtrace. see {#bt_index}.
+    #
+    attr_reader :line
+
+    # @return [Exception]
+    #   returns the wrapped exception
+    #
+    def wrapped_exception
+      @exception
+    end
 
-  def bt_source_location_for(index)
-    backtrace[index] =~ /(.*):(\d+)/
-    [$1, $2.to_i]
-  end
+    def bt_source_location_for(index)
+      backtrace[index] =~ /(.*):(\d+)/
+      [::Regexp.last_match(1), ::Regexp.last_match(2).to_i]
+    end
 
-  def inc_bt_index
-    @bt_index = (@bt_index + 1) % backtrace.size
+    def inc_bt_index
+      @bt_index = (@bt_index + 1) % backtrace.size
+    end
   end
 end

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.
@@ -20,8 +22,10 @@ class Pry
       #
       # @param [Object] receiver
       # @param [String] method_name
-      def initialize(receiver, method_name, binding=nil)
-        @receiver, @name = receiver, method_name
+      def initialize(receiver, method_name)
+        @receiver = receiver
+        @name = method_name
+        @method = nil
       end
 
       # Is the method undefined? (aka `Disowned`)
@@ -44,9 +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)
-        Object.instance_method(:method_missing).bind(self).call(meth_name, *args, &block)
+      # 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
+
+      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
@@ -42,9 +46,6 @@ class Pry
       # transation we make that not happen, which means that alias_method_chains, etc.
       # continue to work.
       #
-      # @param [String] meth_name  The method name before aliasing
-      # @param [Module] target  The owner of the method
-
       def with_method_transaction
         temp_name = "__pry_#{method.original_name}__"
         method = self.method
@@ -54,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
@@ -75,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
 
@@ -97,7 +103,7 @@ class Pry
       def wrap_for_owner(source)
         Pry.current[:pry_owner] = method.owner
         owner_source = definition_for_owner(source)
-        visibility_fix = "#{method.visibility.to_s} #{method.name.to_sym.inspect}"
+        visibility_fix = "#{method.visibility} #{method.name.to_sym.inspect}"
         "Pry.current[:pry_owner].class_eval do; #{owner_source}\n#{visibility_fix}\nend"
       end
 
@@ -116,7 +122,7 @@ class Pry
       def wrap_for_nesting(source)
         nesting = Pry::Code.from_file(method.source_file).nesting_at(method.source_line)
 
-        (nesting + [source] + nesting.map{ "end" } + [""]).join(";")
+        (nesting + [source] + nesting.map { "end" } + [""]).join(";")
       rescue Pry::Indent::UnparseableNestingError
         source
       end

data/lib/pry/method/weird_method_locator.rb

@@ -1,38 +1,48 @@
+# frozen_string_literal: true
+
 class Pry
   class Method
-
     # This class is responsible for locating the *real* `Pry::Method`
     # object captured by a binding.
     #
     # 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.
     class WeirdMethodLocator
       class << self
-
         # Whether the given method object matches the associated binding.
         # If the method object does not match the binding, then it's
         # most likely not the method captured by the binding, and we
         # must commence a search.
         #
         # @param [Pry::Method] method
-        # @param [Binding] b
+        # @param [Binding] binding
         # @return [Boolean]
-        def normal_method?(method, b)
-          method && (method.source_file && method.source_range rescue false) &&
-          File.expand_path(method.source_file) == File.expand_path(b.eval('__FILE__')) &&
-          method.source_range.include?(b.eval('__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 StandardError
+          false
         end
 
-        def weird_method?(method, b)
-          !normal_method?(method, b)
+        def weird_method?(method, binding)
+          !normal_method?(method, binding)
         end
       end
 
@@ -43,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
 
@@ -56,11 +67,16 @@ 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
 
+      def skip_superclass_search?
+        target_mod = @target.eval('self').class
+        target_mod.ancestors.take_while { |mod| mod != target_mod }.any?
+      end
+
       def normal_method?(method)
         self.class.normal_method?(method, target)
       end
@@ -70,50 +86,64 @@ 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__, or if we're in rbx where b.eval('__LINE__')
-      # is broken.
+      # 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
+        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 __LINE__
-        # This may be caused by rbx https://github.com/rubinius/rubinius/issues/953,
-        # or other unknown circumstances (TODO: we should warn the user when this happens)
+        # Uhoh... none of the methods in the chain had the right `__FILE__` and
+        # `__LINE__` due to unknown circumstances.
+        # TODO: we should warn the user when this happens.
         nil
       end
 
@@ -124,21 +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
+          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
 
@@ -150,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)