class YARD::CodeObjects::NamespaceObject

A “namespace” is any object that can store other objects within itself. The two main Ruby objects that can act as namespaces are modules ({ModuleObject}) and classes ({ClassObject}).

Attributes

aliases[R]

A hash containing two keys, :class and :instance, each containing a hash of objects and their alias names. @return [Hash] a list of methods

attributes[R]

A hash containing two keys, class and instance, each containing the attribute name with a { :read, :write } hash for the read and write objects respectively.

@example The attributes of an object

>> Registry.at('YARD::Docstring').attributes
=> {
      :class => { },
      :instance => {
        :ref_tags => {
          :read => #<yardoc method YARD::Docstring#ref_tags>,
          :write => nil
        },
        :object => {
          :read => #<yardoc method YARD::Docstring#object>,
          :write => #<yardoc method YARD::Docstring#object=>
         },
         ...
      }
    }

@return [Hash] a list of methods

child[W]
children[R]

The list of objects defined in this namespace @return [Array<Base>] a list of objects

class_attributes[W]
class_mixins[R]

Class mixins @return [Array<ModuleObject>] a list of mixins

constants[W]
cvars[W]
groups[RW]

@return [Array<String>] a list of ordered group names inside the namespace @since 0.6.0

included_constants[W]
included_meths[W]
instance_attributes[W]
instance_mixins[R]

Instance mixins @return [Array<ModuleObject>] a list of mixins

meths[W]
mixins[W]

Public Class Methods

new(namespace, name, *args, &block) click to toggle source

Creates a new namespace object inside namespace with name. @see Base#initialize

Calls superclass method YARD::CodeObjects::Base.new
# File lib/yard/code_objects/namespace_object.rb, line 56
def initialize(namespace, name, *args, &block)
  @children = CodeObjectList.new(self)
  @class_mixins = CodeObjectList.new(self)
  @instance_mixins = CodeObjectList.new(self)
  @attributes = SymbolHash[:class => SymbolHash.new, :instance => SymbolHash.new]
  @aliases = {}
  @groups = []
  super
end

Public Instance Methods

child(opts = {}) click to toggle source

Looks for a child that matches the attributes specified by opts.

@example Finds a child by name and scope

namespace.child(:name => :to_s, :scope => :instance)
# => #<yardoc method MyClass#to_s>

@return [Base, nil] the first matched child object, or nil

# File lib/yard/code_objects/namespace_object.rb, line 86
def child(opts = {})
  if !opts.is_a?(Hash)
    children.find {|o| o.name == opts.to_sym }
  else
    opts = SymbolHash[opts]
    children.find do |obj|
      opts.each do |meth, value|
        break false if !(value.is_a?(Array) ? value.include?(obj[meth]) : obj[meth] == value)
      end
    end
  end
end
class_attributes() click to toggle source

Only the class attributes @return [Hash] a list of method names and their read/write objects @see attributes

# File lib/yard/code_objects/namespace_object.rb, line 69
def class_attributes
  attributes[:class]
end
constants(opts = {}) click to toggle source

Returns all constants in the namespace

@option opts [Boolean] :included (true) whether or not to include

mixed in constants in list

@return [Array<ConstantObject>] a list of constant objects

# File lib/yard/code_objects/namespace_object.rb, line 164
def constants(opts = {})
  opts = SymbolHash[:included => true].update(opts)
  consts = children.select {|o| o.is_a? ConstantObject }
  consts + (opts[:included] ? included_constants : [])
end
cvars() click to toggle source

Returns class variables defined in this namespace. @return [Array<ClassVariableObject>] a list of class variable objects

# File lib/yard/code_objects/namespace_object.rb, line 186
def cvars
  children.select {|o| o.is_a? ClassVariableObject }
end
included_constants() click to toggle source

Returns constants included from any mixins @return [Array<ConstantObject>] a list of constant objects

# File lib/yard/code_objects/namespace_object.rb, line 172
def included_constants
  instance_mixins.inject([]) do |list, mixin|
    if mixin.respond_to? :constants
      list += mixin.constants.reject do |o|
        child(:name => o.name) || list.find {|o2| o2.name == o.name }
      end
    else
      list
    end
  end
end
included_meths(opts = {}) click to toggle source

Returns methods included from any mixins that match the attributes specified by opts. If no options are specified, returns all included methods.

@option opts [Array<Symbol>, Symbol] :visibility ([:public, :private,

:protected]) the visibility of the methods to list. Can be an array or
single value.

@option opts [Array<Symbol>, Symbol] :scope ([:class, :instance]) the

scope of the methods to list. Can be an array or single value.

@option opts [Boolean] :included (true) whether to include mixed in

methods in the list.

@see meths

# File lib/yard/code_objects/namespace_object.rb, line 144
def included_meths(opts = {})
  opts = SymbolHash[:scope => [:instance, :class]].update(opts)
  [opts[:scope]].flatten.map do |scope|
    mixins(scope).inject([]) do |list, mixin|
      next list if mixin.is_a?(Proxy)
      arr = mixin.meths(opts.merge(:scope => :instance)).reject do |o|
        next false if opts[:all]
        child(:name => o.name, :scope => scope) || list.find {|o2| o2.name == o.name }
      end
      arr.map! {|o| ExtendedMethodObject.new(o) } if scope == :class
      list + arr
    end
  end.flatten
end
instance_attributes() click to toggle source

Only the instance attributes @return [Hash] a list of method names and their read/write objects @see attributes

# File lib/yard/code_objects/namespace_object.rb, line 76
def instance_attributes
  attributes[:instance]
end
meths(opts = {}) click to toggle source

Returns all methods that match the attributes specified by opts. If no options are provided, returns all methods.

@example Finds all private and protected class methods

namespace.meths(:visibility => [:private, :protected], :scope => :class)
# => [#<yardoc method MyClass.privmeth>, #<yardoc method MyClass.protmeth>]

@option opts [Array<Symbol>, Symbol] :visibility ([:public, :private,

:protected]) the visibility of the methods to list. Can be an array or
single value.

@option opts [Array<Symbol>, Symbol] :scope ([:class, :instance]) the

scope of the methods to list. Can be an array or single value.

@option opts [Boolean] :included (true) whether to include mixed in

methods in the list.

@return [Array<MethodObject>] a list of method objects

# File lib/yard/code_objects/namespace_object.rb, line 113
def meths(opts = {})
  opts = SymbolHash[
    :visibility => [:public, :private, :protected],
    :scope => [:class, :instance],
    :included => true
  ].update(opts)

  opts[:visibility] = [opts[:visibility]].flatten
  opts[:scope] = [opts[:scope]].flatten

  ourmeths = children.select do |o|
    o.is_a?(MethodObject) &&
      opts[:visibility].include?(o.visibility) &&
      opts[:scope].include?(o.scope)
  end

  ourmeths + (opts[:included] ? included_meths(opts) : [])
end
mixins(*scopes) click to toggle source

Returns for specific scopes. If no scopes are provided, returns all mixins. @param [Array<Symbol>] scopes a list of scopes (:class, :instance) to

return mixins for. If this is empty, all scopes will be returned.

@return [Array<ModuleObject>] a list of mixins

# File lib/yard/code_objects/namespace_object.rb, line 194
def mixins(*scopes)
  return class_mixins if scopes == [:class]
  return instance_mixins if scopes == [:instance]
  class_mixins | instance_mixins
end