class RSpec::Mocks::MethodReference

Represents a method on an object that may or may not be defined. The method may be an instance method on a module or a method on any object.

@private

Public Class Methods

for(object_reference, method_name) click to toggle source
# File lib/rspec/mocks/method_reference.rb, line 11
def self.for(object_reference, method_name)
  new(object_reference, method_name)
end
new(object_reference, method_name) click to toggle source
# File lib/rspec/mocks/method_reference.rb, line 15
def initialize(object_reference, method_name)
  @object_reference = object_reference
  @method_name = method_name
end

Private Class Methods

instance_method_visibility_for(klass, method_name) click to toggle source
# File lib/rspec/mocks/method_reference.rb, line 75
def self.instance_method_visibility_for(klass, method_name)
  if klass.public_method_defined?(method_name)
    :public
  elsif klass.private_method_defined?(method_name)
    :private
  elsif klass.protected_method_defined?(method_name)
    :protected
  end
end
method_defined_at_any_visibility?(klass, method_name)
method_visibility_for(object, method_name) click to toggle source
# File lib/rspec/mocks/method_reference.rb, line 89
def self.method_visibility_for(object, method_name)
  vis = instance_method_visibility_for(class << object; self; end, method_name)

  # If the method is not defined on the class, `instance_method_visibility_for`
  # returns `nil`. However, it may be handled dynamically by `method_missing`,
  # so here we check `respond_to` (passing false to not check private methods).
  #
  # This only considers the public case, but I don't think it's possible to
  # write `method_missing` in such a way that it handles a dynamic message
  # with private or protected visibility. Ruby doesn't provide you with
  # the caller info.
  return vis unless vis.nil?

  proxy = RSpec::Mocks.space.proxy_for(object)
  respond_to = proxy.method_double_if_exists_for_message(:respond_to?)

  visible = respond_to && respond_to.original_method.call(method_name) ||
    object.respond_to?(method_name)

  return :public if visible
end

Public Instance Methods

defined?() click to toggle source

A method is defined if we are able to get a `Method` object for it. In that case, we can assert against metadata like the arity.

# File lib/rspec/mocks/method_reference.rb, line 46
def defined?
  @object_reference.when_loaded do |m|
    method_defined?(m)
  end
end
implemented?() click to toggle source

A method is implemented if sending the message does not result in a `NoMethodError`. It might be dynamically implemented by `method_missing`.

# File lib/rspec/mocks/method_reference.rb, line 23
def implemented?
  @object_reference.when_loaded do |m|
    method_implemented?(m)
  end
end
unimplemented?() click to toggle source

Returns true if we definitively know that sending the method will result in a `NoMethodError`.

This is not simply the inverse of `implemented?`: there are cases when we don't know if a method is implemented and both `implemented?` and `unimplemented?` will return false.

# File lib/rspec/mocks/method_reference.rb, line 35
def unimplemented?
  @object_reference.when_loaded do |_m|
    return !implemented?
  end

  # If it's not loaded, then it may be implemented but we can't check.
  false
end
visibility() click to toggle source
# File lib/rspec/mocks/method_reference.rb, line 57
def visibility
  @object_reference.when_loaded do |m|
    return visibility_from(m)
  end

  # When it's not loaded, assume it's public. We don't want to
  # wrongly treat the method as private.
  :public
end
with_signature() { |method_signature| ... } click to toggle source
# File lib/rspec/mocks/method_reference.rb, line 52
def with_signature
  return unless (original = original_method)
  yield Support::MethodSignature.new(original)
end

Private Instance Methods

original_method() click to toggle source
# File lib/rspec/mocks/method_reference.rb, line 69
def original_method
  @object_reference.when_loaded do |m|
    self.defined? && find_method(m)
  end
end