rack-contrib 0.9.0 → 0.9.2

data/lib/rack/contrib/relative_redirect.rb

@@ -0,0 +1,44 @@
+require 'rack'
+
+# Rack::RelativeRedirect is a simple middleware that converts relative paths in
+# redirects in absolute urls, so they conform to RFC2616. It allows the user to
+# specify the absolute path to use (with a sensible default), and handles
+# relative paths (those that don't start with a slash) as well.
+class Rack::RelativeRedirect
+  SCHEME_MAP = {'http'=>'80', 'https'=>'443'}
+  # The default proc used if a block is not provided to .new
+  # Just uses the url scheme of the request and the server name.
+  DEFAULT_ABSOLUTE_PROC = proc do |env, res|
+    port = env['SERVER_PORT']
+    scheme = env['rack.url_scheme']
+    "#{scheme}://#{env['SERVER_NAME']}#{":#{port}" unless SCHEME_MAP[scheme] == port}"
+  end
+
+  # Initialize a new RelativeRedirect object with the given arguments.  Arguments:
+  # * app : The next middleware in the chain.  This is always called.
+  # * &block : If provided, it is called with the environment and the response
+  #   from the next middleware. It should return a string representing the scheme
+  #   and server name (such as 'http://example.org').
+  def initialize(app, &block)
+    @app = app
+    @absolute_proc = block || DEFAULT_ABSOLUTE_PROC
+  end
+
+  # Call the next middleware with the environment.  If the request was a
+  # redirect (response status 301, 302, or 303), and the location header does
+  # not start with an http or https url scheme, call the block provided by new
+  # and use that to make the Location header an absolute url.  If the Location
+  # does not start with a slash, make location relative to the path requested.
+  def call(env)
+    res = @app.call(env)
+    if [301,302,303].include?(res[0]) and loc = res[1]['Location'] and !%r{\Ahttps?://}o.match(loc)
+      absolute = @absolute_proc.call(env, res)
+      res[1]['Location'] = if %r{\A/}.match(loc)
+        "#{absolute}#{loc}"
+      else
+        "#{absolute}#{File.dirname(Rack::Utils.unescape(env['PATH_INFO']))}/#{loc}"
+      end
+    end
+    res
+  end
+end

data/lib/rack/contrib/response_cache.rb

@@ -0,0 +1,59 @@
+require 'fileutils'
+require 'rack'
+
+# Rack::ResponseCache is a Rack middleware that caches responses for successful
+# GET requests with no query string to disk or any ruby object that has an
+# []= method (so it works with memcached).  When caching to disk, it works similar to
+# 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
+  # The default proc used if a block is not provided to .new
+  # It unescapes the PATH_INFO of the environment, and makes sure that it doesn't
+  # include '..'.  If the Content-Type of the response is text/(html|css|xml),
+  # return a path with the appropriate extension (.html, .css, or .xml).
+  # If the path ends with a / and the Content-Type is text/html, change the basename
+  # of the path to index.html.
+  DEFAULT_PATH_PROC = proc do |env, res|
+    path = Rack::Utils.unescape(env['PATH_INFO'])
+    if !path.include?('..') and match = /text\/((?:x|ht)ml|css)/o.match(res[1]['Content-Type'])
+      type = match[1]
+      path = "#{path}.#{type}" unless /\.#{type}\z/.match(path)
+      path = File.join(File.dirname(path), 'index.html') if type == 'html' and File.basename(path) == '.html'
+      path
+    end
+  end
+
+  # Initialize a new ReponseCache object with the given arguments.  Arguments:
+  # * app : The next middleware in the chain.  This is always called.
+  # * cache : The place to cache responses.  If a string is provided, a disk
+  #   cache is used, and all cached files will use this directory as the root directory.
+  #   If anything other than a string is provided, it should respond to []=, which will
+  #   be called with a path string and a body value (the 3rd element of the response).
+  # * &block : If provided, it is called with the environment and the response from the next middleware.
+  #   It should return nil or false if the path should not be cached, and should return
+  #   the pathname to use as a string if the result should be cached.
+  #   If not provided, the DEFAULT_PATH_PROC is used.
+  def initialize(app, cache, &block)
+    @app = app
+    @cache = cache
+    @path_proc = block || DEFAULT_PATH_PROC
+  end
+
+  # Call the next middleware with the environment.  If the request was successful (response status 200),
+  # was a GET request, and had an empty query string, call the block set up in initialize to get the path.
+  # If the cache is a string, create any necessary middle directories, and cache the file in the appropriate
+  # subdirectory of cache.  Otherwise, cache the body of the reponse as the value with the path as the key.
+  def call(env)
+    res = @app.call(env)
+    if env['REQUEST_METHOD'] == 'GET' and env['QUERY_STRING'] == '' and res[0] == 200 and path = @path_proc.call(env, res)
+      if @cache.is_a?(String)
+        path = File.join(@cache, path) if @cache
+        FileUtils.mkdir_p(File.dirname(path))
+        File.open(path, 'wb'){|f| res[2].each{|c| f.write(c)}}
+      else
+        @cache[path] = res[2]
+      end
+    end
+    res
+  end
+end

data/lib/rack/contrib/route_exceptions.rb

@@ -4,45 +4,46 @@ module Rack
       [Exception, '/error/internal']
     ]
 
-    ROUTE_EXCEPTIONS_PATH_INFO = 'rack.route_exceptions.path_info'.freeze
-    ROUTE_EXCEPTIONS_EXCEPTION = 'rack.route_exceptions.exception'.freeze
-    ROUTE_EXCEPTIONS_RESPONSE = 'rack.route_exceptions.response'.freeze
+    PATH_INFO = 'rack.route_exceptions.path_info'.freeze
+    EXCEPTION = 'rack.route_exceptions.exception'.freeze
+    RETURNED  = 'rack.route_exceptions.returned'.freeze
+
+    class << self
+      def route(exception, to)
+        ROUTES.delete_if{|k,v| k == exception }
+        ROUTES << [exception, to]
+      end
+
+      alias []= route
+    end
 
     def initialize(app)
       @app = app
     end
 
     def call(env, try_again = true)
-      status, header, body = response = @app.call(env)
-
-      response
+      returned = @app.call(env)
     rescue Exception => exception
       raise(exception) unless try_again
 
       ROUTES.each do |klass, to|
         next unless klass === exception
-        return route(to, env, response, exception)
+        return route(to, env, returned, exception)
       end
 
       raise(exception)
     end
 
-    def route(to, env, response, exception)
-      hash = {
-        ROUTE_EXCEPTIONS_PATH_INFO => env['PATH_INFO'],
-        ROUTE_EXCEPTIONS_EXCEPTION => exception,
-        ROUTE_EXCEPTIONS_RESPONSE => response
-      }
-      env.merge!(hash)
+    def route(to, env, returned, exception)
+      env.merge!(
+        PATH_INFO => env['PATH_INFO'],
+        EXCEPTION => exception,
+        RETURNED => returned
+      )
 
       env['PATH_INFO'] = to
 
       call(env, try_again = false)
     end
-
-    def self.route(exception, to)
-      ROUTES.delete_if{|k,v| k == exception }
-      ROUTES << [exception, to]
-    end
   end
 end

data/lib/rack/contrib/signals.rb

@@ -0,0 +1,63 @@
+module Rack
+  # Installs signal handlers that are safely processed after a request
+  #
+  # NOTE: This middleware should not be used in a threaded environment
+  #
+  # use Rack::Signals.new do
+  #   trap 'INT', lambda {
+  #     puts "Exiting now"
+  #     exit
+  #   }
+  #
+  #   trap_when_ready 'USR1', lambda {
+  #     puts "Exiting when ready"
+  #     exit
+  #   }
+  # end
+  class Signals
+    class BodyWithCallback
+      def initialize(body, callback)
+        @body, @callback = body, callback
+      end
+
+      def each(&block)
+        @body.each(&block)
+        @callback.call
+      end
+    end
+
+    def initialize(app, &block)
+      @app = app
+      @processing = false
+      @when_ready = nil
+      instance_eval(&block)
+    end
+
+    def call(env)
+      begin
+        @processing, @when_ready = true, nil
+        status, headers, body = @app.call(env)
+
+        if handler = @when_ready
+          body = BodyWithCallback.new(body, handler)
+          @when_ready = nil
+        end
+      ensure
+        @processing = false
+      end
+
+      [status, headers, body]
+    end
+
+    def trap_when_ready(signal, handler)
+      when_ready_handler = lambda { |signal|
+        if @processing
+          @when_ready = lambda { handler.call(signal) }
+        else
+          handler.call(signal)
+        end
+      }
+      trap(signal, when_ready_handler)
+    end
+  end
+end

data/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 = 'rack-contrib'
-  s.version = '0.9.0'
-  s.date = '2009-01-23'
+  s.version = '0.9.2'
+  s.date = '2009-03-07'
 
   s.description = "Contributed Rack Middleware and Utilities"
   s.summary     = "Contributed Rack Middleware and Utilities"
@@ -18,8 +18,13 @@ Gem::Specification.new do |s|
     README.rdoc
     Rakefile
     lib/rack/contrib.rb
+    lib/rack/contrib/accept_format.rb
+    lib/rack/contrib/backstage.rb
     lib/rack/contrib/bounce_favicon.rb
     lib/rack/contrib/callbacks.rb
+    lib/rack/contrib/config.rb
+    lib/rack/contrib/csshttprequest.rb
+    lib/rack/contrib/deflect.rb
     lib/rack/contrib/etag.rb
     lib/rack/contrib/evil.rb
     lib/rack/contrib/garbagecollector.rb
@@ -28,16 +33,27 @@ Gem::Specification.new do |s|
     lib/rack/contrib/locale.rb
     lib/rack/contrib/mailexceptions.rb
     lib/rack/contrib/nested_params.rb
+    lib/rack/contrib/not_found.rb
     lib/rack/contrib/post_body_content_type_parser.rb
     lib/rack/contrib/proctitle.rb
     lib/rack/contrib/profiler.rb
+    lib/rack/contrib/relative_redirect.rb
+    lib/rack/contrib/response_cache.rb
     lib/rack/contrib/route_exceptions.rb
     lib/rack/contrib/sendfile.rb
+    lib/rack/contrib/signals.rb
     lib/rack/contrib/time_zone.rb
     rack-contrib.gemspec
+    test/404.html
+    test/Maintenance.html
     test/mail_settings.rb
+    test/spec_rack_accept_format.rb
+    test/spec_rack_backstage.rb
     test/spec_rack_callbacks.rb
+    test/spec_rack_config.rb
     test/spec_rack_contrib.rb
+    test/spec_rack_csshttprequest.rb
+    test/spec_rack_deflect.rb
     test/spec_rack_etag.rb
     test/spec_rack_evil.rb
     test/spec_rack_garbagecollector.rb
@@ -45,9 +61,12 @@ Gem::Specification.new do |s|
     test/spec_rack_lighttpd_script_name_fix.rb
     test/spec_rack_mailexceptions.rb
     test/spec_rack_nested_params.rb
+    test/spec_rack_not_found.rb
     test/spec_rack_post_body_content_type_parser.rb
     test/spec_rack_proctitle.rb
     test/spec_rack_profiler.rb
+    test/spec_rack_relative_redirect.rb
+    test/spec_rack_response_cache.rb
     test/spec_rack_sendfile.rb
   ]
   # = MANIFEST =
@@ -55,7 +74,7 @@ Gem::Specification.new do |s|
   s.test_files = s.files.select {|path| path =~ /^test\/spec_.*\.rb/}
 
   s.extra_rdoc_files = %w[README.rdoc COPYING]
-  s.add_dependency 'rack', '~> 0.9.1'
+  s.add_dependency 'rack', '>= 0.9.1'
   s.add_dependency 'test-spec', '~> 0.9.0'
   s.add_development_dependency 'tmail', '>= 1.2'
   s.add_development_dependency 'json', '>= 1.1'

data/test/404.html

@@ -0,0 +1 @@
+Not Found

data/test/Maintenance.html

@@ -0,0 +1 @@
+Under maintenance.

data/test/spec_rack_accept_format.rb

@@ -0,0 +1,72 @@
+require 'test/spec'
+require 'rack/mock'
+require 'rack/contrib/accept_format'
+require 'rack/mime'
+
+context "Rack::AcceptFormat" do
+  app = lambda { |env| [200, {'Content-Type' => 'text/plain'}, env['PATH_INFO']] }
+
+  specify "should do nothing when a format extension is already provided" do
+    request = Rack::MockRequest.env_for("/resource.json")
+    body = Rack::AcceptFormat.new(app).call(request).last
+    body.should == "/resource.json"
+  end
+
+  context "default extention" do
+    specify "should allow custom default" do
+      request = Rack::MockRequest.env_for("/resource")
+      body = Rack::AcceptFormat.new(app, '.xml').call(request).last
+      body.should == "/resource.xml"
+    end
+
+    specify "should default to html" do
+      request = Rack::MockRequest.env_for("/resource")
+      body = Rack::AcceptFormat.new(app).call(request).last
+      body.should == "/resource.html"
+    end
+
+    specify "should notmalize custom extention" do
+      request = Rack::MockRequest.env_for("/resource")
+
+      body = Rack::AcceptFormat.new(app,'xml').call(request).last #no dot prefix
+      body.should == "/resource.xml"
+
+      body = Rack::AcceptFormat.new(app, :xml).call(request).last
+      body.should == "/resource.xml"
+    end
+  end
+
+  context "there is no format extension" do
+    Rack::Mime::MIME_TYPES.clear
+
+    def mime(ext, type)
+      ext = ".#{ext}" unless ext.to_s[0] == ?.
+      Rack::Mime::MIME_TYPES[ext.to_s] = type
+    end
+
+    specify "should add the default extension if no Accept header" do
+      request = Rack::MockRequest.env_for("/resource")
+      body = Rack::AcceptFormat.new(app).call(request).last
+      body.should == "/resource.html"
+    end
+
+    specify "should add the default extension if the Accept header is not registered in the Mime::Types" do
+      request = Rack::MockRequest.env_for("/resource", 'HTTP_ACCEPT' => 'application/json;q=1.0, text/html;q=0.8, */*;q=0.1')
+      body = Rack::AcceptFormat.new(app).call(request).last
+      body.should == "/resource.html"
+    end
+
+    specify "should add the correct extension if the Accept header is registered in the Mime::Types" do
+      mime :json, 'application/json'
+      request = Rack::MockRequest.env_for("/resource", 'HTTP_ACCEPT' => 'application/json;q=1.0, text/html;q=0.8, */*;q=0.1')
+      body = Rack::AcceptFormat.new(app).call(request).last
+      body.should == "/resource.json"
+    end
+  end
+
+  specify "shouldn't confuse extention when there are dots in path" do
+    request = Rack::MockRequest.env_for("/parent.resource/resource")
+    body = Rack::AcceptFormat.new(app, '.html').call(request).last
+    body.should == "/parent.resource/resource.html"
+  end
+end

data/test/spec_rack_backstage.rb

@@ -0,0 +1,26 @@
+require 'test/spec'
+require 'rack/builder'
+require 'rack/mock'
+require 'rack/contrib/backstage'
+
+context "Rack::Backstage" do
+  specify "shows maintenances page if present" do
+    app = Rack::Builder.new do
+      use Rack::Backstage, 'test/Maintenance.html'
+      run lambda { |env| [200, {'Content-Type' => 'text/plain'}, ["Hello, World!"]] }
+    end
+    response = Rack::MockRequest.new(app).get('/')
+    response.body.should.equal('Under maintenance.')
+    response.status.should.equal(503)
+  end
+
+  specify "passes on request if page is not present" do
+    app = Rack::Builder.new do
+      use Rack::Backstage, 'test/Nonsense.html'
+      run lambda { |env| [200, {'Content-Type' => 'text/plain'}, ["Hello, World!"]] }
+    end
+    response = Rack::MockRequest.new(app).get('/')
+    response.body.should.equal('Hello, World!')
+    response.status.should.equal(200)
+  end
+end

data/test/spec_rack_callbacks.rb

@@ -43,7 +43,7 @@ context "Rack::Callbacks" do
       before Flame
       before Pacify, "with love"
 
-      run lambda {|env| [200, {}, env['flame'] + env['peace']] }
+      run lambda {|env| [200, {}, [env['flame'], env['peace']]] }
 
       after Finale
       after TheEnd
@@ -62,4 +62,4 @@ context "Rack::Callbacks" do
 
     response.headers['last'].should.equal 'TheEnd'
   end
-end
+end

data/test/spec_rack_config.rb

@@ -0,0 +1,22 @@
+require 'test/spec'
+require 'rack/mock'
+require 'rack/contrib/config'
+
+context "Rack::Config" do
+
+  specify "should accept a block that modifies the environment" do
+    app = Rack::Builder.new do
+      use Rack::Lint
+      use Rack::ContentLength
+      use Rack::Config do |env|
+        env['greeting'] = 'hello'
+      end
+      run lambda { |env|
+        [200, {'Content-Type' => 'text/plain'}, [env['greeting'] || '']]
+      }
+    end
+    response = Rack::MockRequest.new(app).get('/')
+    response.body.should.equal('hello')
+  end
+
+end