# class ActiveSupport::Cache::FileStore

A cache store implementation which stores everything on the filesystem.

FileStore implements the Strategy::LocalCache strategy which implements an in-memory cache inside of a block.

### Constants

DIR_FORMATTER
EXCLUDED_DIRS
FILENAME_MAX_SIZE

### Attributes

cache_path[R]

### Public Class Methods

new(cache_path, options = nil) click to toggle source

    # File lib/active_support/cache/file_store.rb, line 19
    def initialize(cache_path, options = nil)
      super(options)
      @cache_path = cache_path.to_s
      extend Strategy::LocalCache
    end

### Public Instance Methods

cleanup(options = nil) click to toggle source

    # File lib/active_support/cache/file_store.rb, line 30
    def cleanup(options = nil)
      options = merged_options(options)
      each_key(options) do |key|
        entry = read_entry(key, options)
        delete_entry(key, options) if entry && entry.expired?
      end
    end

clear(options = nil) click to toggle source

    # File lib/active_support/cache/file_store.rb, line 25
    def clear(options = nil)
      root_dirs = Dir.entries(cache_path).reject{|f| f.in?(EXCLUDED_DIRS)}
      FileUtils.rm_r(root_dirs.collect{|f| File.join(cache_path, f)})
    end

decrement(name, amount = 1, options = nil) click to toggle source

    # File lib/active_support/cache/file_store.rb, line 52
    def decrement(name, amount = 1, options = nil)
      file_name = key_file_path(namespaced_key(name, options))
      lock_file(file_name) do
        options = merged_options(options)
        if num = read(name, options)
          num = num.to_i - amount
          write(name, num, options)
          num
        else
          nil
        end
      end
    end

delete_matched(matcher, options = nil) click to toggle source

    # File lib/active_support/cache/file_store.rb, line 66
    def delete_matched(matcher, options = nil)
      options = merged_options(options)
      instrument(:delete_matched, matcher.inspect) do
        matcher = key_matcher(matcher, options)
        search_dir(cache_path) do |path|
          key = file_path_key(path)
          delete_entry(key, options) if key.match(matcher)
        end
      end
    end

increment(name, amount = 1, options = nil) click to toggle source

    # File lib/active_support/cache/file_store.rb, line 38
    def increment(name, amount = 1, options = nil)
      file_name = key_file_path(namespaced_key(name, options))
      lock_file(file_name) do
        options = merged_options(options)
        if num = read(name, options)
          num = num.to_i + amount
          write(name, num, options)
          num
        else
          nil
        end
      end
    end

### Protected Instance Methods

delete_entry(key, options) click to toggle source

    # File lib/active_support/cache/file_store.rb, line 95
    def delete_entry(key, options)
      file_name = key_file_path(key)
      if File.exist?(file_name)
        begin
          File.delete(file_name)
          delete_empty_directories(File.dirname(file_name))
          true
        rescue => e
          # Just in case the error was caused by another process deleting the file first.
          raise e if File.exist?(file_name)
          false
        end
      end
    end

read_entry(key, options) click to toggle source

    # File lib/active_support/cache/file_store.rb, line 79
    def read_entry(key, options)
      file_name = key_file_path(key)
      if File.exist?(file_name)
        File.open(file_name) { |f| Marshal.load(f) }
      end
    rescue
      nil
    end

write_entry(key, entry, options) click to toggle source

    # File lib/active_support/cache/file_store.rb, line 88
    def write_entry(key, entry, options)
      file_name = key_file_path(key)
      ensure_cache_path(File.dirname(file_name))
      File.atomic_write(file_name, cache_path) {|f| Marshal.dump(entry, f)}
      true
    end