class RDoc::ClassModule
ClassModule
is the base class for objects representing either a class or a module.
Attributes
Comment and the location it came from. Use add_comment
to add comments
Constants that are aliases for this class or module
Class or module this constant is an alias for
Public Class Methods
Return a RDoc::ClassModule
of class class_type
that is a copy of module module
. Used to promote modules to classes.
# File rdoc/class_module.rb, line 50 def self.from_module class_type, mod klass = class_type.new mod.name mod.comment_location.each do |comment, location| klass.add_comment comment, location end klass.parent = mod.parent klass.section = mod.section klass.viewer = mod.viewer klass.attributes.concat mod.attributes klass.method_list.concat mod.method_list klass.aliases.concat mod.aliases klass.external_aliases.concat mod.external_aliases klass.constants.concat mod.constants klass.includes.concat mod.includes klass.extends.concat mod.extends klass.methods_hash.update mod.methods_hash klass.constants_hash.update mod.constants_hash klass.current_section = mod.current_section klass.in_files.concat mod.in_files klass.sections.concat mod.sections klass.unmatched_alias_lists = mod.unmatched_alias_lists klass.current_section = mod.current_section klass.visibility = mod.visibility klass.classes_hash.update mod.classes_hash klass.modules_hash.update mod.modules_hash klass.metadata.update mod.metadata klass.document_self = mod.received_nodoc ? nil : mod.document_self klass.document_children = mod.document_children klass.force_documentation = mod.force_documentation klass.done_documenting = mod.done_documenting # update the parent of all children (klass.attributes + klass.method_list + klass.aliases + klass.external_aliases + klass.constants + klass.includes + klass.extends + klass.classes + klass.modules).each do |obj| obj.parent = klass obj.full_name = nil end klass end
Creates a new ClassModule
with name
with optional superclass
This is a constructor for subclasses, and must never be called directly.
RDoc::Context::new
# File rdoc/class_module.rb, line 111 def initialize(name, superclass = nil) @constant_aliases = [] @diagram = nil @is_alias_for = nil @name = name @superclass = superclass @comment_location = [] # [[comment, location]] super() end
Public Instance Methods
Adds comment
to this ClassModule’s list of comments at location
. This method is preferred over comment=
since it allows ri data to be updated across multiple runs.
# File rdoc/class_module.rb, line 127 def add_comment comment, location return unless document_self original = comment comment = case comment when RDoc::Comment then comment.normalize else normalize_comment comment end if location.parser == RDoc::Parser::C @comment_location.delete_if { |(_, l)| l == location } end @comment_location << [comment, location] self.comment = original end
Ancestors list for this ClassModule: the list of included modules (classes will add their superclass if any).
Returns the included classes or modules, not the includes themselves. The returned values are either String or RDoc::NormalModule
instances (see RDoc::Include#module
).
The values are returned in reverse order of their inclusion, which is the order suitable for searching methods/attributes in the ancestors. The superclass, if any, comes last.
# File rdoc/class_module.rb, line 171 def ancestors includes.map { |i| i.module }.reverse end
HTML fragment reference for this module or class. See RDoc::NormalClass#aref
and RDoc::NormalModule#aref
# File rdoc/class_module.rb, line 183 def aref "#{aref_prefix}-#{full_name}" end
Clears the comment. Used by the Ruby parser.
# File rdoc/class_module.rb, line 195 def clear_comment @comment = '' end
Prepares this ClassModule
for use by a generator.
# File rdoc/class_module.rb, line 223 def complete min_visibility update_aliases remove_nodoc_children update_includes remove_invisible min_visibility end
Handy wrapper for marking up this class or module’s comment
# File rdoc/generator/markup.rb, line 131 def description markup @comment_location end
Does this ClassModule
or any of its methods have document_self set?
# File rdoc/class_module.rb, line 233 def document_self_or_methods document_self || method_list.any?{ |m| m.document_self } end
Does this class or module have a comment with content or is received_nodoc
true?
# File rdoc/class_module.rb, line 241 def documented? return true if @received_nodoc return false if @comment_location.empty? @comment_location.any? { |comment, _| not comment.empty? } end
Iterates the ancestors of this class or module for which an RDoc::ClassModule
exists.
# File rdoc/class_module.rb, line 251 def each_ancestor # :yields: module return enum_for __method__ unless block_given? ancestors.each do |mod| next if String === mod next if self == mod yield mod end end
Looks for a symbol in the ancestors
. See Context#find_local_symbol.
# File rdoc/class_module.rb, line 264 def find_ancestor_local_symbol symbol each_ancestor do |m| res = m.find_local_symbol(symbol) return res if res end nil end
Finds a class or module with name
in this namespace or its descendants
# File rdoc/class_module.rb, line 276 def find_class_named name return self if full_name == name return self if @name == name @classes.values.find do |klass| next if klass == self klass.find_class_named name end end
Return the fully qualified name of this class or module
# File rdoc/class_module.rb, line 289 def full_name @full_name ||= if RDoc::ClassModule === parent then "#{parent.full_name}::#{@name}" else @name end end
Merges class_module
into this ClassModule
.
The data in class_module
is preferred over the receiver.
# File rdoc/class_module.rb, line 435 def merge class_module @parent = class_module.parent @parent_name = class_module.parent_name other_document = parse class_module.comment_location if other_document then document = parse @comment_location document = document.merge other_document @comment = @comment_location = document end cm = class_module other_files = cm.in_files merge_collections attributes, cm.attributes, other_files do |add, attr| if add then add_attribute attr else @attributes.delete attr @methods_hash.delete attr.pretty_name end end merge_collections constants, cm.constants, other_files do |add, const| if add then add_constant const else @constants.delete const @constants_hash.delete const.name end end merge_collections includes, cm.includes, other_files do |add, incl| if add then add_include incl else @includes.delete incl end end @includes.uniq! # clean up merge_collections extends, cm.extends, other_files do |add, ext| if add then add_extend ext else @extends.delete ext end end @extends.uniq! # clean up merge_collections method_list, cm.method_list, other_files do |add, meth| if add then add_method meth else @method_list.delete meth @methods_hash.delete meth.pretty_name end end merge_sections cm self end
Does this object represent a module?
# File rdoc/class_module.rb, line 570 def module? false end
Allows overriding the initial name.
Used for modules and classes that are constant aliases.
# File rdoc/class_module.rb, line 579 def name= new_name @name = new_name end
Name to use to generate the url: modules and classes that are aliases for another module or class return the name of the latter.
# File rdoc/class_module.rb, line 622 def name_for_path is_alias_for ? is_alias_for.full_name : full_name end
Returns the classes and modules that are not constants aliasing another class or module. For use by formatters only (caches its result).
# File rdoc/class_module.rb, line 631 def non_aliases @non_aliases ||= classes_and_modules.reject { |cm| cm.is_alias_for } end
Parses comment_location
into an RDoc::Markup::Document
composed of multiple RDoc::Markup::Documents with their file set.
RDoc::Text#parse
# File rdoc/class_module.rb, line 587 def parse comment_location case comment_location when String then super when Array then docs = comment_location.map do |comment, location| doc = super comment doc.file = location doc end RDoc::Markup::Document.new(*docs) when RDoc::Comment then doc = super comment_location.text, comment_location.format doc.file = comment_location.location doc when RDoc::Markup::Document then return comment_location else raise ArgumentError, "unknown comment class #{comment_location.class}" end end
Path to this class or module for use with HTML generator output.
# File rdoc/class_module.rb, line 613 def path http_url @store.rdoc.generator.class_dir end
Updates the child modules or classes of class/module parent
by deleting the ones that have been removed from the documentation.
parent_hash
is either parent.modules_hash
or parent.classes_hash
and all_hash
is ::all_modules_hash or ::all_classes_hash.
# File rdoc/class_module.rb, line 643 def remove_nodoc_children prefix = self.full_name + '::' modules_hash.each_key do |name| full_name = prefix + name modules_hash.delete name unless @store.modules_hash[full_name] end classes_hash.each_key do |name| full_name = prefix + name classes_hash.delete name unless @store.classes_hash[full_name] end end
Search record used by RDoc::Generator::JsonIndex
# File rdoc/class_module.rb, line 672 def search_record [ name, full_name, full_name, '', path, '', snippet(@comment_location), ] end
Sets the store for this class or module and its contained code objects.
RDoc::CodeObject#store=
# File rdoc/class_module.rb, line 687 def store= store super @attributes .each do |attr| attr.store = store end @constants .each do |const| const.store = store end @includes .each do |incl| incl.store = store end @extends .each do |ext| ext.store = store end @method_list.each do |meth| meth.store = store end end
Get the superclass of this class. Attempts to retrieve the superclass object, returns the name if it is not known.
# File rdoc/class_module.rb, line 701 def superclass @store.find_class_named(@superclass) || @superclass end
Set the superclass of this class to superclass
# File rdoc/class_module.rb, line 708 def superclass=(superclass) raise NoMethodError, "#{full_name} is a module" if module? @superclass = superclass end
‘module’ or ‘class’
# File rdoc/class_module.rb, line 724 def type module? ? 'module' : 'class' end
Updates the child modules & classes by replacing the ones that are aliases through a constant.
The aliased module/class is replaced in the children and in RDoc::Store#modules_hash
or RDoc::Store#classes_hash
by a copy that has RDoc::ClassModule#is_alias_for
set to the aliased module/class, and this copy is added to #aliases
of the aliased module/class.
Formatters can use the non_aliases
method to retrieve children that are not aliases, for instance to list the namespace content, since the aliased modules are included in the constants of the class/module, that are listed separately.
# File rdoc/class_module.rb, line 743 def update_aliases constants.each do |const| next unless cm = const.is_alias_for cm_alias = cm.dup cm_alias.name = const.name # Don't move top-level aliases under Object, they look ugly there unless RDoc::TopLevel === cm_alias.parent then cm_alias.parent = self cm_alias.full_name = nil # force update for new parent end cm_alias.aliases.clear cm_alias.is_alias_for = cm if cm.module? then @store.modules_hash[cm_alias.full_name] = cm_alias modules_hash[const.name] = cm_alias else @store.classes_hash[cm_alias.full_name] = cm_alias classes_hash[const.name] = cm_alias end cm.aliases << cm_alias end end
Deletes from extends
those whose module has been removed from the documentation.
# File rdoc/class_module.rb, line 791 def update_extends extends.reject! do |ext| mod = ext.module !(String === mod) && @store.modules_hash[mod.full_name].nil? end extends.uniq! end
Deletes from includes
those whose module has been removed from the documentation.
# File rdoc/class_module.rb, line 776 def update_includes includes.reject! do |include| mod = include.module !(String === mod) && @store.modules_hash[mod.full_name].nil? end includes.uniq! end