Parent

Class/Module Index [+]

Quicksearch

YARD::CodeObjects::Proxy

The Proxy class is a way to lazily resolve code objects in cases where the object may not yet exist. A proxy simply stores an unresolved path until a method is called on the object, at which point it does a lookup using {Registry.resolve}. If the object is not found, a warning is raised and {ProxyMethodError} might be raised.

@example Creates a Proxy to the String class from a module

# When the String class is parsed this method will
# begin to act like the String ClassObject.
Proxy.new(mymoduleobj, "String")

@see Registry.resolve @see ProxyMethodError

Attributes

namespace[R]
parent[R]

Public Class Methods

===(other) click to toggle source
# File lib/yard/code_objects/proxy.rb, line 19
def self.===(other) other.is_a?(self) end
new(namespace, name, type = nil) click to toggle source

Creates a new Proxy

@raise [ArgumentError] if namespace is not a NamespaceObject @return [Proxy] self

# File lib/yard/code_objects/proxy.rb, line 28
def initialize(namespace, name, type = nil)
  namespace = Registry.root if !namespace || namespace == :root

  if name =~ /^#{NSEPQ}/
    namespace = Registry.root
    name = name[2..-1]
  end

  if name =~ /(?:#{NSEPQ}|#{ISEPQ}|#{CSEPQ})([^#{NSEPQ}#{ISEPQ}#{CSEPQ}]+)$/
    @orignamespace, @origname = namespace, name
    @imethod = true if name.include? ISEP
    namespace = Proxy.new(namespace, $`) unless $`.empty?
    name = $1
  else
    @orignamespace, @origname, @imethod = nil, nil, nil
  end

  @name = name.to_sym
  @namespace = namespace
  @obj = nil
  @imethod ||= nil
  self.type = type

  if @namespace.is_a?(ConstantObject)
    @origname = nil # forget these for a constant
    @orignamespace = nil
    @namespace = Proxy.new(@namespace.namespace, @namespace.value)
  end

  unless @namespace.is_a?(NamespaceObject) or @namespace.is_a?(Proxy)
    raise ArgumentError, "Invalid namespace object: #{namespace}"
  end

  # If the name begins with "::" (like "::String")
  # this is definitely a root level object, so
  # remove the namespace and attach it to the root
  if @name =~ /^#{NSEPQ}/
    @name.gsub!(/^#{NSEPQ}/, '')
    @namespace = Registry.root
  end
end

Public Instance Methods

<=>(other) click to toggle source

@return [Boolean]

# File lib/yard/code_objects/proxy.rb, line 119
def <=>(other)
  if other.respond_to? :path
    path <=> other.path
  else
    false
  end
end
==(other) click to toggle source
Alias for: equal?
===(other) click to toggle source

@return [Boolean]

# File lib/yard/code_objects/proxy.rb, line 110
def ===(other)
  if obj = to_obj
    obj === other
  else
    self.class <= other.class
  end
end
class() click to toggle source

Returns the class name of the object the proxy is mimicking, if resolved. Otherwise returns Proxy. @return [Class] the resolved object's class or Proxy

# File lib/yard/code_objects/proxy.rb, line 143
def class
  if obj = to_obj
    obj.class
  else
    Proxy
  end
end
equal?(other) click to toggle source

@return [Boolean]

# File lib/yard/code_objects/proxy.rb, line 128
def equal?(other)
  if other.respond_to? :path
    path == other.path
  else
    false
  end
end
Also aliased as: ==
hash() click to toggle source

@return [Integer] the object's hash value (for equality checking)

# File lib/yard/code_objects/proxy.rb, line 138
def hash; path.hash end
inspect() click to toggle source

Returns a text representation of the Proxy @return [String] the object's inspect method or P(OBJECTPATH)

# File lib/yard/code_objects/proxy.rb, line 77
def inspect
  if obj = to_obj
    obj.inspect
  else
    "P(#{path})"
  end
end
instance_of?(klass) click to toggle source

@return [Boolean]

# File lib/yard/code_objects/proxy.rb, line 170
def instance_of?(klass)
  self.class == klass
end
is_a?(klass) click to toggle source

@return [Boolean]

# File lib/yard/code_objects/proxy.rb, line 101
def is_a?(klass)
  if obj = to_obj
    obj.is_a?(klass)
  else
    self.class <= klass
  end
end
kind_of?(klass) click to toggle source

@return [Boolean]

# File lib/yard/code_objects/proxy.rb, line 175
def kind_of?(klass)
  self.class <= klass
end
method_missing(meth, *args, &block) click to toggle source

Dispatches the method to the resolved object.

@raise [ProxyMethodError] if the proxy cannot find the real object

# File lib/yard/code_objects/proxy.rb, line 191
def method_missing(meth, *args, &block)
  if obj = to_obj
    obj.__send__(meth, *args, &block)
  else
    log.warn "Load Order / Name Resolution Problem on #{path}:"
    log.warn "-"
    log.warn "Something is trying to call #{meth} on object #{path} before it has been recognized."
    log.warn "This error usually means that you need to modify the order in which you parse files"
    log.warn "so that #{path} is parsed before methods or other objects attempt to access it."
    log.warn "-"
    log.warn "YARD will recover from this error and continue to parse but you *may* have problems"
    log.warn "with your generated documentation. You should probably fix this."
    log.warn "-"
    begin
      super
    rescue NoMethodError
      raise ProxyMethodError, "Proxy cannot call method ##{meth} on object '#{path}'"
    end
  end
end
name(prefix = false) click to toggle source

(see Base#name)

# File lib/yard/code_objects/proxy.rb, line 71
def name(prefix = false)
  prefix ? (@imethod ? ISEP : '') + @name.to_s : @name
end
path() click to toggle source

If the proxy resolves to an object, returns its path, otherwise guesses at the correct path using the original namespace and name.

@return [String] the assumed path of the proxy (or the real path

of the resolved object)
# File lib/yard/code_objects/proxy.rb, line 90
def path
  if obj = to_obj
    obj.path
  else
    proxy_path
  end
end
Also aliased as: to_s, to_str
respond_to?(meth, include_private = false) click to toggle source

@return [Boolean]

# File lib/yard/code_objects/proxy.rb, line 180
def respond_to?(meth, include_private = false)
  if obj = to_obj
    obj.respond_to?(meth, include_private)
  else
    super
  end
end
root?() click to toggle source

This class is never a root object

# File lib/yard/code_objects/proxy.rb, line 213
def root?; false end
to_s() click to toggle source
Alias for: path
to_str() click to toggle source
Alias for: path
type() click to toggle source

Returns the type of the proxy. If it cannot be resolved at the time of the call, it will either return the inferred proxy type (see {type=}) or :proxy @return [Symbol] the Proxy's type @see type=

# File lib/yard/code_objects/proxy.rb, line 156
def type
  if obj = to_obj
    obj.type
  else
    @type || :proxy
  end
end
type=(type) click to toggle source

Allows a parser to infer the type of the proxy by its path. @param [to_sym] type the proxy's inferred type @return [void]

# File lib/yard/code_objects/proxy.rb, line 167
def type=(type) @type = type ? type.to_sym : nil end

[Validate]

Generated with the Darkfish Rdoc Generator 2.