tricycle-rack-contrib 0.9.5 → 0.9.6

data/README.rdoc

@@ -50,11 +50,11 @@ interface:
 
 Git is the quickest way to the rack-contrib sources:
 
-  git clone git://github.com/rack/rack-contrib.git
+  git clone git://github.com/tricycle/rack-contrib.git
 
-Gems are currently available from GitHub clones:
+Gems are currently available from Gemcutter:
 
-  gem install rack-rack-contrib --source=http://gems.github.com/
+  gem install tricycle-rack-contrib --source=http://gemcutter.org/
 
 Requiring 'rack/contrib' will add autoloads to the Rack modules for all of the
 components included. The following example shows what a simple rackup
@@ -73,6 +73,7 @@ components included. The following example shows what a simple rackup
 === Links
 
 rack-contrib on GitHub:: <http://github.com/rack/rack-contrib>
+tricycle-rack-contrib on GitHub:: <http://github.com/tricycle/rack-contrib>
 Rack:: <http://rack.rubyforge.org/>
 Rack On GitHub:: <http://github.org/rack/rack>
 rack-devel mailing list:: <http://groups.google.com/group/rack-devel>

data/lib/rack/contrib/response_cache.rb

@@ -7,6 +7,18 @@ require 'rack'
 # Rails' page caching, allowing you to cache dynamic pages to static files that can
 # be served directly by a front end webserver.
 class Rack::ResponseCache
+  CONTENT_TYPES = {
+    "application/pdf" => %w[pdf],
+    "application/xhtml+xml" => %w[xhtml],
+    "text/css" => %w[css],
+    "text/csv" => %w[csv],
+    "text/html" => %w[html htm],
+    "text/javascript" => %w[js], "application/javascript" => %w[js],
+    "text/plain" => %w[txt],
+    "text/xml" => %w[xml],
+  }
+  ALLOWED_EXTENSIONS = CONTENT_TYPES.collect {|k, v| v }.flatten.uniq
+
   # The default proc used if a block is not provided to .new
   # Doesn't cache unless path does not contain '..', Content-Type is
   # whitelisted, and path agrees with Content-Type
@@ -15,34 +27,31 @@ class Rack::ResponseCache
   DEFAULT_PATH_PROC = proc do |env, res|
     path = Rack::Utils.unescape(env['PATH_INFO'])
     
-    content_types = {
-      "application/pdf" => %w[pdf],
-      "application/xhtml+xml" => %w[xhtml],
-      "text/css" => %w[css],
-      "text/csv" => %w[csv],
-      "text/html" => %w[html htm],
-      "text/javascript" => %w[js], "application/javascript" => %w[js],
-      "text/plain" => %w[txt],
-      "text/xml" => %w[xml],
-    }
-    content_type = res[1]['Content-Type'].to_s
+    content_type = res[1]['Content-Type'].to_s.split(';').first
+    extension = File.extname(path)[1..-1]
     
-    if !path.include?('..') and extensions = content_types[content_type]
+    if !path.include?('..') and (allowed_extensions_for_content_type = CONTENT_TYPES[content_type])
       # path doesn't include '..' and Content-Type is whitelisted
       case
       when path.match(/\/$/) && content_type == "text/html"
         # path ends in / and Content-Type is text/html
         path << "index.html"
-      when File.extname(path) == ""
-        # no extension
-        path << ".#{extensions.first}"
-      when !extensions.include?(File.extname(path)[1..-1])
-        # extension agrees with Content-Type
+      when path.match(/\/$/) && content_type != "text/html"
+        # path ends in / and Content-Type is not text/html - don't cache
+        path = nil
+      when File.extname(path) == "" ||
+        (!ALLOWED_EXTENSIONS.include?(extension) && content_type == "text/html")
+        # no extension OR
+        # unrecognized extension AND content_type is text/html
+        path << ".#{allowed_extensions_for_content_type.first}"
+      when !allowed_extensions_for_content_type.include?(extension)
+        # extension doesn't agree with Content-Type (but extension is recognized) - don't cache
         path = nil
       else
         # do nothing, path is alright
       end
     else
+      # don't cache
       path = nil
     end
     

data/test/spec_rack_response_cache.rb

@@ -23,40 +23,40 @@ context Rack::ResponseCache do
   end
 
   specify "should cache results to disk if cache is a string" do
-    request(:cache=>@def_disk_cache)
+    request(:cache => @def_disk_cache)
     F.read(F.join(@def_disk_cache, 'path', 'to', 'blah.html')).should.equal @def_value.first
-    request(:path=>'/path/3', :cache=>@def_disk_cache)
+    request(:path => '/path/3', :cache => @def_disk_cache)
     F.read(F.join(@def_disk_cache, 'path', '3.html')).should.equal @def_value.first
   end
 
   specify "should cache results to given cache if cache is not a string" do
     request
-    @cache.should.equal('/path/to/blah.html'=>@def_value)
-    request(:path=>'/path/3')
-    @cache.should.equal('/path/to/blah.html'=>@def_value, '/path/3.html'=>@def_value)
+    @cache.should.equal('/path/to/blah.html' => @def_value)
+    request(:path => '/path/3')
+    @cache.should.equal('/path/to/blah.html' => @def_value, '/path/3.html' => @def_value)
   end
 
   specify "should not cache results if request method is not GET" do
-    request(:meth=>:post)
+    request(:meth => :post)
     @cache.should.equal({})
-    request(:meth=>:put)
+    request(:meth => :put)
     @cache.should.equal({})
-    request(:meth=>:delete)
+    request(:meth => :delete)
     @cache.should.equal({})
   end
 
-  specify "should not cache results if there is a query string" do
-    request(:path=>'/path/to/blah?id=1')
+  specify "should not cache results if there is a non-empty query string" do
+    request(:path => '/path/to/blah?id=1')
     @cache.should.equal({})
-    request(:path=>'/path/to/?id=1')
+    request(:path => '/path/to/?id=1')
     @cache.should.equal({})
-    request(:path=>'/?id=1')
+    request(:path => '/?id=1')
     @cache.should.equal({})
   end
 
   specify "should cache results if there is an empty query string" do
-    request(:path=>'/?')
-    @cache.should.equal('/index.html'=>@def_value)
+    request(:path => '/?')
+    @cache.should.equal('/index.html' => @def_value)
   end
 
   specify "should not cache results if the request is not sucessful (status 200)" do
@@ -95,38 +95,38 @@ context Rack::ResponseCache do
   end
 
   specify "should not cache results if the block returns nil or false" do
-    request(:rc_block=>proc{false})
+    request(:rc_block => proc{false})
     @cache.should.equal({})
-    request(:rc_block=>proc{nil})
+    request(:rc_block => proc{nil})
     @cache.should.equal({})
   end
 
   specify "should cache results to path returned by block" do
-    request(:rc_block=>proc{"1"})
-    @cache.should.equal("1"=>@def_value)
-    request(:rc_block=>proc{"2"})
-    @cache.should.equal("1"=>@def_value, "2"=>@def_value)
+    request(:rc_block => proc{"1"})
+    @cache.should.equal("1" => @def_value)
+    request(:rc_block => proc{"2"})
+    @cache.should.equal("1" => @def_value, "2" => @def_value)
   end
 
   specify "should pass the environment and response to the block" do
     e, r = nil, nil
-    request(:rc_block=>proc{|env,res| e, r = env, res; nil})
+    request(:rc_block => proc{|env,res| e, r = env, res; nil})
     e['PATH_INFO'].should.equal @def_path
     e['REQUEST_METHOD'].should.equal 'GET'
     e['QUERY_STRING'].should.equal ''
-    r.should.equal([200, {"Content-Type"=>"text/html"}, ["rack-response-cache"]])
+    r.should.equal([200, {"Content-Type" => "text/html"}, ["rack-response-cache"]])
   end
 
   specify "should unescape the path by default" do
-    request(:path=>'/path%20with%20spaces')
-    @cache.should.equal('/path with spaces.html'=>@def_value)
-    request(:path=>'/path%3chref%3e')
-    @cache.should.equal('/path with spaces.html'=>@def_value, '/path<href>.html'=>@def_value)
+    request(:path => '/path%20with%20spaces')
+    @cache.should.equal('/path with spaces.html' => @def_value)
+    request(:path => '/path%3chref%3e')
+    @cache.should.equal('/path with spaces.html' => @def_value, '/path<href>.html' => @def_value)
   end
 
   specify "should cache html mime_type without extension at .html" do
-    request(:path=>'/a')
-    @cache.should.equal('/a.html'=>@def_value)
+    request(:path => '/a')
+    @cache.should.equal('/a.html' => @def_value)
   end
 
   {
@@ -141,36 +141,58 @@ context Rack::ResponseCache do
   }.each do |extension, mime_types|
     mime_types.each do |mime_type|
       specify "should cache #{mime_type} responses with the extension ('#{extension}') unchanged" do
-        request(:path=>"/a.#{extension}", :headers=>{'CT'=>mime_type})
-        @cache.should.equal("/a.#{extension}"=>@def_value)
+        request(:path => "/a.#{extension}", :headers => {'CT' => mime_type})
+        @cache.should.equal("/a.#{extension}" => @def_value)
       end
 
       specify "should cache #{mime_type} responses with the relevant extension ('#{extension}') added if not already present" do
-        request(:path=>'/a', :headers=>{'CT'=>mime_type})
-        @cache.should.equal("/a.#{extension}"=>@def_value)
+        request(:path => '/a', :headers => {'CT' => mime_type})
+        @cache.should.equal("/a.#{extension}" => @def_value)
       end
     end
   end
   
   specify "should cache 'text/html' responses with the extension ('htm') unchanged" do
-    request(:path=>"/a.htm", :headers=>{'CT'=>"text/html"})
-    @cache.should.equal("/a.htm"=>@def_value)
+    request(:path => "/a.htm", :headers => {'CT' => "text/html"})
+    @cache.should.equal("/a.htm" => @def_value)
   end
   
   [:css, :xml, :xhtml, :js, :txt, :pdf, :csv].each do |extension|
     specify "should not cache if extension and content-type don't agree" do
-      request(:path=>"/d.#{extension}", :headers=>{'CT'=>'text/html'})
+      request(:path => "/d.#{extension}", :headers => {'CT' => 'text/html'})
       @cache.should.equal({})
     end    
   end
 
-  specify "should cache html responses with empty basename to index.html by default" do
-    request(:path=>'/')
-    @cache.should.equal('/index.html'=>@def_value)
-    request(:path=>'/blah/')
-    @cache.should.equal('/index.html'=>@def_value, '/blah/index.html'=>@def_value)
-    request(:path=>'/blah/2/')
-    @cache.should.equal('/index.html'=>@def_value, '/blah/index.html'=>@def_value, '/blah/2/index.html'=>@def_value)
+  specify "should cache text/html responses with empty basename to index.html" do
+    request(:path => '/',        :headers => {'CT' => "text/html"})
+    request(:path => '/blah/',   :headers => {'CT' => "text/html"})
+    request(:path => '/blah/2/', :headers => {'CT' => "text/html"})
+    @cache.should.equal("/index.html"        => @def_value,
+                        "/blah/index.html"   => @def_value,
+                        "/blah/2/index.html" => @def_value)
+  end
+  
+  specify "should not cache non-text/html responses with empty basename" do
+    request(:path => '/',        :headers => {'CT' => "text/csv"})
+    request(:path => '/blah/',   :headers => {'CT' => "text/css"})
+    request(:path => '/blah/2/', :headers => {'CT' => "text/plain"})
+    @cache.should.equal({})
+  end
+  
+  specify "should cache unrecognized extensions with text/html content-type at .html" do
+    request(:path => "/a.seo", :headers => {'CT' => "text/html"})
+    @cache.should.equal("/a.seo.html" => @def_value)
+  end
+
+  specify "should not cache unrecognized content-types" do
+    request(:path => "/a", :headers => {'CT' => "text/unrecognised"})
+    @cache.should.equal({})
+  end
+
+  specify "should recognize content-types with supplied parameters (eg. charset)" do
+    request(:path => "/a", :headers => {'CT' => "text/html; charset=utf-8"})
+    @cache.should.equal("/a.html" => @def_value)
   end
 
   specify "should raise an error if a cache argument is not provided" do

data/tricycle-rack-contrib.gemspec

@@ -3,8 +3,8 @@ Gem::Specification.new do |s|
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
 
   s.name = 'tricycle-rack-contrib'
-  s.version = '0.9.5'
-  s.date = '2010-01-06'
+  s.version = '0.9.6'
+  s.date = '2010-01-07'
 
   s.description = "Contributed Rack Middleware and Utilities, including Tricycle's modifications"
   s.summary     = "Contributed Rack Middleware and Utilities, including Tricycle's modifications"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: tricycle-rack-contrib
 version: !ruby/object:Gem::Version 
-  version: 0.9.5
+  version: 0.9.6
 platform: ruby
 authors: 
 - tricycle
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-06 00:00:00 +11:00
+date: 2010-01-07 00:00:00 +11:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency