module YARD::Registry

def all(*types)
  if types.empty?
    thread_local_store.values.select {|obj| obj != root }
  else
    list = []
    types.each do |type|
      list += thread_local_store.values_for_type(type)
    end
    list
  end
end

def at(path) path ? thread_local_store[path] : nil end

def checksum_for(data)
  Digest::SHA1.hexdigest(data)
end

def checksums
  thread_local_store.checksums
end

def clear
  self.thread_local_store = RegistryStore.new
end

def delete(object)
  thread_local_store.delete(object.path)
end

def delete_from_disk
  thread_local_store.destroy
end

def each(&block)
  all.each(&block)
end

def global_yardoc_file(spec, for_writing = false)
  path = spec.doc_dir
  yfile = spec.doc_dir(DEFAULT_YARDOC_FILE)
  if for_writing
    if File.writable?(path) ||
       (!File.directory?(path) && File.writable?(File.dirname(path)))
      return yfile
    end
  elsif !for_writing && File.exist?(yfile)
    return yfile
  end
end

def instance; self end

def load(files = [], reparse = false)
  if files.is_a?(Array)
    if File.exist?(yardoc_file) && !reparse
      load_yardoc
    else
      size = thread_local_store.keys.size
      YARD.parse(files)
      save if thread_local_store.keys.size > size
    end
  elsif files.is_a?(String)
    load_yardoc(files)
  else
    raise ArgumentError, "Must take a list of files to parse or the .yardoc file to load."
  end
  self
end

def load!(file = yardoc_file)
  clear
  thread_local_store.load!(file)
  self
end

def load_all
  thread_local_store.load_all
  self
end

def load_yardoc(file = yardoc_file)
  clear
  thread_local_store.load(file)
  self
end

def local_yardoc_file(spec, for_writing = false)
  path = Registry::LOCAL_YARDOC_INDEX
  FileUtils.mkdir_p(path) if for_writing
  path = File.join(path, "#{spec.full_name}.yardoc")
  if for_writing
    path
  else
    File.exist?(path) ? path : nil
  end
end

def locale(name)
  thread_local_store.locale(name)
end

def lock_for_writing(file = yardoc_file, &block)
  thread_local_store.lock_for_writing(file, &block)
end

def locked_for_writing?(file = yardoc_file)
  thread_local_store.locked_for_writing?(file)
end

def old_global_yardoc_file(spec, for_writing = false)
  path = spec.full_gem_path
  yfile = File.join(path, DEFAULT_YARDOC_FILE)
  return yfile if for_writing && File.writable?(path)
  return yfile if !for_writing && File.exist?(yfile)
end

def partial_resolve(namespace, name, type = nil)
  obj = at(name) || at('#' + name) if namespace.root?
  return obj if obj && (type.nil? || obj.type == type)
  [CodeObjects::NSEP, CodeObjects::CSEP, ''].each do |s|
    next if s.empty? && name =~ /^\w/
    path = name
    path = [namespace.path, name].join(s) if namespace != root
    found = at(path)
    return found if found && (type.nil? || found.type == type)
  end
  nil
end

def paths(reload = false)
  thread_local_store.keys(reload).map(&:to_s)
end

def po_dir
  Thread.current[:__yard_po_dir__] ||= DEFAULT_PO_DIR
end

def po_dir=(dir) Thread.current[:__yard_po_dir__] = dir end

def proxy_types
  thread_local_store.proxy_types
end

def register(object)
  return if object.is_a?(CodeObjects::Proxy)
  thread_local_store[object.path] = object
end

def resolve(namespace, name, inheritance = false, proxy_fallback = false, type = nil)
  thread_local_resolver.lookup_by_path name,
    :namespace => namespace, :inheritance => inheritance,
    :proxy_fallback => proxy_fallback, :type => type
end

def root; thread_local_store[:root] end

def save(merge = false, file = yardoc_file)
  thread_local_store.save(merge, file)
end

def single_object_db; Thread.current[:__yard_single_db__] end

def single_object_db=(v) Thread.current[:__yard_single_db__] = v end

def thread_local_resolver
  Thread.current[:__yard_resolver__] ||= RegistryResolver.new
end

def thread_local_store
  Thread.current[:__yard_registry__] ||= clear
end

def thread_local_store=(value)
  Thread.current[:__yard_registry__] = value
end

def yardoc_file
  Thread.current[:__yard_yardoc_file__] ||= DEFAULT_YARDOC_FILE
end

def yardoc_file=(v) Thread.current[:__yard_yardoc_file__] = v end

def yardoc_file_for_gem(gem, ver_require = ">= 0", for_writing = false)
  specs = YARD::GemIndex.find_all_by_name(gem, ver_require)
  return if specs.empty?
  result = nil
  specs.reverse.each do |spec|
    if gem =~ /^yard-doc-/
      path = File.join(spec.full_gem_path, DEFAULT_YARDOC_FILE)
      result = File.exist?(path) && !for_writing ? path : nil
      result ? break : next
    end
    if for_writing
      result = global_yardoc_file(spec, for_writing) ||
               old_global_yardoc_file(spec, for_writing) ||
               local_yardoc_file(spec, for_writing)
    else
      result = local_yardoc_file(spec, for_writing) ||
               global_yardoc_file(spec, for_writing) ||
               old_global_yardoc_file(spec, for_writing)
    end
    break if result
  end
  result
end