Class: YARD::CodeObjects::NamespaceObject

Inherits:
Base
  • Object
show all
Defined in:
lib/yard/code_objects/namespace_object.rb

Overview

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).

Instance Attribute Summary

Instance Method Summary

Methods inherited from Base

#==, ===, #[], #[]=, #add_file, #dynamic?, #file, #format, #format_source, #has_tag?, #inspect, #line, #method_missing, #name, new, #parent, #parent=, #path, #relative_path, #root?, #sep, #tag, #tags, #to_s, #type

Constructor Details

- (NamespaceObject) initialize(namespace, name, *args, &block)

Creates a new namespace object inside namespace with name.

See Also:



52
53
54
55
56
57
58
59
 
# File 'lib/yard/code_objects/namespace_object.rb', line 52

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 = {}
  super
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method in the class YARD::CodeObjects::Base

Instance Attribute Details

- (Hash) aliases (readonly)

A hash containing two keys, :class and :instance, each containing a hash of objects and their alias names.

Returns:

  • (Hash) — a list of methods 


40
41
42
 
# File 'lib/yard/code_objects/namespace_object.rb', line 40

def aliases
  @aliases
end

- (Hash) attributes (readonly)

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.

Examples:

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=> 
           },
           ...
        }
      }

Returns:

  • (Hash) — a list of methods 


35
36
37
 
# File 'lib/yard/code_objects/namespace_object.rb', line 35

def attributes
  @attributes
end

- (Base?) child(opts = {}) (readonly)

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

Examples:

Finds a child by name and scope 

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

Returns:

  • (Base, nil) — the first matched child object, or nil 


81
82
83
84
85
86
87
88
89
90
91
92
 
# File 'lib/yard/code_objects/namespace_object.rb', line 81

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

- (Array<Base>) children (readonly)

The list of objects defined in this namespace

Returns:



12
13
14
 
# File 'lib/yard/code_objects/namespace_object.rb', line 12

def children
  @children
end

- (Hash) class_attributes (readonly)

Only the class attributes

Returns:

  • (Hash) — a list of method names and their read/write objects

See Also:



64
65
66
 
# File 'lib/yard/code_objects/namespace_object.rb', line 64

def class_attributes
  attributes[:class]
end

- (Array<ModuleObject>) class_mixins (readonly)

Class mixins

Returns:



44
45
46
 
# File 'lib/yard/code_objects/namespace_object.rb', line 44

def class_mixins
  @class_mixins
end

- (Array<ConstantObject>) constants(opts = {}) (readonly)

Returns all constants in the namespace

Options Hash (opts):

  • (Boolean) :included — default: true — whether or not to include mixed in constants in list

Returns:



158
159
160
161
162
 
# File 'lib/yard/code_objects/namespace_object.rb', line 158

def constants(opts = {})
  opts = SymbolHash[:included => true].update(opts)
  consts = children.select {|o| o.is_a? ConstantObject }
  consts + (opts[:included] ? included_constants : [])
end

- (Array<ClassVariableObject>) cvars (readonly)

Returns class variables defined in this namespace.

Returns:



180
181
182
 
# File 'lib/yard/code_objects/namespace_object.rb', line 180

def cvars 
  children.select {|o| o.is_a? ClassVariableObject }
end

- (Array<ConstantObject>) included_constants (readonly)

Returns constants included from any mixins

Returns:



166
167
168
169
170
171
172
173
174
175
176
 
# File 'lib/yard/code_objects/namespace_object.rb', line 166

def included_constants
  instance_mixins.reverse.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

- (Object) included_meths(opts = {}) (readonly)

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

Options Hash (opts):

  • (Array<Symbol>, Symbol) :visibility — default: [:public, :private, :protected] — the visibility of the methods to list. Can be an array or single value.
  • (Array<Symbol>, Symbol) :scope — default: [:class, :instance] — the scope of the methods to list. Can be an array or single value.
  • (Boolean) :included — default: true — whether to include mixed in methods in the list.

See Also:



139
140
141
142
143
144
145
146
147
148
149
150
151
 
# File 'lib/yard/code_objects/namespace_object.rb', line 139

def included_meths(opts = {})
  opts = SymbolHash[:scope => [:instance, :class]].update(opts)
  [opts[:scope]].flatten.map do |scope|
    mixins(scope).reverse.inject([]) do |list, mixin|
      next list if mixin.is_a?(Proxy)
      arr = mixin.meths(opts.merge(:scope => :instance)).reject do |o|
        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

- (Hash) instance_attributes (readonly)

Only the instance attributes

Returns:

  • (Hash) — a list of method names and their read/write objects

See Also:



71
72
73
 
# File 'lib/yard/code_objects/namespace_object.rb', line 71

def instance_attributes 
  attributes[:instance]
end

- (Array<ModuleObject>) instance_mixins (readonly)

Instance mixins

Returns:



48
49
50
 
# File 'lib/yard/code_objects/namespace_object.rb', line 48

def instance_mixins
  @instance_mixins
end

- (Array<MethodObject>) meths(opts = {}) (readonly)

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

Examples:

Finds all private and protected class methods 

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

Options Hash (opts):

  • (Array<Symbol>, Symbol) :visibility — default: [:public, :private, :protected] — the visibility of the methods to list. Can be an array or single value.
  • (Array<Symbol>, Symbol) :scope — default: [:class, :instance] — the scope of the methods to list. Can be an array or single value.
  • (Boolean) :included — default: true — whether to include mixed in methods in the list.

Returns:



108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
 
# File 'lib/yard/code_objects/namespace_object.rb', line 108

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

- (Array<ModuleObject>) mixins(*scopes) (readonly)

Returns for specific scopes. If no scopes are provided, returns all mixins.

Parameters:

  • (Array<Symbol>) scopes — a list of scopes (:class, :instance) to return mixins for. If this is empty, all scopes will be returned.

Returns:



188
189
190
191
192
 
# File 'lib/yard/code_objects/namespace_object.rb', line 188

def mixins(*scopes)
  return class_mixins if scopes == [:class]
  return instance_mixins if scopes == [:instance]
  class_mixins | instance_mixins
end