pry 0.9.12.2 → 0.14.2

data/lib/pry/{commands/edit/method_patcher.rb → method/patcher.rb}

@@ -1,37 +1,42 @@
+# frozen_string_literal: true
+
 class Pry
-  class Command::Edit
-    class MethodPatcher
-      attr_accessor :_pry_
-      attr_accessor :code_object
+  class Method
+    class Patcher
+      attr_accessor :method
+
+      # rubocop:disable Style/ClassVars
+      @@source_cache = {}
+      # rubocop:enable Style/ClassVars
+
+      def initialize(method)
+        @method = method
+      end
 
-      def initialize(_pry_, code_object)
-        @_pry_ = _pry_
-        @code_object = code_object
+      def self.code_for(filename)
+        @@source_cache[filename]
       end
 
       # perform the patch
-      def perform_patch
-        if code_object.alias?
+      def patch_in_ram(source)
+        if method.alias?
           with_method_transaction do
-            _pry_.evaluate_ruby patched_code
+            redefine source
           end
         else
-          _pry_.evaluate_ruby patched_code
+          redefine source
         end
       end
 
       private
 
-      def patched_code
-        @patched_code ||= wrap(Pry::Editor.edit_tempfile_with_content(adjusted_lines))
+      def redefine(source)
+        @@source_cache[cache_key] = source
+        TOPLEVEL_BINDING.eval wrap(source), cache_key
       end
 
-      # The method code adjusted so that the first line is rewritten
-      # so that def self.foo --> def foo
-      def adjusted_lines
-        lines = code_object.source.lines.to_a
-        lines[0] = definition_line_for_owner(lines.first)
-        lines
+      def cache_key
+        "pry-redefined(0x#{method.owner.object_id.to_s(16)}##{method.name})"
       end
 
       # Run some code ensuring that at the end target#meth_name will not have changed.
@@ -41,21 +46,21 @@ 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_#{code_object.original_name}__"
-        co = code_object
-        code_object.owner.class_eval do
-          alias_method temp_name, co.original_name
+        temp_name = "__pry_#{method.original_name}__"
+        method = self.method
+        method.owner.class_eval do
+          alias_method temp_name, method.original_name
           yield
-          alias_method co.name, co.original_name
-          alias_method co.original_name, temp_name
+          alias_method method.name, method.original_name
+          alias_method method.original_name, temp_name
         end
-
       ensure
-        co.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
@@ -68,13 +73,15 @@ class Pry
       # This is necessarily done by String manipulation because we can't find out what
       # syntax is needed for the argument list by ruby-level introspection.
       #
-      # @param String   The original definition line. e.g. def self.foo(bar, baz=1)
-      # @return String  The new definition line. e.g. def foo(bar, baz=1)
-      def definition_line_for_owner(line)
-        if line =~ /^def (?:.*?\.)?#{Regexp.escape(code_object.original_name)}(?=[\(\s;]|$)/
-          "def #{code_object.original_name}#{$'}"
+      # @param [String] line The original definition line. e.g. def self.foo(bar, baz=1)
+      # @return [String]  The new definition line. e.g. def foo(bar, baz=1)
+      def definition_for_owner(line)
+        if line =~ /\Adef (?:.*?\.)?#{Regexp.escape(method.original_name)}(?=[\(\s;]|$)/
+          "def #{method.original_name}#{$'}"
         else
-          raise CommandError, "Could not find original `def #{code_object.original_name}` line to patch."
+          raise CommandError,
+                "Could not find original `def #{method.original_name}` line " \
+                "to patch."
         end
       end
 
@@ -87,15 +94,17 @@ class Pry
 
       # Update the source code so that when it has the right owner when eval'd.
       #
-      # This (combined with definition_line_for_owner) is backup for the case that
+      # This (combined with definition_for_owner) is backup for the case that
       # wrap_for_nesting fails, to ensure that the method will stil be defined in
       # the correct place.
       #
       # @param [String] source  The source to wrap
       # @return [String]
       def wrap_for_owner(source)
-        Pry.current[:pry_owner] = code_object.owner
-        "Pry.current[:pry_owner].class_eval do\n#{source}\nend"
+        Pry.current[:pry_owner] = method.owner
+        owner_source = definition_for_owner(source)
+        visibility_fix = "#{method.visibility} #{method.name.to_sym.inspect}"
+        "Pry.current[:pry_owner].class_eval do; #{owner_source}\n#{visibility_fix}\nend"
       end
 
       # Update the new source code to have the correct Module.nesting.
@@ -111,10 +120,10 @@ class Pry
       # @param [String] source  The source to wrap.
       # @return [String]
       def wrap_for_nesting(source)
-        nesting = Pry::Code.from_file(code_object.source_file).nesting_at(code_object.source_line)
+        nesting = Pry::Code.from_file(method.source_file).nesting_at(method.source_line)
 
-        (nesting + [source] + nesting.map{ "end" } + [""]).join("\n")
-      rescue Pry::Indent::UnparseableNestingError => e
+        (nesting + [source] + nesting.map { "end" } + [""]).join(";")
+      rescue Pry::Indent::UnparseableNestingError
         source
       end
     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,48 +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
-          else
-            guess = guess.super
-          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
 
@@ -122,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
 
@@ -148,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)
@@ -164,7 +200,7 @@ class Pry
       end
 
       def valid_file?(file)
-        (File.exists?(file) && !File.directory?(file)) || Pry.eval_path == file
+        (File.exist?(file) && !File.directory?(file)) || Pry.eval_path == file
       end
 
       def lines_for_file(file)