class ActiveSupport::Cache::Entry

to save space in the cache.
Entry that is put into caches. It supports expiration time on entries and can compress values

def compressed? 

def compressed?
  @compressed
end

def create (raw_value, created_at, options = {})

of as serialized Ruby objects.
used by implementations that store cache entries in a native format instead
Create an entry with internal attributes set. This method is intended to be 
def create (raw_value, created_at, options = {})
  entry = new(nil)
  entry.instance_variable_set(:@value, raw_value)
  entry.instance_variable_set(:@created_at, created_at.to_f)
  entry.instance_variable_set(:@compressed, !!options[:compressed])
  entry.instance_variable_set(:@expires_in, options[:expires_in])
  entry
end

def expired?

value set when the entry was created.
Check if the entry is expired. The +expires_in+ parameter can override the 
def expired?
  if @expires_in && @created_at + @expires_in <= Time.now.to_f
    true
  else
    false
  end
end

def expires_at

Seconds since the epoch when the cache entry will expire. 
def expires_at
  @expires_in ? @created_at + @expires_in : nil
end

def expires_at=(time)

Set a new time to live on the entry so it expires at the given time. 
def expires_at=(time)
  if time
    @expires_in = time.to_f - @created_at
  else
    @expires_in = nil
  end
end

def initialize(value, options = {})

+:compress+, +:compress_threshold+, and +:expires_in+.
Create a new cache entry for the specified value. Options supported are 
def initialize(value, options = {})
  @compressed = false
  @expires_in = options[:expires_in]
  @expires_in = @expires_in.to_f if @expires_in
  @created_at = Time.now.to_f
  if value
    if should_compress?(value, options)
      @value = Zlib::Deflate.deflate(Marshal.dump(value))
      @compressed = true
    else
      @value = value
    end
  else
    @value = nil
  end
end

def raw_value

Get the raw value. This value may be serialized and compressed. 
def raw_value
  @value
end

def should_compress?(value, options) 

def should_compress?(value, options)
  if options[:compress] && value
    unless value.is_a?(Numeric)
      compress_threshold = options[:compress_threshold] || DEFAULT_COMPRESS_LIMIT
      serialized_value = value.is_a?(String) ? value : Marshal.dump(value)
      return true if serialized_value.size >= compress_threshold
    end
  end
  false
end

def size

if the data is compressed.
Get the size of the cached value. This could be less than value.size 
def size
  if @value.nil?
    0
  elsif @value.respond_to?(:bytesize)
    @value.bytesize
  else
    Marshal.dump(@value).bytesize
  end
end

def value

Get the value stored in the cache. 
def value
  if @value
    val = compressed? ? Marshal.load(Zlib::Inflate.inflate(@value)) : @value
    unless val.frozen?
      val.freeze rescue nil
    end
    val
  end
end