Class: Pry::Method::WeirdMethodLocator

Inherits:
Object
  • Object
show all
Defined in:
lib/pry/method/weird_method_locator.rb

Overview

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.

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(method, target) ⇒ WeirdMethodLocator

Returns a new instance of WeirdMethodLocator

Parameters:

  • method (Pry::Method)

    The seed method.

  • target (Binding)

    The Binding that captures the method we want to locate.



49
50
51
# File 'lib/pry/method/weird_method_locator.rb', line 49

def initialize(method, target)
  @method, @target = method, target
end

Instance Attribute Details

#methodObject

Returns the value of attribute method



43
44
45
# File 'lib/pry/method/weird_method_locator.rb', line 43

def method
  @method
end

#targetObject

Returns the value of attribute target



44
45
46
# File 'lib/pry/method/weird_method_locator.rb', line 44

def target
  @target
end

Class Method Details

.normal_method?(method, b) ⇒ Boolean

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.

Parameters:

Returns:

  • (Boolean)


28
29
30
31
32
33
34
35
36
# File 'lib/pry/method/weird_method_locator.rb', line 28

def normal_method?(method, b)
  if method and method.source_file and method.source_range
    binding_file, binding_line = b.eval('__FILE__'), b.eval('__LINE__')
    File.expand_path(method.source_file) == File.expand_path(binding_file) and
    method.source_range.include?(binding_line)
  end
rescue
  false
end

.weird_method?(method, b) ⇒ Boolean

Returns:

  • (Boolean)


38
39
40
# File 'lib/pry/method/weird_method_locator.rb', line 38

def weird_method?(method, b)
  not normal_method?(method, b)
end

Instance Method Details

#all_methods_for(obj) ⇒ Object (private)



192
193
194
195
196
# File 'lib/pry/method/weird_method_locator.rb', line 192

def all_methods_for(obj)
  obj.public_methods(false) +
    obj.private_methods(false) +
    obj.protected_methods(false)
end

#expanded_source_location(sl) ⇒ Object (private)



146
147
148
149
150
151
152
153
154
# File 'lib/pry/method/weird_method_locator.rb', line 146

def expanded_source_location(sl)
  return if !sl

  if pry_file?
    sl
  else
    [File.expand_path(sl.first), sl.last]
  end
end

#find_method_in_superclassPry::Method? (private)

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.

Returns:

  • (Pry::Method, nil)

    The Pry::Method representing the superclass method.



108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
# File 'lib/pry/method/weird_method_locator.rb', line 108

def find_method_in_superclass
  guess = method
  if skip_superclass_search?
    return guess
  end
  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 normal_method?(guess)
      return guess
    elsif guess != guess.super
      guess = guess.super
    else
      break
    end
  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)
  nil
end

#find_renamed_methodPry::Method? (private)

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.

Returns:

  • (Pry::Method, nil)

    The Pry::Method representing the renamed method



137
138
139
140
141
142
143
144
# File 'lib/pry/method/weird_method_locator.rb', line 137

def find_renamed_method
  return if !valid_file?(target_file)
  alias_name = all_methods_for(target_self).find do |v|
    expanded_source_location(target_self.method(v).source_location) == renamed_method_source_location
  end

  alias_name && Pry::Method(target_self.method(alias_name))
end

#get_methodPry::Method?

Returns The Pry::Method that matches the given binding.

Returns:

  • (Pry::Method, nil)

    The Pry::Method that matches the given binding.



55
56
57
# File 'lib/pry/method/weird_method_locator.rb', line 55

def get_method
  find_method_in_superclass || find_renamed_method
end

#index_to_line_number(index) ⇒ Object (private)



174
175
176
177
# File 'lib/pry/method/weird_method_locator.rb', line 174

def index_to_line_number(index)
  # Pry.line_buffer is 0-indexed
  pry_file? ? index : index + 1
end

#lines_for_file(file) ⇒ Object (private)



183
184
185
186
187
188
189
190
# File 'lib/pry/method/weird_method_locator.rb', line 183

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

#lost_method?Boolean

Returns Whether the Pry::Method is unrecoverable This usually happens when the method captured by the Binding has been subsequently deleted.

Returns:

  • (Boolean)

    Whether the Pry::Method is unrecoverable This usually happens when the method captured by the Binding has been subsequently deleted.



62
63
64
# File 'lib/pry/method/weird_method_locator.rb', line 62

def lost_method?
  !!(get_method.nil? && renamed_method_source_location)
end

#normal_method?(method) ⇒ Boolean (private)

Returns:

  • (Boolean)


73
74
75
# File 'lib/pry/method/weird_method_locator.rb', line 73

def normal_method?(method)
  self.class.normal_method?(method, target)
end

#pry_file?Boolean (private)

Returns:

  • (Boolean)


89
90
91
# File 'lib/pry/method/weird_method_locator.rb', line 89

def pry_file?
  Pry.eval_path == target.eval('__FILE__')
end

#renamed_method_source_locationArray<String, Fixnum> (private)

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.

Returns:

  • (Array<String, Fixnum>)

    The source_location of the renamed method



163
164
165
166
167
168
169
170
171
172
# File 'lib/pry/method/weird_method_locator.rb', line 163

def renamed_method_source_location
  return @original_method_source_location if defined?(@original_method_source_location)

  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?Boolean (private)

Returns:

  • (Boolean)


68
69
70
71
# File 'lib/pry/method/weird_method_locator.rb', line 68

def skip_superclass_search?
  target_mod = @target.eval('self').class
  target_mod.ancestors.take_while {|mod| mod != target_mod }.any?
end

#target_fileObject (private)



81
82
83
# File 'lib/pry/method/weird_method_locator.rb', line 81

def target_file
  pry_file? ? target.eval('__FILE__') : File.expand_path(target.eval('__FILE__'))
end

#target_lineObject (private)



85
86
87
# File 'lib/pry/method/weird_method_locator.rb', line 85

def target_line
  target.eval('__LINE__')
end

#target_selfObject (private)



77
78
79
# File 'lib/pry/method/weird_method_locator.rb', line 77

def target_self
  target.eval('self')
end

#valid_file?(file) ⇒ Boolean (private)

Returns:

  • (Boolean)


179
180
181
# File 'lib/pry/method/weird_method_locator.rb', line 179

def valid_file?(file)
  (File.exist?(file) && !File.directory?(file)) || Pry.eval_path == file
end