pry 0.10.pre.1-java → 0.10.0.pre2-java

data/lib/pry/input_lock.rb

@@ -0,0 +1,132 @@
+require 'thread'
+
+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 << 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(&block)
+      @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
+
+      block.call
+
+    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 ? block.call : __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(&block)
+      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
+
+    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,27 @@
+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
+    },
+
+    "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
+    },
+
+    "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
+    }
+  }
+end

data/lib/pry/last_exception.rb

@@ -0,0 +1,61 @@
+#
+# {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::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
+    end
+  end
+
+  def respond_to_missing?(name, include_private = false)
+    @e.respond_to?(name)
+  end
+
+  #
+  # @return [String]
+  #  returns the path to a file for the current backtrace. see {#bt_index}.
+  #
+  def file
+    @file
+  end
+
+  #
+  # @return [Fixnum]
+  #  returns the line for the current backtrace. see {#bt_index}.
+  #
+  def line
+    @line
+  end
+
+  # @return [Exception]
+  #   returns the wrapped exception
+  #
+  def wrapped_exception
+    @e
+  end
+
+  def bt_source_location_for(index)
+    backtrace[index] =~ /(.*):(\d+)/
+    [$1, $2.to_i]
+  end
+
+  def inc_bt_index
+    @bt_index = (@bt_index + 1) % backtrace.size
+  end
+end

data/lib/pry/method.rb

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 require 'pry/helpers/documentation_helpers'
 
 class Pry
@@ -17,16 +16,21 @@ class Pry
   # This class wraps the normal `Method` and `UnboundMethod` classes
   # to provide extra functionality useful to Pry.
   class Method
-    include RbxMethod if Helpers::BaseHelpers.rbx?
+    require 'pry/method/weird_method_locator'
+    require 'pry/method/disowned'
+    require 'pry/method/patcher'
+
+    extend Helpers::BaseHelpers
+    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.
       #
-      # @param [String, nil] name The name of the method to retrieve, or `nil` to
-      #   delegate to `from_binding` instead.
+      # @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
@@ -34,24 +38,30 @@ class Pry
       # @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 no method could be located matching the parameters.
+      #   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?
-          from_binding(target)
+          nil
         elsif name.to_s =~ /(.+)\#(\S+)\Z/
           context, meth_name = $1, $2
-          from_module(target.eval(context), meth_name)
-        elsif name.to_s =~ /(.+)\.(\S+)\Z/
+          from_module(target.eval(context), meth_name, target)
+        elsif name.to_s =~ /(.+)(\[\])\Z/
           context, meth_name = $1, $2
-          from_obj(target.eval(context), meth_name)
+          from_obj(target.eval(context), meth_name, target)
+        elsif name.to_s =~ /(.+)(\.|::)(\S+)\Z/
+          context, meth_name = $1, $3
+          from_obj(target.eval(context), meth_name, target)
         elsif options[:instance]
-          from_module(target.eval("self"), name)
+          from_module(target.eval("self"), name, target)
         elsif options[:methods]
-          from_obj(target.eval("self"), name)
+          from_obj(target.eval("self"), name, target)
         else
           from_str(name, target, :instance => true) or
             from_str(name, target, :methods => true)
         end
+
+      rescue Pry::RescuableException
+        nil
       end
 
       # Given a `Binding`, try to extract the `::Method` it originated from and
@@ -62,59 +72,54 @@ class Pry
       # @return [Pry::Method, nil]
       #
       def from_binding(b)
-        meth_name = b.eval('__method__')
+        meth_name = b.eval('::Kernel.__method__')
         if [:__script__, nil].include?(meth_name)
           nil
         else
           method = begin
-                     new(b.eval("Object.instance_method(:method).bind(self).call(#{meth_name.to_s.inspect})"))
+                     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
 
-          # it's possible in some cases that the method we find by this approach is a sub-method of
-          # the one we're currently in, consider:
-          #
-          # class A; def b; binding.pry; end; end
-          # class B < A; def b; super; end; end
-          #
-          # Given that we can normally find the source_range of methods, and that we know which
-          # __FILE__ and __LINE__ the binding is at, we can hope to disambiguate these cases.
-          #
-          # This obviously won't work if the source is unavaiable for some reason, or if both
-          # methods have the same __FILE__ and __LINE__, or if we're in rbx where b.eval('__LINE__')
-          # is broken.
-          #
-          guess = method
-
-          while guess
-            # needs rescue if this is a Disowned method or a C method or something...
-            # TODO: Fix up the exception handling so we don't need a bare rescue
-            if (guess.source_file && guess.source_range rescue false) &&
-                File.expand_path(guess.source_file) == File.expand_path(b.eval('__FILE__')) &&
-                guess.source_range.include?(b.eval('__LINE__'))
-              return guess
-            else
-              guess = guess.super
-            end
+          if WeirdMethodLocator.weird_method?(method, b)
+            WeirdMethodLocator.new(method, b).get_method || method
+          else
+            method
           end
-
-          # Uhoh... none of the methods in the chain had the right __FILE__ and __LINE__
-          # This may be caused by rbx https://github.com/rubinius/rubinius/issues/953,
-          # or other unknown circumstances (TODO: we should warn the user when this happens)
-          method
         end
       end
 
+      # In order to support 2.0 Refinements we need to look up methods
+      # inside the relevant Binding.
+      # @param [Object] obj The owner/receiver of the method.
+      # @param [Symbol] method_name The name of the method.
+      # @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)
+        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])")
+      ensure
+        Pry.current[:obj] = Pry.current[:name] = nil
+      end
+
       # Given a `Class` or `Module` and the name of a method, try to
       # instantiate a `Pry::Method` containing the instance method of
       # that name. Return `nil` if no such method exists.
       #
       # @param [Class, Module] klass
       # @param [String] name
+      # @param [Binding] target The binding where the method is looked up.
       # @return [Pry::Method, nil]
-      def from_class(klass, name)
-        new(safe_send(klass, :instance_method, name)) rescue nil
+      def from_class(klass, name, target=TOPLEVEL_BINDING)
+        new(lookup_method_via_binding(klass, name, :instance_method, target)) rescue nil
       end
       alias from_module from_class
 
@@ -124,9 +129,10 @@ class Pry
       #
       # @param [Object] obj
       # @param [String] name
+      # @param [Binding] target The binding where the method is looked up.
       # @return [Pry::Method, nil]
-      def from_obj(obj, name)
-        new(safe_send(obj, :method, name)) rescue nil
+      def from_obj(obj, name, target=TOPLEVEL_BINDING)
+        new(lookup_method_via_binding(obj, name, :method, target)) rescue nil
       end
 
       # Get all of the instance methods of a `Class` or `Module`
@@ -134,15 +140,34 @@ class Pry
       # @param [Boolean] include_super Whether to include methods from ancestors.
       # @return [Array[Pry::Method]]
       def all_from_class(klass, include_super=true)
-        all_from_common(klass, :instance_method, include_super)
+        %w(public protected private).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
 
+      #
       # Get all of the methods on an `Object`
+      #
       # @param [Object] obj
-      # @param [Boolean] include_super Whether to include methods from ancestors.
+      #
+      # @param [Boolean] include_super
+      #   indicates whether or not to include methods from ancestors.
+      #
       # @return [Array[Pry::Method]]
+      #
       def all_from_obj(obj, include_super=true)
-        all_from_common(obj, :method, include_super)
+        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
@@ -153,7 +178,7 @@ class Pry
         if Class === obj
           singleton_class_resolution_order(obj) + instance_resolution_order(Class)
         else
-          klass = singleton_class(obj) rescue obj.class
+          klass = singleton_class_of(obj) rescue obj.class
           instance_resolution_order(klass)
         end
       end
@@ -165,46 +190,42 @@ class Pry
       # @return [Array[Class, Module]]
       def instance_resolution_order(klass)
         # include klass in case it is a singleton class,
-        ([klass] + klass.ancestors).uniq
+        ([klass] + Pry::Method.safe_send(klass, :ancestors)).uniq
       end
 
-      private
+      def method_definition?(name, definition_line)
+        singleton_method_definition?(name, definition_line) ||
+          instance_method_definition?(name, definition_line)
+      end
 
-      # See all_from_class and all_from_obj.
-      # If method_type is :instance_method, obj must be a `Class` or a `Module`
-      # If method_type is :method, obj can be any `Object`
-      #
-      # N.B. we pre-cache the visibility here to avoid O(N²) behaviour in "ls".
-      def all_from_common(obj, method_type, include_super=true)
-        %w(public protected private).map do |visibility|
-          safe_send(obj, :"#{visibility}_#{method_type}s", include_super).map do |method_name|
-            new(safe_send(obj, method_type, method_name), :visibility => visibility.to_sym)
-          end
-        end.flatten(1)
+      def singleton_method_definition?(name, definition_line)
+        /^define_singleton_method\(?\s*[:\"\']#{Regexp.escape(name)}|^def\s*self\.#{Regexp.escape(name)}/ =~ definition_line.strip
       end
 
-      # Acts like send but ignores any methods defined below Object or Class in the
-      # inheritance hierarchy.
-      # This is required to introspect methods on objects like Net::HTTP::Get that
-      # have overridden the `method` method.
-      def safe_send(obj, method, *args, &block)
-        (Module === obj ? Module : Object).instance_method(method).bind(obj).call(*args, &block)
+      def instance_method_definition?(name, definition_line)
+        /^define_method\(?\s*[:\"\']#{Regexp.escape(name)}|^def\s*#{Regexp.escape(name)}/ =~ definition_line.strip
       end
-      public :safe_send
 
       # Get the singleton classes of superclasses that could define methods on
       # the given class object, and any modules they include.
       # If a module is included at multiple points in the ancestry, only
       # the lowest copy will be returned.
       def singleton_class_resolution_order(klass)
-        resolution_order = klass.ancestors.map do |anc|
-          [singleton_class(anc)] + singleton_class(anc).included_modules if anc.is_a?(Class)
-        end.compact.flatten(1)
+        ancestors = Pry::Method.safe_send(klass, :ancestors)
+        resolution_order = ancestors.grep(Class).map do |anc|
+          [singleton_class_of(anc), *singleton_class_of(anc).included_modules]
+        end.flatten(1)
 
         resolution_order.reverse.uniq.reverse - Class.included_modules
       end
 
-      def singleton_class(obj); class << obj; self; end end
+      def singleton_class_of(obj)
+        begin
+          class << obj; self; end
+        rescue TypeError # can't define singleton. Fixnum, Symbol, Float, ...
+          obj.class
+        end
+      end
     end
 
     # A new instance of `Pry::Method` wrapping the given `::Method`, `UnboundMethod`, or `Proc`.
@@ -229,6 +250,12 @@ class Pry
       @wrapped_owner ||= Pry::WrappedModule.new(owner)
     end
 
+    # Get underlying object wrapped by this Pry::Method instance
+    # @return [Method, UnboundMethod, Proc]
+    def wrapped
+      @method
+    end
+
     # Is the method undefined? (aka `Disowned`)
     # @return [Boolean] false
     def undefined?
@@ -248,26 +275,18 @@ class Pry
     def source
       @source ||= case source_type
                   when :c
-                    info = pry_doc_info
-                    if info and info.source
-                      code = strip_comments_from_c_code(info.source)
-                    end
+                    c_source
                   when :ruby
-                    # clone of MethodSource.source_helper that knows to use our
-                    # hacked version of source_location for rbx core methods, and
-                    # our input buffer for methods defined in (pry)
-                    file, line = *source_location
-                    raise SourceNotFoundError, "Could not locate source for #{name_with_owner}!" unless file
-
-                    begin
-                      code = Pry::Code.from_file(file).expression_at(line)
-                    rescue SyntaxError => e
-                      raise MethodSource::SourceNotFoundError.new(e.message)
-                    end
-                    strip_leading_whitespace(code)
+                    ruby_source
                   end
     end
 
+    # Update the live copy of the method's source.
+    def redefine(source)
+      Patcher.new(self).patch_in_ram source
+      Pry::Method(owner.instance_method(name))
+    end
+
     # Can we get the source code for this method?
     # @return [Boolean]
     def source?
@@ -278,20 +297,13 @@ class Pry
 
     # @return [String, nil] The documentation for the method, or `nil` if it's
     #   unavailable.
-    # @raise [CommandError] Raises when the method was defined in the REPL.
     def doc
       @doc ||= case source_type
         when :c
           info = pry_doc_info
           info.docstring if info
         when :ruby
-          if Helpers::BaseHelpers.rbx? && !pry_method?
-            strip_leading_hash_and_whitespace_from_ruby_comments(core_doc)
-          elsif pry_method?
-            strip_leading_hash_and_whitespace_from_ruby_comments(doc_for_pry_method)
-          else
-            strip_leading_hash_and_whitespace_from_ruby_comments(@method.comment)
-          end
+          get_comment_content(comment)
         end
     end
 
@@ -301,20 +313,11 @@ class Pry
       source_location.nil? ? :c : :ruby
     end
 
-    def source_location
-      if @method.source_location && Helpers::BaseHelpers.rbx?
-        file, line = @method.source_location
-        [RbxPath.convert_path_to_full(file), line]
-      else
-        @method.source_location
-      end
-    end
-
     # @return [String, nil] The name of the file the method is defined in, or
     #   `nil` if the filename is unavailable.
     def source_file
       if source_location.nil?
-        if !Helpers::BaseHelpers.rbx? and source_type == :c
+        if !rbx? and source_type == :c
           info = pry_doc_info
           info.file if info
         end
@@ -398,11 +401,43 @@ class Pry
       !!(source_file and source_file =~ /(\(.*\))|<.*>/)
     end
 
+    # @return [Boolean] Whether the method is unbound.
+    def unbound_method?
+      is_a?(::UnboundMethod)
+    end
+
+    # @return [Boolean] Whether the method is bound.
+    def bound_method?
+      is_a?(::Method)
+    end
+
+    # @return [Boolean] Whether the method is a singleton method.
+    def singleton_method?
+      wrapped_owner.singleton_class?
+    end
+
     # @return [Boolean] Was the method defined within the Pry REPL?
     def pry_method?
       source_file == Pry.eval_path
     end
 
+    # @return [Array<String>] All known aliases for the method.
+    def aliases
+      owner = @method.owner
+      # Avoid using `to_sym` on {Method#name}, which returns a `String`, because
+      # it won't be garbage collected.
+      name = @method.name
+
+      all_methods_to_compare = owner.instance_methods | owner.private_instance_methods
+      alias_list = all_methods_to_compare.combination(2).select do |pair|
+        pair.include?(name) &&
+          owner.instance_method(pair.first) == owner.instance_method(pair.last)
+      end.flatten
+      alias_list.delete(name)
+
+      alias_list.map(&:to_s)
+    end
+
     # @return [Boolean] Is the method definitely an alias?
     def alias?
       name != original_name
@@ -435,113 +470,77 @@ class Pry
       @method.send(method_name, *args, &block)
     end
 
-    private
-      # @return [YARD::CodeObjects::MethodObject]
-      # @raise [CommandError] Raises 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)"
-        else
-          raise CommandError, "Cannot locate this method: #{name}. Try `gem install pry-doc` to get access to Ruby Core documentation."
-        end
-      end
-
-      # FIXME: a very similar method to this exists on WrappedModule: extract_doc_for_candidate
-      def doc_for_pry_method
-        _, line_num = source_location
-
-        buffer = ""
-        Pry.line_buffer[0..(line_num - 1)].each do |line|
-          # Add any line that is a valid ruby comment,
-          # but clear as soon as we hit a non comment line.
-          if (line =~ /^\s*#/) || (line =~ /^\s*$/)
-            buffer << line.lstrip
-          else
-            buffer.replace("")
-          end
-        end
+    def comment
+      Pry::Code.from_file(source_file).comment_describing(source_line)
+    end
 
-        buffer
-      end
+    private
 
-      # @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
-        times.times do
-          i = ancestors.index(next_owner) + 1
-          while ancestors[i] && !(ancestors[i].method_defined?(name) || ancestors[i].private_method_defined?(name))
-            i += 1
-          end
-          next_owner = ancestors[i] or return nil
+    # @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)"
+      else
+        fail_msg = "Cannot locate this method: #{name}."
+        if mri?
+          fail_msg += ' Try `gem-install pry-doc` to get access to Ruby Core documentation.'
         end
-        next_owner.instance_method(name) rescue nil
+        raise CommandError, fail_msg
       end
+    end
 
-      # @param [String] first_ln The first line of a method definition.
-      # @return [String, nil]
-      def method_name_from_first_line(first_ln)
-        return nil if first_ln.strip !~ /^def /
-
-        tokens = CodeRay.scan(first_ln, :ruby)
-        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]
-            return t2.first
-          end
+    # @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
+      times.times do
+        i = ancestors.index(next_owner) + 1
+        while ancestors[i] && !(ancestors[i].method_defined?(name) || ancestors[i].private_method_defined?(name))
+          i += 1
         end
-
-        nil
+        next_owner = ancestors[i] or return nil
       end
 
-    # A Disowned Method is one that's been removed from the class on which it was defined.
-    #
-    # e.g.
-    # class C
-    #   def foo
-    #     C.send(:undefine_method, :foo)
-    #     Pry::Method.from_binding(binding)
-    #   end
-    # end
-    #
-    # In this case we assume that the "owner" is the singleton class of the receiver.
-    #
-    # This occurs mainly in Sinatra applications.
-    class Disowned < Method
-      attr_reader :receiver, :name
+      safe_send(next_owner, :instance_method, name) rescue nil
+    end
 
-      # Create a new Disowned method.
-      #
-      # @param [Object] receiver
-      # @param [String] method_name
-      def initialize(receiver, method_name)
-        @receiver, @name = receiver, method_name
-      end
+    # @param [String] first_ln The first line of a method definition.
+    # @return [String, nil]
+    def method_name_from_first_line(first_ln)
+      return nil if first_ln.strip !~ /^def /
 
-      # Is the method undefined? (aka `Disowned`)
-      # @return [Boolean] true
-      def undefined?
-        true
+      tokens = CodeRay.scan(first_ln, :ruby)
+      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]
+          return t2.first
+        end
       end
 
-      # Can we get the source for this method?
-      # @return [Boolean] false
-      def source?
-        false
-      end
+      nil
+    end
 
-      # Get the hypothesized owner of the method.
-      #
-      # @return [Object]
-      def owner
-        class << receiver; self; end
+    def c_source
+      info = pry_doc_info
+      if info and info.source
+        strip_comments_from_c_code(info.source)
       end
+    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)
+    def ruby_source
+      # clone of MethodSource.source_helper that knows to use our
+      # hacked version of source_location for rbx core methods, and
+      # our input buffer for methods defined in (pry)
+      file, line = *source_location
+      raise SourceNotFoundError, "Could not locate source for #{name_with_owner}!" unless file
+
+      begin
+        code = Pry::Code.from_file(file).expression_at(line)
+      rescue SyntaxError => e
+        raise MethodSource::SourceNotFoundError.new(e.message)
       end
+      strip_leading_whitespace(code)
     end
   end
 end