class Sprockets::Cache

The options hash is passed to the underlying cache implementation.
affect other processes if shared cache is being used.
Clear the entire cache. Be careful with this method since it could
clear(options)
Returns argument value.
value - A JSON serializable object.
key - An opaque String with a length less than 250 characters.
then later key “foo” with value “baz” is an undefined behavior.
Will only be called once per key. Setting a key “foo” with value “bar”,
set(key, value)
Returns an JSON serializable object.
key - An opaque String with a length less than 250 characters.
get(key)
The Backend cache store must implement two methods.
Backend cache interface
methods marked public on this class.
Environment#cache will always return a wrapped Cache interface. See the
environment.cache = Sprockets::Cache::MemoryStore.new(1000)
Always assign the backend store instance to Environment#cache=.
Public cache interface
even when the backend uses get/set or read/write.
Public: Wrapper interface to backend cache stores. Ensures a consistent API

def self.default_logger 

def self.default_logger
  logger = Logger.new($stderr)
  logger.level = Logger::FATAL
  logger
end

def clear(options=nil)

Returns truthy on success, potentially raises exception on failure

Public: Clear cache 
def clear(options=nil)
  @cache_wrapper.clear
  @fetch_cache.clear
end

def expand_key(key)

Returns a String with a length less than 250 characters.

key - JSON serializable key

Memcache.
The String should be under 250 characters so its compatible with

Internal: Expand object cache key into a short String key. 
def expand_key(key)
  digest_key = DigestUtils.pack_urlsafe_base64digest(DigestUtils.digest(key))
  namespace = digest_key[0, 2]
  "sprockets/v#{VERSION}/#{namespace}/#{digest_key}"
end

def fetch(key)

Returns a JSON serializable object.

cache.fetch("foo") { "bar" }

Examples

Must return a consistent JSON serializable object for the given key.
block -
key - JSON serializable key

Public: Prefer API to retrieve and set values in the cache store. 
def fetch(key)
  start = Time.now.to_f
  expanded_key = expand_key(key)
  value = @fetch_cache.get(expanded_key)
  if value.nil?
    value = @cache_wrapper.get(expanded_key)
    if value.nil?
      value = yield
      @cache_wrapper.set(expanded_key, value)
      @logger.debug do
        ms = "(#{((Time.now.to_f - start) * 1000).to_i}ms)"
        "Sprockets Cache miss #{peek_key(key)}  #{ms}"
      end
    end
    @fetch_cache.set(expanded_key, value)
  end
  value
end

def get(key, local = false)

Returns a JSON serializable object or nil if there was a cache miss.

local - Check local cache first (default: false)
key - JSON serializable key

Cache#fetch API over using this.
depending on the backend store being used. Prefer the
This API may be used publicly, but may have undefined behavior

store.
Public: Low level API to retrieve item directly from the backend cache 
def get(key, local = false)
  expanded_key = expand_key(key)
  if local && value = @fetch_cache.get(expanded_key)
    return value
  end
  value = @cache_wrapper.get(expanded_key)
  @fetch_cache.set(expanded_key, value) if local
  value
end

def get_cache_wrapper(cache) 

def get_cache_wrapper(cache)
  if cache.is_a?(Cache)
    cache
  # `Cache#get(key)` for Memcache
  elsif cache.respond_to?(:get)
    GetWrapper.new(cache)
  # `Cache#[key]` so `Hash` can be used
  elsif cache.respond_to?(:[])
    HashWrapper.new(cache)
  # `Cache#read(key)` for `ActiveSupport::Cache` support
  elsif cache.respond_to?(:read)
    ReadWriteWrapper.new(cache)
  else
    cache = Sprockets::Cache::NullStore.new
    GetWrapper.new(cache)
  end
end

def initialize(cache = nil, logger = self.class.default_logger)

cache - A compatible backend cache store instance.

use Environment#cache to retreive a wrapped interface.
Always assign a backend cache store instance to Environment#cache= and

Internal: Wrap a backend cache store. 
def initialize(cache = nil, logger = self.class.default_logger)
  @cache_wrapper = get_cache_wrapper(cache)
  @fetch_cache   = Cache::MemoryStore.new(1024)
  @logger        = logger
end

def inspect

Returns String.

Public: Pretty inspect 
def inspect
  "#<#{self.class} local=#{@fetch_cache.inspect} store=#{@cache_wrapper.cache.inspect}>"
end

def peek_key(key)

Returns a String with a length less than 100 characters.

Internal: Show first 100 characters of cache key for logging purposes. 
def peek_key(key)
  case key
  when Integer
    key.to_s
  when String
    key[0, PEEK_SIZE].inspect
  when Array
    str = []
    key.each { |k| str << peek_key(k) }
    str.join(':')[0, PEEK_SIZE]
  else
    peek_key(DigestUtils.pack_urlsafe_base64digest(DigestUtils.digest(key)))
  end
end

def set(key, value, local = false)

Returns the value argument.

local - Set on local cache (default: false)
a different value for the given key has undefined behavior.
value - A consistent JSON serializable object for the given key. Setting
key - JSON serializable key

Cache#fetch API over using this.
depending on the backend store being used. Prefer the
This API may be used publicly, but may have undefined behavior

Public: Low level API to set item directly to the backend cache store. 
def set(key, value, local = false)
  expanded_key = expand_key(key)
  @fetch_cache.set(expanded_key, value) if local
  @cache_wrapper.set(expanded_key, value)
end