Class: YARD::CodeObjects::ClassObject

Inherits:
NamespaceObject show all
Defined in:
lib/yard/code_objects/class_object.rb

Overview

A ClassObject represents a Ruby class in source code. It is a ModuleObject with extra inheritance semantics through the superclass.

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(namespace, name, *args, &block) ⇒ ClassObject

Creates a new class object in namespace with name

See Also:



14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# File 'lib/yard/code_objects/class_object.rb', line 14

def initialize(namespace, name, *args, &block)
  super

  if is_exception?
    self.superclass ||= "::Exception" unless P(namespace, name) == P(:Exception)
  else
    case P(namespace, name).path
    when "BasicObject"
      nil
    when "Object"
      self.superclass ||= "::BasicObject"
    else
      self.superclass ||= "::Object"
    end
  end
end

Dynamic Method Handling

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

Instance Attribute Details

#superclassClassObject

The YARD::CodeObjects::ClassObject that this class object inherits from in Ruby source.



9
10
11
# File 'lib/yard/code_objects/class_object.rb', line 9

def superclass
  @superclass
end

Instance Method Details

#constants(opts = {}) ⇒ Array<ConstantObject>

Returns the list of constants matching the options hash.

Options Hash (opts):

  • :inherited (Boolean) — default: true

    whether inherited constant should be included in the list

  • :included (Boolean) — default: true

    whether mixed in constant should be included in the list



100
101
102
103
# File 'lib/yard/code_objects/class_object.rb', line 100

def constants(opts = {})
  opts = SymbolHash[:inherited => true].update(opts)
  super(opts) + (opts[:inherited] ? inherited_constants : [])
end

#inheritance_tree(include_mods = false) ⇒ Array<NamespaceObject>

Returns the inheritance tree of the object including self.



44
45
46
47
48
49
50
51
52
53
54
# File 'lib/yard/code_objects/class_object.rb', line 44

def inheritance_tree(include_mods = false)
  list = (include_mods ? mixins(:instance, :class) : [])
  if superclass.is_a?(Proxy) || superclass.respond_to?(:inheritance_tree)
    list += [superclass] unless superclass == P(:Object) || superclass == P(:BasicObject)
  end
  [self] + list.map do |m|
    next m if m == self
    next m unless m.respond_to?(:inheritance_tree)
    m.inheritance_tree(include_mods)
  end.flatten.uniq
end

#inherited_constantsArray<ConstantObject>

Returns only the constants that were inherited.



108
109
110
111
112
113
114
115
116
117
118
# File 'lib/yard/code_objects/class_object.rb', line 108

def inherited_constants
  inheritance_tree[1..-1].inject([]) do |list, superclass|
    if superclass.is_a?(Proxy)
      list
    else
      list += superclass.constants.reject do |o|
        child(:name => o.name) || list.find {|o2| o2.name == o.name }
      end
    end
  end
end

#inherited_meths(opts = {}) ⇒ Array<MethodObject>

Returns only the methods that were inherited.



78
79
80
81
82
83
84
85
86
87
88
89
90
# File 'lib/yard/code_objects/class_object.rb', line 78

def inherited_meths(opts = {})
  inheritance_tree[1..-1].inject([]) do |list, superclass|
    if superclass.is_a?(Proxy)
      list
    else
      list += superclass.meths(opts).reject do |o|
        next(false) if opts[:all]
        child(:name => o.name, :scope => o.scope) ||
          list.find {|o2| o2.name == o.name && o2.scope == o.scope }
      end
    end
  end
end

#is_exception?Boolean

Whether or not the class is a Ruby Exception



34
35
36
# File 'lib/yard/code_objects/class_object.rb', line 34

def is_exception?
  inheritance_tree.reverse.any? {|o| BUILTIN_EXCEPTIONS_HASH.has_key? o.path }
end

#meths(opts = {}) ⇒ Array<MethodObject>

Returns the list of methods matching the options hash. Returns all methods if hash is empty.

Options Hash (opts):

  • :inherited (Boolean) — default: true

    whether inherited methods should be included in the list

  • :included (Boolean) — default: true

    whether mixed in methods should be included in the list



65
66
67
68
69
70
71
72
73
# File 'lib/yard/code_objects/class_object.rb', line 65

def meths(opts = {})
  opts = SymbolHash[:inherited => true].update(opts)
  list = super(opts)
  list += inherited_meths(opts).reject do |o|
    next(false) if opts[:all]
    list.find {|o2| o2.name == o.name && o2.scope == o.scope }
  end if opts[:inherited]
  list
end