pry 0.10.1 → 0.14.1

data/lib/pry/method.rb

@@ -1,4 +1,6 @@
-require 'pry/helpers/documentation_helpers'
+# frozen_string_literal: true
+
+require 'method_source'
 
 class Pry
   class << self
@@ -15,51 +17,52 @@ class Pry
 
   # This class wraps the normal `Method` and `UnboundMethod` classes
   # to provide extra functionality useful to Pry.
-  class Method
-    require 'pry/method/weird_method_locator'
-    require 'pry/method/disowned'
-    require 'pry/method/patcher'
-
+  class Method # rubocop:disable Metrics/ClassLength
     extend Helpers::BaseHelpers
+    extend Forwardable
+
     include Helpers::BaseHelpers
     include Helpers::DocumentationHelpers
     include CodeObject::Helpers
 
     class << self
       # Given a string representing a method name and optionally a binding to
-      # search in, find and return the requested method wrapped in a `Pry::Method`
-      # instance.
+      # search in, find and return the requested method wrapped in a
+      # `Pry::Method` instance.
       #
       # @param [String] name The name of the method to retrieve.
       # @param [Binding] target The context in which to search for the method.
       # @param [Hash] options
-      # @option options [Boolean] :instance Look for an instance method if `name` doesn't
-      #   contain any context.
-      # @option options [Boolean] :methods Look for a bound/singleton method if `name` doesn't
-      #   contain any context.
-      # @return [Pry::Method, nil] A `Pry::Method` instance containing the requested
-      #   method, or `nil` if name is `nil` or no method could be located matching the parameters.
-      def from_str(name, target=TOPLEVEL_BINDING, options={})
+      # @option options [Boolean] :instance Look for an instance method if
+      #   `name` doesn't contain any context.
+      # @option options [Boolean] :methods Look for a bound/singleton method if
+      #  `name` doesn't contain any context.
+      # @return [Pry::Method, nil] A `Pry::Method` instance containing the
+      #   requested method, or `nil` if name is `nil` or no method could be
+      #   located matching the parameters.
+      def from_str(name, target = TOPLEVEL_BINDING, options = {})
         if name.nil?
           nil
         elsif name.to_s =~ /(.+)\#(\S+)\Z/
-          context, meth_name = $1, $2
+          context = Regexp.last_match(1)
+          meth_name = Regexp.last_match(2)
           from_module(target.eval(context), meth_name, target)
         elsif name.to_s =~ /(.+)(\[\])\Z/
-          context, meth_name = $1, $2
+          context = Regexp.last_match(1)
+          meth_name = Regexp.last_match(2)
           from_obj(target.eval(context), meth_name, target)
         elsif name.to_s =~ /(.+)(\.|::)(\S+)\Z/
-          context, meth_name = $1, $3
+          context = Regexp.last_match(1)
+          meth_name = Regexp.last_match(3)
           from_obj(target.eval(context), meth_name, target)
         elsif options[:instance]
           from_module(target.eval("self"), name, target)
         elsif options[:methods]
           from_obj(target.eval("self"), name, target)
         else
-          from_str(name, target, :instance => true) or
-            from_str(name, target, :methods => true)
+          from_str(name, target, instance: true) ||
+            from_str(name, target, methods: true)
         end
-
       rescue Pry::RescuableException
         nil
       end
@@ -68,26 +71,33 @@ class Pry
       # use it to instantiate a `Pry::Method`. Return `nil` if this isn't
       # possible.
       #
-      # @param [Binding] b
+      # @param [Binding] binding
       # @return [Pry::Method, nil]
       #
-      def from_binding(b)
-        meth_name = b.eval('::Kernel.__method__')
+      def from_binding(binding)
+        meth_name = binding.eval('::Kernel.__method__')
         if [:__script__, nil].include?(meth_name)
           nil
         else
-          method = begin
-                     if Object === b.eval('self')
-                       new(Kernel.instance_method(:method).bind(b.eval("self")).call(meth_name))
-                     else
-                       new(b.eval('class << self; self; end.instance_method(::Kernel.__method__).bind(self)'))
-                     end
-                   rescue NameError, NoMethodError
-                     Disowned.new(b.eval('self'), meth_name.to_s)
-                   end
-
-          if WeirdMethodLocator.weird_method?(method, b)
-            WeirdMethodLocator.new(method, b).get_method || method
+          method =
+            begin
+              if Object === binding.eval('self') # rubocop:disable Style/CaseEquality
+                new(
+                  Kernel.instance_method(:method)
+                    .bind(binding.eval("self"))
+                    .call(meth_name)
+                )
+              else
+                str = 'class << self; self; end' \
+                      '.instance_method(::Kernel.__method__).bind(self)'
+                new(binding.eval(str))
+              end
+            rescue NameError, NoMethodError # rubocop:disable Lint/ShadowedException
+              Disowned.new(binding.eval('self'), meth_name.to_s)
+            end
+
+          if WeirdMethodLocator.weird_method?(method, binding)
+            WeirdMethodLocator.new(method, binding).find_method || method
           else
             method
           end
@@ -101,11 +111,16 @@ class Pry
       # @param [Symbol] method_type The type of method: :method or :instance_method
       # @param [Binding] target The binding where the method is looked up.
       # @return [Method, UnboundMethod] The 'refined' method object.
-      def lookup_method_via_binding(obj, method_name, method_type, target=TOPLEVEL_BINDING)
+      def lookup_method_via_binding(
+        obj, method_name, method_type, target = TOPLEVEL_BINDING
+      )
         Pry.current[:obj] = obj
         Pry.current[:name] = method_name
         receiver = obj.is_a?(Module) ? "Module" : "Kernel"
-        target.eval("::#{receiver}.instance_method(:#{method_type}).bind(Pry.current[:obj]).call(Pry.current[:name])")
+        target.eval(
+          "::#{receiver}.instance_method(:#{method_type})" \
+          ".bind(Pry.current[:obj]).call(Pry.current[:name])"
+        )
       ensure
         Pry.current[:obj] = Pry.current[:name] = nil
       end
@@ -118,8 +133,10 @@ class Pry
       # @param [String] name
       # @param [Binding] target The binding where the method is looked up.
       # @return [Pry::Method, nil]
-      def from_class(klass, name, target=TOPLEVEL_BINDING)
-        new(lookup_method_via_binding(klass, name, :instance_method, target)) rescue nil
+      def from_class(klass, name, target = TOPLEVEL_BINDING)
+        new(lookup_method_via_binding(klass, name, :instance_method, target))
+      rescue StandardError
+        nil
       end
       alias from_module from_class
 
@@ -131,20 +148,27 @@ class Pry
       # @param [String] name
       # @param [Binding] target The binding where the method is looked up.
       # @return [Pry::Method, nil]
-      def from_obj(obj, name, target=TOPLEVEL_BINDING)
-        new(lookup_method_via_binding(obj, name, :method, target)) rescue nil
+      def from_obj(obj, name, target = TOPLEVEL_BINDING)
+        new(lookup_method_via_binding(obj, name, :method, target))
+      rescue StandardError
+        nil
       end
 
       # Get all of the instance methods of a `Class` or `Module`
       # @param [Class,Module] klass
       # @param [Boolean] include_super Whether to include methods from ancestors.
       # @return [Array[Pry::Method]]
-      def all_from_class(klass, include_super=true)
-        %w(public protected private).map do |visibility|
-          safe_send(klass, :"#{visibility}_instance_methods", include_super).map do |method_name|
-            new(safe_send(klass, :instance_method, method_name), :visibility => visibility.to_sym)
+      def all_from_class(klass, include_super = true)
+        %w[public protected private].flat_map do |visibility|
+          safe_send(
+            klass, :"#{visibility}_instance_methods", include_super
+          ).map do |method_name|
+            new(
+              safe_send(klass, :instance_method, method_name),
+              visibility: visibility.to_sym
+            )
           end
-        end.flatten(1)
+        end
       end
 
       #
@@ -157,28 +181,23 @@ class Pry
       #
       # @return [Array[Pry::Method]]
       #
-      def all_from_obj(obj, include_super=true)
+      def all_from_obj(obj, include_super = true)
         all_from_class(singleton_class_of(obj), include_super)
       end
 
-      #
-      # @deprecated
-      #  please use {#all_from_obj} instead.
-      #  the `method_type` argument is ignored.
-      #
-      def all_from_common(obj, method_type = nil, include_super=true)
-        all_from_obj(obj, include_super)
-      end
-
       # Get every `Class` and `Module`, in order, that will be checked when looking
       # for an instance method to call on this object.
       # @param [Object] obj
       # @return [Array[Class, Module]]
       def resolution_order(obj)
-        if Class === obj
+        if Class === obj # rubocop:disable Style/CaseEquality
           singleton_class_resolution_order(obj) + instance_resolution_order(Class)
         else
-          klass = singleton_class_of(obj) rescue obj.class
+          klass = begin
+                    singleton_class_of(obj)
+                  rescue StandardError
+                    obj.class
+                  end
           instance_resolution_order(klass)
         end
       end
@@ -199,11 +218,17 @@ class Pry
       end
 
       def singleton_method_definition?(name, definition_line)
-        /^define_singleton_method\(?\s*[:\"\']#{Regexp.escape(name)}|^def\s*self\.#{Regexp.escape(name)}/ =~ definition_line.strip
+        regexp =
+          /^define_singleton_method\(?\s*[:\"\']#{Regexp.escape(name)}|
+           ^def\s*self\.#{Regexp.escape(name)}/x
+        regexp =~ definition_line.strip
       end
 
       def instance_method_definition?(name, definition_line)
-        /^define_method\(?\s*[:\"\']#{Regexp.escape(name)}|^def\s*#{Regexp.escape(name)}/ =~ definition_line.strip
+        regexp =
+          /^define_method\(?\s*[:\"\']#{Regexp.escape(name)}|
+           ^def\s*#{Regexp.escape(name)}/x
+        regexp =~ definition_line.strip
       end
 
       # Get the singleton classes of superclasses that could define methods on
@@ -212,33 +237,37 @@ class Pry
       # the lowest copy will be returned.
       def singleton_class_resolution_order(klass)
         ancestors = Pry::Method.safe_send(klass, :ancestors)
-        resolution_order = ancestors.grep(Class).map do |anc|
+        resolution_order = ancestors.grep(Class).flat_map do |anc|
           [singleton_class_of(anc), *singleton_class_of(anc).included_modules]
-        end.flatten(1)
+        end
 
         resolution_order.reverse.uniq.reverse - Class.included_modules
       end
 
       def singleton_class_of(obj)
-        begin
-          class << obj; self; end
-        rescue TypeError # can't define singleton. Fixnum, Symbol, Float, ...
-          obj.class
-        end
+        class << obj; self; end
+      rescue TypeError # can't define singleton. Fixnum, Symbol, Float, ...
+        obj.class
       end
     end
 
-    # A new instance of `Pry::Method` wrapping the given `::Method`, `UnboundMethod`, or `Proc`.
+    # Workaround for https://github.com/pry/pry/pull/2086
+    def_delegators :@method, :owner, :parameters, :receiver
+
+    # A new instance of `Pry::Method` wrapping the given `::Method`,
+    # `UnboundMethod`, or `Proc`.
     #
     # @param [::Method, UnboundMethod, Proc] method
     # @param [Hash] known_info Can be used to pre-cache expensive to compute stuff.
     # @return [Pry::Method]
-    def initialize(method, known_info={})
+    def initialize(method, known_info = {})
       @method = method
       @visibility = known_info[:visibility]
     end
 
-    # Get the name of the method as a String, regardless of the underlying Method#name type.
+    # Get the name of the method as a String, regardless of the underlying
+    # Method#name type.
+    #
     # @return [String]
     def name
       @method.name.to_s
@@ -298,7 +327,8 @@ class Pry
     # @return [String, nil] The documentation for the method, or `nil` if it's
     #   unavailable.
     def doc
-      @doc ||= case source_type
+      @doc ||=
+        case source_type
         when :c
           info = pry_doc_info
           info.docstring if info
@@ -317,7 +347,7 @@ class Pry
     #   `nil` if the filename is unavailable.
     def source_file
       if source_location.nil?
-        if !rbx? and source_type == :c
+        if source_type == :c
           info = pry_doc_info
           info.file if info
         end
@@ -341,33 +371,38 @@ class Pry
     # @return [Symbol] The visibility of the method. May be `:public`,
     #   `:protected`, or `:private`.
     def visibility
-     @visibility ||= if owner.public_instance_methods.any? { |m| m.to_s == name }
-                       :public
-                     elsif owner.protected_instance_methods.any? { |m| m.to_s == name }
-                       :protected
-                     elsif owner.private_instance_methods.any? { |m| m.to_s == name }
-                       :private
-                     else
-                       :none
-                     end
+      @visibility ||=
+        if owner.public_instance_methods.any? { |m| m.to_s == name }
+          :public
+        elsif owner.protected_instance_methods.any? { |m| m.to_s == name }
+          :protected
+        elsif owner.private_instance_methods.any? { |m| m.to_s == name }
+          :private
+        else
+          :none
+        end
     end
 
     # @return [String] A representation of the method's signature, including its
     #   name and parameters. Optional and "rest" parameters are marked with `*`
-    #   and block parameters with `&`. If the parameter names are unavailable,
-    #   they're given numbered names instead.
+    #   and block parameters with `&`. Keyword arguments are shown with `:`
+    #   If the parameter names are unavailable, they're given numbered names instead.
     #   Paraphrased from `awesome_print` gem.
     def signature
       if respond_to?(:parameters)
-        args = parameters.inject([]) do |arr, (type, name)|
-          name ||= (type == :block ? 'block' : "arg#{arr.size + 1}")
-          arr << case type
-                 when :req   then name.to_s
-                 when :opt   then "#{name}=?"
-                 when :rest  then "*#{name}"
-                 when :block then "&#{name}"
-                 else '?'
-                 end
+        args = parameters.inject([]) do |args_array, (arg_type, name)|
+          name ||= (arg_type == :block ? 'block' : "arg#{args_array.size + 1}")
+          args_array.push(
+            case arg_type
+            when :req    then name.to_s
+            when :opt    then "#{name}=?"
+            when :rest   then "*#{name}"
+            when :block  then "&#{name}"
+            when :key    then "#{name}:?"
+            when :keyreq then "#{name}:"
+            else '?'
+            end
+          )
         end
       else
         args = (1..arity.abs).map { |i| "arg#{i}" }
@@ -379,8 +414,8 @@ class Pry
 
     # @return [Pry::Method, nil] The wrapped method that is called when you
     #   use "super" in the body of this method.
-    def super(times=1)
-      if UnboundMethod === @method
+    def super(times = 1)
+      if @method.is_a?(UnboundMethod)
         sup = super_using_ancestors(Pry::Method.instance_resolution_order(owner), times)
       else
         sup = super_using_ancestors(Pry::Method.resolution_order(receiver), times)
@@ -393,12 +428,13 @@ class Pry
     #   before any aliasing, or `nil` if it can't be determined.
     def original_name
       return nil if source_type != :ruby
+
       method_name_from_first_line(source.lines.first)
     end
 
     # @return [Boolean] Was the method defined outside a source file?
     def dynamically_defined?
-      !!(source_file and source_file =~ /(\(.*\))|<.*>/)
+      !!(source_file && source_file =~ /(\(.*\))|<.*>/)
     end
 
     # @return [Boolean] Whether the method is unbound.
@@ -444,30 +480,36 @@ class Pry
     end
 
     # @return [Boolean]
-    def ==(obj)
-      if obj.is_a? Pry::Method
-        obj == @method
-      else
-        @method == obj
-      end
+    def ==(other)
+      return other == @method if other.is_a?(Pry::Method)
+
+      @method == other
     end
 
     # @param [Class] klass
     # @return [Boolean]
     def is_a?(klass)
-      klass == Pry::Method or @method.is_a?(klass)
+      (klass == Pry::Method) || @method.is_a?(klass)
     end
     alias kind_of? is_a?
 
     # @param [String, Symbol] method_name
     # @return [Boolean]
-    def respond_to?(method_name)
-      super or @method.respond_to?(method_name)
+    def respond_to?(method_name, include_all = false)
+      super || @method.respond_to?(method_name, include_all)
     end
 
     # Delegate any unknown calls to the wrapped method.
     def method_missing(method_name, *args, &block)
-      @method.send(method_name, *args, &block)
+      if @method.respond_to?(method_name)
+        @method.__send__(method_name, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      @method.respond_to?(method_name) || super
     end
 
     def comment
@@ -479,12 +521,17 @@ class Pry
     # @return [YARD::CodeObjects::MethodObject]
     # @raise [CommandError] when the method can't be found or `pry-doc` isn't installed.
     def pry_doc_info
-      if Pry.config.has_pry_doc
-        Pry::MethodInfo.info_for(@method) or raise CommandError, "Cannot locate this method: #{name}. (source_location returns nil)"
+      if defined?(PryDoc)
+        Pry::MethodInfo.info_for(@method) ||
+          raise(
+            CommandError,
+            "Cannot locate this method: #{name}. (source_location returns nil)"
+          )
       else
         fail_msg = "Cannot locate this method: #{name}."
-        if mri?
-          fail_msg += ' Try `gem-install pry-doc` to get access to Ruby Core documentation.'
+        if Helpers::Platform.mri?
+          fail_msg += " Invoke the 'gem-install pry-doc' Pry command to get " \
+                      "access to Ruby Core documentation.\n"
         end
         raise CommandError, fail_msg
       end
@@ -492,17 +539,23 @@ class Pry
 
     # @param [Class, Module] ancestors The ancestors to investigate
     # @return [Method] The unwrapped super-method
-    def super_using_ancestors(ancestors, times=1)
-      next_owner = self.owner
+    def super_using_ancestors(ancestors, times = 1)
+      next_owner = owner
       times.times do
         i = ancestors.index(next_owner) + 1
-        while ancestors[i] && !(ancestors[i].method_defined?(name) || ancestors[i].private_method_defined?(name))
+        while ancestors[i] &&
+              !(ancestors[i].method_defined?(name) ||
+                ancestors[i].private_method_defined?(name))
           i += 1
         end
-        next_owner = ancestors[i] or return nil
+        (next_owner = ancestors[i]) || (return nil)
       end
 
-      safe_send(next_owner, :instance_method, name) rescue nil
+      begin
+        safe_send(next_owner, :instance_method, name)
+      rescue StandardError
+        nil
+      end
     end
 
     # @param [String] first_ln The first line of a method definition.
@@ -510,7 +563,7 @@ class Pry
     def method_name_from_first_line(first_ln)
       return nil if first_ln.strip !~ /^def /
 
-      tokens = CodeRay.scan(first_ln, :ruby)
+      tokens = SyntaxHighlighter.tokenize(first_ln)
       tokens = tokens.tokens.each_slice(2) if tokens.respond_to?(:tokens)
       tokens.each_cons(2) do |t1, t2|
         if t2.last == :method || t2.last == :ident && t1 == [".", :operator]
@@ -523,22 +576,22 @@ class Pry
 
     def c_source
       info = pry_doc_info
-      if info and info.source
-        strip_comments_from_c_code(info.source)
-      end
+      strip_comments_from_c_code(info.source) if info && info.source
     end
 
     def ruby_source
-      # clone of MethodSource.source_helper that knows to use our
-      # hacked version of source_location for rbx core methods, and
-      # our input buffer for methods defined in (pry)
+      # Clone of `MethodSource.source_helper` that knows to use our
+      # hacked version of `source_location` for our input buffer for methods
+      # defined in `(pry)`.
       file, line = *source_location
-      raise SourceNotFoundError, "Could not locate source for #{name_with_owner}!" unless file
+      unless file
+        raise SourceNotFoundError, "Could not locate source for #{name_with_owner}!"
+      end
 
       begin
         code = Pry::Code.from_file(file).expression_at(line)
       rescue SyntaxError => e
-        raise MethodSource::SourceNotFoundError.new(e.message)
+        raise MethodSource::SourceNotFoundError, e.message
       end
       strip_leading_whitespace(code)
     end

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(%r{[^/]*})
 
-        loop do
-          # Scan for as long as we don't see a slash
-          next_segment << scanner.scan(/[^\/]*/)
+            if complete?(next_segment) || scanner.eos?
+              scanner.getch # consume the slash
+              break
+            else
+              next_segment += scanner.getch # append the slash
+            end
+          end
 
-          if complete?(next_segment) || scanner.eos?
-            scanner.getch # consume the slash
-            break
+          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
@@ -74,9 +82,10 @@ class Pry
         "Exception: #{err.inspect}"
       ].join("\n")
 
-      raise CommandError.new(msg).tap { |e|
-        e.set_backtrace err.backtrace
-      }
+      command_error = CommandError.new(msg)
+      command_error.set_backtrace(err.backtrace)
+
+      raise command_error
     end
   end
 end