pry 0.9.12.2 → 0.14.2

data/lib/pry/wrapped_module.rb

@@ -1,4 +1,4 @@
-require 'pry/module_candidate'
+# frozen_string_literal: true
 
 class Pry
   class << self
@@ -26,12 +26,8 @@ class Pry
     # @return [Module, nil] The module or `nil` (if conversion failed).
     # @example
     #   Pry::WrappedModule.from_str("Pry::Code")
-    def self.from_str(mod_name, target=TOPLEVEL_BINDING)
-      if safe_to_evaluate?(mod_name, target)
-        Pry::WrappedModule.new(target.eval(mod_name))
-      else
-        nil
-      end
+    def self.from_str(mod_name, target = TOPLEVEL_BINDING)
+      Pry::WrappedModule.new(target.eval(mod_name)) if safe_to_evaluate?(mod_name, target)
     rescue RescuableException
       nil
     end
@@ -48,6 +44,8 @@ class Pry
       # @return [Boolean]
       def safe_to_evaluate?(str, target)
         return true if str.strip == "self"
+        return false if str =~ /%/
+
         kind = target.eval("defined?(#{str})")
         kind =~ /variable|constant/
       end
@@ -56,37 +54,27 @@ class Pry
     # @raise [ArgumentError] if the argument is not a `Module`
     # @param [Module] mod
     def initialize(mod)
-      raise ArgumentError, "Tried to initialize a WrappedModule with a non-module #{mod.inspect}" unless ::Module === mod
+      unless mod.is_a?(Module)
+        raise ArgumentError, "Tried to initialize a WrappedModule with a " \
+                             "non-module #{mod.inspect}"
+      end
+
       @wrapped = mod
       @memoized_candidates = []
       @host_file_lines = nil
       @source = nil
       @source_location = nil
       @doc = nil
+      @all_source_locations_by_popularity = nil
     end
 
     # Returns an array of the names of the constants accessible in the wrapped
-    # module. This provides a consistent interface between 1.8 and 1.9 and also
-    # avoids the problem of accidentally calling the singleton method
-    # `Module.constants`.
-    # @param [Boolean] inherit (true) Include the names of constants from
-    #   included modules?
+    # module. This avoids the problem of accidentally calling the singleton
+    # method `Module.constants`.
+    # @param [Boolean] inherit Include the names of constants from included
+    #   modules?
     def constants(inherit = true)
-      method = Module.instance_method(:constants).bind(@wrapped)
-
-      # If we're on 1.8, we have to manually remove ancestors' constants. If
-      # we're on 1.9, though, it's better to use the built-in `inherit` param,
-      # since it doesn't do things like incorrectly remove Pry::Config.
-      if method.arity == 0
-        consts = method.call
-        if !inherit
-          consts -= (@wrapped.ancestors - [@wrapped]).map(&:constants).flatten
-        end
-      else
-        consts = method.call(inherit)
-      end
-
-      consts
+      Module.instance_method(:constants).bind(@wrapped).call(inherit)
     end
 
     # The prefix that would appear before methods defined on this class.
@@ -96,7 +84,7 @@ class Pry
     # @return String
     def method_prefix
       if singleton_class?
-        if Module === singleton_instance
+        if Module === singleton_instance # rubocop:disable Style/CaseEquality
           "#{WrappedModule.new(singleton_instance).nonblank_name}."
         else
           "self."
@@ -120,7 +108,11 @@ class Pry
     # Is this a singleton class?
     # @return [Boolean]
     def singleton_class?
-      wrapped != wrapped.ancestors.first
+      if Pry::Method.safe_send(wrapped, :respond_to?, :singleton_class?)
+        Pry::Method.safe_send(wrapped, :singleton_class?)
+      else
+        wrapped != Pry::Method.safe_send(wrapped, :ancestors).first
+      end
     end
 
     # Is this strictly a module? (does not match classes)
@@ -141,29 +133,36 @@ class Pry
     #
     # @return [Object]
     def singleton_instance
-      raise ArgumentError, "tried to get instance of non singleton class" unless singleton_class?
+      unless singleton_class?
+        raise ArgumentError, "tried to get instance of non singleton class"
+      end
 
-      if Helpers::BaseHelpers.jruby?
+      if Helpers::Platform.jruby?
         wrapped.to_java.attached
       else
-        @singleton_instance ||= ObjectSpace.each_object(wrapped).detect{ |x| (class << x; self; end) == wrapped }
+        @singleton_instance ||= ObjectSpace.each_object(wrapped).detect do |x|
+          (class << x; self; end) == wrapped
+        end
       end
     end
 
     # Forward method invocations to the wrapped module
     def method_missing(method_name, *args, &block)
-      wrapped.send(method_name, *args, &block)
+      if wrapped.respond_to?(method_name)
+        wrapped.send(method_name, *args, &block)
+      else
+        super
+      end
     end
 
-    def respond_to?(method_name)
-      super || wrapped.respond_to?(method_name)
+    def respond_to_missing?(method_name, include_private = false)
+      wrapped.respond_to?(method_name, include_private) || super
     end
 
     # Retrieve the source location of a module. Return value is in same
     # format as Method#source_location. If the source location
     # cannot be found this method returns `nil`.
     #
-    # @param [Module] mod The module (or class).
     # @return [Array<String, Fixnum>, nil] The source location of the
     #   module (or class), or `nil` if no source location found.
     def source_location
@@ -177,14 +176,14 @@ class Pry
     def file
       Array(source_location).first
     end
-    alias_method :source_file, :file
+    alias source_file file
 
     # @return [Fixnum, nil] The associated line for the module (i.e
     #   the primary candidate: highest ranked monkeypatch).
     def line
       Array(source_location).last
     end
-    alias_method :source_line, :line
+    alias source_line line
 
     # Returns documentation for the module.
     # This documentation is for the primary candidate, if
@@ -238,7 +237,7 @@ class Pry
     # @param [Fixnum] rank
     # @return [Pry::WrappedModule::Candidate]
     def candidate(rank)
-      @memoized_candidates[rank] ||= Candidate.new(self, rank)
+      @memoized_candidates[rank] ||= WrappedModule::Candidate.new(self, rank)
     end
 
     # @return [Fixnum] The number of candidate definitions for the
@@ -247,19 +246,14 @@ class Pry
       method_candidates.count
     end
 
-    # @note On JRuby 1.9 and higher, in certain conditions, this method chucks
-    #   away its ability to be quick (when there are lots of monkey patches,
-    #   like in Rails). However, it should be efficient enough on other rubies.
-    # @see https://github.com/jruby/jruby/issues/525
-    # @return [Enumerator, Array] on JRuby 1.9 and higher returns Array, on
-    #  other rubies returns Enumerator
+    # @return [Array]
     def candidates
-      enum = generator.new do |y|
-               (0...number_of_candidates).each do |num|
-                 y.yield candidate(num)
-               end
-             end
-      Pry::Helpers::BaseHelpers.jruby_19? ? enum.to_a : enum
+      enum = Enumerator.new do |y|
+        (0...number_of_candidates).each do |num|
+          y.yield candidate(num)
+        end
+      end
+      enum
     end
 
     # @return [Boolean] Whether YARD docs are available for this module.
@@ -273,38 +267,30 @@ class Pry
     #   When `self` is a `Module` then return the
     #   nth ancestor, otherwise (in the case of classes) return the
     #   nth ancestor that is a class.
-    def super(times=1)
+    def super(times = 1)
       return self if times.zero?
 
-      if wrapped.is_a?(Class)
-        sup = ancestors.select { |v| v.is_a?(Class) }[times]
-      else
-        sup = ancestors[times]
-      end
+      sup =
+        if wrapped.is_a?(Class)
+          ancestors.select { |v| v.is_a?(Class) }[times]
+        else
+          ancestors[times]
+        end
 
       Pry::WrappedModule(sup) if sup
     end
 
     private
 
-    # Ruby 1.8 doesn't support `Enumerator` (it's called Generator instead)
-    #
-    # @return [Object] Return the appropriate generator class.
-    def generator
-      @generator ||= if defined?(Enumerator)
-                       Enumerator
-                     else
-                       require 'generator'
-                       Generator
-                     end
-    end
-
-    # @return [Pry::WrappedModule::Candidate] The candidate of rank 0,
-    #   that is the 'monkey patch' of this module with the highest
-    #   number of methods. It is considered the 'canonical' definition
-    #   for the module.
+    # @return [Pry::WrappedModule::Candidate] The candidate with the
+    #   highest rank, that is the 'monkey patch' of this module with the
+    #   highest number of methods, which contains a source code line that
+    #   defines the module. It is considered the 'canonical' definition
+    #   for the module. In the absense of a suitable candidate, the
+    #   candidate of rank 0 will be returned, or a CommandError raised if
+    #   there are no candidates at all.
     def primary_candidate
-      @primary_candidate ||= candidate(0)
+      @primary_candidate ||= candidates.find(&:file) || candidate(0)
     end
 
     # @return [Array<Array<Pry::Method>>] The array of `Pry::Method` objects,
@@ -315,7 +301,7 @@ class Pry
     #   speed up source code extraction.
     def method_candidates
       @method_candidates ||= all_source_locations_by_popularity.map do |group|
-        methods_sorted_by_source_line  = group.last.sort_by(&:source_line)
+        methods_sorted_by_source_line = group.last.sort_by(&:source_line)
         [methods_sorted_by_source_line.first, methods_sorted_by_source_line.last]
       end
     end
@@ -324,40 +310,52 @@ class Pry
     def all_source_locations_by_popularity
       return @all_source_locations_by_popularity if @all_source_locations_by_popularity
 
-      ims = all_relevant_methods_for(wrapped)
-      @all_source_locations_by_popularity = ims.group_by { |v| Array(v.source_location).first }.
-        sort_by { |k, v| -v.size }
+      ims = all_relevant_methods_for(wrapped).group_by do |v|
+        Array(v.source_location).first
+      end
+
+      @all_source_locations_by_popularity = ims.sort_by do |path, methods|
+        expanded = File.expand_path(path)
+        load_order = $LOADED_FEATURES.index { |file| expanded.end_with?(file) }
+
+        [-methods.size, load_order || (1.0 / 0.0)]
+      end
     end
 
     # We only want methods that have a non-nil `source_location`. We also
     # skip some spooky internal methods.
-    # (i.e we skip `__class_init__` because it's an odd rbx specific thing that causes tests to fail.)
+    #
     # @return [Array<Pry::Method>]
     def all_relevant_methods_for(mod)
-      all_methods_for(mod).select(&:source_location).
-        reject{ |x| x.name == '__class_init__' || method_defined_by_forwardable_module?(x) }
+      methods = all_methods_for(mod).select(&:source_location)
+        .reject { |x| method_defined_by_forwardable_module?(x) }
+
+      return methods unless methods.empty?
+
+      safe_send(mod, :constants).flat_map do |const_name|
+        if (const = nested_module?(mod, const_name))
+          all_relevant_methods_for(const)
+        else
+          []
+        end
+      end
     end
 
     # Return all methods (instance methods and class methods) for a
     # given module.
     # @return [Array<Pry::Method>]
     def all_methods_for(mod)
-      all_from_common(mod, :instance_method) + all_from_common(mod, :method)
-    end
-
-    # FIXME: a variant of this method is also found in Pry::Method
-    def all_from_common(mod, method_type)
-      %w(public protected private).map do |visibility|
-        safe_send(mod, :"#{visibility}_#{method_type}s", false).select do |method_name|
-          if method_type == :method
-            safe_send(mod, method_type, method_name).owner == class << mod; self; end
-          else
-            safe_send(mod, method_type, method_name).owner == mod
-          end
-        end.map do |method_name|
-          Pry::Method.new(safe_send(mod, method_type, method_name), :visibility => visibility.to_sym)
-        end
-      end.flatten
+      Pry::Method.all_from_obj(mod, false) + Pry::Method.all_from_class(mod, false)
+    end
+
+    def nested_module?(parent, name)
+      return if safe_send(parent, :autoload?, name)
+
+      child = safe_send(parent, :const_get, name)
+      return unless child.is_a?(Module)
+      return unless safe_send(child, :name) == "#{safe_send(parent, :name)}::#{name}"
+
+      child
     end
 
     # Detect methods that are defined with `def_delegator` from the Forwardable
@@ -373,11 +371,12 @@ class Pry
     def lines_for_file(file)
       @lines_for_file ||= {}
 
-      if file == Pry.eval_path
-        @lines_for_file[file] ||= Pry.line_buffer.drop(1)
-      else
-        @lines_for_file[file] ||= File.readlines(file)
-      end
+      @lines_for_file[file] ||=
+        if file == Pry.eval_path
+          Pry.line_buffer.drop(1)
+        else
+          File.readlines(file)
+        end
     end
   end
 end