padrino-cache 0.6.1 → 0.9.16

data/.gitignore

@@ -19,3 +19,5 @@ rdoc
 pkg
 
 ## PROJECT::SPECIFIC
+*.rdb
+test/tmp/*

data/LICENSE

@@ -17,4 +17,4 @@ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -1,22 +1,7 @@
-= padrino-cache
-
-== Installation
-
-To install the 'full-stack' padrino framework, simply grab the latest version from gemcutter:
-
-  $ sudo gem install padrino --source http://gemcutter.org
-  
-This will install the necessary padrino gems to get you started.
-Now you are ready to use this gem to enhance your existing Sinatra projects or build new Padrino applications.
-
-You can also install only the padrino-cache gem for more fine-grained use:
-
-  $ sudo gem install padrino-cache --source http://gemcutter.org
-  
-== Usage
+= Painless Page and Fragment Caching (padrino-cache)
 
 Not implemented yet.
 
 == Copyright
 
-Copyright (c) 2010 Padrino. See LICENSE for details.
+Copyright (c) 2010 Padrino. See LICENSE for details.

data/Rakefile

@@ -1,61 +1,5 @@
-require 'rubygems'
-require 'rake'
-
-GEM_VERSION = File.read(File.dirname(__FILE__) + '/VERSION')
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name = "padrino-cache"
-    gem.summary = "Page and fragment caching for Padrino"
-    gem.description = "Caching support for memcached, page and fragment"
-    gem.email = "nesquena@gmail.com"
-    gem.homepage = "http://github.com/padrino/padrino-framework/tree/master/padrino-cache"
-    gem.authors = ["Padrino Team", "Nathan Esquenazi", "Davide D'Agostino", "Arthur Chiu"]
-    gem.add_runtime_dependency     "sinatra",       ">= 0.9.2"
-    gem.add_runtime_dependency     "padrino-core",  "= #{GEM_VERSION}"
-    gem.add_development_dependency "haml",          ">= 2.2.1"
-    gem.add_development_dependency "shoulda",       ">= 0"
-    gem.add_development_dependency "mocha",         ">= 0.9.7"
-    gem.add_development_dependency "rack-test",     ">= 0.5.0"
-    gem.add_development_dependency "webrat",        ">= 0.5.1"
-    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
-  end
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
-end
-
-require 'rake/testtask'
-Rake::TestTask.new(:test) do |test|
-  test.libs << 'test'
-  test.pattern = 'test/**/test_*.rb'
-  test.verbose = true
-end
-
-begin
-  require 'rcov/rcovtask'
-  Rcov::RcovTask.new do |test|
-    test.libs << 'test'
-    test.pattern = 'test/**/test_*.rb'
-    test.verbose = true
-  end
-rescue LoadError
-  task :rcov do
-    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
-  end
-end
+# coding:utf-8
+RAKE_ROOT = __FILE__
 
-task :test => :check_dependencies
-
-task :default => :test
-
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
-
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "padrino-admin #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
+require 'rubygems'
+require File.expand_path(File.dirname(__FILE__) + '/../gem_rake_helper')

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

@@ -0,0 +1,15 @@
+module Padrino
+  module Cache
+    module Helpers
+      module CacheStore
+        def expire(*key)
+          if key.size == 1 and key.first.is_a?(String)
+            self.class.cache_store.delete(key)
+          else
+            self.class.cache_store.delete(self.class.url(*key))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Padrino
+  module Cache
+    module Helpers
+      module Fragment
+        include Padrino::Helpers::OutputHelpers
+
+        def cache(key, opts = nil, &block)
+          if self.class.caching?
+            if value = self.class.cache_store.get(key)
+              concat_content(value)
+            else
+              value = capture_html(&block)
+              self.class.cache_store.set(key, value, opts)
+              concat_content(value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Padrino
+  module Cache
+    module Helpers
+      module Page
+        def expires_in(time)
+          @_last_expires_in = time
+        end
+        def self.padrino_route_added(route, verb, path, args, options, block)
+          if route.cache and %w(GET HEAD).include?(verb)
+            route.add_before_filter(Proc.new {
+              if self.class.caching?
+                value = self.class.cache_store.get(route.cache.respond_to?(:call) ? route.cache.call(request) : env['PATH_INFO'])
+                halt 200, value if value
+              end
+            })
+            route.add_after_filter(Proc.new { |something|
+              if self.class.caching?
+                if @_last_expires_in
+                  self.class.cache_store.set(route.cache.respond_to?(:call) ? route.cache.call(request) : env['PATH_INFO'], @_response_buffer, :expires_in => @_last_expires_in)
+                  @_last_expires_in = nil
+                else
+                  self.class.cache_store.set(route.cache.respond_to?(:call) ? route.cache.call(request) : env['PATH_INFO'], @_response_buffer)
+                end
+              end
+            })
+          end
+        end
+      end
+    end
+  end
+end

data/lib/padrino-cache/store/file.rb

@@ -0,0 +1,61 @@
+module Padrino
+  module Cache
+    module Store
+      class File
+        def initialize(root)
+          @root = root
+        end
+
+        def get(key)
+          init
+          if ::File.exist?(path_for_key(key))
+            contents = ::File.read(path_for_key(key))
+            expires_in, body = contents.split("\n", 2)
+            expires_in = expires_in.to_i
+            if expires_in == -1 or Time.new.to_i < expires_in
+              body
+            else
+              delete(key)
+              nil
+            end
+          else
+            nil
+          end
+        end
+
+        def set(key, value, opts = nil)
+          init
+          if opts && opts[:expires_in]
+            expires_in = opts[:expires_in].to_i
+            expires_in = Time.new.to_i + expires_in if expires_in < EXPIRES_EDGE
+          else
+            expires_in = -1
+          end
+          ::File.open(path_for_key(key), 'w') { |f| f << expires_in.to_s << "\n" << value.to_s } if value
+        end
+
+        def delete(key)
+          init
+          FileUtils.rm_rf(path_for_key(key))
+        end
+
+        def flush
+          FileUtils.rm_rf(@root)
+        end
+
+        private
+        def path_for_key(key)
+          ::File.join(@root, Rack::Utils.escape(key.to_s))
+        end
+
+        def init
+          unless @init
+            FileUtils.rm_rf(@root)
+            FileUtils.mkdir_p(@root)
+            @init = true
+          end
+        end
+      end # File
+    end # Store
+  end # Cache
+end # Padrino

data/lib/padrino-cache/store/memcache.rb

@@ -0,0 +1,43 @@
+begin
+  require 'memcached'
+rescue LoadError
+  raise "You must install memecached to use the Memecache cache store backend"
+end
+
+module Padrino
+  module Cache
+    module Store
+      class Memcache
+        def initialize(*args)
+          @backend = Memcached.new(*args)
+        rescue
+          raise
+        end
+
+        def get(key)
+          @backend.get(key)
+        rescue Memcached::NotFound
+          nil
+        end
+
+        def set(key, value, opts = nil)
+          if opts && opts[:expires_in]
+            expires_in = opts[:expires_in].to_i
+            expires_in = Time.new.to_i + expires_in if expires_in < EXPIRES_EDGE
+            @backend.set(key, value, expires_in)
+          else
+            @backend.set(key, value)
+          end
+        end
+
+        def delete(key)
+          @backend.delete(key)
+        end
+        
+        def flush
+          @backend.flush
+        end
+      end # Memcached
+    end # Store
+  end # Cache
+end # Padrino

data/lib/padrino-cache/store/memory.rb

@@ -0,0 +1,50 @@
+module Padrino
+  module Cache
+    module Store
+      class Memory
+        def initialize(size = 5000)
+          @size, @entries, @index = size, [], {}
+        end
+
+        def get(key)
+          if @index.key?(key) and value = @index[key]
+            expires_in, body = value
+            if expires_in == -1 or Time.new.to_i < expires_in
+              set(key, body, :expires_in => expires_in)
+              body
+            else
+              delete(key)
+              nil
+            end
+          else
+            nil
+          end
+        end
+
+        def set(key, value, opts = nil)
+          delete(key) if @index.key?(key)
+          if opts && opts[:expires_in]
+            expires_in = opts[:expires_in].to_i
+            expires_in = Time.new.to_i + expires_in if expires_in < EXPIRES_EDGE
+          else
+            expires_in = -1
+          end
+          @entries.push(key)
+          @index[key] = [expires_in, value]
+
+          while @entries.size > @size
+            delete(@entries.shift)
+          end
+        end
+
+        def delete(key)
+          @index.delete(key)
+        end
+
+        def flush
+          @index = Hash.new
+        end
+      end # Memory
+    end # Store
+  end # Cache
+end # Padrino

data/lib/padrino-cache/store/redis.rb

@@ -0,0 +1,38 @@
+begin
+  require 'redis'
+rescue LoadError
+  raise "You must install redis to use the Redis cache store backend"
+end
+
+module Padrino
+  module Cache
+    module Store
+      class Redis
+        def initialize(*args)
+          @backend = ::Redis.new(*args)
+        end
+
+        def get(key)
+          @backend.get(key)
+        end
+
+        def set(key, value, opts = nil)
+          if opts && opts[:expires_in]
+            expires_in = opts[:expires_in].to_i
+            @backend.setex(key, expires_in, value)
+          else
+            @backend.set(key, value)
+          end
+        end
+
+        def delete(key)
+          @backend.del(key)
+        end
+
+        def flush
+          @backend.flushdb
+        end
+      end # Redis
+    end # Store
+  end # Cache
+end # Padrino

data/lib/padrino-cache/store.rb

@@ -0,0 +1,12 @@
+module Padrino
+  module Cache
+    module Store
+      EXPIRES_EDGE = 86400
+
+      autoload :File,     'padrino-cache/store/file'
+      autoload :Memcache, 'padrino-cache/store/memcache'
+      autoload :Memory,   'padrino-cache/store/memory'
+      autoload :Redis,    'padrino-cache/store/redis'
+    end # Store
+  end # Cache
+end # Padrino

data/lib/padrino-cache.rb

@@ -0,0 +1,35 @@
+require 'fileutils'
+require 'padrino-core'
+require 'padrino-helpers'
+#FileSet.glob_require('padrino-cache/{helpers}/*.rb', __FILE__)
+Dir.glob(File.dirname(__FILE__) + '/padrino-cache/helpers/*.rb') {|file| require file}
+
+module Padrino
+  module Cache
+    ##
+    # Register these helpers:
+    #
+    #   Padrino::Cache::FragmentHelpers
+    #   Padrino::Cache::PageHelpers
+    #
+    # for Padrino::Application
+    #
+
+    autoload :Store, 'padrino-cache/store'
+
+    class << self
+      def registered(app)
+        app.helpers Padrino::Cache::Helpers::CacheStore
+        app.helpers Padrino::Cache::Helpers::Fragment
+        app.helpers Padrino::Cache::Helpers::Page
+        app.set :cache_store, Padrino::Cache::Store::File.new(File.join(app.root, 'tmp', 'cache'))
+        app.disable :caching
+      end
+      alias :included :registered
+
+      def padrino_route_added(route, verb, path, args, options, block)
+        Padrino::Cache::Helpers::Page.padrino_route_added(route, verb, path, args, options, block)
+      end
+    end
+  end # Helpers
+end # Padrino

data/padrino-cache.gemspec

@@ -1,67 +1,19 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
-# -*- encoding: utf-8 -*-
+require File.expand_path("../../padrino-core/lib/padrino-core/version.rb", __FILE__)
 
 Gem::Specification.new do |s|
-  s.name = %q{padrino-cache}
-  s.version = "0.6.1"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.name = "padrino-cache"
+  s.rubyforge_project = "padrino-cache"
   s.authors = ["Padrino Team", "Nathan Esquenazi", "Davide D'Agostino", "Arthur Chiu"]
-  s.date = %q{2010-01-14}
-  s.description = %q{Caching support for memcached, page and fragment}
-  s.email = %q{nesquena@gmail.com}
-  s.extra_rdoc_files = [
-    "README.rdoc"
-  ]
-  s.files = [
-    ".document",
-     ".gitignore",
-     "LICENSE",
-     "README.rdoc",
-     "Rakefile",
-     "VERSION",
-     "lib/padrino-cache.rb",
-     "padrino-cache.gemspec",
-     "test/helper.rb",
-     "test/test_padrino_cache.rb"
-  ]
-  s.homepage = %q{http://github.com/padrino/padrino-framework/tree/master/padrino-cache}
+  s.email = "padrinorb@gmail.com"
+  s.summary = "Page and fragment caching for Padrino"
+  s.homepage = "http://www.padrinorb.com"
+  s.description = "Caching support for memcached, page and fragment"
+  s.required_rubygems_version = ">= 1.3.6"
+  s.version = Padrino.version
+  s.date = Time.now.strftime("%Y-%m-%d")
+  s.extra_rdoc_files = Dir["*.rdoc"]
+  s.files = %w(.document .gitignore LICENSE README.rdoc Rakefile padrino-cache.gemspec) + Dir.glob("{bin,lib,test}/**/*")
   s.rdoc_options = ["--charset=UTF-8"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.5}
-  s.summary = %q{Page and fragment caching for Padrino}
-
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<sinatra>, [">= 0.9.2"])
-      s.add_runtime_dependency(%q<padrino-core>, ["= 0.6.1"])
-      s.add_development_dependency(%q<haml>, [">= 2.2.1"])
-      s.add_development_dependency(%q<shoulda>, [">= 0"])
-      s.add_development_dependency(%q<mocha>, [">= 0.9.7"])
-      s.add_development_dependency(%q<rack-test>, [">= 0.5.0"])
-      s.add_development_dependency(%q<webrat>, [">= 0.5.1"])
-    else
-      s.add_dependency(%q<sinatra>, [">= 0.9.2"])
-      s.add_dependency(%q<padrino-core>, ["= 0.6.1"])
-      s.add_dependency(%q<haml>, [">= 2.2.1"])
-      s.add_dependency(%q<shoulda>, [">= 0"])
-      s.add_dependency(%q<mocha>, [">= 0.9.7"])
-      s.add_dependency(%q<rack-test>, [">= 0.5.0"])
-      s.add_dependency(%q<webrat>, [">= 0.5.1"])
-    end
-  else
-    s.add_dependency(%q<sinatra>, [">= 0.9.2"])
-    s.add_dependency(%q<padrino-core>, ["= 0.6.1"])
-    s.add_dependency(%q<haml>, [">= 2.2.1"])
-    s.add_dependency(%q<shoulda>, [">= 0"])
-    s.add_dependency(%q<mocha>, [">= 0.9.7"])
-    s.add_dependency(%q<rack-test>, [">= 0.5.0"])
-    s.add_dependency(%q<webrat>, [">= 0.5.1"])
-  end
-end
-
+  s.require_path = "lib"
+  s.add_runtime_dependency("padrino-core", Padrino.version)
+end

data/test/helper.rb

@@ -1,67 +1,25 @@
-require 'rubygems'
-require 'test/unit'
-require 'shoulda'
-require 'mocha'
-require 'rack/test'
-require 'webrat'
+ENV['PADRINO_ENV'] = 'test'
+PADRINO_ROOT = File.dirname(__FILE__) unless defined? PADRINO_ROOT
 
+require File.expand_path('../../../load_paths', __FILE__)
+require File.join(File.dirname(__FILE__), '..', '..', 'padrino-core', 'test', 'helper')
 require 'padrino-cache'
+require 'fileutils'
+require 'uuid'
 
 class Test::Unit::TestCase
-  include Rack::Test::Methods
-  include Webrat::Methods
-  include Webrat::Matchers
 
-  Webrat.configure do |config|
-    config.mode = :rack
-  end
-
-  def stop_time_for_test
-    time = Time.now
-    Time.stubs(:now).returns(time)
-    return time
-  end
+  def executable_on_path(binary)
+    @matches = []
 
-  # assert_has_tag(:h1, :content => "yellow") { "<h1>yellow</h1>" }
-  # In this case, block is the html to evaluate
-  def assert_has_tag(name, attributes = {}, &block)
-    html = block && block.call
-    matcher = HaveSelector.new(name, attributes)
-    raise "Please specify a block!" if html.blank?
-    assert matcher.matches?(html), matcher.failure_message
-  end
+    ENV['PATH'].split(":").each do |path|
+      bintest = File.executable?("#{path}/#{binary}")
+      pathmatch = "#{path}/#{binary}"
+      @matches << pathmatch if bintest == true
+    end
 
-  # assert_has_no_tag, tag(:h1, :content => "yellow") { "<h1>green</h1>" }
-  # In this case, block is the html to evaluate
-  def assert_has_no_tag(name, attributes = {}, &block)
-    html = block && block.call
-    attributes.merge!(:count => 0)
-    matcher = HaveSelector.new(name, attributes)
-    raise "Please specify a block!" if html.blank?
-    assert matcher.matches?(html), matcher.failure_message
-  end
+    @matches.length == 1 ? @matches.first : false
 
-  # Silences the output by redirecting to stringIO
-  # silence_logger { ...commands... } => "...output..."
-  def silence_logger(&block)
-    orig_stdout = $stdout
-    $stdout = log_buffer = StringIO.new
-    block.call
-    $stdout = orig_stdout
-    log_buffer.rewind && log_buffer.read
   end
 
-  # Asserts that a file matches the pattern
-  def assert_match_in_file(pattern, file)
-    assert File.exist?(file), "File '#{file}' does not exist!"
-    assert_match pattern, File.read(file)
-  end
 end
-
-module Webrat
-  module Logging
-    def logger # :nodoc:
-      @logger = nil
-    end
-  end
-end

data/test/test_padrino_cache.rb

@@ -1,7 +1,186 @@
-require File.dirname(__FILE__) + '/helper'
+require File.expand_path(File.dirname(__FILE__) + '/helper')
 
 class TestPadrinoCache < Test::Unit::TestCase
-  should "probably rename this file and start testing for real" do
+  should 'cache a fragment' do
+    called = false
+    mock_app do
+      register Padrino::Cache
+      enable :caching
+      get("/foo"){ cache(:test) { called ? halt(500) : (called = 'test fragment') } }
+    end
+    get "/foo"
+    assert_equal 200, status
+    assert_equal 'test fragment', body
+    get "/foo"
+    assert_equal 200, status
+    assert_equal 'test fragment', body
+    assert_not_equal called, false
+  end
+
+  should 'cache a page' do
+    called = false
+    mock_app do
+      register Padrino::Cache
+      enable :caching
+      get('/foo', :cache => true){ called ? halt(500) : (called = 'test page') }
+    end
+    get "/foo"
+    assert_equal 200, status
+    assert_equal 'test page', body
+    get "/foo"
+    assert_equal 200, status
+    assert_equal 'test page', body
+    assert_not_equal false, called
+  end
+
+  should 'delete from the cache' do
+    called = false
+    mock_app do
+      register Padrino::Cache
+      enable :caching
+      get('/foo', :cache => true){ called ? 'test page again' : (called = 'test page') }
+      get('/delete_foo'){ expire('/foo') }
+    end
+    get "/foo"
+    assert_equal 200, status
+    assert_equal 'test page', body
+    get "/delete_foo"
+    get "/foo"
+    assert_equal 200, status
+    assert_equal 'test page again', body
+    assert_not_equal false, called
+  end
+
+  should 'accept custom cache keys' do
+    mock_app do
+      register Padrino::Cache
+      enable :caching
+      get('/foo', :cache => proc{|req| "cached"}){ 'test' }
+      get('/bar', :cache => proc{|req| "cached"}){ halt 500 }
+    end
+    get "/foo"
+    assert_equal 200, status
+    assert_equal 'test', body
+    get "/bar"
+    assert_equal 200, status
+    assert_equal 'test', body
+  end
+
+  should 'delete based on urls' do
+    called = false
+    mock_app do
+      register Padrino::Cache
+      enable :caching
+      get(:foo, :with => :id, :cache => true) { called ? 'test page again' : (called = 'test page') }
+      get(:delete_foo, :with => :id) { expire(:foo, params[:id]) }
+    end
+    get "/foo/12"
+    assert_equal 200, status
+    assert_equal 'test page', body
+    get "/delete_foo/12"
+    get "/foo/12"
+    assert_equal 200, status
+    assert_equal 'test page again', body
+  end
 
+  should 'accept allow controller-wide caching' do
+    called = false
+    mock_app do
+      controller :cache => true do
+        register Padrino::Cache
+        enable :caching
+        get("/foo"){ called ? halt(500) : (called = 'test') }
+      end
+    end
+    get "/foo"
+    assert_equal 200, status
+    assert_equal 'test', body
+    get "/foo"
+    assert_equal 200, status
+    assert_equal 'test', body
   end
-end
+
+  should 'allow cache disabling on a per route basis' do
+    called = false
+    mock_app do
+      register Padrino::Cache
+      enable :caching
+      controller :cache => true do
+        get("/foo", :cache => false){ called ? 'test again' : (called = 'test') }
+      end
+    end
+    get "/foo"
+    assert_equal 200, status
+    assert_equal 'test', body
+    get "/foo"
+    assert_equal 200, status
+    assert_equal 'test again', body
+  end
+
+  should 'allow expiring for pages' do
+    called = false
+    mock_app do
+      register Padrino::Cache
+      enable :caching
+      controller :cache => true do
+        get("/foo") {
+          expires_in 1
+          called ? 'test again' : (called = 'test')
+        }
+      end
+    end
+    get "/foo"
+    assert_equal 200, status
+    assert_equal 'test', body
+    get "/foo"
+    assert_equal 200, status
+    assert_equal 'test', body
+    sleep 2
+    get "/foo"
+    assert_equal 200, status
+    assert_equal 'test again', body
+  end
+
+  should 'allow expiring for fragments' do
+    called = false
+    mock_app do
+      register Padrino::Cache
+      enable :caching
+      controller do
+        get("/foo") {
+          expires_in 1
+          cache(:test, :expires_in => 2) do
+            called ? 'test again' : (called = 'test')
+          end
+        }
+      end
+    end
+    get "/foo"
+    assert_equal 200, status
+    assert_equal 'test', body
+    get "/foo"
+    assert_equal 200, status
+    assert_equal 'test', body
+    sleep 2
+    get "/foo"
+    assert_equal 200, status
+    assert_equal 'test again', body
+  end
+
+  should 'allow disabling of the cache' do
+    called = false
+    mock_app do
+      register Padrino::Cache
+      disable :caching
+      controller :cache => true do
+        get("/foo"){ called ? halt(500) : (called = 'test') }
+      end
+    end
+    get "/foo"
+    assert_equal 200, status
+    assert_equal 'test', body
+    get "/foo"
+    assert_equal 500, status
+  end
+
+end

data/test/test_stores.rb

@@ -0,0 +1,98 @@
+require File.expand_path(File.dirname(__FILE__) + '/helper')
+
+COMMON_TESTS = <<-HERE_DOC
+should 'set and get a value' do
+  @cache.set('val', 'test')
+  assert_equal 'test', @cache.get('val')
+end
+
+should "return nil trying to get a value that doesn't exist" do
+  assert_equal nil, @cache.get('test')
+end
+
+should "set a value that expires" do
+  @cache.set('val', 'test', :expires_in => 1)
+  assert_equal 'test', @cache.get('val')
+  sleep 2
+  assert_equal nil, @cache.get('val')
+end
+
+should 'delete a value' do
+  @cache.set('val', 'test')
+  assert_equal 'test', @cache.get('val')
+  @cache.delete('val')
+  assert_equal nil, @cache.get('val')
+end
+HERE_DOC
+
+begin
+  # we're just going to assume memcached is running on the default port
+  Padrino::Cache::Store::Memcache.new('127.0.0.1:11211', :exception_retry_limit => 1).set('ping','alive')
+
+  class TestMemcacheStore < Test::Unit::TestCase
+    def setup
+      @cache = Padrino::Cache::Store::Memcache.new('127.0.0.1:11211', :exception_retry_limit => 1)
+      @cache.flush
+    end
+
+    def teardown
+      @cache.flush
+    end
+
+    eval COMMON_TESTS
+  end
+rescue
+  warn "Skipping memcached tests"
+end
+
+
+begin
+  Padrino::Cache::Store::Redis.new(:host => '127.0.0.1', :port => 6379, :db => 0).set('ping','alive')
+  class TestRedisStore < Test::Unit::TestCase
+    def setup
+      @cache = Padrino::Cache::Store::Redis.new(:host => '127.0.0.1', :port => 6379, :db => 0)
+      @cache.flush
+    end
+
+    def teardown
+      @cache.flush
+    end
+
+    eval COMMON_TESTS
+  end
+rescue
+  warn "Skipping redis tests"
+end
+
+class TestFileStore < Test::Unit::TestCase
+  def setup
+    @apptmp = "#{Dir.tmpdir}/padrino-tests/#{UUID.new.generate}"
+    FileUtils.mkdir_p(@apptmp)
+    @cache = Padrino::Cache::Store::File.new(@apptmp)
+  end
+
+  def teardown
+    @cache.flush
+  end
+
+  eval COMMON_TESTS
+end
+
+class TestInMemoryStore < Test::Unit::TestCase
+  def setup
+    @cache = Padrino::Cache::Store::Memory.new(50)
+  end
+
+  def teardown
+    @cache.flush
+  end
+
+  eval COMMON_TESTS
+
+  should "only store 50 entries" do
+    51.times { |i| @cache.set(i.to_s, i.to_s) }
+    assert_equal nil, @cache.get('0')
+    assert_equal '1', @cache.get('1')
+  end
+
+end

metadata

@@ -1,7 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: padrino-cache
 version: !ruby/object:Gem::Version 
-  version: 0.6.1
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 9
+  - 16
+  version: 0.9.16
 platform: ruby
 authors: 
 - Padrino Team
@@ -12,81 +18,27 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-14 00:00:00 +01:00
+date: 2010-09-24 00:00:00 +02:00
 default_executable: 
 dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: sinatra
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 0.9.2
-    version: 
 - !ruby/object:Gem::Dependency 
   name: padrino-core
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        version: 0.6.1
-    version: 
-- !ruby/object:Gem::Dependency 
-  name: haml
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 2.2.1
-    version: 
-- !ruby/object:Gem::Dependency 
-  name: shoulda
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
-    version: 
-- !ruby/object:Gem::Dependency 
-  name: mocha
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 0.9.7
-    version: 
-- !ruby/object:Gem::Dependency 
-  name: rack-test
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 0.5.0
-    version: 
-- !ruby/object:Gem::Dependency 
-  name: webrat
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 0.5.1
-    version: 
+        hash: 27
+        segments: 
+        - 0
+        - 9
+        - 16
+        version: 0.9.16
+  type: :runtime
+  version_requirements: *id001
 description: Caching support for memcached, page and fragment
-email: nesquena@gmail.com
+email: padrinorb@gmail.com
 executables: []
 
 extensions: []
@@ -99,13 +51,21 @@ files:
 - LICENSE
 - README.rdoc
 - Rakefile
-- VERSION
-- lib/padrino-cache.rb
 - padrino-cache.gemspec
+- lib/padrino-cache/helpers/cache_store.rb
+- lib/padrino-cache/helpers/fragment.rb
+- lib/padrino-cache/helpers/page.rb
+- lib/padrino-cache/store/file.rb
+- lib/padrino-cache/store/memcache.rb
+- lib/padrino-cache/store/memory.rb
+- lib/padrino-cache/store/redis.rb
+- lib/padrino-cache/store.rb
+- lib/padrino-cache.rb
 - test/helper.rb
 - test/test_padrino_cache.rb
+- test/test_stores.rb
 has_rdoc: true
-homepage: http://github.com/padrino/padrino-framework/tree/master/padrino-cache
+homepage: http://www.padrinorb.com
 licenses: []
 
 post_install_message: 
@@ -114,21 +74,29 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
+      hash: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
 requirements: []
 
-rubyforge_project: 
-rubygems_version: 1.3.5
+rubyforge_project: padrino-cache
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Page and fragment caching for Padrino

data/VERSION

@@ -1 +0,0 @@
-0.6.1