class RDoc::Store

# File lib/rdoc/store.rb, line 119
def initialize(options, path: nil, type: nil)
  @options  = options
  @dry_run  = options.dry_run
  @encoding = options.encoding
  @path     = path || options.op_dir
  @type     = type

  @cache = {
    :ancestors                   => {},
    :attributes                  => {},
    :class_methods               => {},
    :c_class_variables           => {},
    :c_singleton_class_variables => {},
    :encoding                    => @encoding,
    :instance_methods            => {},
    :main                        => options.main_page,
    :modules                     => [],
    :pages                       => [],
    :title                       => options.title,
  }

  @classes_hash = {}
  @modules_hash = {}
  @files_hash   = {}

  @c_enclosure_classes = {}
  @c_enclosure_names   = {}

  @c_class_variables           = {}
  @c_singleton_class_variables = {}

  @unique_classes = nil
  @unique_modules = nil
end

# File lib/rdoc/store.rb, line 158
def add_c_enclosure(variable, namespace)
  @c_enclosure_classes[variable] = namespace
end

# File lib/rdoc/store.rb, line 165
def add_c_variables(c_parser)
  filename = c_parser.top_level.relative_name

  @c_class_variables[filename] = make_variable_map c_parser.classes

  @c_singleton_class_variables[filename] = c_parser.singleton_classes
end

# File lib/rdoc/store.rb, line 177
def add_file(absolute_name, relative_name: absolute_name, parser: nil)
  unless top_level = @files_hash[relative_name]
    top_level = TopLevel.new absolute_name, relative_name
    top_level.parser = parser if parser
    top_level.store = self
    @files_hash[relative_name] = top_level
    @page_index = nil
  end

  top_level
end

# File lib/rdoc/store.rb, line 319
def all_classes
  @classes_hash.values
end

# File lib/rdoc/store.rb, line 326
def all_classes_and_modules
  @classes_hash.values + @modules_hash.values
end

# File lib/rdoc/store.rb, line 413
def all_files
  @files_hash.values
end

# File lib/rdoc/store.rb, line 420
def all_modules
  modules_hash.values
end

# File lib/rdoc/store.rb, line 429
def ancestors
  @cache[:ancestors]
end

# File lib/rdoc/store.rb, line 436
def attributes
  @cache[:attributes]
end

# File lib/rdoc/store.rb, line 443
def cache_path
  File.join @path, 'cache.ri'
end

# File lib/rdoc/store.rb, line 450
def class_file(klass_name)
  name = klass_name.split('::').last
  File.join class_path(klass_name), "cdesc-#{name}.ri"
end

# File lib/rdoc/store.rb, line 459
def class_methods
  @cache[:class_methods]
end

# File lib/rdoc/store.rb, line 466
def class_path(klass_name)
  File.join @path, *klass_name.split('::')
end

# File lib/rdoc/store.rb, line 473
def classes_hash
  @classes_hash
end

# File lib/rdoc/store.rb, line 282
def cleanup_stale_contributions
  all_classes_and_modules.each do |cm|
    cm.comment_location.delete_if { |_, comments| comments.empty? }
    cm.rebuild_comment_from_location

    cm.in_files.select! { |tl| cm.comment_location.key?(tl) ||
      cm.method_list.any? { |m| m.file == tl } ||
      cm.attributes.any? { |a| a.file == tl } ||
      cm.constants.any? { |c| c.file == tl } }

    if cm.in_files.empty?
      if cm.is_a?(NormalModule)
        @modules_hash.delete(cm.full_name)
      else
        @classes_hash.delete(cm.full_name)
      end
      cm.parent&.classes_hash&.delete(cm.name)
      cm.parent&.modules_hash&.delete(cm.name)
    end
  end
end

# File lib/rdoc/store.rb, line 216
def clear_file_contributions(relative_name, keep_position: false)
  top_level = @files_hash[relative_name]
  return unless top_level

  top_level.classes_or_modules.each do |cm|
    # Remove methods and attributes contributed by this file
    cm.method_list.reject! { |m| m.file == top_level }
    cm.attributes.reject! { |a| a.file == top_level }

    # Rebuild methods_hash from remaining methods and attributes
    cm.methods_hash.clear
    cm.method_list.each { |m| cm.methods_hash[m.pretty_name] = m }
    cm.attributes.each { |a| cm.methods_hash[a.pretty_name] = a }

    # Remove constants contributed by this file
    cm.constants.reject! { |c| c.file == top_level }
    cm.constants_hash.clear
    cm.constants.each { |c| cm.constants_hash[c.name] = c }

    # Remove includes, extends, and aliases from this file
    cm.includes.reject! { |i| i.file == top_level }
    cm.extends.reject! { |e| e.file == top_level }
    cm.aliases.reject! { |a| a.file == top_level }
    cm.external_aliases.reject! { |a| a.file == top_level }

    # Clear or remove comment entries from this file
    if cm.is_a?(ClassModule)
      if keep_position
        cm.comment_location[top_level] = [] if cm.comment_location.key?(top_level)
      else
        cm.comment_location.delete(top_level)
      end
      cm.rebuild_comment_from_location
    end

    unless keep_position
      # Remove this file from the class/module's file list
      cm.in_files.delete(top_level)

      # If no files contribute to this class/module anymore, remove it
      # from the store entirely.  This handles file deletion correctly
      # for classes that are only defined in the deleted file, while
      # preserving classes that span multiple files.
      if cm.in_files.empty?
        if cm.is_a?(NormalModule)
          @modules_hash.delete(cm.full_name)
        else
          @classes_hash.delete(cm.full_name)
        end
        cm.parent&.classes_hash&.delete(cm.name)
        cm.parent&.modules_hash&.delete(cm.name)
      end
    end
  end

  # Clear the TopLevel's class/module list to prevent duplicates
  top_level.classes_or_modules.clear
end

# File lib/rdoc/store.rb, line 509
def complete(min_visibility)
  fix_basic_object_inheritance

  # cache included modules before they are removed from the documentation
  all_classes_and_modules.each { |cm| cm.ancestors }

  unless min_visibility == :nodoc
    remove_nodoc @classes_hash
    remove_nodoc @modules_hash
  end

  @unique_classes = find_unique @classes_hash
  @unique_modules = find_unique @modules_hash

  unique_classes_and_modules.each do |cm|
    cm.complete min_visibility
  end

  @files_hash.each_key do |file_name|
    tl = @files_hash[file_name]

    unless tl.text?
      tl.modules_hash.clear
      tl.classes_hash.clear

      tl.classes_or_modules.each do |cm|
        name = cm.full_name
        if cm.type == 'class'
          tl.classes_hash[name] = cm if @classes_hash[name]
        else
          tl.modules_hash[name] = cm if @modules_hash[name]
        end
      end
    end
  end
end

# File lib/rdoc/store.rb, line 549
def files_hash
  @files_hash
end

# File lib/rdoc/store.rb, line 556
def find_c_enclosure(variable)
  @c_enclosure_classes.fetch variable do
    break unless name = @c_enclosure_names[variable]

    mod = find_class_or_module name

    unless mod
      loaded_mod = load_class_data name

      file = loaded_mod.in_files.first

      return unless file # legacy data source

      file.store = self

      mod = file.add_module NormalModule, name
    end

    @c_enclosure_classes[variable] = mod
  end
end

# File lib/rdoc/store.rb, line 581
def find_class_named(name)
  @classes_hash[name]
end

# File lib/rdoc/store.rb, line 588
def find_class_named_from(name, from)
  from = find_class_named from unless Context === from

  until TopLevel === from do
    return nil unless from

    klass = from.find_class_named name
    return klass if klass

    from = from.parent
  end

  find_class_named name
end

# File lib/rdoc/store.rb, line 606
def find_class_or_module(name)
  name = $' if name =~ /^::/
  @classes_hash[name] || @modules_hash[name]
end

# File lib/rdoc/store.rb, line 614
def find_file_named(name)
  @files_hash[name]
end

# File lib/rdoc/store.rb, line 621
def find_module_named(name)
  @modules_hash[name]
end

# File lib/rdoc/store.rb, line 629
def find_text_page(file_name)
  page = @files_hash[file_name]
  page if page&.text?
end

# File lib/rdoc/store.rb, line 641
def find_unique(all_hash)
  unique = []

  all_hash.each_pair do |full_name, cm|
    unique << cm if full_name == cm.full_name
  end

  unique
end

# File lib/rdoc/store.rb, line 660
def fix_basic_object_inheritance
  basic = classes_hash['BasicObject']
  return unless basic
  basic.superclass = nil
end

# File lib/rdoc/store.rb, line 669
def friendly_path
  case type
  when :gem
    parent = File.expand_path '..', @path
    "gem #{File.basename parent}"
  when :home   then ::RDoc.home
  when :site   then 'ruby site'
  when :system then 'ruby core'
  else @path
  end
end

# File lib/rdoc/store.rb, line 689
def instance_methods
  @cache[:instance_methods]
end

# File lib/rdoc/store.rb, line 697
def load_all
  load_cache

  module_names.each do |module_name|
    mod = find_class_or_module(module_name) || load_class(module_name)

    # load method documentation since the loaded class/module does not have
    # it
    loaded_methods = mod.method_list.map do |method|
      load_method module_name, method.full_name
    end

    mod.method_list.replace loaded_methods

    loaded_attributes = mod.attributes.map do |attribute|
      load_method module_name, attribute.full_name
    end

    mod.attributes.replace loaded_attributes
  end

  all_classes_and_modules.each do |mod|
    descendent_re = /^#{mod.full_name}::[^:]+$/

    module_names.each do |name|
      next unless name =~ descendent_re

      descendent = find_class_or_module name

      case descendent
      when NormalClass
        mod.classes_hash[name] = descendent
      when NormalModule
        mod.modules_hash[name] = descendent
      end
    end
  end

  @page_index = nil
  @cache[:pages].each do |page_name|
    @files_hash[page_name] = load_page(page_name)
  end
end

# File lib/rdoc/store.rb, line 744
def load_cache
  #orig_enc = @encoding

  @cache = marshal_load(cache_path)

  load_enc = @cache[:encoding]

  # TODO this feature will be time-consuming to add:
  # a) Encodings may be incompatible but transcodeable
  # b) Need to warn in the appropriate spots, wherever they may be
  # c) Need to handle cross-cache differences in encodings
  # d) Need to warn when generating into a cache with different encodings
  #
  #if orig_enc and load_enc != orig_enc then
  #  warn "Cached encoding #{load_enc} is incompatible with #{orig_enc}\n" \
  #       "from #{path}/cache.ri" unless
  #    Encoding.compatible? orig_enc, load_enc
  #end

  @encoding = load_enc unless @encoding

  @cache[:pages]                       ||= []
  @cache[:main]                        ||= nil
  @cache[:c_class_variables]           ||= {}
  @cache[:c_singleton_class_variables] ||= {}

  @cache[:c_class_variables].each do |_, map|
    map.each do |variable, name|
      @c_enclosure_names[variable] = name
    end
  end

  @cache
rescue Errno::ENOENT
end

# File lib/rdoc/store.rb, line 783
def load_class(klass_name)
  obj = load_class_data klass_name

  obj.store = self

  case obj
  when NormalClass
    @classes_hash[klass_name] = obj
  when SingleClass
    @classes_hash[klass_name] = obj
  when NormalModule
    @modules_hash[klass_name] = obj
  end
end

# File lib/rdoc/store.rb, line 801
def load_class_data(klass_name)
  file = class_file klass_name

  marshal_load(file)
rescue Errno::ENOENT => e
  error = MissingFileError.new(self, file, klass_name)
  error.set_backtrace e.backtrace
  raise error
end

# File lib/rdoc/store.rb, line 814
def load_method(klass_name, method_name)
  file = method_file klass_name, method_name

  obj = marshal_load(file)
  obj.store = self
  obj.parent ||= find_class_or_module(klass_name) || load_class(klass_name)
  obj
rescue Errno::ENOENT => e
  error = MissingFileError.new(self, file, klass_name + method_name)
  error.set_backtrace e.backtrace
  raise error
end

# File lib/rdoc/store.rb, line 830
def load_page(page_name)
  file = page_file page_name

  obj = marshal_load(file)
  obj.store = self
  obj
rescue Errno::ENOENT => e
  error = MissingFileError.new(self, file, page_name)
  error.set_backtrace e.backtrace
  raise error
end

# File lib/rdoc/store.rb, line 846
def main
  @cache[:main]
end

# File lib/rdoc/store.rb, line 853
def main=(page)
  @cache[:main] = page
end

# File lib/rdoc/store.rb, line 861
def make_variable_map(variables)
  map = {}

  variables.each { |variable, class_module|
    map[variable] = class_module.full_name
  }

  map
end

# File lib/rdoc/store.rb, line 373
def merge_rbs_signatures(signatures)
  @rbs_signatures = signatures
end

# File lib/rdoc/store.rb, line 874
def method_file(klass_name, method_name)
  method_name = method_name.split('::').last
  method_name =~ /#(.*)/
  method_type = $1 ? 'i' : 'c'
  method_name = $1 if $1
  method_name = method_name.gsub(/\W/) { "%%%02x" % $&[0].ord }

  File.join class_path(klass_name), "#{method_name}-#{method_type}.ri"
end

# File lib/rdoc/store.rb, line 888
def module_names
  @cache[:modules]
end

# File lib/rdoc/store.rb, line 895
def modules_hash
  @modules_hash
end

# File lib/rdoc/store.rb, line 902
def page(name)
  @page_index ||= @files_hash.each_value.each_with_object({}) do |file, index|
    index[file.page_name] ||= file
    index[file.base_name] ||= file
  end

  @page_index[name]
end

# File lib/rdoc/store.rb, line 914
def page_file(page_name)
  file_name = File.basename(page_name).gsub('.', '_')

  File.join @path, File.dirname(page_name), "page-#{file_name}.ri"
end

# File lib/rdoc/store.rb, line 383
def rbs_signature_for(method_attr)
  return nil unless @rbs_signatures
  cm = method_attr.parent
  return nil unless cm.respond_to?(:full_name)

  key = method_attr.singleton ? "#{cm.full_name}.#{method_attr.name}" : "#{cm.full_name}##{method_attr.name}"
  sig = @rbs_signatures[key]

  # RBS keys constructors as #initialize, but RDoc renames them to .new
  if !sig && method_attr.name == 'new' && method_attr.singleton
    sig = @rbs_signatures["#{cm.full_name}#initialize"]
  end

  # For aliases, fall through to the canonical method (its inline #:
  # takes precedence over any sidecar signature on the alias's name).
  if !sig && method_attr.is_alias_for
    canonical = method_attr.is_alias_for
    sig = canonical.type_signature_lines || rbs_signature_for(canonical)
  end

  sig
end

# File lib/rdoc/store.rb, line 199
def remove_file(relative_name)
  top_level = @files_hash.delete(relative_name)
  @c_class_variables.delete(relative_name)
  @c_singleton_class_variables.delete(relative_name)
  return unless top_level

  @page_index = nil
  remove_classes_and_modules(top_level.classes_or_modules)
end

# File lib/rdoc/store.rb, line 925
def remove_nodoc(all_hash)
  all_hash.keys.each do |name|
    context = all_hash[name]
    all_hash.delete(name) if context.remove_from_documentation?
  end
end

# File lib/rdoc/store.rb, line 308
def resolve_c_superclasses
  @classes_hash.each_value do |klass|
    if klass.superclass.is_a?(String) && (candidate = find_c_enclosure(klass.superclass))
      klass.superclass = candidate
    end
  end
end

# File lib/rdoc/store.rb, line 935
def save
  load_cache

  all_classes_and_modules.each do |klass|
    save_class klass

    klass.each_method do |method|
      save_method klass, method
    end

    klass.attributes.each do |attribute|
      save_method klass, attribute
    end
  end

  all_files.each do |file|
    save_page file
  end

  save_cache
end

# File lib/rdoc/store.rb, line 960
def save_cache
  clean_cache_collection @cache[:ancestors]
  clean_cache_collection @cache[:attributes]
  clean_cache_collection @cache[:class_methods]
  clean_cache_collection @cache[:instance_methods]

  @cache[:modules].uniq!
  @cache[:modules].sort!

  @cache[:pages].uniq!
  @cache[:pages].sort!

  @cache[:encoding] = @encoding # this gets set twice due to assert_cache

  @cache[:c_class_variables].merge!           @c_class_variables
  @cache[:c_singleton_class_variables].merge! @c_singleton_class_variables

  return if @dry_run

  File.open cache_path, 'wb' do |io|
    Marshal.dump @cache, io
  end
end

# File lib/rdoc/store.rb, line 987
def save_class(klass)
  full_name = klass.full_name

  FileUtils.mkdir_p class_path(full_name) unless @dry_run

  @cache[:modules] << full_name

  path = class_file full_name

  begin
    disk_klass = load_class full_name

    klass = disk_klass.merge klass
  rescue MissingFileError
  end

  # BasicObject has no ancestors
  ancestors = klass.direct_ancestors.compact.map do |ancestor|
    # HACK for classes we don't know about (class X < RuntimeError)
    String === ancestor ? ancestor : ancestor.full_name
  end

  @cache[:ancestors][full_name] ||= []
  @cache[:ancestors][full_name].concat ancestors

  attribute_definitions = klass.attributes.map do |attribute|
    "#{attribute.definition} #{attribute.name}"
  end

  unless attribute_definitions.empty?
    @cache[:attributes][full_name] ||= []
    @cache[:attributes][full_name].concat attribute_definitions
  end

  to_delete = []

  unless klass.method_list.empty?
    @cache[:class_methods][full_name]    ||= []
    @cache[:instance_methods][full_name] ||= []

    class_methods, instance_methods =
      klass.method_list.partition { |meth| meth.singleton }

    class_methods    = class_methods.   map { |method| method.name }
    instance_methods = instance_methods.map { |method| method.name }
    attribute_names  = klass.attributes.map { |attr|   attr.name }

    old = @cache[:class_methods][full_name] - class_methods
    to_delete.concat old.map { |method|
      method_file full_name, "#{full_name}::#{method}"
    }

    old = @cache[:instance_methods][full_name] -
      instance_methods - attribute_names
    to_delete.concat old.map { |method|
      method_file full_name, "#{full_name}##{method}"
    }

    @cache[:class_methods][full_name]    = class_methods
    @cache[:instance_methods][full_name] = instance_methods
  end

  return if @dry_run

  FileUtils.rm_f to_delete

  File.open path, 'wb' do |io|
    Marshal.dump klass, io
  end
end

# File lib/rdoc/store.rb, line 1061
def save_method(klass, method)
  full_name = klass.full_name

  FileUtils.mkdir_p class_path(full_name) unless @dry_run

  cache = if method.singleton
            @cache[:class_methods]
          else
            @cache[:instance_methods]
          end
  cache[full_name] ||= []
  cache[full_name] << method.name

  return if @dry_run

  File.open method_file(full_name, method.full_name), 'wb' do |io|
    Marshal.dump method, io
  end
end

# File lib/rdoc/store.rb, line 1084
def save_page(page)
  return unless page.text?

  path = page_file page.full_name

  FileUtils.mkdir_p File.dirname(path) unless @dry_run

  cache[:pages] ||= []
  cache[:pages] << page.full_name

  return if @dry_run

  File.open path, 'wb' do |io|
    Marshal.dump page, io
  end
end

# File lib/rdoc/store.rb, line 1110
def source
  case type
  when :gem    then File.basename File.expand_path '..', @path
  when :home   then 'home'
  when :site   then 'site'
  when :system then 'ruby'
  else @path
  end
end

# File lib/rdoc/store.rb, line 1124
def title
  @cache[:title]
end

# File lib/rdoc/store.rb, line 1131
def title=(title)
  @cache[:title] = title
end

# File lib/rdoc/store.rb, line 345
def type_name_lookup
  @type_name_lookup ||= begin
    lookup = {}
    unqualified_names = {}
    ambiguous_names = {}
    all_classes_and_modules.each do |cm|
      lookup[cm.full_name] = cm.path
      unqualified_name = cm.name

      if ambiguous_names[unqualified_name]
        # already known ambiguous, skip
      elsif unqualified_names.key?(unqualified_name)
        unqualified_names.delete(unqualified_name)
        ambiguous_names[unqualified_name] = true
      else
        unqualified_names[unqualified_name] = cm.path
      end
    end
    lookup.merge!(unqualified_names)
  end
end

# File lib/rdoc/store.rb, line 1140
def unique_classes
  @unique_classes
end

# File lib/rdoc/store.rb, line 1148
def unique_classes_and_modules
  @unique_classes + @unique_modules
end

# File lib/rdoc/store.rb, line 1156
def unique_modules
  @unique_modules
end