pry 0.9.12.2 → 0.14.2

data/lib/pry/input_completer.rb

@@ -0,0 +1,283 @@
+# frozen_string_literal: true
+
+# taken from irb
+# Implements tab completion for Readline in Pry
+class Pry
+  class InputCompleter
+    NUMERIC_REGEXP = /^(-?(0[dbo])?[0-9_]+(\.[0-9_]+)?([eE]-?[0-9]+)?)\.([^.]*)$/.freeze
+    ARRAY_REGEXP = /^([^\]]*\])\.([^.]*)$/.freeze
+    SYMBOL_REGEXP = /^(:[^:.]*)$/.freeze
+    SYMBOL_METHOD_CALL_REGEXP = /^(:[^:.]+)\.([^.]*)$/.freeze
+    REGEX_REGEXP = %r{^(/[^/]*/)\.([^.]*)$}.freeze
+    PROC_OR_HASH_REGEXP = /^([^\}]*\})\.([^.]*)$/.freeze
+    TOPLEVEL_LOOKUP_REGEXP = /^::([A-Z][^:\.\(]*)$/.freeze
+    CONSTANT_REGEXP = /^([A-Z][A-Za-z0-9]*)$/.freeze
+    CONSTANT_OR_METHOD_REGEXP = /^([A-Z].*)::([^:.]*)$/.freeze
+    HEX_REGEXP = /^(-?0x[0-9a-fA-F_]+)\.([^.]*)$/.freeze
+    GLOBALVARIABLE_REGEXP = /^(\$[^.]*)$/.freeze
+    VARIABLE_REGEXP = /^([^."].*)\.([^.]*)$/.freeze
+
+    RESERVED_WORDS = %w[
+      BEGIN END
+      alias and
+      begin break
+      case class
+      def defined do
+      else elsif end ensure
+      false for
+      if in
+      module
+      next nil not
+      or
+      redo rescue retry return
+      self super
+      then true
+      undef unless until
+      when while
+      yield
+    ].freeze
+
+    WORD_ESCAPE_STR = " \t\n\"\\'`><=;|&{(".freeze
+
+    def initialize(input, pry = nil)
+      @pry = pry
+      @input = input
+      if @input.respond_to?(:basic_word_break_characters=)
+        @input.basic_word_break_characters = WORD_ESCAPE_STR
+      end
+
+      return unless @input.respond_to?(:completion_append_character=)
+
+      @input.completion_append_character = nil
+    end
+
+    # Return a new completion proc for use by Readline.
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    def call(str, options = {})
+      custom_completions = options[:custom_completions] || []
+      # if there are multiple contexts e.g. cd 1/2/3
+      # get new target for 1/2 and find candidates for 3
+      path, input = build_path(str)
+
+      if path.call.empty?
+        target = options[:target]
+      else
+        # Assume the user is tab-completing the 'cd' command
+        begin
+          target = Pry::ObjectPath.new(path.call, @pry.binding_stack).resolve.last
+        # but if that doesn't work, assume they're doing division with no spaces
+        rescue Pry::CommandError
+          target = options[:target]
+        end
+      end
+
+      begin
+        bind = target
+        # Complete stdlib symbols
+        case input
+        when REGEX_REGEXP # Regexp
+          receiver = Regexp.last_match(1)
+          message = Regexp.quote(Regexp.last_match(2))
+          candidates = Regexp.instance_methods.collect(&:to_s)
+          select_message(path, receiver, message, candidates)
+        when ARRAY_REGEXP # Array
+          receiver = Regexp.last_match(1)
+          message = Regexp.quote(Regexp.last_match(2))
+          candidates = Array.instance_methods.collect(&:to_s)
+          select_message(path, receiver, message, candidates)
+        when PROC_OR_HASH_REGEXP # Proc or Hash
+          receiver = Regexp.last_match(1)
+          message = Regexp.quote(Regexp.last_match(2))
+          candidates = Proc.instance_methods.collect(&:to_s)
+          candidates |= Hash.instance_methods.collect(&:to_s)
+          select_message(path, receiver, message, candidates)
+        when SYMBOL_REGEXP # Symbol
+          if Symbol.respond_to?(:all_symbols)
+            sym = Regexp.quote(Regexp.last_match(1))
+            candidates = Symbol.all_symbols.collect { |s| ":" + s.id2name }
+            candidates.grep(/^#{sym}/)
+          else
+            []
+          end
+        when TOPLEVEL_LOOKUP_REGEXP # Absolute Constant or class methods
+          receiver = Regexp.last_match(1)
+          candidates = Object.constants.collect(&:to_s)
+          candidates.grep(/^#{receiver}/).collect { |e| "::" + e }
+        when CONSTANT_REGEXP # Constant
+          message = Regexp.last_match(1)
+          begin
+            context = target.eval("self")
+            context = context.class unless context.respond_to? :constants
+            candidates = context.constants.collect(&:to_s)
+          rescue StandardError
+            candidates = []
+          end
+          candidates = candidates.grep(/^#{message}/).collect(&path)
+        when CONSTANT_OR_METHOD_REGEXP # Constant or class methods
+          receiver = Regexp.last_match(1)
+          message = Regexp.quote(Regexp.last_match(2))
+          begin
+            candidates = eval( # rubocop:disable Security/Eval
+              "#{receiver}.constants.collect(&:to_s)", bind, __FILE__, __LINE__
+            )
+            candidates |= eval( # rubocop:disable Security/Eval
+              "#{receiver}.methods.collect(&:to_s)", bind, __FILE__, __LINE__
+            )
+          rescue Pry::RescuableException
+            candidates = []
+          end
+          candidates.grep(/^#{message}/).collect { |e| receiver + "::" + e }
+        when SYMBOL_METHOD_CALL_REGEXP # method call on a Symbol
+          receiver = Regexp.last_match(1)
+          message = Regexp.quote(Regexp.last_match(2))
+          candidates = Symbol.instance_methods.collect(&:to_s)
+          select_message(path, receiver, message, candidates)
+        when NUMERIC_REGEXP
+          # Numeric
+          receiver = Regexp.last_match(1)
+          message = Regexp.quote(Regexp.last_match(5))
+          begin
+            # rubocop:disable Security/Eval
+            candidates = eval(receiver, bind).methods.collect(&:to_s)
+            # rubocop:enable Security/Eval
+          rescue Pry::RescuableException
+            candidates = []
+          end
+          select_message(path, receiver, message, candidates)
+        when HEX_REGEXP
+          # Numeric(0xFFFF)
+          receiver = Regexp.last_match(1)
+          message = Regexp.quote(Regexp.last_match(2))
+          begin
+            # rubocop:disable Security/Eval
+            candidates = eval(receiver, bind).methods.collect(&:to_s)
+            # rubocop:enable Security/Eval
+          rescue Pry::RescuableException
+            candidates = []
+          end
+          select_message(path, receiver, message, candidates)
+        when GLOBALVARIABLE_REGEXP # global
+          regmessage = Regexp.new(Regexp.quote(Regexp.last_match(1)))
+          candidates = global_variables.collect(&:to_s).grep(regmessage)
+        when VARIABLE_REGEXP # variable
+          receiver = Regexp.last_match(1)
+          message = Regexp.quote(Regexp.last_match(2))
+
+          gv = eval("global_variables", bind, __FILE__, __LINE__).collect(&:to_s)
+          lv = eval("local_variables", bind, __FILE__, __LINE__).collect(&:to_s)
+          cv = eval("self.class.constants", bind, __FILE__, __LINE__).collect(&:to_s)
+
+          if (gv | lv | cv).include?(receiver) || /^[A-Z]/ =~ receiver && /\./ !~ receiver
+            # foo.func and foo is local var. OR
+            # Foo::Bar.func
+            begin
+              candidates = eval( # rubocop:disable Security/Eval
+                "#{receiver}.methods", bind, __FILE__, __LINE__
+              ).collect(&:to_s)
+            rescue Pry::RescuableException
+              candidates = []
+            end
+          else
+            # func1.func2
+            require 'set'
+            candidates = Set.new
+            to_ignore = ignored_modules
+            ObjectSpace.each_object(Module) do |m|
+              next if begin
+                        to_ignore.include?(m)
+                      rescue StandardError
+                        true
+                      end
+
+              # 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
+          end
+          select_message(path, receiver, message, candidates.sort)
+        when /^\.([^.]*)$/
+          # Unknown(maybe String)
+          receiver = ""
+          message = Regexp.quote(Regexp.last_match(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, __FILE__, __LINE__ - 2
+          ).collect(&:to_s)
+
+          if eval("respond_to?(:class_variables)", bind, __FILE__, __LINE__)
+            candidates += eval(
+              "class_variables", bind, __FILE__, __LINE__
+            ).collect(&:to_s)
+          end
+          candidates =
+            (candidates | RESERVED_WORDS | custom_completions)
+              .grep(/^#{Regexp.quote(input)}/)
+          candidates.collect(&path)
+        end
+      rescue Pry::RescuableException
+        []
+      end
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+    def select_message(path, receiver, message, candidates)
+      candidates.grep(/^#{message}/).collect do |e|
+        next unless e =~ /^[a-zA-Z_]/
+
+        path.call(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[%r{/\.}]
+
+      trailing_slash = input.end_with?('/')
+      contexts = input.chomp('/').split(%r{/})
+      input = contexts[-1]
+      path = proc do |i|
+        p = contexts[0..-2].push(i).join('/')
+        p += '/' if trailing_slash && !i.nil?
+        p
+      end
+      [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
+
+      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
+      end
+
+      # FIXME: Add Pry here as well?
+      %i[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
+end

data/lib/pry/input_lock.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+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
+  # that threads to not conflict with each other. The latest thread to request
+  # ownership of the input wins.
+  class InputLock
+    class Interrupt < Exception; end # rubocop:disable Lint/InheritException
+
+    class << self
+      attr_accessor :input_locks
+      attr_accessor :global_lock
+    end
+
+    self.input_locks = {}
+    self.global_lock = Mutex.new
+
+    def self.for(input)
+      # XXX This method leaks memory, as we never unregister an input once we
+      # are done with it. Fortunately, the leak is tiny (or so we hope).  In
+      # usual scenarios, we would leak the StringIO that is passed to be
+      # evaluated from the command line.
+      global_lock.synchronize do
+        input_locks[input] ||= Pry::InputLock.new
+      end
+    end
+
+    def initialize
+      @mutex = Mutex.new
+      @cond = ConditionVariable.new
+      @owners = []
+      @interruptible = false
+    end
+
+    # Adds ourselves to the ownership list. The last one in the list may access
+    # the input through interruptible_region().
+    def __with_ownership
+      @mutex.synchronize do
+        # Three cases:
+        # 1) There are no owners, in this case we are good to go.
+        # 2) The current owner of the input is not reading the input (it might
+        #    just be evaluating some ruby that the user typed).
+        #    The current owner will figure out that it cannot go back to reading
+        #    the input since we are adding ourselves to the @owners list, which
+        #    in turns makes us the current owner.
+        # 3) The owner of the input is in the interruptible region, reading from
+        #    the input. It's safe to send an Interrupt exception to interrupt
+        #    the owner. It will then proceed like in case 2).
+        #    We wait until the owner sets the interruptible flag back
+        #    to false, meaning that he's out of the interruptible region.
+        #    Note that the owner may receive multiple interrupts since, but that
+        #    should be okay (and trying to avoid it is futile anyway).
+        while @interruptible
+          @owners.last.raise Interrupt
+          @cond.wait(@mutex)
+        end
+        @owners << Thread.current
+      end
+
+      yield
+    ensure
+      @mutex.synchronize do
+        # We are releasing any desire to have the input ownership by removing
+        # ourselves from the list.
+        @owners.delete(Thread.current)
+
+        # We need to wake up the thread at the end of the @owners list, but
+        # sadly Ruby doesn't allow us to choose which one we wake up, so we wake
+        # them all up.
+        @cond.broadcast
+      end
+    end
+
+    def with_ownership(&block)
+      # If we are in a nested with_ownership() call (nested pry context), we do nothing.
+      nested = @mutex.synchronize { @owners.include?(Thread.current) }
+      nested ? yield : __with_ownership(&block)
+    end
+
+    def enter_interruptible_region
+      @mutex.synchronize do
+        # We patiently wait until we are the owner. This may happen as another
+        # thread calls with_ownership() because of a binding.pry happening in
+        # another thread.
+        @cond.wait(@mutex) until @owners.last == Thread.current
+
+        # We are the legitimate owner of the input. We mark ourselves as
+        # interruptible, so other threads can send us an Interrupt exception
+        # while we are blocking from reading the input.
+        @interruptible = true
+      end
+    end
+
+    def leave_interruptible_region
+      @mutex.synchronize do
+        # We check if we are still the owner, because we could have received an
+        # Interrupt right after the following @cond.broadcast, making us retry.
+        @interruptible = false if @owners.last == Thread.current
+        @cond.broadcast
+      end
+    rescue Interrupt
+      # We need to guard against a spurious interrupt delivered while we are
+      # trying to acquire the lock (the rescue block is no longer in our scope).
+      retry
+    end
+
+    def interruptible_region
+      enter_interruptible_region
+
+      # XXX Note that there is a chance that we get the interrupt right after
+      # the readline call succeeded, but we'll never know, and we will retry the
+      # call, discarding that piece of input.
+      yield
+    rescue Interrupt
+      # We were asked to back off. The one requesting the interrupt will be
+      # waiting on the conditional for the interruptible flag to change to false.
+      # Note that there can be some inefficiency, as we could immediately
+      # succeed in enter_interruptible_region(), even before the one requesting
+      # the ownership has the chance to register itself as an owner.
+      # To mitigate the issue, we sleep a little bit.
+      leave_interruptible_region
+      sleep 0.01
+      retry
+    ensure
+      leave_interruptible_region
+    end
+  end
+end

data/lib/pry/inspector.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+class Pry
+  class Inspector
+    MAP = {
+      "default" => {
+        value: Pry.config.print,
+        description: <<-DESCRIPTION.each_line.map(&:lstrip!)
+          The default Pry inspector. It has paging and color support, and uses
+          pretty_inspect when printing an object.
+        DESCRIPTION
+      },
+
+      "simple" => {
+        value: proc do |output, value|
+          begin
+            output.puts value.inspect
+          rescue RescuableException
+            output.puts "unknown"
+          end
+        end,
+        description: <<-DESCRIPTION.each_line.map(&:lstrip)
+          A simple inspector that uses #puts and #inspect when printing an
+          object. It has no pager, color, or pretty_inspect support.
+        DESCRIPTION
+      },
+
+      "clipped" => {
+        value: proc do |output, value|
+          output.puts Pry.view_clip(value, id: true)
+        end,
+        description: <<-DESCRIPTION.each_line.map(&:lstrip)
+          The clipped inspector has the same features as the 'simple' inspector
+          but prints large objects as a smaller string.
+        DESCRIPTION
+      }
+    }.freeze
+  end
+end

data/lib/pry/last_exception.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+#
+# {Pry::LastException} is a proxy class who wraps an Exception object for
+# {Pry#last_exception}. it extends the exception object with methods that
+# help pry commands be useful.
+#
+# the original exception object is not modified and method calls are forwarded
+# to the wrapped exception object.
+#
+class Pry
+  class LastException < BasicObject
+    attr_accessor :bt_index
+
+    def initialize(exception)
+      @exception = exception
+      @bt_index = 0
+      @file, @line = bt_source_location_for(0)
+    end
+
+    def method_missing(name, *args, &block)
+      if @exception.respond_to?(name)
+        @exception.public_send(name, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(name, include_all = false)
+      @exception.respond_to?(name, include_all)
+    end
+
+    #
+    # @return [String]
+    #  returns the path to a file for the current backtrace. see {#bt_index}.
+    #
+    attr_reader :file
+
+    #
+    # @return [Fixnum]
+    #  returns the line for the current backtrace. see {#bt_index}.
+    #
+    attr_reader :line
+
+    # @return [Exception]
+    #   returns the wrapped exception
+    #
+    def wrapped_exception
+      @exception
+    end
+
+    def bt_source_location_for(index)
+      backtrace[index] =~ /(.*):(\d+)/
+      [::Regexp.last_match(1), ::Regexp.last_match(2).to_i]
+    end
+
+    def inc_bt_index
+      @bt_index = (@bt_index + 1) % backtrace.size
+    end
+  end
+end

data/lib/pry/method/disowned.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Pry
   class Method
     # A Disowned Method is one that's been removed from the class on which it was defined.
@@ -20,8 +22,10 @@ class Pry
       #
       # @param [Object] receiver
       # @param [String] method_name
-      def initialize(receiver, method_name, binding=nil)
-        @receiver, @name = receiver, method_name
+      def initialize(receiver, method_name)
+        @receiver = receiver
+        @name = method_name
+        @method = nil
       end
 
       # Is the method undefined? (aka `Disowned`)
@@ -44,9 +48,19 @@ class Pry
       end
 
       # 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)
+      # rubocop:disable Style/MethodMissingSuper
+      def method_missing(method_name, *args, &block)
+        if method(:name).respond_to?(method_name)
+          raise "Cannot call '#{method_name}' on an undef'd method."
+        end
+
+        method = Object.instance_method(:method_missing).bind(self)
+        method.call(method_name, *args, &block)
+      end
+      # rubocop:enable Style/MethodMissingSuper
+
+      def respond_to_missing?(method_name, include_private = false)
+        !method(:name).respond_to?(method_name) || super
       end
     end
   end