Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://ruby.github.io/rdoc/RDoc/ClassModule.html below:

class RDoc::ClassModule - rdoc Documentation

1. RDoc::
2. ClassModule

ClassModule is the base class for objects representing either a class or a module.

Constants that are aliases for this class or module

Class or module this constant is an alias for

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

  

  (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

Return a RDoc::ClassModule of class class_type that is a copy of module module. Used to promote modules to classes.

def initialize(name, superclass = nil)
  @constant_aliases = []
  @is_alias_for     = nil
  @name             = name
  @superclass       = superclass
  @comment_location = [] 

  super()
end

Creates a new ClassModule with name with optional superclass

This is a constructor for subclasses, and must never be called directly.

def ancestors
  includes.map { |i| i.module }.reverse
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.

def complete(min_visibility)
  update_aliases
  remove_nodoc_children
  embed_mixins
  update_includes
  update_extends
  remove_invisible min_visibility
end

Prepares this ClassModule for use by a generator.

See RDoc::Store#complete

def description
  markup @comment_location
end

Handy wrapper for marking up this class or module’s comment

Ancestors of this class or module only

def document_self_or_methods
  document_self || method_list.any?{ |m| m.document_self }
end

Does this ClassModule or any of its methods have document_self set?

def documented?
  return true if @received_nodoc
  return false if @comment_location.empty?
  @comment_location.any? { |comment, _| not comment.empty? }
end

Does this class or module have a comment with content or is received_nodoc true?

def each_ancestor 
  return enum_for __method__ unless block_given?

  ancestors.each do |mod|
    next if String === mod
    next if self == mod
    yield mod
  end
end

Iterates the ancestors of this class or module for which an RDoc::ClassModule exists.

def embed_mixins
  return unless options.embed_mixins

  includes.each do |include|
    next if String === include.module
    include.module.method_list.each do |code_object|
      add_method(prepare_to_embed(code_object))
    end
    include.module.constants.each do |code_object|
      add_constant(prepare_to_embed(code_object))
    end
    include.module.attributes.each do |code_object|
      add_attribute(prepare_to_embed(code_object))
    end
  end

  extends.each do |ext|
    next if String === ext.module
    ext.module.method_list.each do |code_object|
      add_method(prepare_to_embed(code_object, true))
    end
    ext.module.attributes.each do |code_object|
      add_attribute(prepare_to_embed(code_object, true))
    end
  end
end

def find_ancestor_local_symbol(symbol)
  each_ancestor do |m|
    res = m.find_local_symbol(symbol)
    return res if res
  end

  nil
end

Looks for a symbol in the ancestors. See Context#find_local_symbol.

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

Finds a class or module with name in this namespace or its descendants

def full_name
  @full_name ||= if RDoc::ClassModule === parent then
                   "#{parent.full_name}::#{@name}"
                 else
                   @name
                 end
end

Return the fully qualified name of this class or module

def fully_qualified_nesting_namespaces
  return nesting_namespaces if nesting_namespaces.length < 2
  @fqns ||= nesting_namespaces.inject([]) do |list, n|
    list << (list.empty? ? n : "#{list.last}::#{n}")
  end
end

Return array of fully qualified nesting namespaces.

For example, if full_name is A::B::C, this method returns ["A", "A::B", "A::B::C"]

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 = RDoc::Comment.from_document(document)
    @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! 

  merge_collections extends, cm.extends, other_files do |add, ext|
    if add then
      add_extend ext
    else
      @extends.delete ext
    end
  end

  @extends.uniq! 

  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

Merges class_module into this ClassModule.

The data in class_module is preferred over the receiver.

Does this object represent a module?

def name=(new_name)
  @name = new_name
end

Allows overriding the initial name.

Used for modules and classes that are constant aliases.

def name_for_path
  is_alias_for ? is_alias_for.full_name : full_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.

def nesting_namespaces
  @namespaces ||= full_name.split("::").reject(&:empty?)
end

Return array of full_name splitted by ::.

def non_aliases
  @non_aliases ||= classes_and_modules.reject { |cm| cm.is_alias_for }
end

Returns the classes and modules that are not constants aliasing another class or module. For use by formatters only (caches its result).

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

Parses comment_location into an RDoc::Markup::Document composed of multiple RDoc::Markup::Documents with their file set.

def path
  prefix = options.class_module_path_prefix
  return http_url unless prefix
  File.join(prefix, http_url)
end

Path to this class or module for use with HTML generator output.

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

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.

def search_record
  [
    name,
    full_name,
    full_name,
    '',
    path,
    '',
    snippet(@comment_location),
  ]
end

Search record used by RDoc::Generator::JsonIndex

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

Sets the store for this class or module and its contained code objects.

def super_classes
  result = []
  parent = self
  while parent = parent.superclass
    result << parent
    return result if parent.is_a?(String)
  end
  result
end

Get all super classes of this class in an array. The last element might be a string if the name is unknown.

def superclass
  @store.find_class_named(@superclass) || @superclass
end

Get the superclass of this class. Attempts to retrieve the superclass object, returns the name if it is not known.

def superclass=(superclass)
  raise NoMethodError, "#{full_name} is a module" if module?
  case superclass
  when RDoc::ClassModule
    @superclass = superclass.full_name
  when nil, String
    @superclass = superclass
  else
    raise TypeError, "superclass must be a String or RDoc::ClassModule, not #{superclass.class}"
  end
end

Set the superclass of this class to superclass

where superclass is one of:

• nil

• a String containing the full name of the superclass

• the RDoc::ClassModule representing the superclass

def type
  module? ? 'module' : 'class'
end

‘module’ or ‘class’

def update_aliases
  constants.each do |const|
    next unless cm = const.is_alias_for
    cm_alias = cm.dup
    cm_alias.name = const.name

    
    unless RDoc::TopLevel === cm_alias.parent then
      cm_alias.parent = self
      cm_alias.full_name = nil 
    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

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.

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 extends those whose module has been removed from the documentation.

def update_includes
  includes.reject! do |include|
    mod = include.module
    !(String === mod) && @store.modules_hash[mod.full_name].nil?
  end

  includes.uniq!
end

Deletes from includes those whose module has been removed from the documentation.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4