pry 0.10.4 → 0.11.0

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/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/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/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

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

data/lib/pry/plugins.rb

@@ -60,6 +60,16 @@ class Pry
 
       alias active? active
       alias enabled? enabled
+
+      def supported?
+        pry_version = Gem::Version.new(VERSION)
+        spec.dependencies.each do |dependency|
+          if dependency.name == "pry"
+            return dependency.requirement.satisfied_by?(pry_version)
+          end
+        end
+        true
+      end
     end
 
     def initialize
@@ -68,11 +78,11 @@ class Pry
 
     # Find all installed Pry plugins and store them in an internal array.
     def locate_plugins
-      Gem.refresh
-      (Gem::Specification.respond_to?(:each) ? Gem::Specification : Gem.source_index.find_name('')).each do |gem|
+      gem_list.each do |gem|
         next if gem.name !~ PRY_PLUGIN_PREFIX
         plugin_name = gem.name.split('-', 2).last
-        @plugins << Plugin.new(plugin_name, gem.name, gem, true) if !gem_located?(gem.name)
+        plugin = Plugin.new(plugin_name, gem.name, gem, false)
+        @plugins << plugin.tap(&:enable!) if plugin.supported? && !plugin_located?(plugin)
       end
       @plugins
     end
@@ -95,8 +105,13 @@ class Pry
     end
 
     private
-    def gem_located?(gem_name)
-      @plugins.any? { |plugin| plugin.gem_name == gem_name }
+    def plugin_located?(plugin)
+      @plugins.any? { |existing| existing.gem_name == plugin.gem_name }
+    end
+
+    def gem_list
+      Gem.refresh
+      Gem::Specification.respond_to?(:each) ? Gem::Specification : Gem.source_index.find_name('')
     end
   end
 

data/lib/pry/pry_class.rb

@@ -5,7 +5,7 @@ class Pry
   LOCAL_RC_FILE = "./.pryrc"
 
   class << self
-    extend Forwardable
+    extend Pry::Forwardable
     attr_accessor :custom_completions
     attr_accessor :current_line
     attr_accessor :line_buffer
@@ -32,6 +32,21 @@ class Pry
     def history
       @history ||= History.new
     end
+
+    #
+    # @example
+    #  Pry.configure do |config|
+    #     config.eager_load! # optional
+    #     config.input =     # ..
+    #     config.foo = 2
+    #  end
+    #
+    # @yield [config]
+    #   Yields a block with {Pry.config} as its argument.
+    #
+    def configure
+      yield config
+    end
   end
 
   #
@@ -81,7 +96,7 @@ class Pry
     expanded = Pathname.new(File.expand_path(file)).realpath.to_s
     # For rbx 1.9 mode [see rubinius issue #2165]
     File.exist?(expanded) ? expanded : nil
-  rescue Errno::ENOENT
+  rescue Errno::ENOENT, Errno::EACCES
     nil
   end
 
@@ -124,6 +139,11 @@ you can add "Pry.config.windows_console_warning = false" to your .pryrc.
     # note these have to be loaded here rather than in pry_instance as
     # we only want them loaded once per entire Pry lifetime.
     load_rc_files
+  end
+
+  def self.final_session_setup
+    return if @session_finalized
+    @session_finalized = true
     load_plugins if Pry.config.should_load_plugins
     load_requires if Pry.config.should_load_requires
     load_history if Pry.config.history.should_load
@@ -141,6 +161,9 @@ you can add "Pry.config.windows_console_warning = false" to your .pryrc.
   #   Pry.start(Object.new, :input => MyInput.new)
   def self.start(target=nil, options={})
     return if ENV['DISABLE_PRY']
+    if ENV['FAIL_PRY']
+      raise 'You have FAIL_PRY set to true, which results in Pry calls failing'
+    end
     options = options.to_hash
 
     if in_critical_section?
@@ -150,8 +173,8 @@ you can add "Pry.config.windows_console_warning = false" to your .pryrc.
     end
 
     options[:target] = Pry.binding_for(target || toplevel_binding)
-    options[:hooks] = Pry::Hooks.from_hash options.delete(:hooks) if options.key?(:hooks)
     initial_session_setup
+    final_session_setup
 
     # Unless we were given a backtrace, save the current one
     if options[:backtrace].nil?
@@ -233,7 +256,7 @@ you can add "Pry.config.windows_console_warning = false" to your .pryrc.
   # @param [String] command_string The Pry command (including arguments,
   #   if any).
   # @param [Hash] options Optional named parameters.
-  # @return [Object] The return value of the Pry command.
+  # @return [nil]
   # @option options [Object, Binding] :target The object to run the
   #   command under. Defaults to `TOPLEVEL_BINDING` (main).
   # @option options [Boolean] :show_output Whether to show command
@@ -258,6 +281,7 @@ you can add "Pry.config.windows_console_warning = false" to your .pryrc.
 
     pry = Pry.new(:output   => output, :target   => target, :commands => options[:commands])
     pry.eval command_string
+    nil
   end
 
   def self.default_editor_for_platform
@@ -306,6 +330,8 @@ Readline version #{Readline::VERSION} detected - will not auto_resize! correctly
   # Set all the configurable options back to their default values
   def self.reset_defaults
     @initial_session = true
+    @session_finalized = nil
+
     self.config = Pry::Config.new Pry::Config::Default.new
     self.cli = false
     self.current_line = 1