kschrader-sinatra-cache 0.2.3

data/README.textile

@@ -0,0 +1,126 @@
+h1. Sinatra::Cache
+
+Adds a very *simple* Page Caching functionality to "Sinatra":http://www.sinatrarb.com/
+
+<hr>
+
+h3. *PLEASE KEEP THIS IN MIND* 
+
+This is *unfinished work*, so use with care.
+
+If you find it lacking or badly coded, please feel free to fork and improve. I'll be very happy :)
+
+<hr>
+
+
+h3. TODO's
+
+
+= Make caching an option of the normal <tt>erb()/haml()/sass()</tt> methods, sort of like this:
+<pre><code>
+  erb(:index, :cache => true/false)
+  
+  # alternatively enable caching by setting a global config like this
+  set :cache_enabled_for :all || :only/except => ['/','/contact',...]
+  
+</code></pre>
+
+
+= Improve the logging output to the standard Sinatra output (if we are having :logging enabled )
+
+= Add fragment caching...
+
+= Enable the options functionality for the <tt>:cache</tt> & <tt>:cache_expire</tt> methods, so that they can take custom extensions and more
+
+
+<hr>
+
+
+h3. CONFIGURATION
+
+*Example 1: Sinatra 'classic' app.*
+
+  <pre><code>
+  <snip....>
+  require 'sinatra/cache'
+  
+  # toggle for the cache functionality.
+  set :cache_enabled, true
+  # sets the default extension for cached files
+  set :cache_page_extension, '.html'
+  # sets the Cache dir to the root of the /public directory.
+  set :cache_output_dir, '' # was :cache_dir
+  ...
+  </code></pre>
+
+*Example 2: Sinatra 'sub-classed' app.*
+    
+<pre><code>
+  <snip....>
+  require 'sinatra/cache'
+  
+  class MyApp < Sinatra::Base
+    
+    register Sinatra::Cache
+    
+    # toggle for the cache functionality.
+    set :cache_enabled, true
+    # sets the default extension for cached files
+    set :cache_page_extension, '.html'
+    # sets the Cache output dir to the root of the /public directory.
+    set :cache_output_dir, '' # was :cache_dir
+    
+    <snip....>
+</code></pre>
+
+
+<hr>
+
+
+h3. USAGE
+
+
+Basic Page Caching into static HTML files
+
+<pre><code>
+  get '/contact' do
+    # NB!  options is currently not working
+    cache( erb( :contact ), :options => 'should go here' )
+  end
+</code></pre>
+
+Expiring old pages (ie: after POST or PUT events) 
+
+<pre><code>
+  # not very good example
+  post '/contact' do
+    cache_expire( '/contact', options )
+  end
+</code></pre>
+
+See the "test":test/ and "test/fixtures":test/fixtures/ directories for more examples.
+
+
+<hr>
+
+
+h3. DEFAULT OPTIONS
+
+* <tt>:cache_enabled</tt> => toggle for the cache functionality. Default is: <tt>true</tt>
+* <tt>:cache_page_extension</tt> => sets the default extension for cached files. Default is: <tt>.html</tt>
+* <tt>:cache_output_dir</tt> => sets cache directory where cached files are stored. Default is: ''(empty) == root of /public.<br>
+    set to empty, since the ideal 'system/cache/' does not currently work with Passenger & mod_rewrite :(
+* <tt>:cache_logging</tt> => toggle for logging the cache calls. Default is: <tt>true</tt>
+* <tt>:cache_logging_level</tt> => sets the level of the cache logger. Default is: <tt>:info</tt>.<br>
+    Options:(unused atm) [:info, :warn, :debug]
+
+
+<hr>
+
+h3. Credits
+
+A big *Thank You!* goes to "*rtomayko*":http://github.com/rtomayko/, "*blakemizerany*":http://github.com/blakemizerany/ and others working on the Sinatra framework.
+
+Inspired by code from "Rails":http://rubyonrails.com/ &amp; "Merb":http://merbivore.com/
+and "sinatra-mailer":http://github.com/foca/sinatra-mailer/tree/master
+

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:minor: 2
+:patch: 3
+:major: 0

data/lib/sinatra/cache.rb

@@ -0,0 +1,150 @@
+require 'fileutils'
+# require 'sinatra/base'
+
+module Sinatra 
+    
+  # Sinatra Caching module
+  # 
+  #  TODO:: Need to write documentation here 
+  # 
+  module Cache
+    
+    VERSION = 'Sinatra::Cache v0.2.2'
+    def self.version; VERSION; end
+    
+    
+    module Helpers 
+      
+      # Caches the given URI to a html file in /public
+      # 
+      # <b>Usage:</b>
+      #    >> cache( erb(:contact, :layout => :layout))
+      #      =>  returns the HTML output written to /public/<CACHE_DIR_PATH>/contact.html
+      # 
+      # Also accepts an Options Hash, with the following options:
+      #  * :extension => in case you need to change the file extension
+      #  
+      #  TODO:: implement the opts={} hash functionality. What other options are needed?
+      # 
+      def cache(content, opts={})
+        return content unless options.cache_enabled
+        
+        unless content.nil?
+          content = "#{content}\n#{page_cached_timestamp}"
+          path = cache_page_path(request.path_info,opts)
+          FileUtils.makedirs(File.dirname(path))
+          open(path, 'wb+') { |f| f << content }
+          log("Cached Page: [#{path}]",:info) 
+          content
+        end
+      end
+      
+      # Expires the cached URI (as .html file) in /public
+      # 
+      # <b>Usage:</b>
+      #    >> cache_expire('/contact')
+      #      =>  deletes the /public/<CACHE_DIR_PATH>contact.html page
+      # 
+      #    get '/contact' do 
+      #     cache_expire   # deletes the /public/<CACHE_DIR_PATH>contact.html page as well
+      #    end
+      #
+      #  TODO:: implement the options={} hash functionality. What options are really needed ? 
+      def cache_expire(path = nil, opts={})
+        return unless options.cache_enabled
+        
+        path = (path.nil?) ? cache_page_path(request.path_info) : cache_page_path(path, opts)
+        if File.exist?(path)
+          File.delete(path)
+          log("Expired Page deleted at: [#{path}]",:info)
+        else
+          log("No Expired Page was found at the path: [#{path}]",:info)
+        end
+      end
+      
+      # Prints a basic HTML comment with a timestamp in it, so that you can see when a file was cached last.
+      # 
+      # *NB!* IE6 does NOT like this to be the first line of a HTML document, so output
+      # inside the <head> tag. Many hours wasted on that lesson ;-)
+      # 
+      # <b>Usage:</b>
+      #    >> <%= page_cached_timestamp %>
+      #      => <!--  page cached: 2009-02-24 12:00:00 -->
+      #
+      def page_cached_timestamp
+        "<!-- page cached: #{Time.now.strftime("%Y-%d-%m %H:%M:%S")} -->\n" if options.cache_enabled
+      end
+      
+      # Simple method to see if a file already exists in the cache
+      #
+      # TODO: Testcases!
+      
+      def cached_file_exists(path, opts={})
+        path = (path.nil?) ? cache_page_path(request.path_info) : cache_page_path(path, opts)
+        return File.exist?(path)
+      end
+      
+      private
+        
+        # Establishes the file name of the cached file from the path given
+        # 
+        # TODO:: implement the opts={} functionality, and support for custom extensions on a per request basis. 
+        # 
+        def cache_file_name(path,opts={})
+          name = (path.empty? || path == "/") ? "index" : Rack::Utils.unescape(path.sub(/^(\/)/,'').chomp('/'))
+          opts.each do |key, value|
+            name = name + "." + key.to_s.downcase + "." + value.to_s.downcase
+          end
+          name << options.cache_page_extension # unless (name.split('/').last || name).include? '.'
+          return name
+        end
+        
+        # Sets the full path to the cached page/file
+        # Dependent upon Sinatra.options .public and .cache_dir variables being present and set.
+        # 
+        def cache_page_path(path,opts={})
+          # test if given a full path rather than relative path, otherwise join the public path to cache_dir 
+          # and ensure it is a full path
+          cache_dir = (options.cache_output_dir == File.expand_path(options.cache_output_dir)) ? 
+              options.cache_output_dir : File.expand_path("#{options.public}/#{options.cache_output_dir}")
+          cache_dir = cache_output_dir[0..-2] if cache_dir[-1,1] == '/'
+          "#{cache_dir}/#{cache_file_name(path,opts)}"
+        end
+        
+        #  TODO:: this implementation really stinks, how do I incorporate Sinatra's logger??
+        def log(msg,scope=:debug)
+          if options.cache_logging
+            "Log: msg=[#{msg}]" if scope == options.cache_logging_level
+          else
+            # just ignore the stuff...
+            # puts "just ignoring msg=[#{msg}] since cache_logging => [#{options.cache_logging.to_s}]"
+          end
+        end
+        
+    end #/module Helpers
+    
+    
+    # Sets the default options:
+    # 
+    #  * +:cache_enabled+ => toggle for the cache functionality. Default is: +true+
+    #  * +:cache_page_extension+ => sets the default extension for cached files. Default is: +.html+
+    #  * +:cache_dir+ => sets cache directory where cached files are stored. Default is: ''(empty) == root of /public.<br>
+    #      set to empty, since the ideal 'system/cache/' does not work with Passenger & mod_rewrite :(
+    #  * +cache_logging+ => toggle for logging the cache calls. Default is: +true+
+    #  * +cache_logging_level+ => sets the level of the cache logger. Default is: <tt>:info</tt>.<br>
+    #      Options:(unused atm) [:info, :warn, :debug]
+    # 
+    def self.registered(app)
+      app.helpers(Cache::Helpers)
+      app.set :cache_enabled, true
+      app.set :cache_page_extension, '.html'
+      app.set :cache_output_dir, ''
+      app.set :cache_logging, true
+      app.set :cache_logging_level, :info
+    end
+    
+  end #/module Cache
+  
+  register(Sinatra::Cache)
+  
+end #/module Sinatra

data/test/SPECS.rdoc

@@ -0,0 +1,95 @@
+Test Suite for [Sinatra::Cache v0.2.0] produced on [2009-25-02 at 00:37]
+
+== Sinatra::Cache
+=== ClassMethods
+==== the :version method
+* should have a :version method that returns a String with the version number in it
+* should not interfere with the normal Sinatra VERSION
+=== Instance Methods
+==== Private
+===== :cache_file_name method
+====== when using default options
+* should handle '/' and return 'index.html'
+* should handle top level URI's and return the URI plus '.html'
+* should handle sub level URIs and return the directory/file format
+====== when using customized options
+* should handle '/' and return 'index.html'
+* should handle top level URI's and return the URI plus '.html'
+* should handle sub level URIs and return the directory/file format
+===== :cache_page_path method
+====== when using default options
+* should handle '/' and return the full path to 'index.html'
+* should handle top level URI's and return the full path to the URI plus '.html'
+* should handle sub level URIs and return the full path to the URI
+====== when using customized options
+* should handle '/' and return the full path to 'index.html'
+* should handle top level URI's and return the full path to the URI plus '.html'
+* should handle sub level URIs and return the full path to the URI
+===== :log method
+* MISSING TESTS =>
+==== Public
+===== :cache method
+====== when using default options
+* is tested below in the Page Caching section
+====== when using customized options
+* is tested below in the Page Caching section
+=== configuration methods
+==== when using default options
+* the :cache_enabled option should be correct (true)
+* the :cache_page_extension option should be correct (.html)
+* the :cache_dir option should be correct ('') 
+* the :cache_logging option should be correct (true)
+* the :cache_logging_level option should be correct (:info)
+==== when using customized options
+* the :cache_enabled option should be correct (false)
+* the :cache_page_extension option should be correct (.cache.html)
+* the :cache_dir option should be correct ('system/cache') 
+* the :cache_logging option should be correct (true)
+* the :cache_logging_level option should be correct (:info)
+=== Page Caching
+==== when using default options
+* should NOT cache the un-cached index page
+* should cache the /cache page
+* should expire the /cache page
+==== when using customized options
+* should NOT cache the un-cached index page
+* should NOT cache the /cache page since :cache_enabled => false
+===== and setting cache_enabled => true
+* should cache the /cache page
+* should expire the /cache page
+=== Sinatra::Base
+==== should respond to
+* the :cache_dir method
+* the :cache_dir= method
+* the :cache_dir? method
+* the :cache_enabled method
+* the :cache_enabled= method
+* the :cache_enabled? method
+* the :cache_logging method
+* the :cache_logging= method
+* the :cache_logging? method
+* the :cache_logging_level method
+* the :cache_logging_level= method
+* the :cache_logging_level? method
+* the :cache_page_extension method
+* the :cache_page_extension= method
+* the :cache_page_extension? method
+=== Sinatra::Default
+==== should respond to
+* the :cache_dir method
+* the :cache_dir= method
+* the :cache_dir? method
+* the :cache_enabled method
+* the :cache_enabled= method
+* the :cache_enabled? method
+* the :cache_logging method
+* the :cache_logging= method
+* the :cache_logging? method
+* the :cache_logging_level method
+* the :cache_logging_level= method
+* the :cache_logging_level? method
+* the :cache_page_extension method
+* the :cache_page_extension= method
+* the :cache_page_extension? method
+
+64 specifications (84 requirements), 0 failures

data/test/cache_test.rb

@@ -0,0 +1,434 @@
+require File.dirname(__FILE__) + '/helper'
+require "#{File.dirname(File.dirname(File.expand_path(__FILE__)))}/lib/sinatra/cache"
+
+class Sinatra::Base
+  # include Sinatra::Cache
+end #/class Sinatra::Base
+
+puts "Test Suite for [#{Sinatra::Cache.version}] produced on [#{ Time.now.strftime("%Y-%d-%m at %H:%M") }]"
+
+describe "Sinatra::Cache" do 
+  
+  before(:each) do
+    
+    default_app = mock_app do 
+      register Sinatra::Cache
+      
+      set :public, "#{File.dirname(File.expand_path(__FILE__))}/fixtures/public"
+      set :views, "#{File.dirname(File.expand_path(__FILE__))}/fixtures/views"
+      
+      get '/' do
+        erb(:index)
+      end
+      
+      get '/cache' do
+        # "Hello World from Sinatra Version=[#{Sinatra::VERSION}]"
+        cache("Hello World from Sinatra Version=[#{Sinatra::VERSION}]")
+      end
+      # YES, I know this is NOT ideal, but it's only test ;-)
+      get '/cache_expire' do
+        cache_expire("/cache")
+      end
+      
+    end
+    
+    custom_app = mock_app do
+      register Sinatra::Cache
+      
+      set :public, "#{File.dirname(__FILE__)}/fixtures/public"
+      set :views, "#{File.dirname(__FILE__)}/fixtures/views"
+      
+      set :cache_enabled, false
+      set :cache_page_extension, '.cache.html'
+      set :cache_output_dir, 'system/cache'
+      set :cache_logging, false
+      set :cache_logging_level, :info
+      
+      get '/' do
+        erb :index
+      end
+      
+      get '/cache' do
+        cache("Hello World from Sinatra Version=[#{Sinatra::VERSION}]")
+      end
+      # YES, I know this is NOT ideal, but it's only test ;-)
+      get '/cache_expire' do
+        cache_expire("/cache")
+      end
+    end
+    
+    @default_app = default_app.new
+    @custom_app = custom_app.new
+  end
+  
+  describe "ClassMethods" do 
+    
+    describe "the :version method" do 
+      
+      it "should have a :version method that returns a String with the version number in it" do 
+        v = Sinatra::Cache.version
+        assert_not_nil(v)
+        assert_kind_of(String, v)
+        assert_match(/Sinatra::Cache v\d\.\d\.\d/, v)
+      end
+      
+      it "should not interfere with the normal Sinatra VERSION" do 
+        assert_not_equal(Sinatra::Cache.version, Sinatra::VERSION)
+      end
+      
+    end #/the :version method
+    
+  end #/ClassMethods
+  
+  
+  describe "Instance Methods" do 
+    
+    describe "Private" do 
+      
+      describe ":cache_file_name method" do 
+        
+        # temporary monkeypatch to enable testing
+        module Sinatra::Cache::Helpers 
+          public :cache_file_name
+        end
+        
+        describe "when using default options" do 
+          
+          it "should handle '/' and return 'index.html'" do 
+            expected = "index.html"
+            assert_equal(expected, @default_app.cache_file_name("/"))
+          end
+          
+          it "should handle top level URI's and return the URI plus '.html'" do 
+            expected = "cache.html"
+            assert_equal(expected, @default_app.cache_file_name("/cache"))
+          end
+          
+          it "should handle sub level URIs and return the directory/file format" do 
+            expected = "cache/test.html"
+            assert_equal(expected, @default_app.cache_file_name("/cache/test"))
+          end
+          
+        end #/when using default options
+        
+        describe "when using customized options" do 
+          
+          it "should handle '/' and return 'index.html'" do 
+            expected = "index.cache.html"
+            assert_equal(expected, @custom_app.cache_file_name("/"))
+          end
+          
+          it "should handle top level URI's and return the URI plus '.html'" do 
+            expected = "cache.cache.html"
+            assert_equal(expected, @custom_app.cache_file_name("/cache"))
+          end
+          
+          it "should handle sub level URIs and return the directory/file format" do 
+            expected = "cache/test.cache.html"
+            assert_equal(expected, @custom_app.cache_file_name("/cache/test"))
+          end
+          
+        end #/when using customized options
+        
+      end #/:cache_page_path method
+      
+      describe ":cache_page_path method" do 
+        
+        # temporary monkeypatch to enable testing
+        module Sinatra::Cache::Helpers 
+          public :cache_page_path
+        end
+        
+        describe "when using default options" do 
+          
+          it "should handle '/' and return the full path to 'index.html'" do 
+            expected = "#{public_fixtures_path}/index.html"
+            assert_equal(expected, @default_app.cache_page_path("/"))
+          end
+          
+          it "should handle top level URI's and return the full path to the URI plus '.html'" do 
+            expected = "#{public_fixtures_path}/cache.html"
+            assert_equal(expected, @default_app.cache_page_path("/cache"))
+          end
+          
+          it "should handle sub level URIs and return the full path to the URI" do 
+            expected = "#{public_fixtures_path}/cache/test.html"
+            assert_equal(expected, @default_app.cache_page_path("/cache/test"))
+          end
+          
+        end #/when using default options
+        
+        describe "when using customized options" do 
+          
+          it "should handle '/' and return the full path to 'index.html'" do 
+            expected = "#{public_fixtures_path}/system/cache/index.cache.html"
+            assert_equal(expected, @custom_app.cache_page_path("/"))
+          end
+          
+          it "should handle top level URI's and return the full path to the URI plus '.html'" do 
+            expected = "#{public_fixtures_path}/system/cache/cache.cache.html"
+            assert_equal(expected, @custom_app.cache_page_path("/cache"))
+          end
+          
+          it "should handle sub level URIs and return the full path to the URI" do 
+            expected = "#{public_fixtures_path}/system/cache/cache/test.cache.html"
+            assert_equal(expected, @custom_app.cache_page_path("/cache/test"))
+          end
+          
+        end #/when using customized options
+        
+      end #/:cache_page_path method
+      
+      describe ":log method" do 
+        
+        it "MISSING TESTS =>" do 
+          assert(true)
+        end
+        
+      end #/:log method
+      
+    end #/Private
+    
+    describe "Public" do 
+      
+      describe ":cache method" do 
+        
+        describe "when using default options" do 
+          
+          it "is tested below in the Page Caching section" do 
+            assert true
+          end
+          
+        end #/when using default options
+        
+        describe "when using customized options" do 
+          
+          it "is tested below in the Page Caching section" do 
+            assert true
+          end
+          
+        end #/when using customized options
+        
+      end #/:cache method
+      
+    end #/Public
+    
+  end #/Instance Methods
+  
+  
+  describe "configuration methods" do 
+    
+    describe "when using default options" do 
+      
+      it "the :cache_enabled option should be correct (true)" do 
+        assert_equal(true, @default_app.options.cache_enabled)
+      end
+      
+      it "the :cache_page_extension option should be correct (.html)" do 
+        assert_equal('.html', @default_app.options.cache_page_extension)
+      end
+      
+      it "the :cache_output_dir option should be correct ('') " do 
+        assert_equal('', @default_app.options.cache_output_dir)
+      end
+      
+      it "the :cache_logging option should be correct (true)" do 
+        assert_equal(true, @default_app.options.cache_logging)
+      end
+      
+      it "the :cache_logging_level option should be correct (:info)" do 
+        assert_equal(:info, @default_app.options.cache_logging_level)
+      end
+      
+    end #/default options
+    
+    describe "when using customized options" do 
+      
+      it "the :cache_enabled option should be correct (false)" do 
+        assert_equal(false, @custom_app.options.cache_enabled)
+      end
+      
+      it "the :cache_page_extension option should be correct (.cache.html)" do 
+        assert_equal('.cache.html', @custom_app.options.cache_page_extension)
+      end
+      
+      it "the :cache_output_dir option should be correct ('system/cache') " do 
+        assert_equal('system/cache', @custom_app.options.cache_output_dir)
+      end
+      
+      it "the :cache_logging option should be correct (true)" do 
+        assert_equal(false, @custom_app.options.cache_logging)
+      end
+      
+      it "the :cache_logging_level option should be correct (:info)" do 
+        assert_equal(:info, @custom_app.options.cache_logging_level)
+      end
+      
+    end #/when using customized options
+    
+  end #/configuration methods
+  
+  
+  describe "Page Caching" do 
+    after(:each) do
+      # FileUtils.rm_r(Dir["#{public_fixtures_path}/*"])
+    end
+    
+    describe "when using default options" do 
+      
+      it "should NOT cache the un-cached index page" do 
+        request = Rack::MockRequest.new(@default_app)
+        response = request.get('/')
+        assert response
+        assert_equal '<h1>HOME</h1>', response.body
+        assert_equal(false, test(?f, "#{public_fixtures_path}/index.html"))
+      end
+      
+      it "should cache the /cache page" do 
+        request = Rack::MockRequest.new(@default_app)
+        response = request.get('/cache')
+        assert response
+        assert_match(/^Hello World from Sinatra Version=\[\d\.\d\.\d(\.\d)?\]\n/, response.body)
+        assert(test(?f, "#{public_fixtures_path}/cache.html"))
+        assert_match(/^Hello World from Sinatra Version=\[\d\.\d\.\d(\.\d)?\]\n/, File.read("#{public_fixtures_path}/cache.html"))
+      end
+      
+      it "should expire the /cache page" do 
+        assert(test(?f, "#{public_fixtures_path}/cache.html"))
+        request = Rack::MockRequest.new(@default_app)
+        response = request.get('/cache_expire')
+        assert response
+        #  TODO:: this is dodgy stuff, rework 
+        assert_not_equal('', response.body)
+        assert_equal(false, test(?f, "#{public_fixtures_path}/cache.html"))
+      end
+      
+    end #/when using default options
+    
+    describe "when using customized options" do 
+      
+      it "should NOT cache the un-cached index page" do 
+        request = Rack::MockRequest.new(@custom_app)
+        response = request.get('/')
+        assert response
+        assert_equal '<h1>HOME</h1>', response.body
+        assert_equal(false, test(?f, "#{public_fixtures_path}/index.html"))
+      end
+      
+      it "should NOT cache the /cache page since :cache_enabled => false" do 
+        request = Rack::MockRequest.new(@custom_app)
+        response = request.get('/cache')
+        assert response
+        assert_match(/^Hello World from Sinatra Version=\[\d\.\d\.\d(\.\d)?\]/, response.body)
+        assert_equal(false, test(?f, "#{public_fixtures_path}/cache.cache.html"))
+      end
+      
+      describe "and setting cache_enabled => true" do 
+        
+        before(:each) do
+          custom_enabled_app = mock_app do 
+            register Sinatra::Cache
+            
+            set :public, "#{File.dirname(File.expand_path(__FILE__))}/fixtures/public"
+            set :views, "#{File.dirname(File.expand_path(__FILE__))}/fixtures/views"
+            
+            set :cache_enabled, true
+            set :cache_page_extension, '.cache.html'
+            set :cache_output_dir, 'system/cache'
+            set :cache_logging, true
+            set :cache_logging_level, :info
+            
+            get '/' do
+              erb :index
+            end
+            
+            get '/cache' do
+              cache("Hello World from Sinatra Version=[#{Sinatra::VERSION}]")
+            end
+            
+            # YES, I know this is NOT ideal, but it's only test ;-)
+            get '/cache_expire' do
+              cache_expire("/cache")
+            end
+            
+          end
+          
+          @custom_enabled_app = custom_enabled_app.new
+        end
+        
+        it "should cache the /cache page" do 
+          request = Rack::MockRequest.new(@custom_enabled_app)
+          response = request.get('/cache')
+          assert response
+          assert_match(/^Hello World from Sinatra Version=\[\d\.\d\.\d(\.\d)?\]\n<!-- page cached: \d+-\d+-\d+ \d+:\d+:\d+ -->\n$/, response.body)
+          assert(test(?f, "#{public_fixtures_path}/system/cache/cache.cache.html"))
+          assert_match(/^Hello World from Sinatra Version=\[\d\.\d\.\d(\.\d)?\]\n<!-- page cached: \d+-\d+-\d+ \d+:\d+:\d+ -->\n$/, File.read("#{public_fixtures_path}/system/cache/cache.cache.html"))
+        end
+        
+        it "should expire the /cache page" do 
+          assert(test(?f, "#{public_fixtures_path}/system/cache/cache.cache.html"))
+          request = Rack::MockRequest.new(@custom_enabled_app)
+          response = request.get('/cache_expire')
+          assert response
+          #  TODO:: this is dodgy stuff, rework 
+          assert_not_equal('', response.body)
+          assert_equal(false, test(?f, "#{public_fixtures_path}/system/cache/cache.cache.html"))
+        end
+        
+      end #/and setting cache_enabled => true
+      
+    end #/when using customized options
+    
+    
+  end #/Page Caching
+  
+  
+  describe "Sinatra::Base" do 
+    
+    before do
+      Sinatra::Base.register(Sinatra::Cache)
+    end
+    
+    describe "should respond to" do 
+      
+      [
+        "cache_output_dir", "cache_output_dir=","cache_output_dir?", "cache_enabled","cache_enabled=", "cache_enabled?",
+        "cache_logging","cache_logging=","cache_logging?","cache_logging_level","cache_logging_level=","cache_logging_level?",
+        "cache_page_extension","cache_page_extension=","cache_page_extension?"
+      ].each do |m|
+        
+        it "the :#{m} method" do 
+          assert_respond_to(Sinatra::Base, m.to_sym)
+        end
+        
+      end
+      
+    end #/should respond to
+    
+  end #/Sinatra::Base
+  
+  describe "Sinatra::Default" do 
+    
+    before do
+      Sinatra::Base.register(Sinatra::Cache)
+    end
+    
+    describe "should respond to" do 
+      
+      [
+        "cache_output_dir", "cache_output_dir=","cache_output_dir?", "cache_enabled","cache_enabled=", "cache_enabled?",
+        "cache_logging","cache_logging=","cache_logging?","cache_logging_level","cache_logging_level=","cache_logging_level?",
+        "cache_page_extension","cache_page_extension=","cache_page_extension?"
+      ].each do |m|
+        
+        it "the :#{m} method" do 
+          assert_respond_to(Sinatra::Default, m.to_sym)
+        end
+        
+      end
+      
+    end #/should respond to
+    
+  end #/Sinatra::Default
+  
+end #/Sinatra::Cache

data/test/fixtures/classic.rb

@@ -0,0 +1,25 @@
+## CLASSIC.rb
+## Simple example app of how to use the Sinatra::Cache plugin in a normal 'Classic' Sinatra app.
+
+require "rubygems"
+require "sinatra"
+require 'sinatra/cache'
+
+set :public, "#{File.dirname(__FILE__)}/public"
+set :views, "#{File.dirname(__FILE__)}/views"
+
+
+get '/' do
+  erb(:index)
+end
+
+get '/cache' do
+  cache("Hello World from Sinatra Version=[#{Sinatra::VERSION}]")
+end
+
+# YES, I know this is NOT ideal, but it's only a test ;-)
+get '/cache_expire' do
+  cache_expire("/cache")
+end
+
+#/EOF

data/test/fixtures/myapp.rb

@@ -0,0 +1,36 @@
+## MYAPP.rb
+## Simple example app of how to use the Sinatra::Cache plugin in a new 'Sub-Classed' Sinatra app 
+## that inherits from Sinatra::Base
+
+require "rubygems"
+require "sinatra/base"
+require 'sinatra/cache'
+
+class MyApp < Sinatra::Base
+  
+  register Sinatra::Cache
+  
+  enable :logging
+  enable :static
+  
+  set :public, "#{File.dirname(__FILE__)}/public"
+  set :views, "#{File.dirname(__FILE__)}/views"
+  
+  get '/' do
+    erb(:index)
+  end
+  
+  get '/cache' do
+    cache("Hello World from Sinatra Version=[#{Sinatra::VERSION}]")
+  end
+  
+  # YES, I know this is NOT ideal, but it's only a test ;-)
+  get '/cache_expire' do
+    cache_expire("/cache")
+  end
+  
+end
+
+MyApp.run!(:port => 4568) if __FILE__ == $0
+
+#/EOF

data/test/fixtures/myapp_default.rb

@@ -0,0 +1,37 @@
+## MYAPP_DEFAULT.rb
+## Simple example app of how to use the Sinatra::Cache plugin in a new 'Sub-Classed' Sinatra app 
+## that inherits from Sinatra::Default
+
+require "rubygems"
+require "sinatra/base"
+require 'sinatra/cache'
+
+class MyAppDefault < Sinatra::Default
+  
+  register Sinatra::Cache
+  
+  # these are enabled by default in Sinatra::Default
+  # enable :logging
+  # enable :static
+  
+  set :public, "#{File.dirname(__FILE__)}/public"
+  set :views, "#{File.dirname(__FILE__)}/views"
+  
+  get '/' do
+    erb(:index)
+  end
+  
+  get '/cache' do
+    cache("Hello World from Sinatra Version=[#{Sinatra::VERSION}]")
+  end
+  
+  # YES, I know this is NOT ideal, but it's only a test ;-)
+  get '/cache_expire' do
+    cache_expire("/cache")
+  end
+  
+end
+
+MyAppDefault.run!(:port => 4569) if __FILE__ == $0
+
+#/EOF

data/test/fixtures/views/index.erb

@@ -0,0 +1 @@
+<h1>HOME</h1>

data/test/helper.rb

@@ -0,0 +1,62 @@
+# vendor_sinatra = "#{File.dirname(File.dirname(__FILE__))}/vendor/sinatra"
+# puts vendor_sinatra
+# $LOAD_PATH.unshift "#{vendor_sinatra}/lib" if test(?d, vendor_sinatra)
+
+path_2_my_lib = File.expand_path('../lib')
+$LOAD_PATH.unshift path_2_my_lib
+
+require 'rubygems'
+require 'sinatra/base'
+begin
+  require 'test/spec'
+rescue LoadError
+  raise "These tests depends upon the Test-Spec gem  [sudo gem install test-spec]"
+end
+require 'sinatra/test'
+
+
+# The code below was lovingly plagiarized from Sinatra.
+
+class Sinatra::Base
+  # Allow assertions in request context
+  include Test::Unit::Assertions
+end
+
+class Test::Unit::TestCase
+  include Sinatra::Test
+  
+  def setup
+    Sinatra::Default.set :environment, :test
+  end
+  
+  # Sets up a Sinatra::Base subclass defined with the block
+  # given. Used in setup or individual spec methods to establish
+  # the application.
+  def mock_app(base=Sinatra::Base, &block)
+    @app = Sinatra.new(base, &block)
+  end
+  
+  def restore_default_options
+    Sinatra::Default.set(
+      :environment => :development,
+      :raise_errors => Proc.new { test? },
+      :dump_errors => true,
+      :sessions => false,
+      :logging => Proc.new { ! test? },
+      :methodoverride => true,
+      :static => true,
+      :run => Proc.new { ! test? }
+    )
+  end
+  
+  # quick convenience methods..
+  
+  def fixtures_path
+    "#{File.dirname(File.expand_path(__FILE__))}/fixtures"
+  end
+  
+  def public_fixtures_path
+    "#{fixtures_path}/public"
+  end
+  
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: kschrader-sinatra-cache
+version: !ruby/object:Gem::Version 
+  version: 0.2.3
+platform: ruby
+authors: 
+- kematzy
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-27 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Simple Page Caching for Sinatra [www.sinatrarb.com]
+email: kematzy@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.textile
+- VERSION.yml
+- lib/sinatra
+- lib/sinatra/cache.rb
+- test/cache_test.rb
+- test/fixtures
+- test/fixtures/classic.rb
+- test/fixtures/myapp.rb
+- test/fixtures/myapp_default.rb
+- test/fixtures/public
+- test/fixtures/public/system
+- test/fixtures/public/system/cache
+- test/fixtures/views
+- test/fixtures/views/index.erb
+- test/helper.rb
+- test/SPECS.rdoc
+has_rdoc: true
+homepage: http://github.com/kematzy/sinatra-cache
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Simple Page Caching for Sinatra [www.sinatrarb.com]
+test_files: []
+