class RDoc::TopLevel

def self.all_classes_and_modules
  classes_hash.values + modules_hash.values
end

def self.classes
  classes_hash.values
end

def self.classes_hash
  @all_classes
end

def self.files
  @all_files.values
end

def self.files_hash
  @all_files
end

def self.find_class_named(name)
  classes_hash[name]
end

def self.find_class_named_from name, from
  from = find_class_named from unless RDoc::Context === from
  until RDoc::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

def self.find_class_or_module(name)
  name =~ /^::/
  name = $' || name
  RDoc::TopLevel.classes_hash[name] || RDoc::TopLevel.modules_hash[name]
end

def self.find_file_named(name)
  @all_files[name]
end

def self.find_module_named(name)
  modules_hash[name]
end

def self.modules
  modules_hash.values
end

def self.modules_hash
  @all_modules
end

def self.reset
  @all_classes = {}
  @all_modules = {}
  @all_files   = {}
end

def add_method(method)
  object = self.class.find_class_named 'Object'
  object = add_class RDoc::NormalClass, 'Object' unless object
  object.add_method method
end

def base_name
  File.basename @absolute_name
end

def cvs_url
  url = RDoc::RDoc.current.options.webcvs
  if /%s/ =~ url then
    url % @absolute_name
  else
    url + @absolute_name
  end
end

def find_class_or_module name
  RDoc::TopLevel.find_class_or_module name
end

def find_local_symbol(symbol)
  find_class_or_module(symbol) || super
end

def find_module_named(name)
  find_class_or_module(name) || find_enclosing_module_named(name)
end

def full_name
  @relative_name
end

def http_url(prefix)
  path = [prefix, @relative_name.tr('.', '_')]
  File.join(*path.compact) + '.html'
end

def initialize(file_name)
  super()
  @name = nil
  @relative_name = file_name
  @absolute_name = file_name
  @file_stat     = File.stat(file_name) rescue nil # HACK for testing
  @diagram       = nil
  @parser        = nil
  RDoc::TopLevel.files_hash[file_name] = self
end

def inspect # :nodoc:
  "#<%s:0x%x %p modules: %p classes: %p>" % [
    self.class, object_id,
    base_name,
    @modules.map { |n,m| m },
    @classes.map { |n,c| c }
  ]
end

def last_modified
  @file_stat ? file_stat.mtime.to_s : 'Unknown'
end

def path
  http_url RDoc::RDoc.current.generator.file_dir
end

def pretty_print q # :nodoc:
  q.group 2, "[#{self.class}: ", "]" do
    q.text "base name: #{base_name.inspect}"
    q.breakable
    items = @modules.map { |n,m| m }
    items.push(*@modules.map { |n,c| c })
    q.seplist items do |mod| q.pp mod end
  end
end