padrino-cache 0.11.4 → 0.12.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 374334fdc24a2ded02fce9d03b21176bcb9692b8
-  data.tar.gz: d6d07f4a86e8d5ecbd0fc53654dc328b9240d166
+  metadata.gz: 638e5c5671b96bfdddd92ec93bf3883209c47461
+  data.tar.gz: 6d4bbaed06c182dcfc7357078e24db6264c2b001
 SHA512:
-  metadata.gz: 9d550329256cbf42946e0205fa4edd5670ee01873d9291f0ba5dff6ae77969f712152d3247a2bfdd5e1ce725f94395741c34ef358a08ae61752d8381c806da75
-  data.tar.gz: e9c536170da6ef7e61bcbaf77c6b6acebb13844a7713ab2a4f54652fa38f9c06bcc2df96f02477b31dac6e8225844d8ede8ac754905644483499da18f6628187
+  metadata.gz: 149147b7332bc70ac260cb4c5e75691262f71f6526cbe3d98361d421fc01df118328f844281a67faea933eab099621f1e0d1b68a5f5367a5a3bcfa23c1d14d7e
+  data.tar.gz: 2b6840b7d90f6cb19405b8bfb250b6595a1fb927cbcdf4c0a8142d190c3c05df8cdb6393ebfe32436b8d5b7c17c049d329e4dc62f8e5fd336ec2c8f0a5607619

data/README.rdoc

@@ -5,7 +5,8 @@
 This component enables caching of an application's response contents on
 both page- and fragment-levels. Output cached in this manner is
 persisted, until it expires or is actively expired, in a configurable store
-of your choosing. Several common caching stores are supported out of the box.
+of your choosing. Most popular key/value stores work out of the box. Take a look
+at the [Moneta documentation](http://rubydoc.info/gems/moneta) for a list of all supported stores.
 
 == Caching Quickstart
 
@@ -26,7 +27,7 @@ your needs, you can enable it very easily:
     enable :caching
 
     get '/foo', :cache => true do
-      expires_in 30 # expire cached version at least every 30 seconds
+      expires 30 # expire cached version at least every 30 seconds
       'Hello world'
     end
   end
@@ -44,7 +45,7 @@ You can also cache on a controller-wide basis:
 
     # Requests to routes within '/admin'
     controller '/admin', :cache => true do
-      expires_in 60
+      expires 60
 
       get '/foo' do
         'Url is /admin/foo'
@@ -75,9 +76,9 @@ You can also provide a custom <tt>cache_key</tt> in any route:
 In this way you can manually expire cache with CachedApp.cache.delete(:my_name)
 for example from the Post model after an update.
 
-If you specify <tt>:cache => true</tt> but do not invoke <tt>expires_in</tt>,
+If you specify <tt>:cache => true</tt> but do not invoke <tt>expires</tt>,
 the response will be cached indefinitely. Most of the time, you will want to
-specify the expiry of a cache entry by <tt>expires_in</tt>. Even a relatively
+specify the expiry of a cache entry by <tt>expires</tt>. Even a relatively
 low value--1 or 2 seconds--can greatly increase application efficiency, especially
 when enabled on a very active part of your domain.
 
@@ -110,7 +111,7 @@ easy to integrate into your application. To turn it on, simply provide the
 By default, cached content is persisted with a "file store"--that is, in a
 subdirectory of your application root.
 
-==== <tt>expires_in( seconds )</tt>
+==== <tt>expires( seconds )</tt>
 
 This helper is used within a controller or route to indicate how often cached
 <em>page-level</em> content should persist in the cache.
@@ -126,7 +127,7 @@ be executed; rather, its previous output will be sent to the client with a
     enable :caching          # turns on caching
 
     controller '/blog', :cache => true do
-      expires_in 15
+      expires 15
 
       get '/entries' do
         'just broke up eating twinkies lol'
@@ -134,7 +135,7 @@ be executed; rather, its previous output will be sent to the client with a
     end
   end
 
-Note that the "latest" method call to <tt>expires_in</tt> determines its value: if
+Note that the "latest" method call to <tt>expires</tt> determines its value: if
 called within a route, as opposed to a controller definition, the route's
 value will be assumed.
 
@@ -165,7 +166,7 @@ to be cached. It can be used in within a route:
       get :feed, :map => '/:username' do
         username = params[:username]
 
-        @feed = cache( "feed_for_#{username}", :expires_in => 3 ) do
+        @feed = cache( "feed_for_#{username}", :expires => 3 ) do
           @tweets = Tweet.all( :username => username )
           render 'partials/feedcontent'
         end
@@ -192,7 +193,7 @@ Note that any other action will reference the same content if it uses the same k
       get :feed, :map => '/:username' do
         username = params[:username]
 
-        @feed = cache( "feed_for_#{username}", :expires_in => 3 ) do
+        @feed = cache( "feed_for_#{username}", :expires => 3 ) do
           @tweets = Tweet.all( :username => username )
           render 'partials/feedcontent'
         end
@@ -204,7 +205,7 @@ Note that any other action will reference the same content if it uses the same k
       get :mobile_feed, :map => '/:username.iphone' do
         username = params[:username]
 
-        @feed = cache( "feed_for_#{username}", :expires_in => 3 ) do
+        @feed = cache( "feed_for_#{username}", :expires => 3 ) do
           @tweets = Tweet.all( :username => username )
           render 'partials/feedcontent'
         end
@@ -214,7 +215,8 @@ Note that any other action will reference the same content if it uses the same k
     end
   end
 
-The <tt>opts</tt> argument is actually passed to the underlying store. All stores included with Padrino support the <tt>:expires_in</tt> option out of the box.
+The <tt>opts</tt> argument is actually passed to the underlying store. The stores support the <tt>:expires</tt> option out of the box or
+are enhanced by Moneta to support it.
 
 Finally, to DRY up things a bit, we might do:
 
@@ -226,7 +228,7 @@ Finally, to DRY up things a bit, we might do:
     controller :tweets do
       # This works because all routes in this controller specify :username
       before do
-        @feed = cache( "feed_for_#{params[:username]}", :expires_in => 3 ) do
+        @feed = cache( "feed_for_#{params[:username]}", :expires => 3 ) do
           @tweets = Tweet.all( :username => params[:username] )
           render 'partials/feedcontent'
         end
@@ -253,35 +255,40 @@ You can set a global caching option or a per app caching options.
 
 === Global Caching Options
 
-  Padrino.cache = Padrino::Cache::Store::Memcache.new(::Memcached.new('127.0.0.1:11211', :exception_retry_limit => 1))
-  Padrino.cache = Padrino::Cache::Store::Memcache.new(::Dalli::Client.new('127.0.0.1:11211', :exception_retry_limit => 1))
-  Padrino.cache = Padrino::Cache::Store::Mongo.new(::Mongo::Connection.new(...)
-  Padrino.cache = Padrino::Cache::Store::Redis.new(::Redis.new(:host => '127.0.0.1', :port => 6379, :db => 0))
-  Padrino.cache = Padrino::Cache::Store::Memory.new(50)
-  Padrino.cache = Padrino::Cache::Store::File.new(/my/cache/path)
+  Padrino.cache = Padrino::Cache.new(:LRUHash) # Keeps cached values in memory
+  Padrino.cache = Padrino::Cache.new(:Memcached) # Uses default server at localhost
+  Padrino.cache = Padrino::Cache.new(:Memcached, '127.0.0.1:11211', :exception_retry_limit => 1)
+  Padrino.cache = Padrino::Cache.new(:Memcached, :backend => memcached_or_dalli_instance)
+  Padrino.cache = Padrino::Cache.new(:Redis) # Uses default server at localhost
+  Padrino.cache = Padrino::Cache.new(:Redis, :host => '127.0.0.1', :port => 6379, :db => 0)
+  Padrino.cache = Padrino::Cache.new(:Redis, :backend => redis_instance)
+  Padrino.cache = Padrino::Cache.new(:Mongo) # Uses default server at localhost
+  Padrino.cache = Padrino::Cache.new(:Mongo, :backend => mongo_client_instance)
+  Padrino.cache = Padrino::Cache.new(:File, :dir => Padrino.root('tmp', app_name.to_s, 'cache')) # default choice
 
 You can manage your cache from anywhere in your app:
 
-  Padrino.cache.set('val', 'test')
-  Padrino.cache.get('val') # => 'test'
+  Padrino.cache['val'] = 'test'
+  Padrino.cache['val'] # => 'test'
   Padrino.cache.delete('val')
-  Padrino.cache.flush
+  Padrino.cache.clear
+
+The Padrino cache constructor `Padrino::Cache.new` calls `Moneta.new` to create a cache instance. Please refer to the [Moneta documentation](http://rubydoc.info/gems/moneta) if you
+have special requirements, for example if you want to configure the marshalling mechanism or use a more exotic backend.
 
 ==== Application Caching Options
 
-  set :cache, Padrino::Cache::Store::Memcache.new(::Memcached.new('127.0.0.1:11211', :exception_retry_limit => 1))
-  set :cache, Padrino::Cache::Store::Memcache.new(::Dalli::Client.new('127.0.0.1:11211', :exception_retry_limit => 1))
-  set :cache, Padrino::Cache::Store::Redis.new(::Redis.new(:host => '127.0.0.1', :port => 6379, :db => 0))
-  set :cache, Padrino::Cache::Store::Mongo.new(::Mongo::Connection.new(...))
-  set :cache, Padrino::Cache::Store::Memory.new(50)
-  set :cache, Padrino::Cache::Store::File.new(Padrino.root('tmp', app_name, 'cache') # default choice
+  set :cache, Padrino::Cache.new(:LRUHash)
+  set :cache, Padrino::Cache.new(:Memcached)
+  set :cache, Padrino::Cache.new(:Redis)
+  set :cache, Padrino::Cache.new(:File, :dir => Padrino.root('tmp', app_name.to_s, 'cache')) # default choice
 
 You can manage your cache from anywhere in your app:
 
-  MyApp.cache.set('val', 'test')
-  MyApp.cache.get('val') # => 'test'
+  MyApp.cache['val'] = 'test'
+  MyApp.cache['val'] # => 'test'
   MyApp.cache.delete('val')
-  MyApp.cache.flush
+  MyApp.cache.clear
 
 == Expiring Cached Content
 
@@ -316,7 +323,7 @@ do our user a favor and instantly re-render the feed.
         expire( "feed since #{last_visit}" ) if @tweets.any? { |t| t.deleted_since?( last_visit ) }
 
         session[:last_visit] = Time.now
-        @feed = cache( "feed since #{last_visit}", :expires_in => 60 ) do
+        @feed = cache( "feed since #{last_visit}", :expires => 60 ) do
           @tweets = @tweets.find_all { |t| !t.deleted? }
           render 'partials/feedcontent'
         end

data/lib/padrino-cache.rb

@@ -2,6 +2,8 @@ require 'fileutils' unless defined?(FileUtils)
 require 'padrino-core'
 require 'padrino-helpers'
 FileSet.glob_require('padrino-cache/{helpers}/*.rb', __FILE__)
+require 'moneta'
+require 'padrino-cache/legacy_store'
 
 module Padrino
   class << self
@@ -9,11 +11,11 @@ module Padrino
     # Returns the caching engine.
     #
     # @example
-    #   # with: Padrino.cache = Padrino::Cache::Store::File.new(/my/cache/path)
-    #   Padrino.cache.set('val', 'test')
-    #   Padrino.cache.get('val') # => 'test'
+    #   # with: Padrino.cache = Padrino::Cache.new(:File, :dir => /my/cache/path)
+    #   Padrino.cache['val'] = 'test'
+    #   Padrino.cache['val'] # => 'test'
     #   Padrino.cache.delete('val')
-    #   Padrino.cache.flush
+    #   Padrino.cache.clear
     #
     def cache
       @_cache
@@ -23,22 +25,26 @@ module Padrino
     # Set the caching engine.
     #
     # @param value
-    #   Instance of Padrino::Cache::Store
+    #   Instance of Moneta store
     #
     # @example
-    #   Padrino.cache = Padrino::Cache::Store::Memcache.new(::Memcached.new('127.0.0.1:11211', :exception_retry_limit => 1))
-    #   Padrino.cache = Padrino::Cache::Store::Memcache.new(::Dalli::Client.new('127.0.0.1:11211', :exception_retry_limit => 1))
-    #   Padrino.cache = Padrino::Cache::Store::Redis.new(::Redis.new(:host => '127.0.0.1', :port => 6379, :db => 0))
-    #   Padrino.cache = Padrino::Cache::Store::Mongo.new(::Mongo::Connection.new('127.0.0.1', 27017).db('padrino'), :username => 'username', :password => 'password', :size => 64, :max => 100, :collection => 'cache')
-    #   Padrino.cache = Padrino::Cache::Store::Memory.new(50)
-    #   Padrino.cache = Padrino::Cache::Store::File.new(/my/cache/path)
+    #   Padrino.cache = Padrino::Cache.new(:File, :dir => Padrino.root('tmp', app_name.to_s, 'cache')) # default choice
+    #   Padrino.cache = Padrino::Cache.new(:LRUHash) # Keeps cached values in memory
+    #   Padrino.cache = Padrino::Cache.new(:Memcached) # Uses default server at localhost
+    #   Padrino.cache = Padrino::Cache.new(:Memcached, '127.0.0.1:11211', :exception_retry_limit => 1)
+    #   Padrino.cache = Padrino::Cache.new(:Memcached, :backend => memcached_or_dalli_instance)
+    #   Padrino.cache = Padrino::Cache.new(:Redis) # Uses default server at localhost
+    #   Padrino.cache = Padrino::Cache.new(:Redis, :host => '127.0.0.1', :port => 6379, :db => 0)
+    #   Padrino.cache = Padrino::Cache.new(:Redis, :backend => redis_instance)
+    #   Padrino.cache = Padrino::Cache.new(:Mongo) # Uses default server at localhost
+    #   Padrino.cache = Padrino::Cache.new(:Mongo, :backend => mongo_client_instance)
     #
     #   # You can manage your cache from anywhere in your app:
     #
-    #   Padrino.cache.set('val', 'test')
-    #   Padrino.cache.get('val') # => 'test'
+    #   Padrino.cache['val'] = 'test'
+    #   Padrino.cache['val'] # => 'test'
     #   Padrino.cache.delete('val')
-    #   Padrino.cache.flush
+    #   Padrino.cache.clear
     #
     def cache=(value)
       @_cache= value
@@ -52,9 +58,6 @@ module Padrino
   # of your choosing. Several common caching stores are supported out of the box.
   #
   module Cache
-    autoload :Store,  'padrino-cache/store'
-    autoload :Parser, 'padrino-cache/parser'
-
     class << self
       ##
       # Register these helpers:
@@ -67,29 +70,34 @@ module Padrino
       #
       # By default we use FileStore as showed below:
       #
-      #   set :cache, Padrino::Cache::Store::File.new(File.join(app.root, 'tmp', 'cache'))
+      #   set :cache, Padrino::Cache.new(:File, :dir => Padrino.root('tmp', app_name.to_s, 'cache'))
       #
       # However, you can also change the file store easily in your app.rb:
       #
-      #   set :cache, Padrino::Cache::Store::Memcache.new(::Memcached.new('127.0.0.1:11211', :exception_retry_limit => 1))
-      #   set :cache, Padrino::Cache::Store::Memcache.new(::Dalli::Client.new('127.0.0.1:11211', :exception_retry_limit => 1))
-      #   set :cache, Padrino::Cache::Store::Redis.new(::Redis.new(:host => '127.0.0.1', :port => 6379, :db => 0))
-      #   set :cache, Padrino::Cache::Store::Mongo.new(::Mongo::Connection.new('127.0.0.1', 27017).db('padrino'), :username => 'username', :password => 'password', :size => 64, :max => 100, :collection => 'cache')
-      #   set :cache, Padrino::Cache::Store::Memory.new(50)
-      #   set :cache, Padrino::Cache::Store::File.new(Padrino.root('tmp', app_name.to_s, 'cache')) # default choice
+      #   set :cache, Padrino::Cache.new(:LRUHash) # Keeps cached values in memory
+      #   set :cache, Padrino::Cache.new(:Memcached) # Uses default server at localhost
+      #   set :cache, Padrino::Cache.new(:Memcached, '127.0.0.1:11211', :exception_retry_limit => 1)
+      #   set :cache, Padrino::Cache.new(:Memcached, :backend => memcached_or_dalli_instance)
+      #   set :cache, Padrino::Cache.new(:Redis) # Uses default server at localhost
+      #   set :cache, Padrino::Cache.new(:Redis, :host => '127.0.0.1', :port => 6379, :db => 0)
+      #   set :cache, Padrino::Cache.new(:Redis, :backend => redis_instance)
+      #   set :cache, Padrino::Cache.new(:Mongo) # Uses default server at localhost
+      #   set :cache, Padrino::Cache.new(:Mongo, :backend => mongo_client_instance)
+      #   set :cache, Padrino::Cache.new(:File, :dir => Padrino.root('tmp', app_name.to_s, 'cache')) # default choice
       #
       # You can manage your cache from anywhere in your app:
       #
-      #   MyApp.cache.set('val', 'test')
-      #   MyApp.cache.get('val') # => 'test'
+      #   MyApp.cache['val'] = 'test'
+      #   MyApp.cache['val'] # => 'test'
       #   MyApp.cache.delete('val')
-      #   MyApp.cache.flush
+      #   MyApp.cache.clear
       #
       def registered(app)
         app.helpers Padrino::Cache::Helpers::CacheStore
         app.helpers Padrino::Cache::Helpers::Fragment
         app.helpers Padrino::Cache::Helpers::Page
-        app.set :cache, Padrino::Cache::Store::File.new(Padrino.root('tmp', defined?(app.app_name) ? app.app_name.to_s : '', 'cache'))
+        app.set :cache, Padrino::Cache.new(:File,
+                                           :dir => Padrino.root('tmp', defined?(app.app_name) ? app.app_name.to_s : '', 'cache'))
         app.disable :caching
       end
       alias :included :registered
@@ -99,6 +107,17 @@ module Padrino
       end
     end
 
-    Padrino.cache = Store::Memory.new(50)
+    def self.new(name, options = {})
+      # Activate expiration by default
+      options[:expires] = true unless options.include?(:expires)
+      a = Moneta.new(name, options)
+      Moneta.build do
+        # Use proxy to support deprecated Padrino interface
+        use LegacyStore
+        adapter a
+      end
+    end
+
+    Padrino.cache = Padrino::Cache.new(:LRUHash)
   end
 end

data/lib/padrino-cache/helpers/cache_store.rb

@@ -8,6 +8,7 @@ module Padrino
           else
             settings.cache.delete(self.class.url(*key))
           end
+          nil
         end
       end
     end

data/lib/padrino-cache/helpers/fragment.rb

@@ -23,7 +23,7 @@ module Padrino
         # @param [String] key
         #   cache key
         # @param [Hash] opts
-        #   cache options, e.g :expires_in
+        #   cache options, e.g :expires
         # @param [Proc]
         #   Execution result to store in the cache
         #
@@ -36,7 +36,7 @@ module Padrino
         #       get :feed, :map => '/:username' do
         #         username = params[:username]
         #
-        #         @feed = cache( "feed_for_#{username}", :expires_in => 3 ) do
+        #         @feed = cache( "feed_for_#{username}", :expires => 3 ) do
         #           @tweets = Tweet.all( :username => username )
         #           render 'partials/feedcontent'
         #         end
@@ -47,15 +47,16 @@ module Padrino
         #     end
         #   end
         #
-        def cache(key, opts = nil, &block)
+        # @api public
+        def cache(key, opts = {}, &block)
           if settings.caching?
             began_at = Time.now
-            if value = settings.cache.get(key.to_s)
+            if value = settings.cache[key.to_s]
               logger.debug "GET Fragment", began_at, key.to_s if defined?(logger)
               concat_content(value.html_safe)
             else
               value = capture_html(&block)
-              settings.cache.set(key.to_s, value, opts)
+              settings.cache.store(key.to_s, value, opts)
               logger.debug "SET Fragment", began_at, key.to_s if defined?(logger)
               concat_content(value)
             end

data/lib/padrino-cache/helpers/page.rb

@@ -16,10 +16,10 @@ module Padrino
       #     enable :caching          # turns on caching mechanism
       #
       #     controller '/blog', :cache => true do
-      #       expires_in 15
+      #       expires 15
       #
       #       get '/entries' do
-      #         # expires_in 15 => can also be defined inside a single route
+      #         # expires 15 => can also be defined inside a single route
       #         'Just broke up eating twinkies, lol'
       #       end
       #
@@ -32,7 +32,7 @@ module Padrino
       #
       # You can manually expire cache with CachedApp.cache.delete(:my_name)
       #
-      # Note that the "latest" method call to <tt>expires_in</tt> determines its value: if
+      # Note that the "latest" method call to <tt>expires</tt> determines its value: if
       # called within a route, as opposed to a controller definition, the route's
       # value will be assumed.
       #
@@ -51,17 +51,22 @@ module Padrino
         #
         # @example
         #   controller '/blog', :cache => true do
-        #     expires_in 15
+        #     expires 15
         #
         #     get '/entries' do
-        #       # expires_in 15 => can also be defined inside a single route
         #       'Just broke up eating twinkies, lol'
         #     end
         #   end
         #
+        # @api public
+        def expires(time)
+          @route.cache_expires = time if @route
+          @_last_expires       = time
+        end
+
         def expires_in(time)
-          @route.cache_expires_in = time if @route
-          @_last_expires_in       = time
+          warn 'expires_in has been deprecated in favour of expires'
+          expires(time)
         end
 
         ##
@@ -99,10 +104,13 @@ module Padrino
               if settings.caching?
                 began_at     = Time.now
 
-                value = settings.cache.get(resolve_cache_key || env['PATH_INFO'])
+                value = settings.cache[resolve_cache_key || env['PATH_INFO']]
                 logger.debug "GET Cache", began_at, @route.cache_key || env['PATH_INFO'] if defined?(logger) && value
 
-                if value
+                if value.kind_of?(Hash)
+                  content_type value[:content_type]
+                  halt 200, value[:body]
+                elsif value
                   halt 200, value
                 end
               end
@@ -111,13 +119,16 @@ module Padrino
             route.after_filters do
               if settings.caching? && @_response_buffer.kind_of?(String)
                 began_at     = Time.now
-                content      = @_response_buffer
+                content = {
+                  :body         => @_response_buffer,
+                  :content_type => @_content_type
+                }
 
-                if @_last_expires_in
-                  settings.cache.set(resolve_cache_key || env['PATH_INFO'], content, :expires_in => @_last_expires_in)
-                  @_last_expires_in = nil
+                if @_last_expires
+                  settings.cache.store(resolve_cache_key || env['PATH_INFO'], content, :expires => @_last_expires)
+                  @_last_expires = nil
                 else
-                  settings.cache.set(resolve_cache_key || env['PATH_INFO'], content)
+                  settings.cache.store(resolve_cache_key || env['PATH_INFO'], content)
                 end
 
                 logger.debug "SET Cache", began_at, @route.cache_key || env['PATH_INFO'] if defined?(logger)