activesupport 3.0.pre → 3.0.0.rc

data/CHANGELOG

@@ -1,4 +1,124 @@
-*Edge*
+*Rails 3.0.0 [release candidate] (July 26th, 2010)*
+
+* Removed Object#returning, Object#tap should be used instead. [Santiago Pastorino]
+
+* Deprecation behavior is no longer hardcoded to the name of the environment.
+  Instead, it is set via config.active_support.deprecation and can be one
+  of :log, :stderr or :notify. :notify is a new style that sends the warning
+  via ActiveSupport::Notifications, and is the new default for production
+  [Yehuda Katz]
+
+* Renamed ActiveSupport::Dependecies.load_(once_)paths to autoload_(once_)paths. [fxn]
+
+* Added ActiveSupport::FileUpdateChecker to execute a block only if a set of files changed, used by Router and I18n locale files. [José Valim]
+
+* Added ActiveSupport::DescendantsTracker to track descendants with support to constants reloading. [José Valim]
+
+* ActiveSupport::OrderedHash#merge and #merge! accept a block. #4838 [Paul Mucur, fxn]
+
+* Date#since, #ago, #beginning_of_day, #end_of_day, and #xmlschema honor now the user time zone if set. [Geoff Buesing]
+
+
+*Rails 3.0.0 [beta 4] (June 8th, 2010)*
+
+* Extracted String#truncate from TextHelper#truncate [DHH]
+
+* Ruby 1.9: support UTF-8 case folding.  #4595 [Norman Clarke]
+
+* Removes Array#rand and backports Array#sample from Ruby 1.9, thanks to Marc-Andre Lafortune. [fxn]
+
+* Ruby 1.9: Renames last_(month|year) to prev_(month|year) in Date and Time. [fxn]
+
+* Aliases Date#sunday to Date#end_of_week. [fxn]
+
+* Backports Date#>> from 1.9 so that calculations do the right thing around the calendar reform. [fxn]
+
+* Date#to_time handles properly years in the range 0..138. [fxn]
+
+* Deprecate {{}} as interpolation syntax for I18n in favor of %{} [José Valim]
+
+* Array#to_xml is more powerful and able to handle the same types as Hash#to_xml #4490 [Neeraj Singh]
+
+* Harmonize the caching API and refactor the backends.  #4452 [Brian Durand]
+  All caches:
+  * Add default options to initializer that will be sent to all read, write, fetch, exist?, increment, and decrement
+  * Add support for the :expires_in option to fetch and write for all caches. Cache entries are stored with the create timestamp and a ttl so that expiration can be handled independently of the implementation.
+  * Add support for a :namespace option. This can be used to set a global prefix for cache entries.
+  * Deprecate expand_cache_key on ActiveSupport::Cache and move it to ActionController::Caching and ActionDispatch::Http::Cache since the logic in the method used some Rails specific environment variables and was only used by ActionPack classes. Not very DRY but there didn't seem to be a good shared spot and ActiveSupport really shouldn't be Rails specific.
+  * Add support for :race_condition_ttl to fetch. This setting can prevent race conditions on fetch calls where several processes try to regenerate a recently expired entry at once.
+  * Add support for :compress option to fetch and write which will compress any data over a configurable threshold.
+  * Nil values can now be stored in the cache and are distinct from cache misses for fetch.
+  * Easier API to create new implementations. Just need to implement the methods read_entry, write_entry, and delete_entry instead of overwriting existing methods.
+  * Since all cache implementations support storing objects, update the docs to state that ActiveCache::Cache::Store implementations should store objects. Keys, however, must be strings since some implementations require that.
+  * Increase test coverage.
+  * Document methods which are provided as convenience but which may not be universally available.
+
+  MemoryStore:
+  * MemoryStore can now safely be used as the cache for single server sites.
+  * Make thread safe so that the default cache implementation used by Rails is thread safe. The overhead is minimal and it is still the fastest store available.
+  * Provide :size initialization option indicating the maximum size of the cache in memory (defaults to 32Mb).
+  * Add prune logic that removes the least recently used cache entries to keep the cache size from exceeding the max.
+  * Deprecated SynchronizedMemoryStore since it isn't needed anymore.
+
+  FileStore:
+  * Escape key values so they will work as file names on all file systems, be consistent, and case sensitive
+  * Use a hash algorithm to segment the cache into sub directories so that a large cache doesn't exceed file system limits.
+  * FileStore can be slow so implement the LocalCache strategy to cache reads for the duration of a request.
+  * Add cleanup method to keep the disk from filling up with expired entries.
+  * Fix increment and decrement to use file system locks so they are consistent between processes.
+
+  MemCacheStore:
+  * Support all keys. Previously keys with spaces in them would fail
+  * Deprecate CompressedMemCacheStore since it isn't needed anymore (use :compress => true)
+
+* JSON: encode objects that don't have a native JSON representation using to_hash, if available, instead of instance_values (the old fallback) or to_s (other encoders' default). Encode BigDecimal and Regexp encode as strings to conform with other encoders. Try to transcode non-UTF-8 strings.  [Jeremy Kemper]
+
+
+*Rails 3.0.0 [beta 3] (April 13th, 2010)*
+
+* HashWithIndifferentAccess: remove inherited symbolize_keys! since its keys are always strings.  [Santiago Pastorino]
+
+* Improve transliteration quality.  #4374 [Norman Clarke]
+
+* Speed up and add Ruby 1.9 support for ActiveSupport::Multibyte::Chars#tidy_bytes.  #4350 [Norman Clarke]
+
+
+*Rails 3.0.0 [beta 2] (April 1st, 2010)*
+
+* Reduced load time by deferring configuration of classes using
+  ActiveSupport::on_load(:component_name) [YK]
+
+* Rename #metaclass to #singleton_class now that ruby-core has decided [JK]
+
+* New assertions assert_blank and assert_present.  #4299 [Juanjo Bazan] 
+
+* Use Object#singleton_class instead of #metaclass. Prefer Ruby's choice.  [Jeremy Kemper]
+
+* JSON backend for YAJL. Preferred if available.  #2666 [Brian Lopez]
+
+
+*Rails 3.0.0 [beta 1] (February 4, 2010)*
+
+* Introduce class_attribute to declare inheritable class attributes. Writing an attribute on a subclass behaves just like overriding the superclass reader method.  Unifies and replaces most usage of cattr_accessor, class_inheritable_attribute, superclass_delegating_attribute, and extlib_inheritable_attribute.  [Jeremy Kemper, Yehuda Katz]
+
+* Time#- with a DateTime argument behaves the same as with a Time argument, i.e. returns the difference between self and arg as a Float #3476 [Geoff Buesing]
+
+* YAML serialization for OrderedHash.  #3608 [Gregor Schmidt]
+
+* Update bundled TZInfo to v0.3.16 [Geoff Buesing]
+
+* Georgetown TimeZone is now mapped to "America/Guyana" instead of "America/Argentina/San_Juan" #1821 [Geoff Buesing, Reuben Sivan]
+
+* Changed the default ActiveSupport.use_standard_json_time_format from false to true and
+ActiveSupport.escape_html_entities_in_json from true to false to match previously announced Rails 3 defaults [DHH]
+
+* Added Object#presence that returns the object if it's #present? otherwise returns nil [DHH/Colin Kelley]
+
+* Add Enumerable#exclude? to bring parity to Enumerable#include? and avoid if !x.include?/else calls [DHH]
+
+* Update Edinburgh TimeZone to use "Europe/London" instead of "Europe/Dublin" #3310 [Phil Ross]
+
+* Update bundled TZInfo to v0.3.15 [Geoff Buesing]
 
 * JSON: +Object#to_json+ calls +as_json+ to coerce itself into something natively encodable like +Hash+, +Integer+, or +String+. Override +as_json+ instead of +to_json+ so you're JSON library agnostic.  [Jeremy Kemper]
 

data/README.rdoc

@@ -0,0 +1,33 @@
+= Active Support -- Utility classes and Ruby extensions from Rails
+
+Active Support is a collection of utility classes and standard library
+extensions that were found useful for the Rails framework. These additions
+reside in this package so they can be loaded as needed in Ruby projects
+outside of Rails.
+
+
+== Download and installation
+
+The latest version of Active Support can be installed with Rubygems:
+
+  % [sudo] gem install activesupport
+
+Source code can be downloaded as part of the Rails project on GitHub
+
+* http://github.com/rails/rails/tree/master/activesupport/
+
+
+== License
+
+Active Support is released under the MIT license.
+
+
+== Support
+
+API documentation is at
+
+* http://api.rubyonrails.com
+
+Bug reports and feature requests can be filed with the rest for the Ruby on Rails project here:
+
+* https://rails.lighthouseapp.com/projects/8994-ruby-on-rails/tickets

data/lib/active_support.rb

@@ -34,8 +34,46 @@ module ActiveSupport
   end
 end
 
-require 'active_support/autoload'
-require 'active_support/vendor'
+require "active_support/dependencies/autoload"
 
-require 'i18n'
-I18n.load_path << "#{File.dirname(__FILE__)}/active_support/locale/en.yml"
+module ActiveSupport
+  extend ActiveSupport::Autoload
+
+  autoload :DescendantsTracker
+  autoload :FileUpdateChecker
+  autoload :LogSubscriber
+  autoload :Notifications
+
+  # TODO: Narrow this list down
+  eager_autoload do
+    autoload :BacktraceCleaner
+    autoload :Base64
+    autoload :BasicObject
+    autoload :Benchmarkable
+    autoload :BufferedLogger
+    autoload :Cache
+    autoload :Callbacks
+    autoload :Concern
+    autoload :Configurable
+    autoload :Deprecation
+    autoload :Gzip
+    autoload :Inflector
+    autoload :JSON
+    autoload :Memoizable
+    autoload :MessageEncryptor
+    autoload :MessageVerifier
+    autoload :Multibyte
+    autoload :OptionMerger
+    autoload :OrderedHash
+    autoload :OrderedOptions
+    autoload :Rescuable
+    autoload :SecureRandom
+    autoload :StringInquirer
+    autoload :XmlMini
+  end
+
+  autoload :SafeBuffer, "active_support/core_ext/string/output_safety"
+  autoload :TestCase
+end
+
+autoload :I18n, "active_support/i18n"

data/lib/active_support/backtrace_cleaner.rb

@@ -4,12 +4,14 @@ module ActiveSupport
   # context, so only the relevant lines are included.
   #
   # If you need to reconfigure an existing BacktraceCleaner, like the one in Rails, to show as much as possible, you can always
-  # call BacktraceCleaner#remove_silencers!
+  # call BacktraceCleaner#remove_silencers! Also, if you need to reconfigure an existing BacktraceCleaner so that it does not
+  # filter or modify the paths of any lines of the backtrace, you can call BacktraceCleaner#remove_filters! These two methods
+  # will give you a completely untouched backtrace.
   #
   # Example:
   #
   #   bc = BacktraceCleaner.new
-  #   bc.add_filter   { |line| line.gsub(Rails.root, '') } 
+  #   bc.add_filter   { |line| line.gsub(Rails.root, '') }
   #   bc.add_silencer { |line| line =~ /mongrel|rubygems/ }
   #   bc.clean(exception.backtrace) # will strip the Rails.root prefix and skip any lines from mongrel or rubygems
   #
@@ -18,10 +20,19 @@ module ActiveSupport
     def initialize
       @filters, @silencers = [], []
     end
-    
+
     # Returns the backtrace after all filters and silencers has been run against it. Filters run first, then silencers.
-    def clean(backtrace)
-      silence(filter(backtrace))
+    def clean(backtrace, kind = :silent)
+      filtered = filter(backtrace)
+
+      case kind
+      when :silent
+        silence(filtered)
+      when :noise
+        noise(filtered)
+      else
+        filtered
+      end
     end
 
     # Adds a filter from the block provided. Each line in the backtrace will be mapped against this filter.
@@ -51,21 +62,32 @@ module ActiveSupport
       @silencers = []
     end
 
-    
+    def remove_filters!
+      @filters = []
+    end
+
     private
       def filter(backtrace)
         @filters.each do |f|
           backtrace = backtrace.map { |line| f.call(line) }
         end
-        
+
         backtrace
       end
-      
+
       def silence(backtrace)
         @silencers.each do |s|
           backtrace = backtrace.reject { |line| s.call(line) }
         end
-        
+
+        backtrace
+      end
+
+      def noise(backtrace)
+        @silencers.each do |s|
+          backtrace = backtrace.select { |line| s.call(line) }
+        end
+
         backtrace
       end
   end

data/lib/active_support/benchmarkable.rb

@@ -1,4 +1,5 @@
 require 'active_support/core_ext/benchmark'
+require 'active_support/core_ext/hash/keys'
 
 module ActiveSupport
   module Benchmarkable

data/lib/active_support/buffered_logger.rb

@@ -53,7 +53,6 @@ module ActiveSupport
         FileUtils.mkdir_p(File.dirname(log))
         @log = open(log, (File::WRONLY | File::APPEND | File::CREAT))
         @log.sync = true
-        @log.write("# Logfile created on %s" % [Time.now.to_s])
       end
     end
 
@@ -102,7 +101,11 @@ module ActiveSupport
       @guard.synchronize do
         unless buffer.empty?
           old_buffer = buffer
-          @log.write(old_buffer.join)
+          all_content = StringIO.new
+          old_buffer.each do |content|
+            all_content << content
+          end
+          @log.write(all_content.string)
         end
 
         # Important to do this even if buffer was empty or else @buffer will

data/lib/active_support/builder.rb

@@ -0,0 +1,6 @@
+begin
+  require 'builder'
+rescue LoadError => e
+  $stderr.puts "You don't have builder installed in your application. Please add it to your Gemfile and run bundle install"
+  raise e
+end

data/lib/active_support/cache.rb

@@ -1,23 +1,30 @@
 require 'benchmark'
+require 'zlib'
+require 'active_support/core_ext/array/extract_options'
+require 'active_support/core_ext/array/wrap'
 require 'active_support/core_ext/benchmark'
 require 'active_support/core_ext/exception'
 require 'active_support/core_ext/class/attribute_accessors'
-
-%w(hash nil string time date date_time array big_decimal range object boolean).each do |library|
-  require "active_support/core_ext/#{library}/conversions"
-end
-
-# require 'active_support/core_ext' # FIXME: pulling in all to_param extensions
+require 'active_support/core_ext/numeric/bytes'
+require 'active_support/core_ext/numeric/time'
+require 'active_support/core_ext/object/to_param'
+require 'active_support/core_ext/string/inflections'
 
 module ActiveSupport
   # See ActiveSupport::Cache::Store for documentation.
   module Cache
     autoload :FileStore, 'active_support/cache/file_store'
     autoload :MemoryStore, 'active_support/cache/memory_store'
-    autoload :SynchronizedMemoryStore, 'active_support/cache/synchronized_memory_store'
     autoload :MemCacheStore, 'active_support/cache/mem_cache_store'
+    autoload :SynchronizedMemoryStore, 'active_support/cache/synchronized_memory_store'
     autoload :CompressedMemCacheStore, 'active_support/cache/compressed_mem_cache_store'
 
+    EMPTY_OPTIONS = {}.freeze
+
+    # These options mean something to all cache implementations. Individual cache
+    # implementations may support additional options.
+    UNIVERSAL_OPTIONS = [:namespace, :compress, :compress_threshold, :expires_in, :race_condition_ttl]
+
     module Strategy
       autoload :LocalCache, 'active_support/cache/strategy/local_cache'
     end
@@ -33,7 +40,7 @@ module ActiveSupport
     #
     #   ActiveSupport::Cache.lookup_store(:memory_store)
     #   # => returns a new ActiveSupport::Cache::MemoryStore object
-    #   
+    #
     #   ActiveSupport::Cache.lookup_store(:mem_cache_store)
     #   # => returns a new ActiveSupport::Cache::MemCacheStore object
     #
@@ -48,7 +55,7 @@ module ActiveSupport
     #   ActiveSupport::Cache.lookup_store(MyOwnCacheStore.new)
     #   # => returns MyOwnCacheStore.new
     def self.lookup_store(*store_option)
-      store, *parameters = *([ store_option ].flatten)
+      store, *parameters = *Array.wrap(store_option).flatten
 
       case store
       when Symbol
@@ -62,15 +69,12 @@ module ActiveSupport
       end
     end
 
-    RAILS_CACHE_ID   = ENV["RAILS_CACHE_ID"]
-    RAILS_APP_VERION = ENV["RAILS_APP_VERION"]
-    EXPANDED_CACHE   = RAILS_CACHE_ID || RAILS_APP_VERION
-
     def self.expand_cache_key(key, namespace = nil)
       expanded_cache_key = namespace ? "#{namespace}/" : ""
 
-      if EXPANDED_CACHE
-        expanded_cache_key << "#{RAILS_CACHE_ID || RAILS_APP_VERION}/"
+      prefix = ENV["RAILS_CACHE_ID"] || ENV["RAILS_APP_VERSION"]
+      if prefix
+        expanded_cache_key << "#{prefix}/"
       end
 
       expanded_cache_key <<
@@ -95,26 +99,75 @@ module ActiveSupport
     # ActiveSupport::Cache::MemCacheStore. MemCacheStore is currently the most
     # popular cache store for large production websites.
     #
-    # ActiveSupport::Cache::Store is meant for caching strings. Some cache
-    # store implementations, like MemoryStore, are able to cache arbitrary
-    # Ruby objects, but don't count on every cache store to be able to do that.
+    # Some implementations may not support all methods beyond the basic cache
+    # methods of +fetch+, +write+, +read+, +exist?+, and +delete+.
+    #
+    # ActiveSupport::Cache::Store can store any serializable Ruby object.
     #
     #   cache = ActiveSupport::Cache::MemoryStore.new
-    #   
+    #
     #   cache.read("city")   # => nil
     #   cache.write("city", "Duckburgh")
     #   cache.read("city")   # => "Duckburgh"
+    #
+    # Keys are always translated into Strings and are case sensitive. When an
+    # object is specified as a key, its +cache_key+ method will be called if it
+    # is defined. Otherwise, the +to_param+ method will be called. Hashes and
+    # Arrays can be used as keys. The elements will be delimited by slashes
+    # and Hashes elements will be sorted by key so they are consistent.
+    #
+    #   cache.read("city") == cache.read(:city)   # => true
+    #
+    # Nil values can be cached.
+    #
+    # If your cache is on a shared infrastructure, you can define a namespace for
+    # your cache entries. If a namespace is defined, it will be prefixed on to every
+    # key. The namespace can be either a static value or a Proc. If it is a Proc, it
+    # will be invoked when each key is evaluated so that you can use application logic
+    # to invalidate keys.
+    #
+    #   cache.namespace = lambda { @last_mod_time }  # Set the namespace to a variable
+    #   @last_mod_time = Time.now  # Invalidate the entire cache by changing namespace
+    #
+    # All caches support auto expiring content after a specified number of seconds.
+    # To set the cache entry time to live, you can either specify +:expires_in+ as
+    # an option to the constructor to have it affect all entries or to the +fetch+
+    # or +write+ methods for just one entry.
+    #
+    #   cache = ActiveSupport::Cache::MemoryStore.new(:expire_in => 5.minutes)
+    #   cache.write(key, value, :expire_in => 1.minute)  # Set a lower value for one entry
+    #
+    # Caches can also store values in a compressed format to save space and reduce
+    # time spent sending data. Since there is some overhead, values must be large
+    # enough to warrant compression. To turn on compression either pass
+    # <tt>:compress => true</tt> in the initializer or to +fetch+ or +write+.
+    # To specify the threshold at which to compress values, set
+    # <tt>:compress_threshold</tt>. The default threshold is 32K.
     class Store
-      cattr_accessor :logger, :instance_writter => false
+
+      cattr_accessor :logger, :instance_writer => true
 
       attr_reader :silence
       alias :silence? :silence
 
+      # Create a new cache. The options will be passed to any write method calls except
+      # for :namespace which can be used to set the global namespace for the cache.
+      def initialize (options = nil)
+        @options = options ? options.dup : {}
+      end
+
+      # Get the default options set when the cache was created.
+      def options
+        @options ||= {}
+      end
+
+      # Silence the logger.
       def silence!
         @silence = true
         self
       end
 
+      # Silence the logger within a block.
       def mute
         previous_silence, @silence = defined?(@silence) && @silence, true
         yield
@@ -142,7 +195,7 @@ module ActiveSupport
       #
       #   cache.write("today", "Monday")
       #   cache.fetch("today")  # => "Monday"
-      #   
+      #
       #   cache.fetch("city")   # => nil
       #   cache.fetch("city") do
       #     "Duckburgh"
@@ -155,29 +208,98 @@ module ActiveSupport
       #   cache.write("today", "Monday")
       #   cache.fetch("today", :force => true)  # => nil
       #
+      # Setting <tt>:compress</tt> will store a large cache entry set by the call
+      # in a compressed format.
+      #
+      # Setting <tt>:expires_in</tt> will set an expiration time on the cache
+      # entry if it is set by call.
+      #
+      # Setting <tt>:race_condition_ttl</tt> will invoke logic on entries set with
+      # an <tt>:expires_in</tt> option. If an entry is found in the cache that is
+      # expired and it has been expired for less than the number of seconds specified
+      # by this option and a block was passed to the method call, then the expiration
+      # future time of the entry in the cache will be updated to that many seconds
+      # in the and the block will be evaluated and written to the cache.
+      #
+      # This is very useful in situations where a cache entry is used very frequently
+      # under heavy load. The first process to find an expired cache entry will then
+      # become responsible for regenerating that entry while other processes continue
+      # to use the slightly out of date entry. This can prevent race conditions where
+      # too many processes are trying to regenerate the entry all at once. If the
+      # process regenerating the entry errors out, the entry will be regenerated
+      # after the specified number of seconds.
+      #
+      #   # Set all values to expire after one minute.
+      #   cache = ActiveSupport::Cache::MemoryCache.new(:expires_in => 1.minute)
+      #
+      #   cache.write("foo", "original value")
+      #   val_1 = nil
+      #   val_2 = nil
+      #   sleep 60
+      #
+      #   Thread.new do
+      #     val_1 = cache.fetch("foo", :race_condition_ttl => 10) do
+      #       sleep 1
+      #       "new value 1"
+      #     end
+      #   end
+      #
+      #   Thread.new do
+      #     val_2 = cache.fetch("foo", :race_condition_ttl => 10) do
+      #       "new value 2"
+      #     end
+      #   end
+      #
+      #   # val_1 => "new value 1"
+      #   # val_2 => "original value"
+      #   # cache.fetch("foo") => "new value 1"
+      #
       # Other options will be handled by the specific cache store implementation.
-      # Internally, #fetch calls #read, and calls #write on a cache miss.
+      # Internally, #fetch calls #read_entry, and calls #write_entry on a cache miss.
       # +options+ will be passed to the #read and #write calls.
       #
-      # For example, MemCacheStore's #write method supports the +:expires_in+
-      # option, which tells the memcached server to automatically expire the
-      # cache item after a certain period. This options is also supported by
-      # FileStore's #read method. We can use this option with #fetch too:
+      # For example, MemCacheStore's #write method supports the +:raw+
+      # option, which tells the memcached server to store all values as strings.
+      # We can use this option with #fetch too:
       #
       #   cache = ActiveSupport::Cache::MemCacheStore.new
-      #   cache.fetch("foo", :force => true, :expires_in => 5.seconds) do
-      #     "bar"
+      #   cache.fetch("foo", :force => true, :raw => true) do
+      #     :bar
       #   end
       #   cache.fetch("foo")  # => "bar"
-      #   sleep(6)
-      #   cache.fetch("foo")  # => nil
-      def fetch(key, options = {}, &block)
-        if !options[:force] && value = read(key, options)
-          value
-        elsif block_given?
-          result = instrument(:generate, key, options, &block)
-          write(key, result, options)
-          result
+      def fetch(name, options = nil)
+        if block_given?
+          options = merged_options(options)
+          key = namespaced_key(name, options)
+          unless options[:force]
+            entry = instrument(:read, name, options) do |payload|
+              payload[:super_operation] = :fetch if payload
+              read_entry(key, options)
+            end
+          end
+          if entry && entry.expired?
+            race_ttl = options[:race_condition_ttl].to_f
+            if race_ttl and Time.now.to_f - entry.expires_at <= race_ttl
+              entry.expires_at = Time.now + race_ttl
+              write_entry(key, entry, :expires_in => race_ttl * 2)
+            else
+              delete_entry(key, options)
+            end
+            entry = nil
+          end
+
+          if entry
+            instrument(:fetch_hit, name, options) { |payload| }
+            entry.value
+          else
+            result = instrument(:generate, name, options) do |payload|
+              yield
+            end
+            write(name, result, options)
+            result
+          end
+        else
+          read(name, options)
         end
       end
 
@@ -185,15 +307,50 @@ module ActiveSupport
       # the cache with the given key, then that data is returned. Otherwise,
       # nil is returned.
       #
-      # You may also specify additional options via the +options+ argument.
-      # The specific cache store implementation will decide what to do with
-      # +options+.
+      # Options are passed to the underlying cache implementation.
+      def read(name, options = nil)
+        options = merged_options(options)
+        key = namespaced_key(name, options)
+        instrument(:read, name, options) do |payload|
+          entry = read_entry(key, options)
+          if entry
+            if entry.expired?
+              delete_entry(key, options)
+              payload[:hit] = false if payload
+              nil
+            else
+              payload[:hit] = true if payload
+              entry.value
+            end
+          else
+            payload[:hit] = false if payload
+            nil
+          end
+        end
+      end
+
+      # Read multiple values at once from the cache. Options can be passed
+      # in the last argument.
+      #
+      # Some cache implementation may optimize this method.
       #
-      # For example, FileStore supports the +:expires_in+ option, which
-      # makes the method return nil for cache items older than the specified
-      # period.
-      def read(key, options = nil, &block)
-        instrument(:read, key, options, &block)
+      # Returns a hash mapping the names provided to the values found.
+      def read_multi(*names)
+        options = names.extract_options!
+        options = merged_options(options)
+        results = {}
+        names.each do |name|
+          key = namespaced_key(name, options)
+          entry = read_entry(key, options)
+          if entry
+            if entry.expired?
+              delete_entry(key)
+            else
+              results[name] = entry.value
+            end
+          end
+        end
+        results
       end
 
       # Writes the given value to the cache, with the given key.
@@ -201,70 +358,283 @@ module ActiveSupport
       # You may also specify additional options via the +options+ argument.
       # The specific cache store implementation will decide what to do with
       # +options+.
-      # 
-      # For example, MemCacheStore supports the +:expires_in+ option, which
-      # tells the memcached server to automatically expire the cache item after
-      # a certain period:
+      def write(name, value, options = nil)
+        options = merged_options(options)
+        instrument(:write, name, options) do |payload|
+          entry = Entry.new(value, options)
+          write_entry(namespaced_key(name, options), entry, options)
+        end
+      end
+
+      # Delete an entry in the cache. Returns +true+ if there was an entry to delete.
       #
-      #   cache = ActiveSupport::Cache::MemCacheStore.new
-      #   cache.write("foo", "bar", :expires_in => 5.seconds)
-      #   cache.read("foo")  # => "bar"
-      #   sleep(6)
-      #   cache.read("foo")  # => nil
-      def write(key, value, options = nil, &block)
-        instrument(:write, key, options, &block)
+      # Options are passed to the underlying cache implementation.
+      def delete(name, options = nil)
+        options = merged_options(options)
+        instrument(:delete, name) do |payload|
+          delete_entry(namespaced_key(name, options), options)
+        end
       end
 
-      def delete(key, options = nil, &block)
-        instrument(:delete, key, options, &block)
+      # Return true if the cache contains an entry with this name.
+      #
+      # Options are passed to the underlying cache implementation.
+      def exist?(name, options = nil)
+        options = merged_options(options)
+        instrument(:exist?, name) do |payload|
+          entry = read_entry(namespaced_key(name, options), options)
+          if entry && !entry.expired?
+            true
+          else
+            false
+          end
+        end
       end
 
-      def delete_matched(matcher, options = nil, &block)
-        instrument(:delete_matched, matcher.inspect, options, &block)
+      # Delete all entries whose keys match a pattern.
+      #
+      # Options are passed to the underlying cache implementation.
+      #
+      # Not all implementations may support +delete_matched+.
+      def delete_matched(matcher, options = nil)
+        raise NotImplementedError.new("#{self.class.name} does not support delete_matched")
       end
 
-      def exist?(key, options = nil, &block)
-        instrument(:exist?, key, options, &block)
+      # Increment an integer value in the cache.
+      #
+      # Options are passed to the underlying cache implementation.
+      #
+      # Not all implementations may support +delete_matched+.
+      def increment(name, amount = 1, options = nil)
+        raise NotImplementedError.new("#{self.class.name} does not support increment")
       end
 
-      def increment(key, amount = 1)
-        if num = read(key)
-          write(key, num + amount)
-        else
-          nil
-        end
+      # Increment an integer value in the cache.
+      #
+      # Options are passed to the underlying cache implementation.
+      #
+      # Not all implementations may support +delete_matched+.
+      def decrement(name, amount = 1, options = nil)
+        raise NotImplementedError.new("#{self.class.name} does not support decrement")
       end
 
-      def decrement(key, amount = 1)
-        if num = read(key)
-          write(key, num - amount)
-        else
-          nil
-        end
+      # Cleanup the cache by removing expired entries. Not all cache implementations may
+      # support this method.
+      #
+      # Options are passed to the underlying cache implementation.
+      #
+      # Not all implementations may support +delete_matched+.
+      def cleanup(options = nil)
+        raise NotImplementedError.new("#{self.class.name} does not support cleanup")
       end
 
+      # Clear the entire cache. Not all cache implementations may support this method.
+      # You should be careful with this method since it could affect other processes
+      # if you are using a shared cache.
+      #
+      # Options are passed to the underlying cache implementation.
+      #
+      # Not all implementations may support +delete_matched+.
+      def clear(options = nil)
+        raise NotImplementedError.new("#{self.class.name} does not support clear")
+      end
+
+      protected
+        # Add the namespace defined in the options to a pattern designed to match keys.
+        # Implementations that support delete_matched should call this method to translate
+        # a pattern that matches names into one that matches namespaced keys.
+        def key_matcher(pattern, options)
+          prefix = options[:namespace].is_a?(Proc) ? options[:namespace].call : options[:namespace]
+          if prefix
+            source = pattern.source
+            if source.start_with?('^')
+              source = source[1, source.length]
+            else
+              source = ".*#{source[0, source.length]}"
+            end
+            Regexp.new("^#{Regexp.escape(prefix)}:#{source}", pattern.options)
+          else
+            pattern
+          end
+        end
+
+        # Read an entry from the cache implementation. Subclasses must implement this method.
+        def read_entry(key, options) # :nodoc:
+          raise NotImplementedError.new
+        end
+
+        # Write an entry to the cache implementation. Subclasses must implement this method.
+        def write_entry(key, entry, options) # :nodoc:
+          raise NotImplementedError.new
+        end
+
+        # Delete an entry from the cache implementation. Subclasses must implement this method.
+        def delete_entry(key, options) # :nodoc:
+          raise NotImplementedError.new
+        end
+
       private
-        def expires_in(options)
-          expires_in = options && options[:expires_in]
-          raise ":expires_in must be a number" if expires_in && !expires_in.is_a?(Numeric)
-          expires_in || 0
+        # Merge the default options with ones specific to a method call.
+        def merged_options(call_options) # :nodoc:
+          if call_options
+            options.merge(call_options)
+          else
+            options.dup
+          end
         end
 
-        def instrument(operation, key, options, &block)
+        # Expand a key to be a consistent string value. If the object responds to +cache_key+,
+        # it will be called. Otherwise, the to_param method will be called. If the key is a
+        # Hash, the keys will be sorted alphabetically.
+        def expanded_key(key) # :nodoc:
+          if key.respond_to?(:cache_key)
+            key = key.cache_key.to_s
+          elsif key.is_a?(Array)
+            if key.size > 1
+              key.collect{|element| expanded_key(element)}.to_param
+            else
+              key.first.to_param
+            end
+          elsif key.is_a?(Hash)
+            key = key.to_a.sort{|a,b| a.first.to_s <=> b.first.to_s}.collect{|k,v| "#{k}=#{v}"}.to_param
+          else
+            key = key.to_param
+          end
+        end
+
+        # Prefix a key with the namespace. The two values will be delimited with a colon.
+        def namespaced_key(key, options)
+          key = expanded_key(key)
+          namespace = options[:namespace] if options
+          prefix = namespace.is_a?(Proc) ? namespace.call : namespace
+          key = "#{prefix}:#{key}" if prefix
+          key
+        end
+
+        def instrument(operation, key, options = nil)
           log(operation, key, options)
 
           if self.class.instrument
             payload = { :key => key }
             payload.merge!(options) if options.is_a?(Hash)
-            ActiveSupport::Notifications.instrument(:"cache_#{operation}", payload, &block)
+            ActiveSupport::Notifications.instrument("cache_#{operation}.active_support", payload){ yield(payload) }
           else
-            yield
+            yield(nil)
           end
         end
 
-        def log(operation, key, options)
-          return unless logger && !silence?
-          logger.debug("Cache #{operation}: #{key}#{options ? " (#{options.inspect})" : ""}")
+        def log(operation, key, options = nil)
+          return unless logger && logger.debug? && !silence?
+          logger.debug("Cache #{operation}: #{key}#{options.blank? ? "" : " (#{options.inspect})"}")
+        end
+    end
+
+    # Entry that is put into caches. It supports expiration time on entries and can compress values
+    # to save space in the cache.
+    class Entry
+      attr_reader :created_at, :expires_in
+
+      DEFAULT_COMPRESS_LIMIT = 16.kilobytes
+
+      class << self
+        # Create an entry with internal attributes set. This method is intended to be
+        # used by implementations that store cache entries in a native format instead
+        # of as serialized Ruby objects.
+        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
+      end
+
+      # Create a new cache entry for the specified value. Options supported are
+      # +:compress+, +:compress_threshold+, and +:expires_in+.
+      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
+
+      # Get the raw value. This value may be serialized and compressed.
+      def raw_value
+        @value
+      end
+
+      # 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
+
+      def compressed?
+        @compressed
+      end
+
+      # Check if the entry is expired. The +expires_in+ parameter can override the
+      # value set when the entry was created.
+      def expired?
+        if @expires_in && @created_at + @expires_in <= Time.now.to_f
+          true
+        else
+          false
+        end
+      end
+
+      # 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
+
+      # Seconds since the epoch when the cache entry will expire.
+      def expires_at
+        @expires_in ? @created_at + @expires_in : nil
+      end
+
+      # Get the size of the cached value. This could be less than value.size
+      # if the data is compressed.
+      def size
+        if @value.nil?
+          0
+        elsif @value.respond_to?(:bytesize)
+          @value.bytesize
+        else
+          Marshal.dump(@value).bytesize
+        end
+      end
+
+      private
+        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
     end
   end