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:



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

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

#aliasesHash (readonly) Originally defined in class NamespaceObject

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

#attributesHash (readonly) Originally defined in class NamespaceObject

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

#base_docstringDocstring (readonly) Originally defined in class Base

The non-localized documentation string associated with the object

Since:

  • 0.8.4

#child(opts = {}) ⇒ Base? Originally defined in class NamespaceObject

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>

#childrenArray<Base> (readonly) Originally defined in class NamespaceObject

The list of objects defined in this namespace

#class_attributesHash Originally defined in class NamespaceObject

Only the class attributes

See Also:

#class_mixinsArray<ModuleObject> (readonly) Originally defined in class NamespaceObject

Class mixins

#constants(opts = {}) ⇒ Array<ConstantObject> Originally defined in class NamespaceObject

Returns all constants in the namespace

Options Hash (opts):

  • :included (Boolean) — default: true

    whether or not to include mixed in constants in list

#cvarsArray<ClassVariableObject> Originally defined in class NamespaceObject

Returns class variables defined in this namespace.

#dynamicBoolean Originally defined in class Base

Marks whether or not the method is conditionally defined at runtime

#filesArray<String> (readonly) Originally defined in class Base

The files the object was defined in. To add a file, use #add_file.

See Also:

#groupString Originally defined in class Base

Returns the group this object is associated with

Since:

  • 0.6.0

#groupsArray<String> Originally defined in class NamespaceObject

Returns a list of ordered group names inside the namespace

Since:

  • 0.6.0

#included_constantsArray<ConstantObject> Originally defined in class NamespaceObject

Returns constants included from any mixins

#included_meths(opts = {}) ⇒ Object Originally defined in class NamespaceObject

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

  • :visibility (Array<Symbol>, Symbol) — default: [:public, :private, :protected]

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

  • :scope (Array<Symbol>, Symbol) — default: [:class, :instance]

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

  • :included (Boolean) — default: true

    whether to include mixed in methods in the list.

See Also:

#instance_attributesHash Originally defined in class NamespaceObject

Only the instance attributes

See Also:

#instance_mixinsArray<ModuleObject> (readonly) Originally defined in class NamespaceObject

Instance mixins

#meths(opts = {}) ⇒ Array<MethodObject> Originally defined in class NamespaceObject

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

  • :visibility (Array<Symbol>, Symbol) — default: [:public, :private, :protected]

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

  • :scope (Array<Symbol>, Symbol) — default: [:class, :instance]

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

  • :included (Boolean) — default: true

    whether to include mixed in methods in the list.

#mixins(*scopes) ⇒ Array<ModuleObject> Originally defined in class NamespaceObject

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

#namespaceNamespaceObject Also known as: parent Originally defined in class Base

The namespace the object is defined in. If the object is in the top level namespace, this is Registry.root

#signatureString Originally defined in class Base

The one line signature representing an object. For a method, this will be of the form “def meth(arguments…)”. This is usually the first source line.

#sourceString? Originally defined in class Base

The source code associated with the object

#source_typeSymbol Originally defined in class Base

Language of the source code associated with the object. Defaults to :ruby.

#superclassClassObject

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



7
8
9
# File 'lib/yard/code_objects/class_object.rb', line 7

def superclass
  @superclass
end

#visibilitySymbol Originally defined in class Base

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



98
99
100
101
# File 'lib/yard/code_objects/class_object.rb', line 98

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.



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

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.



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

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.



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

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



32
33
34
# File 'lib/yard/code_objects/class_object.rb', line 32

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



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

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