pry 0.10.4 → 0.11.0.pre

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,137 @@ 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
+        else
+          # func1.func2
+          candidates = []
+          ObjectSpace.each_object(Module){|m|
             begin
-              candidates = eval("#{receiver}.methods", bind).collect(&:to_s)
+              name = m.name.to_s
             rescue Pry::RescuableException
-              candidates = []
+              name = ""
             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)
+            next if name != "IRB::Context" and
+            /^(IRB|SLex|RubyLex|RubyToken)/ =~ name
 
-          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)
+            # 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
-      rescue Pry::RescuableException
-        []
-      end
-    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)
 
-    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
+        if eval("respond_to?(:class_variables)", bind)
+          candidates += eval("class_variables", bind).collect(&:to_s)
         end
-      }.compact
+        candidates = (candidates|ReservedWords|custom_completions).grep(/^#{Regexp.quote(input)}/)
+        candidates.collect(&path)
+      end
+    rescue Pry::RescuableException
+      []
     end
+  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
+  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
-      return path, input
+    }.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
 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
@@ -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?(*a)
+    @boxed_io.respond_to?(*a)
+  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

data/lib/pry/pager.rb

@@ -14,11 +14,12 @@ class Pry::Pager
   end
 
   # Send the given text through the best available pager (if `Pry.config.pager` is
-  # enabled).
-  # If you want to send text through in chunks as you generate it, use `open` to
-  # get a writable object instead.
-  # @param [String] text A piece of text to run through a pager.
-  # @param [IO] output (`$stdout`) An object to send output to.
+  # enabled). If you want to send text through in chunks as you generate it, use `open`
+  # to get a writable object instead.
+  #
+  # @param [String] text
+  #   Text to run through a pager.
+  #
   def page(text)
     open do |pager|
       pager << text
@@ -27,7 +28,6 @@ class Pry::Pager
 
   # Yields a pager object (`NullPager`, `SimplePager`, or `SystemPager`).  All
   # pagers accept output with `#puts`, `#print`, `#write`, and `#<<`.
-  # @param [IO] output (`$stdout`) An object to send output to.
   def open
     pager = best_available
     yield pager
@@ -48,7 +48,6 @@ class Pry::Pager
   # `#print`, `#write`, and `#<<`. You must call `#close` when you're done
   # writing output to a pager, and you must rescue `Pry::Pager::StopPaging`.
   # These requirements can be avoided by using `.open` instead.
-  # @param [#<<] output ($stdout) An object to send output to.
   def best_available
     if !_pry_.config.pager
       NullPager.new(_pry_.output)
@@ -139,7 +138,11 @@ class Pry::Pager
       if @system_pager.nil?
         @system_pager = begin
           pager_executable = default_pager.split(' ').first
-          `which #{pager_executable}`
+          if Pry::Helpers::BaseHelpers.windows? || Pry::Helpers::BaseHelpers.windows_ansi?
+            `where #{pager_executable}`
+          else
+            `which #{pager_executable}`
+          end
           $?.success?
         rescue
           false