pry 0.10.4-java → 0.11.0-java

data/lib/pry/indent.rb

@@ -66,8 +66,10 @@ class Pry
     #
     # :reserved and :keywords are the CodeRay 0.9.8 and 1.0.0 respectively
     # classifications of "super", "next", "return", etc.
-    STATEMENT_END_TOKENS = IGNORE_TOKENS + [:regexp, :integer, :float, :keyword,
-                                            :delimiter, :reserved]
+    STATEMENT_END_TOKENS = IGNORE_TOKENS + [:regexp, :integer, :float,
+                                            :keyword, :delimiter, :reserved,
+                                            :instance_variable,
+                                            :class_variable, :global_variable]
 
     # Collection of tokens that should appear dedented even though they
     # don't affect the surrounding code.
@@ -223,6 +225,8 @@ class Pry
 
         seen_for_at << add_after if OPTIONAL_DO_TOKENS.include?(token)
 
+        next if is_singleline_if
+
         if kind == :delimiter
           track_delimiter(token)
         elsif OPEN_TOKENS.keys.include?(token) && !is_optional_do && !is_singleline_if

data/lib/pry/input_completer.rb

@@ -106,137 +106,155 @@ class Pry::InputCompleter
         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
+          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/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.rb

@@ -140,11 +140,11 @@ class Pry
       # @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|
+        %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
 
       #
@@ -163,7 +163,7 @@ class Pry
 
       #
       # @deprecated
-      #  please use {#all_from_obj} instead.
+      #  please use {all_from_obj} instead.
       #  the `method_type` argument is ignored.
       #
       def all_from_common(obj, method_type = nil, include_super=true)
@@ -212,9 +212,9 @@ 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
@@ -359,13 +359,13 @@ class Pry
     #   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}"
+        args = parameters.inject([]) do |arr, (typ, nam)|
+          nam ||= (typ == :block ? 'block' : "arg#{arr.size + 1}")
+          arr << case typ
+                 when :req   then nam.to_s
+                 when :opt   then "#{nam}=?"
+                 when :rest  then "*#{nam}"
+                 when :block then "&#{nam}"
                  else '?'
                  end
         end
@@ -461,8 +461,8 @@ class Pry
 
     # @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 or @method.respond_to?(method_name, include_all)
     end
 
     # Delegate any unknown calls to the wrapped method.
@@ -484,7 +484,7 @@ class Pry
       else
         fail_msg = "Cannot locate this method: #{name}."
         if mri?
-          fail_msg += ' Try `gem-install pry-doc` to get access to Ruby Core documentation.'
+          fail_msg += " Invoke the 'gem-install pry-doc' Pry command to get access to Ruby Core documentation.\n"
         end
         raise CommandError, fail_msg
       end

data/lib/pry/method/disowned.rb

@@ -22,6 +22,7 @@ class Pry
       # @param [String] method_name
       def initialize(receiver, method_name, binding=nil)
         @receiver, @name = receiver, method_name
+        @method = nil
       end
 
       # Is the method undefined? (aka `Disowned`)

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

data/lib/pry/output.rb

@@ -1,50 +1,49 @@
-class Pry
-  class Output
-    attr_reader :_pry_
+class Pry::Output
+  attr_reader :_pry_
 
-    def initialize(_pry_)
-      @_pry_ = _pry_
-    end
-
-    def puts(*objs)
-      return print "\n" if objs.empty?
+  def initialize(_pry_)
+    @_pry_ = _pry_
+    @boxed_io = _pry_.config.output
+  end
 
-      objs.each do |obj|
-        if ary = Array.try_convert(obj)
-          puts(*ary)
-        else
-          print "#{obj.to_s.chomp}\n"
-        end
+  def puts(*objs)
+    return print "\n" if objs.empty?
+    objs.each do |obj|
+      if ary = Array.try_convert(obj)
+        puts(*ary)
+      else
+        print "#{obj.to_s.chomp}\n"
       end
-
-      nil
     end
+    nil
+  end
 
-    def print(*objs)
-      objs.each do |obj|
-        _pry_.config.output.print decolorize_maybe(obj.to_s)
-      end
-
-      nil
+  def print(*objs)
+    objs.each do |obj|
+      @boxed_io.print decolorize_maybe(obj.to_s)
     end
-    alias << print
-    alias write print
+    nil
+  end
+  alias << print
+  alias write print
 
-    # If _pry_.config.color is currently false, removes ansi escapes from the string.
-    def decolorize_maybe(str)
-      if _pry_.config.color
-        str
-      else
-        Helpers::Text.strip_color str
-      end
-    end
+  def tty?
+    @boxed_io.respond_to?(:tty?) and @boxed_io.tty?
+  end
 
-    def method_missing(name, *args, &block)
-      _pry_.config.output.send(name, *args, &block)
-    end
+  def method_missing(name, *args, &block)
+    @boxed_io.__send__(name, *args, &block)
+  end
+
+  def respond_to_missing?(m, include_all=false)
+    @boxed_io.respond_to?(m, include_all)
+  end
 
-    def respond_to_missing?(*a)
-      _pry_.config.respond_to?(*a)
+  def decolorize_maybe(str)
+    if _pry_.config.color
+      str
+    else
+      Pry::Helpers::Text.strip_color str
     end
   end
 end