class Pry::Method::WeirdMethodLocator

This class is responsible for locating the real `Pry::Method` object captured by a binding.

Given a `Binding` from inside a method and a 'seed' Pry::Method object, there are primarily two situations where the seed method doesn't match the Binding:

  1. The Pry::Method is from a subclass

  2. The Pry::Method represents a method of the same name while the original

was renamed to something else. For 1. we search vertically up the inheritance chain, and for 2. we search laterally along the object's method table.

When we locate the method that matches the Binding we wrap it in Pry::Method and return it, or return nil if we fail.

Attributes

method[RW]
target[RW]

Public Class Methods

new(method, target) click to toggle source

@param [Pry::Method] method The seed method. @param [Binding] target The Binding that captures the method

we want to locate.
# File lib/pry/method/weird_method_locator.rb, line 54
def initialize(method, target)
  @method = method
  @target = target
end
normal_method?(method, binding) click to toggle source

Whether the given method object matches the associated binding. If the method object does not match the binding, then it's most likely not the method captured by the binding, and we must commence a search.

@param [Pry::Method] method @param [Binding] binding @return [Boolean]

# File lib/pry/method/weird_method_locator.rb, line 28
def normal_method?(method, binding)
  if method && method.source_file && method.source_range
    if binding.respond_to?(:source_location)
      binding_file, binding_line = binding.source_location
    else
      binding_file = binding.eval('__FILE__')
      binding_line = binding.eval('__LINE__')
    end
    (File.expand_path(method.source_file) == File.expand_path(binding_file)) &&
      method.source_range.include?(binding_line)
  end
rescue StandardError
  false
end
weird_method?(method, binding) click to toggle source
# File lib/pry/method/weird_method_locator.rb, line 43
def weird_method?(method, binding)
  !normal_method?(method, binding)
end

Public Instance Methods

find_method() click to toggle source

@return [Pry::Method, nil] The Pry::Method that matches the

given binding.
# File lib/pry/method/weird_method_locator.rb, line 61
def find_method
  find_method_in_superclass || find_renamed_method
end
lost_method?() click to toggle source

@return [Boolean] Whether the Pry::Method is unrecoverable

This usually happens when the method captured by the Binding
has been subsequently deleted.
# File lib/pry/method/weird_method_locator.rb, line 68
def lost_method?
  !!(find_method.nil? && renamed_method_source_location)
end

Private Instance Methods

all_methods_for(obj) click to toggle source
# File lib/pry/method/weird_method_locator.rb, line 214
def all_methods_for(obj)
  obj.public_methods(false) +
    obj.private_methods(false) +
    obj.protected_methods(false)
end
expanded_source_location(source_location) click to toggle source
# File lib/pry/method/weird_method_locator.rb, line 166
def expanded_source_location(source_location)
  return unless source_location

  if pry_file?
    source_location
  else
    [File.expand_path(source_location.first), source_location.last]
  end
end
find_method_in_superclass() click to toggle source

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__.

@return [Pry::Method, nil] The Pry::Method representing the

superclass method.
# File lib/pry/method/weird_method_locator.rb, line 130
def find_method_in_superclass
  guess = method
  return guess if skip_superclass_search?

  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
    return guess if normal_method?(guess)
    break if guess == guess.super

    guess = guess.super
  end

  # Uhoh... none of the methods in the chain had the right `__FILE__` and
  # `__LINE__` due to unknown circumstances.
  # TODO: we should warn the user when this happens.
  nil
end
find_renamed_method() click to toggle source

This is the case where the name of a method has changed (via alias_method) so we locate the Method object for the renamed method.

@return [Pry::Method, nil] The Pry::Method representing the

renamed method
# File lib/pry/method/weird_method_locator.rb, line 155
def find_renamed_method
  return unless valid_file?(target_file)

  alias_name = all_methods_for(target_self).find do |v|
    location = target_self.method(v).source_location
    expanded_source_location(location) == renamed_method_source_location
  end

  alias_name && Pry::Method(target_self.method(alias_name))
end
index_to_line_number(index) click to toggle source
# File lib/pry/method/weird_method_locator.rb, line 196
def index_to_line_number(index)
  # Pry.line_buffer is 0-indexed
  pry_file? ? index : index + 1
end
lines_for_file(file) click to toggle source
# File lib/pry/method/weird_method_locator.rb, line 205
def lines_for_file(file)
  @lines_for_file ||= {}
  @lines_for_file[file] ||= if Pry.eval_path == file
                              Pry.line_buffer
                            else
                              File.readlines(file)
                            end
end
normal_method?(method) click to toggle source
# File lib/pry/method/weird_method_locator.rb, line 79
def normal_method?(method)
  self.class.normal_method?(method, target)
end
pry_file?() click to toggle source
# File lib/pry/method/weird_method_locator.rb, line 105
def pry_file?
  file =
    if target.respond_to?(:source_location)
      target.source_location.first
    else
      target.eval('__FILE__')
    end
  Pry.eval_path == file
end
renamed_method_source_location() click to toggle source

Use static analysis to locate the start of the method definition. We have the `__FILE__` and `__LINE__` from the binding and the original name of the method so we search up until we find a def/define_method, etc defining a method of the appropriate name.

@return [Array<String, Fixnum>] The `source_location` of the

renamed method
# File lib/pry/method/weird_method_locator.rb, line 183
def renamed_method_source_location
  if defined?(@original_method_source_location)
    return @original_method_source_location
  end

  source_index = lines_for_file(target_file)[0..(target_line - 1)].rindex do |v|
    Pry::Method.method_definition?(method.name, v)
  end

  @original_method_source_location =
    source_index && [target_file, index_to_line_number(source_index)]
end
skip_superclass_search?() click to toggle source
# File lib/pry/method/weird_method_locator.rb, line 74
def skip_superclass_search?
  target_mod = @target.eval('self').class
  target_mod.ancestors.take_while { |mod| mod != target_mod }.any?
end
target_file() click to toggle source
# File lib/pry/method/weird_method_locator.rb, line 87
def target_file
  file =
    if target.respond_to?(:source_location)
      target.source_location.first
    else
      target.eval('__FILE__')
    end
  pry_file? ? file : File.expand_path(file)
end
target_line() click to toggle source
# File lib/pry/method/weird_method_locator.rb, line 97
def target_line
  if target.respond_to?(:source_location)
    target.source_location.last
  else
    target.eval('__LINE__')
  end
end
target_self() click to toggle source
# File lib/pry/method/weird_method_locator.rb, line 83
def target_self
  target.eval('self')
end
valid_file?(file) click to toggle source
# File lib/pry/method/weird_method_locator.rb, line 201
def valid_file?(file)
  (File.exist?(file) && !File.directory?(file)) || Pry.eval_path == file
end