pry 0.12.2-java → 0.13.0-java

data/lib/pry/input_lock.rb

@@ -1,10 +1,12 @@
+# 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
+    class Interrupt < Exception; end # rubocop:disable Lint/InheritException
 
     class << self
       attr_accessor :input_locks
@@ -33,7 +35,7 @@ class Pry
 
     # Adds ourselves to the ownership list. The last one in the list may access
     # the input through interruptible_region().
-    def __with_ownership(&block)
+    def __with_ownership
       @mutex.synchronize do
         # Three cases:
         # 1) There are no owners, in this case we are good to go.
@@ -56,8 +58,7 @@ class Pry
         @owners << Thread.current
       end
 
-      block.call
-
+      yield
     ensure
       @mutex.synchronize do
         # We are releasing any desire to have the input ownership by removing
@@ -74,7 +75,7 @@ class Pry
     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 ? block.call : __with_ownership(&block)
+      nested ? yield : __with_ownership(&block)
     end
 
     def enter_interruptible_region
@@ -104,14 +105,13 @@ class Pry
       retry
     end
 
-    def interruptible_region(&block)
+    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.
-      block.call
-
+      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.
@@ -122,7 +122,6 @@ class Pry
       leave_interruptible_region
       sleep 0.01
       retry
-
     ensure
       leave_interruptible_region
     end

data/lib/pry/inspector.rb

@@ -1,27 +1,39 @@
-class Pry::Inspector
-  MAP = {
-    "default" => {
-      value: Pry::DEFAULT_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
-    },
+# frozen_string_literal: true
 
-    "simple" => {
-      value: Pry::SIMPLE_PRINT,
-      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
-    },
+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
+      },
 
-    "clipped" => {
-      value: Pry::CLIPPED_PRINT,
-      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
-    }
-  }
+      "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

@@ -1,3 +1,5 @@
+# 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
@@ -6,56 +8,54 @@
 # the original exception object is not modified and method calls are forwarded
 # to the wrapped exception object.
 #
-class Pry::LastException < BasicObject
-  attr_accessor :bt_index
-
-  def initialize(e)
-    @e = e
-    @bt_index = 0
-    @file, @line = bt_source_location_for(0)
-  end
-
-  def method_missing(name, *args, &block)
-    if @e.respond_to?(name)
-      @e.public_send(name, *args, &block)
-    else
-      super
+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
-  end
-
-  def respond_to_missing?(name, include_all = false)
-    @e.respond_to?(name, include_all)
-  end
 
-  #
-  # @return [String]
-  #  returns the path to a file for the current backtrace. see {#bt_index}.
-  #
-  def file
-    @file
-  end
+    def method_missing(name, *args, &block)
+      if @exception.respond_to?(name)
+        @exception.public_send(name, *args, &block)
+      else
+        super
+      end
+    end
 
-  #
-  # @return [Fixnum]
-  #  returns the line for the current backtrace. see {#bt_index}.
-  #
-  def line
-    @line
-  end
+    def respond_to_missing?(name, include_all = false)
+      @exception.respond_to?(name, include_all)
+    end
 
-  # @return [Exception]
-  #   returns the wrapped exception
-  #
-  def wrapped_exception
-    @e
-  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+)/
-    [$1, $2.to_i]
-  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
+    def inc_bt_index
+      @bt_index = (@bt_index + 1) % backtrace.size
+    end
   end
 end

data/lib/pry/method.rb

@@ -1,4 +1,6 @@
-require 'pry/helpers/documentation_helpers'
+# frozen_string_literal: true
+
+require 'method_source'
 
 class Pry
   class << self
@@ -15,51 +17,52 @@ class Pry
 
   # This class wraps the normal `Method` and `UnboundMethod` classes
   # to provide extra functionality useful to Pry.
-  class Method
-    require 'pry/method/weird_method_locator'
-    require 'pry/method/disowned'
-    require 'pry/method/patcher'
-
+  class Method # rubocop:disable Metrics/ClassLength
     extend Helpers::BaseHelpers
+    extend Forwardable
+
     include Helpers::BaseHelpers
     include Helpers::DocumentationHelpers
     include CodeObject::Helpers
 
     class << self
       # Given a string representing a method name and optionally a binding to
-      # search in, find and return the requested method wrapped in a `Pry::Method`
-      # instance.
+      # search in, find and return the requested method wrapped in a
+      # `Pry::Method` instance.
       #
       # @param [String] name The name of the method to retrieve.
       # @param [Binding] target The context in which to search for the method.
       # @param [Hash] options
-      # @option options [Boolean] :instance Look for an instance method if `name` doesn't
-      #   contain any context.
-      # @option options [Boolean] :methods Look for a bound/singleton method if `name` doesn't
-      #   contain any context.
-      # @return [Pry::Method, nil] A `Pry::Method` instance containing the requested
-      #   method, or `nil` if name is `nil` or no method could be located matching the parameters.
+      # @option options [Boolean] :instance Look for an instance method if
+      #   `name` doesn't contain any context.
+      # @option options [Boolean] :methods Look for a bound/singleton method if
+      #  `name` doesn't contain any context.
+      # @return [Pry::Method, nil] A `Pry::Method` instance containing the
+      #   requested method, or `nil` if name is `nil` or no method could be
+      #   located matching the parameters.
       def from_str(name, target = TOPLEVEL_BINDING, options = {})
         if name.nil?
           nil
         elsif name.to_s =~ /(.+)\#(\S+)\Z/
-          context, meth_name = $1, $2
+          context = Regexp.last_match(1)
+          meth_name = Regexp.last_match(2)
           from_module(target.eval(context), meth_name, target)
         elsif name.to_s =~ /(.+)(\[\])\Z/
-          context, meth_name = $1, $2
+          context = Regexp.last_match(1)
+          meth_name = Regexp.last_match(2)
           from_obj(target.eval(context), meth_name, target)
         elsif name.to_s =~ /(.+)(\.|::)(\S+)\Z/
-          context, meth_name = $1, $3
+          context = Regexp.last_match(1)
+          meth_name = Regexp.last_match(3)
           from_obj(target.eval(context), meth_name, target)
         elsif options[:instance]
           from_module(target.eval("self"), name, target)
         elsif options[:methods]
           from_obj(target.eval("self"), name, target)
         else
-          from_str(name, target, instance: true) or
+          from_str(name, target, instance: true) ||
             from_str(name, target, methods: true)
         end
-
       rescue Pry::RescuableException
         nil
       end
@@ -68,26 +71,33 @@ class Pry
       # use it to instantiate a `Pry::Method`. Return `nil` if this isn't
       # possible.
       #
-      # @param [Binding] b
+      # @param [Binding] binding
       # @return [Pry::Method, nil]
       #
-      def from_binding(b)
-        meth_name = b.eval('::Kernel.__method__')
+      def from_binding(binding)
+        meth_name = binding.eval('::Kernel.__method__')
         if [:__script__, nil].include?(meth_name)
           nil
         else
-          method = begin
-                     if Object === b.eval('self')
-                       new(Kernel.instance_method(:method).bind(b.eval("self")).call(meth_name))
-                     else
-                       new(b.eval('class << self; self; end.instance_method(::Kernel.__method__).bind(self)'))
-                     end
-                   rescue NameError, NoMethodError
-                     Disowned.new(b.eval('self'), meth_name.to_s)
-                   end
-
-          if WeirdMethodLocator.weird_method?(method, b)
-            WeirdMethodLocator.new(method, b).get_method || method
+          method =
+            begin
+              if Object === binding.eval('self') # rubocop:disable Style/CaseEquality
+                new(
+                  Kernel.instance_method(:method)
+                    .bind(binding.eval("self"))
+                    .call(meth_name)
+                )
+              else
+                str = 'class << self; self; end' \
+                      '.instance_method(::Kernel.__method__).bind(self)'
+                new(binding.eval(str))
+              end
+            rescue NameError, NoMethodError # rubocop:disable Lint/ShadowedException
+              Disowned.new(binding.eval('self'), meth_name.to_s)
+            end
+
+          if WeirdMethodLocator.weird_method?(method, binding)
+            WeirdMethodLocator.new(method, binding).find_method || method
           else
             method
           end
@@ -101,11 +111,16 @@ class Pry
       # @param [Symbol] method_type The type of method: :method or :instance_method
       # @param [Binding] target The binding where the method is looked up.
       # @return [Method, UnboundMethod] The 'refined' method object.
-      def lookup_method_via_binding(obj, method_name, method_type, target = TOPLEVEL_BINDING)
+      def lookup_method_via_binding(
+        obj, method_name, method_type, target = TOPLEVEL_BINDING
+      )
         Pry.current[:obj] = obj
         Pry.current[:name] = method_name
         receiver = obj.is_a?(Module) ? "Module" : "Kernel"
-        target.eval("::#{receiver}.instance_method(:#{method_type}).bind(Pry.current[:obj]).call(Pry.current[:name])")
+        target.eval(
+          "::#{receiver}.instance_method(:#{method_type})" \
+          ".bind(Pry.current[:obj]).call(Pry.current[:name])"
+        )
       ensure
         Pry.current[:obj] = Pry.current[:name] = nil
       end
@@ -119,7 +134,9 @@ class Pry
       # @param [Binding] target The binding where the method is looked up.
       # @return [Pry::Method, nil]
       def from_class(klass, name, target = TOPLEVEL_BINDING)
-        new(lookup_method_via_binding(klass, name, :instance_method, target)) rescue nil
+        new(lookup_method_via_binding(klass, name, :instance_method, target))
+      rescue StandardError
+        nil
       end
       alias from_module from_class
 
@@ -132,7 +149,9 @@ class Pry
       # @param [Binding] target The binding where the method is looked up.
       # @return [Pry::Method, nil]
       def from_obj(obj, name, target = TOPLEVEL_BINDING)
-        new(lookup_method_via_binding(obj, name, :method, target)) rescue nil
+        new(lookup_method_via_binding(obj, name, :method, target))
+      rescue StandardError
+        nil
       end
 
       # Get all of the instance methods of a `Class` or `Module`
@@ -140,9 +159,14 @@ 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).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)
+        %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
       end
@@ -161,24 +185,19 @@ class Pry
         all_from_class(singleton_class_of(obj), include_super)
       end
 
-      #
-      # @deprecated
-      #  please use {all_from_obj} instead.
-      #  the `method_type` argument is ignored.
-      #
-      def all_from_common(obj, _method_type = nil, include_super = true)
-        all_from_obj(obj, include_super)
-      end
-
       # Get every `Class` and `Module`, in order, that will be checked when looking
       # for an instance method to call on this object.
       # @param [Object] obj
       # @return [Array[Class, Module]]
       def resolution_order(obj)
-        if Class === obj
+        if Class === obj # rubocop:disable Style/CaseEquality
           singleton_class_resolution_order(obj) + instance_resolution_order(Class)
         else
-          klass = singleton_class_of(obj) rescue obj.class
+          klass = begin
+                    singleton_class_of(obj)
+                  rescue StandardError
+                    obj.class
+                  end
           instance_resolution_order(klass)
         end
       end
@@ -199,11 +218,17 @@ class Pry
       end
 
       def singleton_method_definition?(name, definition_line)
-        /^define_singleton_method\(?\s*[:\"\']#{Regexp.escape(name)}|^def\s*self\.#{Regexp.escape(name)}/ =~ definition_line.strip
+        regexp =
+          /^define_singleton_method\(?\s*[:\"\']#{Regexp.escape(name)}|
+           ^def\s*self\.#{Regexp.escape(name)}/x
+        regexp =~ definition_line.strip
       end
 
       def instance_method_definition?(name, definition_line)
-        /^define_method\(?\s*[:\"\']#{Regexp.escape(name)}|^def\s*#{Regexp.escape(name)}/ =~ definition_line.strip
+        regexp =
+          /^define_method\(?\s*[:\"\']#{Regexp.escape(name)}|
+           ^def\s*#{Regexp.escape(name)}/x
+        regexp =~ definition_line.strip
       end
 
       # Get the singleton classes of superclasses that could define methods on
@@ -220,15 +245,17 @@ class Pry
       end
 
       def singleton_class_of(obj)
-        begin
-          class << obj; self; end
-        rescue TypeError # can't define singleton. Fixnum, Symbol, Float, ...
-          obj.class
-        end
+        class << obj; self; end
+      rescue TypeError # can't define singleton. Fixnum, Symbol, Float, ...
+        obj.class
       end
     end
 
-    # A new instance of `Pry::Method` wrapping the given `::Method`, `UnboundMethod`, or `Proc`.
+    # Workaround for https://github.com/pry/pry/pull/2086
+    def_delegators :@method, :owner, :parameters, :receiver
+
+    # A new instance of `Pry::Method` wrapping the given `::Method`,
+    # `UnboundMethod`, or `Proc`.
     #
     # @param [::Method, UnboundMethod, Proc] method
     # @param [Hash] known_info Can be used to pre-cache expensive to compute stuff.
@@ -238,7 +265,9 @@ class Pry
       @visibility = known_info[:visibility]
     end
 
-    # Get the name of the method as a String, regardless of the underlying Method#name type.
+    # Get the name of the method as a String, regardless of the underlying
+    # Method#name type.
+    #
     # @return [String]
     def name
       @method.name.to_s
@@ -342,15 +371,16 @@ class Pry
     # @return [Symbol] The visibility of the method. May be `:public`,
     #   `:protected`, or `:private`.
     def visibility
-     @visibility ||= if owner.public_instance_methods.any? { |m| m.to_s == name }
-                       :public
-                     elsif owner.protected_instance_methods.any? { |m| m.to_s == name }
-                       :protected
-                     elsif owner.private_instance_methods.any? { |m| m.to_s == name }
-                       :private
-                     else
-                       :none
-                     end
+      @visibility ||=
+        if owner.public_instance_methods.any? { |m| m.to_s == name }
+          :public
+        elsif owner.protected_instance_methods.any? { |m| m.to_s == name }
+          :protected
+        elsif owner.private_instance_methods.any? { |m| m.to_s == name }
+          :private
+        else
+          :none
+        end
     end
 
     # @return [String] A representation of the method's signature, including its
@@ -385,7 +415,7 @@ class Pry
     # @return [Pry::Method, nil] The wrapped method that is called when you
     #   use "super" in the body of this method.
     def super(times = 1)
-      if UnboundMethod === @method
+      if @method.is_a?(UnboundMethod)
         sup = super_using_ancestors(Pry::Method.instance_resolution_order(owner), times)
       else
         sup = super_using_ancestors(Pry::Method.resolution_order(receiver), times)
@@ -404,7 +434,7 @@ class Pry
 
     # @return [Boolean] Was the method defined outside a source file?
     def dynamically_defined?
-      !!(source_file and source_file =~ /(\(.*\))|<.*>/)
+      !!(source_file && source_file =~ /(\(.*\))|<.*>/)
     end
 
     # @return [Boolean] Whether the method is unbound.
@@ -450,30 +480,36 @@ class Pry
     end
 
     # @return [Boolean]
-    def ==(obj)
-      if obj.is_a? Pry::Method
-        obj == @method
-      else
-        @method == obj
-      end
+    def ==(other)
+      return other == @method if other.is_a?(Pry::Method)
+
+      @method == other
     end
 
     # @param [Class] klass
     # @return [Boolean]
     def is_a?(klass)
-      klass == Pry::Method or @method.is_a?(klass)
+      (klass == Pry::Method) || @method.is_a?(klass)
     end
     alias kind_of? is_a?
 
     # @param [String, Symbol] method_name
     # @return [Boolean]
     def respond_to?(method_name, include_all = false)
-      super or @method.respond_to?(method_name, include_all)
+      super || @method.respond_to?(method_name, include_all)
     end
 
     # Delegate any unknown calls to the wrapped method.
     def method_missing(method_name, *args, &block)
-      @method.send(method_name, *args, &block)
+      if @method.respond_to?(method_name)
+        @method.__send__(method_name, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      @method.respond_to?(method_name) || super
     end
 
     def comment
@@ -485,12 +521,17 @@ class Pry
     # @return [YARD::CodeObjects::MethodObject]
     # @raise [CommandError] when the method can't be found or `pry-doc` isn't installed.
     def pry_doc_info
-      if Pry.config.has_pry_doc
-        Pry::MethodInfo.info_for(@method) or raise CommandError, "Cannot locate this method: #{name}. (source_location returns nil)"
+      if defined?(PryDoc)
+        Pry::MethodInfo.info_for(@method) ||
+          raise(
+            CommandError,
+            "Cannot locate this method: #{name}. (source_location returns nil)"
+          )
       else
         fail_msg = "Cannot locate this method: #{name}."
         if Helpers::Platform.mri?
-          fail_msg += " Invoke the 'gem-install pry-doc' Pry command to get access to Ruby Core documentation.\n"
+          fail_msg += " Invoke the 'gem-install pry-doc' Pry command to get " \
+                      "access to Ruby Core documentation.\n"
         end
         raise CommandError, fail_msg
       end
@@ -499,16 +540,22 @@ class Pry
     # @param [Class, Module] ancestors The ancestors to investigate
     # @return [Method] The unwrapped super-method
     def super_using_ancestors(ancestors, times = 1)
-      next_owner = self.owner
+      next_owner = owner
       times.times do
         i = ancestors.index(next_owner) + 1
-        while ancestors[i] && !(ancestors[i].method_defined?(name) || ancestors[i].private_method_defined?(name))
+        while ancestors[i] &&
+              !(ancestors[i].method_defined?(name) ||
+                ancestors[i].private_method_defined?(name))
           i += 1
         end
-        next_owner = ancestors[i] or return nil
+        (next_owner = ancestors[i]) || (return nil)
       end
 
-      safe_send(next_owner, :instance_method, name) rescue nil
+      begin
+        safe_send(next_owner, :instance_method, name)
+      rescue StandardError
+        nil
+      end
     end
 
     # @param [String] first_ln The first line of a method definition.
@@ -516,7 +563,7 @@ class Pry
     def method_name_from_first_line(first_ln)
       return nil if first_ln.strip !~ /^def /
 
-      tokens = CodeRay.scan(first_ln, :ruby)
+      tokens = SyntaxHighlighter.tokenize(first_ln)
       tokens = tokens.tokens.each_slice(2) if tokens.respond_to?(:tokens)
       tokens.each_cons(2) do |t1, t2|
         if t2.last == :method || t2.last == :ident && t1 == [".", :operator]
@@ -529,9 +576,7 @@ class Pry
 
     def c_source
       info = pry_doc_info
-      if info and info.source
-        strip_comments_from_c_code(info.source)
-      end
+      strip_comments_from_c_code(info.source) if info && info.source
     end
 
     def ruby_source
@@ -539,12 +584,14 @@ class Pry
       # hacked version of `source_location` for our input buffer for methods
       # defined in `(pry)`.
       file, line = *source_location
-      raise SourceNotFoundError, "Could not locate source for #{name_with_owner}!" unless file
+      unless file
+        raise SourceNotFoundError, "Could not locate source for #{name_with_owner}!"
+      end
 
       begin
         code = Pry::Code.from_file(file).expression_at(line)
       rescue SyntaxError => e
-        raise MethodSource::SourceNotFoundError.new(e.message)
+        raise MethodSource::SourceNotFoundError, e.message
       end
       strip_leading_whitespace(code)
     end