Method: YARD::Registry.resolve

Defined in:

lib/yard/registry.rb

.resolve(namespace, name, inheritance = false, proxy_fallback = false, type = nil) ⇒ CodeObjects::Base, ...

Attempts to find an object by name starting at namespace, performing a lookup similar to Ruby’s method of resolving a constant in a namespace.

Examples:

Looks for instance method #reverse starting from A::B::C

Registry.resolve(P("A::B::C"), "#reverse")

Looks for a constant in the root namespace

Registry.resolve(nil, 'CONSTANT')

Looks for a class method respecting the inheritance tree

Registry.resolve(myclass, 'mymethod', true)

Looks for a constant but returns a proxy if not found

Registry.resolve(P('A::B::C'), 'D', false, true) # => #<yardoc proxy A::B::C::D>

Looks for a complex path from a namespace

Registry.resolve(P('A::B'), 'B::D') # => #<yardoc class A::B::D>

Parameters:

• namespace (CodeObjects::NamespaceObject, nil) —

  the starting namespace (module or class). If nil or :root, starts from the root object.

• name (String, Symbol) —

  the name (or complex path) to look for from namespace.

• inheritance (Boolean) (defaults to: false) —

  Follows inheritance chain (mixins, superclass) when performing name resolution if set to true.

• proxy_fallback (Boolean) (defaults to: false) —

  If true, returns a proxy representing the unresolved path (namespace + name) if no object is found.

• type (Symbol, nil) (defaults to: nil) —

  the CodeObjects::Base#type that the resolved object must be equal to. No type checking if nil.

Returns:

• (CodeObjects::Base) —

  the object if it is found

• (CodeObjects::Proxy) —

  a Proxy representing the object if proxy_fallback is true.

• (nil) —

  if proxy_fallback is false and no object was found.

See Also:

• P

# File 'lib/yard/registry.rb', line 303

def resolve(namespace, name, inheritance = false, proxy_fallback = false, type = nil)
  thread_local_resolver.lookup_by_path name,
    :namespace => namespace, :inheritance => inheritance,
    :proxy_fallback => proxy_fallback, :type => type
end