class Geminabox::Geminabox::DiskCache

def cache(key)
  key_hash = key_hash(key)
  read(key_hash) || write(key_hash, yield)
end

def ensure_dir_exists!
  FileUtils.mkdir_p(root_path)
end

def flush
  FileUtils.rm_rf(root_path)
  ensure_dir_exists!
end

def flush_key(key)
  path = path(key_hash(key))
  FileUtils.rm_f(path)
end

def initialize(root_path)
  @root_path = root_path
  ensure_dir_exists!
end

def key_hash(key)
  Digest::MD5.hexdigest(key)
end

def marshal_cache(key)
  key_hash = key_hash(key)
  marshal_read(key_hash) || marshal_write(key_hash, yield)
end

def marshal_read(key_hash)
  read_int(key_hash) do |path|
    begin
      File.open(path) {|fp| Marshal.load(fp) }
    rescue Errno::ENOENT, EOFError
      # There is a possibility that the file is removed by another process.
      # Marshal.load raises EOFError if the file is removed after File.open(path) succeeds.
      # Return nil if the file does not exist.
      nil
    end
  end
end

def marshal_write(key_hash, value)
  write_int(key_hash) { |f| Marshal.dump(value, f) }
  value
end

def path(key_hash)
  File.join(root_path, key_hash)
end

def read(key_hash)
  read_int(key_hash) do |path|
    begin
      File.read(path)
    rescue Errno::ENOENT
      # There is a possibility that the file is removed by another process
      # after checking File.exist?. Return nil if the file does not exist.
      nil
    end
  end
end

def read_int(key_hash)
  path = path(key_hash)
  yield(path) if File.exist?(path)
end

def write(key_hash, value)
  write_int(key_hash) { |f| f << value }
  value
end

def write_int(key_hash)
  File.open(path(key_hash), 'wb') { |f| yield(f) }
end