class Ronn::Index

Maintains a list of links / references to manuals and other resources.

def self.[](path)

one exists.
file. The index is loaded from the corresponding index.txt file if
Retrieve an Index for , where is a directory or normal 
def self.[](path)
  (@indexes ||= {})[index_path_for_file(path)] ||=
    Index.new(index_path_for_file(path))
end

def self.index_path_for_file(file) 

def self.index_path_for_file(file)
  File.expand_path(
    if File.directory?(file)
      File.join(file, 'index.txt')
    else
      File.join(File.dirname(file), 'index.txt')
    end
  )
end

def <<(path) 

def <<(path)
  raise ArgumentError, "local paths only" if path =~ /(https?|mailto):/
  return self if any? { |ref| ref.path == File.expand_path(path) }
  relative_path = relative_to_index(path)
  @references << \
    if path =~ /\.ronn?$/
      reference manual(path).reference_name, relative_path
    else
      reference File.basename(path), relative_path
    end
  self
end

def [](name) 

def [](name)
  references.find { |ref| ref.name == name }
end

def add_manual(manual) 

def add_manual(manual)
  @manuals[File.expand_path(manual.path)] = manual
  self << manual.path
end

def each(&bk) 

def each(&bk)
  references.each(&bk)
end

def empty? 

def empty?
  references.empty?
end

def exist?

Determine whether the index file exists. 
def exist?
  File.exist?(path)
end

def first 

def first
  references.first
end

def initialize(path, &bk) 

def initialize(path, &bk)
  @path = path
  @references = []
  @manuals    = {}
  if block_given?
    read! yield
  elsif exist?
    read! File.read(path)
  end
end

def last 

def last
  references.last
end

def manual(path) 

def manual(path)
  @manuals[File.expand_path(path)] ||= Document.new(path)
end

def manuals 

def manuals
  select { |ref| ref.relative? && ref.ronn? }.
  map    { |ref| manual(ref.path) }
end

def read!(data)

Load index data from a string. 
def read!(data)
  data.each_line do |line|
    line = line.strip.gsub(/\s*#.*$/, '')
    if !line.empty?
      name, url = line.split(/ +/, 2)
      @references << reference(name, url)
    end
  end
end

def reference(name, path) 

def reference(name, path)
  Reference.new(self, name, path)
end

def relative_to_index(path) 

def relative_to_index(path)
  path = File.expand_path(path)
  index_dir = File.dirname(File.expand_path(self.path))
  path.sub(/^#{index_dir}\//, '')
end

def size 

def size
  references.size
end

def to_a 

def to_a
  references
end

def to_h 

def to_h
  to_a.map { |doc| doc.to_hash }
end

def to_text 

def to_text
  map { |ref| [ref.name, ref.location].join(' ') }.join("\n")
end