Class: ActiveSupport::Cache::FileStore

# File 'activesupport/lib/active_support/cache/file_store.rb', line 33

def clear(options = nil)
  root_dirs = (Dir.children(cache_path) - GITKEEP_FILES)
  FileUtils.rm_r(root_dirs.collect { |f| File.join(cache_path, f) })
rescue Errno::ENOENT, Errno::ENOTEMPTY
end

# File 'activesupport/lib/active_support/cache/file_store.rb', line 80

def decrement(name, amount = 1, options = nil)
  options = merged_options(options)
  key = normalize_key(name, options)

  instrument(:decrement, key, amount: amount) do
    modify_value(name, -amount, options)
  end
end

# File 'activesupport/lib/active_support/cache/file_store.rb', line 195

def delete_empty_directories(dir)
  return if File.realpath(dir) == File.realpath(cache_path)
  if Dir.children(dir).empty?
    Dir.delete(dir) rescue nil
    delete_empty_directories(File.dirname(dir))
  end
end

# File 'activesupport/lib/active_support/cache/file_store.rb', line 131

def delete_entry(key, **options)
  if File.exist?(key)
    begin
      File.delete(key)
      delete_empty_directories(File.dirname(key))
      true
    rescue
      # Just in case the error was caused by another process deleting the file first.
      raise if File.exist?(key)
      false
    end
  else
    false
  end
end

# File 'activesupport/lib/active_support/cache/file_store.rb', line 89

def delete_matched(matcher, options = nil)
  options = merged_options(options)
  matcher = key_matcher(matcher, options)

  instrument(:delete_matched, matcher.inspect) do
    search_dir(cache_path) do |path|
      key = file_path_key(path)
      delete_entry(path, **options) if key.match(matcher)
    end
  end
end

# File 'activesupport/lib/active_support/cache/file_store.rb', line 204

def ensure_cache_path(path)
  FileUtils.makedirs(path) unless File.exist?(path)
end

# File 'activesupport/lib/active_support/cache/file_store.rb', line 189

def file_path_key(path)
  fname = path[cache_path.to_s.size..-1].split(File::SEPARATOR, 4).last.delete(File::SEPARATOR)
  URI.decode_www_form_component(fname, Encoding::UTF_8)
end

# File 'activesupport/lib/active_support/cache/file_store.rb', line 60

def increment(name, amount = 1, options = nil)
  options = merged_options(options)
  key = normalize_key(name, options)

  instrument(:increment, key, amount: amount) do
    modify_value(name, amount, options)
  end
end

# File 'activesupport/lib/active_support/cache/file_store.rb', line 101

def inspect # :nodoc:
  "#<#{self.class.name} cache_path=#{@cache_path}, options=#{@options.inspect}>"
end

# File 'activesupport/lib/active_support/cache/file_store.rb', line 148

def lock_file(file_name, &block)
  if File.exist?(file_name)
    File.open(file_name, "r+") do |f|
      f.flock File::LOCK_EX
      yield
    ensure
      f.flock File::LOCK_UN
    end
  else
    yield
  end
end

# File 'activesupport/lib/active_support/cache/file_store.rb', line 222

def modify_value(name, amount, options)
  options = merged_options(options)
  key = normalize_key(name, options)
  version = normalize_version(name, options)
  amount = Integer(amount)

  lock_file(key) do
    entry = read_entry(key, **options)

    if !entry || entry.expired? || entry.mismatched?(version)
      write(name, amount, options)
      amount
    else
      num = entry.value.to_i + amount
      entry = Entry.new(num, expires_at: entry.expires_at, version: entry.version)
      write_entry(key, entry)
      num
    end
  end
end

# File 'activesupport/lib/active_support/cache/file_store.rb', line 162

def normalize_key(key, options)
  key = super
  fname = URI.encode_www_form_component(key)

  if fname.size > FILEPATH_MAX_SIZE
    fname = ActiveSupport::Digest.hexdigest(key)
  end

  hash = Zlib.adler32(fname)
  hash, dir_1 = hash.divmod(0x1000)
  dir_2 = hash.modulo(0x1000)

  # Make sure file name doesn't exceed file system limits.
  if fname.length < FILENAME_MAX_SIZE
    fname_paths = fname
  else
    fname_paths = []
    begin
      fname_paths << fname[0, FILENAME_MAX_SIZE]
      fname = fname[FILENAME_MAX_SIZE..-1]
    end until fname.blank?
  end

  File.join(cache_path, DIR_FORMATTER % dir_1, DIR_FORMATTER % dir_2, fname_paths)
end

# File 'activesupport/lib/active_support/cache/file_store.rb', line 106

def read_entry(key, **options)
  if payload = read_serialized_entry(key, **options)
    entry = deserialize_entry(payload)
    entry if entry.is_a?(Cache::Entry)
  end
end

# File 'activesupport/lib/active_support/cache/file_store.rb', line 113

def read_serialized_entry(key, **)
  File.binread(key) if File.exist?(key)
rescue => error
  logger.error("FileStoreError (#{error}): #{error.message}") if logger
  nil
end

# File 'activesupport/lib/active_support/cache/file_store.rb', line 208

def search_dir(dir, &callback)
  return if !File.exist?(dir)
  Dir.each_child(dir) do |d|
    name = File.join(dir, d)
    if File.directory?(name)
      search_dir(name, &callback)
    else
      callback.call name
    end
  end
end

# File 'activesupport/lib/active_support/cache/file_store.rb', line 120

def write_entry(key, entry, **options)
  write_serialized_entry(key, serialize_entry(entry, **options), **options)
end

# File 'activesupport/lib/active_support/cache/file_store.rb', line 124

def write_serialized_entry(key, payload, **options)
  return false if options[:unless_exist] && File.exist?(key)
  ensure_cache_path(File.dirname(key))
  File.atomic_write(key, cache_path) { |f| f.write(payload) }
  true
end