pry 0.10.3 → 0.12.2

data/lib/pry/input_completer.rb

@@ -34,7 +34,7 @@ class Pry::InputCompleter
                    "yield" ]
 
   Operators = [
-               "%", "&", "*", "**", "+",  "-",  "/",
+               "%", "&", "*", "**", "+", "-", "/",
                "<", "<<", "<=", "<=>", "==", "===", "=~", ">", ">=", ">>",
                "[]", "[]=", "^", "!", "!=", "!~"
               ]
@@ -92,7 +92,7 @@ class Pry::InputCompleter
       when SYMBOL_REGEXP # Symbol
         if Symbol.respond_to?(:all_symbols)
           sym        = Regexp.quote($1)
-          candidates = Symbol.all_symbols.collect{|s| ":" << s.id2name}
+          candidates = Symbol.all_symbols.collect { |s| ":" << s.id2name }
           candidates.grep(/^#{sym}/)
         else
           []
@@ -100,143 +100,166 @@ class Pry::InputCompleter
       when TOPLEVEL_LOOKUP_REGEXP # Absolute Constant or class methods
         receiver = $1
         candidates = Object.constants.collect(&:to_s)
-        candidates.grep(/^#{receiver}/).collect{|e| "::" << e}
+        candidates.grep(/^#{receiver}/).collect { |e| "::" << e }
       when CONSTANT_REGEXP # Constant
         message = $1
         begin
           context = target.eval("self")
           context = context.class unless context.respond_to? :constants
-                                    candidates = context.constants.collect(&:to_s)
-                                  rescue
-                                    candidates = []
-                                  end
-          candidates = candidates.grep(/^#{message}/).collect(&path)
-        when CONSTANT_OR_METHOD_REGEXP # Constant or class methods
-          receiver = $1
-          message = Regexp.quote($2)
-          begin
-            candidates = eval("#{receiver}.constants.collect(&:to_s)", bind)
-            candidates |= eval("#{receiver}.methods.collect(&:to_s)", bind)
-          rescue Pry::RescuableException
-            candidates = []
-          end
-          candidates.grep(/^#{message}/).collect{|e| receiver + "::" + e}
-        when SYMBOL_METHOD_CALL_REGEXP # method call on a Symbol
-          receiver = $1
-          message = Regexp.quote($2)
-          candidates = Symbol.instance_methods.collect(&:to_s)
-          select_message(path, receiver, message, candidates)
-        when NUMERIC_REGEXP
-          # Numeric
-          receiver = $1
-          message = Regexp.quote($5)
-          begin
-            candidates = eval(receiver, bind).methods.collect(&:to_s)
-          rescue Pry::RescuableException
-            candidates = []
-          end
-          select_message(path, receiver, message, candidates)
-        when HEX_REGEXP
-          # Numeric(0xFFFF)
-          receiver = $1
-          message = Regexp.quote($2)
+          candidates = context.constants.collect(&:to_s)
+        rescue
+          candidates = []
+        end
+        candidates = candidates.grep(/^#{message}/).collect(&path)
+      when CONSTANT_OR_METHOD_REGEXP # Constant or class methods
+        receiver = $1
+        message = Regexp.quote($2)
+        begin
+          candidates = eval("#{receiver}.constants.collect(&:to_s)", bind)
+          candidates |= eval("#{receiver}.methods.collect(&:to_s)", bind)
+        rescue Pry::RescuableException
+          candidates = []
+        end
+        candidates.grep(/^#{message}/).collect { |e| receiver + "::" + e }
+      when SYMBOL_METHOD_CALL_REGEXP # method call on a Symbol
+        receiver = $1
+        message = Regexp.quote($2)
+        candidates = Symbol.instance_methods.collect(&:to_s)
+        select_message(path, receiver, message, candidates)
+      when NUMERIC_REGEXP
+        # Numeric
+        receiver = $1
+        message = Regexp.quote($5)
+        begin
+          candidates = eval(receiver, bind).methods.collect(&:to_s)
+        rescue Pry::RescuableException
+          candidates = []
+        end
+        select_message(path, receiver, message, candidates)
+      when HEX_REGEXP
+        # Numeric(0xFFFF)
+        receiver = $1
+        message = Regexp.quote($2)
+        begin
+          candidates = eval(receiver, bind).methods.collect(&:to_s)
+        rescue Pry::RescuableException
+          candidates = []
+        end
+        select_message(path, receiver, message, candidates)
+      when GLOBALVARIABLE_REGEXP # global
+        regmessage = Regexp.new(Regexp.quote($1))
+        candidates = global_variables.collect(&:to_s).grep(regmessage)
+      when VARIABLE_REGEXP # variable
+        receiver = $1
+        message = Regexp.quote($2)
+
+        gv = eval("global_variables", bind).collect(&:to_s)
+        lv = eval("local_variables", bind).collect(&:to_s)
+        cv = eval("self.class.constants", bind).collect(&:to_s)
+
+        if (gv | lv | cv).include?(receiver) or /^[A-Z]/ =~ receiver && /\./ !~ receiver
+          # foo.func and foo is local var. OR
+          # Foo::Bar.func
           begin
-            candidates = eval(receiver, bind).methods.collect(&:to_s)
+            candidates = eval("#{receiver}.methods", bind).collect(&:to_s)
           rescue Pry::RescuableException
             candidates = []
           end
-          select_message(path, receiver, message, candidates)
-        when GLOBALVARIABLE_REGEXP # global
-          regmessage = Regexp.new(Regexp.quote($1))
-          candidates = global_variables.collect(&:to_s).grep(regmessage)
-        when VARIABLE_REGEXP # variable
-          receiver = $1
-          message = Regexp.quote($2)
-
-          gv = eval("global_variables", bind).collect(&:to_s)
-          lv = eval("local_variables", bind).collect(&:to_s)
-          cv = eval("self.class.constants", bind).collect(&:to_s)
-
-          if (gv | lv | cv).include?(receiver) or /^[A-Z]/ =~ receiver && /\./ !~ receiver
-            # foo.func and foo is local var. OR
-            # Foo::Bar.func
-            begin
-              candidates = eval("#{receiver}.methods", bind).collect(&:to_s)
-            rescue Pry::RescuableException
-              candidates = []
-            end
-          else
-            # func1.func2
-            candidates = []
-            ObjectSpace.each_object(Module){|m|
-              begin
-                name = m.name.to_s
-              rescue Pry::RescuableException
-                name = ""
-              end
-              next if name != "IRB::Context" and
-              /^(IRB|SLex|RubyLex|RubyToken)/ =~ name
-
-              # jruby doesn't always provide #instance_methods() on each
-              # object.
-              if m.respond_to?(:instance_methods)
-                candidates.concat m.instance_methods(false).collect(&:to_s)
-              end
-            }
-            candidates.sort!
-            candidates.uniq!
-          end
-          select_message(path, receiver, message, candidates)
-        when /^\.([^.]*)$/
-          # Unknown(maybe String)
-          receiver = ""
-          message = Regexp.quote($1)
-          candidates = String.instance_methods(true).collect(&:to_s)
-          select_message(path, receiver, message, candidates)
         else
-          candidates = eval(
-                            "methods | private_methods | local_variables | " \
-                            "self.class.constants | instance_variables",
-                            bind
-                            ).collect(&:to_s)
-
-          if eval("respond_to?(:class_variables)", bind)
-            candidates += eval("class_variables", bind).collect(&:to_s)
-          end
-          candidates = (candidates|ReservedWords|custom_completions).grep(/^#{Regexp.quote(input)}/)
-          candidates.collect(&path)
+          # func1.func2
+          require 'set'
+          candidates = Set.new
+          to_ignore = ignored_modules
+          ObjectSpace.each_object(Module) { |m|
+            next if (to_ignore.include?(m) rescue true)
+
+            # jruby doesn't always provide #instance_methods() on each
+            # object.
+            if m.respond_to?(:instance_methods)
+              candidates.merge m.instance_methods(false).collect(&:to_s)
+            end
+          }
+        end
+        select_message(path, receiver, message, candidates.sort)
+      when /^\.([^.]*)$/
+        # Unknown(maybe String)
+        receiver = ""
+        message = Regexp.quote($1)
+        candidates = String.instance_methods(true).collect(&:to_s)
+        select_message(path, receiver, message, candidates)
+      else
+        candidates = eval(
+                          "methods | private_methods | local_variables | " \
+                          "self.class.constants | instance_variables",
+                          bind
+                          ).collect(&:to_s)
+
+        if eval("respond_to?(:class_variables)", bind)
+          candidates += eval("class_variables", bind).collect(&:to_s)
         end
-      rescue Pry::RescuableException
-        []
+        candidates = (candidates | ReservedWords | custom_completions).grep(/^#{Regexp.quote(input)}/)
+        candidates.collect(&path)
       end
+    rescue Pry::RescuableException
+      []
     end
+  end
 
-    def select_message(path, receiver, message, candidates)
-      candidates.grep(/^#{message}/).collect { |e|
-        case e
-        when /^[a-zA-Z_]/
-          path.call(receiver + "." << e)
-        when /^[0-9]/
-        when *Operators
-          #receiver + " " << e
-        end
-      }.compact
+  def select_message(path, receiver, message, candidates)
+    candidates.grep(/^#{message}/).collect { |e|
+      case e
+      when /^[a-zA-Z_]/
+        path.call(receiver + "." << e)
+      when /^[0-9]/
+      when *Operators
+        #receiver + " " << e
+      end
+    }.compact
+  end
+
+  # build_path seperates the input into two parts: path and input.
+  # input is the partial string that should be completed
+  # path is a proc that takes an input and builds a full path.
+  def build_path(input)
+    # check to see if the input is a regex
+    return proc { |i| i.to_s }, input if input[/\/\./]
+
+    trailing_slash = input.end_with?('/')
+    contexts = input.chomp('/').split(/\//)
+    input = contexts[-1]
+    path = proc do |i|
+      p = contexts[0..-2].push(i).join('/')
+      p += '/' if trailing_slash && !i.nil?
+      p
     end
+    return path, input
+  end
+
+  def ignored_modules
+    # We could cache the result, but IRB is not loaded by default.
+    # And this is very fast anyway.
+    # By using this approach, we avoid Module#name calls, which are
+    # relatively slow when there are a lot of anonymous modules defined.
+    s = Set.new
 
-    # build_path seperates the input into two parts: path and input.
-    # input is the partial string that should be completed
-    # path is a proc that takes an input and builds a full path.
-    def build_path(input)
-      # check to see if the input is a regex
-      return proc {|i| i.to_s }, input if input[/\/\./]
-      trailing_slash = input.end_with?('/')
-      contexts = input.chomp('/').split(/\//)
-      input = contexts[-1]
-      path = proc do |i|
-        p = contexts[0..-2].push(i).join('/')
-        p += '/' if trailing_slash && !i.nil?
-        p
+    scanner = lambda do |m|
+      next if s.include?(m) # IRB::ExtendCommandBundle::EXCB recurses.
+
+      s << m
+      m.constants(false).each do |c|
+        value = m.const_get(c)
+        scanner.call(value) if value.is_a?(Module)
       end
-      return path, input
     end
+
+    # FIXME: Add Pry here as well?
+    [:IRB, :SLex, :RubyLex, :RubyToken].each do |module_name|
+      next unless Object.const_defined?(module_name)
+
+      scanner.call(Object.const_get(module_name))
+    end
+
+    s.delete(IRB::Context) if defined?(IRB::Context)
+    s
+  end
 end

data/lib/pry/input_lock.rb

@@ -1,5 +1,3 @@
-require 'thread'
-
 class Pry
   # There is one InputLock per input (such as STDIN) as two REPLs on the same
   # input makes things delirious. InputLock serializes accesses to the input so

data/lib/pry/last_exception.rb

@@ -23,8 +23,8 @@ class Pry::LastException < BasicObject
     end
   end
 
-  def respond_to_missing?(name, include_private = false)
-    @e.respond_to?(name)
+  def respond_to_missing?(name, include_all = false)
+    @e.respond_to?(name, include_all)
   end
 
   #

data/lib/pry/method/disowned.rb

@@ -20,8 +20,9 @@ class Pry
       #
       # @param [Object] receiver
       # @param [String] method_name
-      def initialize(receiver, method_name, binding=nil)
+      def initialize(receiver, method_name)
         @receiver, @name = receiver, method_name
+        @method = nil
       end
 
       # Is the method undefined? (aka `Disowned`)
@@ -46,6 +47,7 @@ class Pry
       # 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)
       end
     end

data/lib/pry/method/patcher.rb

@@ -42,9 +42,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
@@ -97,7 +94,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 +113,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,6 +1,5 @@
 class Pry
   class Method
-
     # This class is responsible for locating the *real* `Pry::Method`
     # object captured by a binding.
     #
@@ -16,7 +15,6 @@ class Pry
     # 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
@@ -26,13 +24,17 @@ class Pry
         # @param [Binding] b
         # @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__'))
+          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)
+          end
+        rescue
+          false
         end
 
         def weird_method?(method, b)
-          !normal_method?(method, b)
+          not normal_method?(method, b)
         end
       end
 
@@ -61,6 +63,11 @@ class Pry
 
       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
@@ -91,13 +98,15 @@ class Pry
       # __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.
+      # 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
 
         while guess
           # needs rescue if this is a Disowned method or a C method or something...
@@ -111,9 +120,9 @@ class Pry
           end
         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
 
@@ -125,6 +134,7 @@ class Pry
       #   renamed method
       def find_renamed_method
         return if !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
         end