class RDoc::ClassModule

# File lib/rdoc/code_object/class_module.rb, line 61
def self.from_module(class_type, mod)
  klass = class_type.new mod.name

  mod.comment_location.each do |location, comments|
    comments.each { |comment| 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

  # 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

# File lib/rdoc/code_object/class_module.rb, line 121
def initialize(name, superclass = nil)
  @constant_aliases = []
  @is_alias_for     = nil
  @name             = name
  @superclass       = superclass
  @comment_location = {} # Hash of { location => [comments] }

  super()
end

# File lib/rdoc/code_object/class_module.rb, line 136
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

  (@comment_location[location] ||= []) << comment

  self.comment = original
end

# File lib/rdoc/code_object/class_module.rb, line 176
def ancestors
  included_ancestors
end

# File lib/rdoc/code_object/class_module.rb, line 196
def aref
  "#{aref_prefix}-#{full_name.downcase.gsub('::', '-')}"
end

# File lib/rdoc/code_object/class_module.rb, line 220
def clear_comment
  @comment = ''
end

# File lib/rdoc/code_object/class_module.rb, line 248
def complete(min_visibility)
  update_aliases
  remove_nodoc_children
  embed_mixins
  update_includes
  update_extends
  remove_invisible min_visibility
end

# File lib/rdoc/generator/markup.rb, line 168
def description
  markup @comment_location
end

# File lib/rdoc/code_object/class_module.rb, line 260
def document_self_or_methods
  document_self || method_list.any?{ |m| m.document_self }
end

# File lib/rdoc/code_object/class_module.rb, line 268
def documented?
  return true if @received_nodoc
  return false if @comment_location.empty?
  @comment_location.each_value.any? { |comments| comments.any? { |c| not c.empty? } }
end

# File lib/rdoc/code_object/class_module.rb, line 278
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

# File lib/rdoc/code_object/class_module.rb, line 941
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

# File lib/rdoc/code_object/class_module.rb, line 291
def find_ancestor_local_symbol(symbol)
  each_ancestor do |m|
    res = m.find_local_symbol(symbol)
    return res if res
  end

  nil
end

# File lib/rdoc/code_object/class_module.rb, line 303
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

# File lib/rdoc/code_object/class_module.rb, line 316
def full_name
  @full_name ||= if RDoc::ClassModule === parent then
                   "#{parent.full_name}::#{@name}"
                 else
                   @name
                 end
end

# File lib/rdoc/code_object/class_module.rb, line 336
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

# File lib/rdoc/code_object/class_module.rb, line 208
def legacy_aref
  "#{aref_prefix}-#{full_name}"
end

# File lib/rdoc/code_object/class_module.rb, line 482
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 = if document.parts.first.is_a?(RDoc::Markup::Document)
                          document.parts.group_by(&:file)
                        else
                          { document.file => [document] }
                        end
  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

# File lib/rdoc/code_object/class_module.rb, line 623
def module?
  false
end

# File lib/rdoc/code_object/class_module.rb, line 632
def name=(new_name)
  @name = new_name
end

# File lib/rdoc/code_object/class_module.rb, line 679
def name_for_path
  is_alias_for ? is_alias_for.name_for_path : full_name
end

# File lib/rdoc/code_object/class_module.rb, line 327
def nesting_namespaces
  @namespaces ||= full_name.split("::").reject(&:empty?)
end

# File lib/rdoc/code_object/class_module.rb, line 688
def non_aliases
  @non_aliases ||= classes_and_modules.reject { |cm| cm.is_alias_for }
end

# File lib/rdoc/code_object/class_module.rb, line 640
def parse(comment_location)
  case comment_location
  when String then
    super
  when Hash then
    docs = comment_location.flat_map do |location, comments|
      comments.map do |comment|
        doc = super comment
        doc.file = location
        doc
      end
    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

# File lib/rdoc/code_object/class_module.rb, line 668
def path
  prefix = options.class_module_path_prefix
  return http_url unless prefix
  File.join(prefix, http_url)
end

# File lib/rdoc/code_object/class_module.rb, line 758
def rebuild_comment_from_location
  texts = @comment_location.each_value.flat_map { |comments|
    comments.filter_map { |c| c.to_s unless c.empty? }
  }
  merged = texts.join("\n---\n")
  @comment = merged.empty? ? '' : RDoc::Comment.new(merged)
end

# File lib/rdoc/code_object/class_module.rb, line 700
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

# File lib/rdoc/code_object/class_module.rb, line 732
def search_record
  [
    name,
    full_name,
    full_name,
    '',
    path,
    '',
    snippet(@comment_location),
  ]
end

# File lib/rdoc/code_object/class_module.rb, line 747
def search_snippet
  first_comment = @comment_location.each_value.first&.first
  return '' unless first_comment && !first_comment.empty?

  snippet(first_comment)
end

# File lib/rdoc/code_object/class_module.rb, line 769
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

# File lib/rdoc/code_object/class_module.rb, line 812
def super_classes
  result = []
  # Degenerate input can produce a cyclic superclass chain
  visited = [full_name]
  parent = self
  while parent = parent.superclass
    if parent.is_a?(String)
      result << parent
      break
    end
    break if visited.include?(parent.full_name)
    visited << parent.full_name
    result << parent
  end
  result
end

# File lib/rdoc/code_object/class_module.rb, line 783
def superclass
  @store.find_class_named(@superclass) || @superclass
end

# File lib/rdoc/code_object/class_module.rb, line 796
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

# File lib/rdoc/code_object/class_module.rb, line 840
def type
  module? ? 'module' : 'class'
end

# File lib/rdoc/code_object/class_module.rb, line 859
def update_aliases
  constants.each do |const|
    cm = const.is_alias_for
    cm ||= const.resolved_alias_target if const.is_a?(RDoc::Constant)
    next unless cm

    # Resolve chained aliases (A = B = C) to the real class/module.
    cm = @store.find_class_or_module(cm.full_name) || cm
    while (target = cm.is_alias_for)
      cm = target
    end

    cm_alias = cm.dup
    cm_alias.name = const.name

    if full_name == 'Object'
      # Don't move top-level aliases under Object, they look ugly there
      cm_alias.parent = top_level
    else
      cm_alias.parent = self
    end
    cm_alias.full_name = nil # force update for new parent

    # Don't clobber a real (non-alias) class/module already living at this
    # name. Mirrors the BasicObject = BlankSlate guard in
    # Context#add_module_alias. Existing alias copies (set by
    # add_module_alias or a previous update_aliases pass) carry is_alias_for,
    # so they're still overwritable here.
    existing = @store.find_class_or_module(cm_alias.full_name)
    next if existing && !existing.is_alias_for

    # Persist a lazy-resolved target so Stats#report_constants and
    # Constant#marshal_dump observe the alias relationship. Skipped
    # aliases (above) intentionally leave the constant unmarked.
    const.is_alias_for ||= cm

    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

# File lib/rdoc/code_object/class_module.rb, line 931
def update_extends
  extends.reject! do |ext|
    mod = ext.module

    !(String === mod) && @store.modules_hash[mod.full_name].nil?
  end

  extends.uniq!
end

# File lib/rdoc/code_object/class_module.rb, line 916
def update_includes
  includes.reject! do |include|
    mod = include.module
    !(String === mod) && @store.modules_hash[mod.full_name].nil?
  end

  includes.uniq!
end