rack-contrib 0.9.0

data/lib/rack/contrib/proctitle.rb

@@ -0,0 +1,30 @@
+module Rack
+  # Middleware to update the process title ($0) with information about the
+  # current request. Based loosely on:
+  # - http://purefiction.net/mongrel_proctitle/
+  # - http://github.com/grempe/thin-proctitle/tree/master
+  #
+  # NOTE: This will not work properly in a multi-threaded environment.
+  class ProcTitle
+    F = ::File
+    PROGNAME = F.basename($0)
+
+    def initialize(app)
+      @app = app
+      @appname = Dir.pwd.split('/').reverse.
+        find { |name| name !~ /^(\d+|current|releases)$/ } || PROGNAME
+      @requests = 0
+      $0 = "#{PROGNAME} [#{@appname}] init ..."
+    end
+
+    def call(env)
+      host, port = env['SERVER_NAME'], env['SERVER_PORT']
+      meth, path = env['REQUEST_METHOD'], env['PATH_INFO']
+      @requests += 1
+      $0 = "#{PROGNAME} [#{@appname}/#{port}] (#{@requests}) " \
+           "#{meth} #{path}"
+
+      @app.call(env)
+    end
+  end
+end

data/lib/rack/contrib/profiler.rb

@@ -0,0 +1,106 @@
+require 'ruby-prof'
+
+module Rack
+  # Set the profile=process_time query parameter to download a
+  # calltree profile of the request.
+  #
+  # Pass the :printer option to pick a different result format.
+  class Profiler
+    MODES = %w(
+      process_time
+      wall_time
+      cpu_time
+      allocations
+      memory
+      gc_runs
+      gc_time
+    )
+
+    DEFAULT_PRINTER = RubyProf::CallTreePrinter
+    DEFAULT_CONTENT_TYPE = 'application/octet-stream'
+
+    PRINTER_CONTENT_TYPE = {
+      RubyProf::FlatPrinter => 'text/plain',
+      RubyProf::GraphPrinter => 'text/plain',
+      RubyProf::GraphHtmlPrinter => 'text/html'
+    }
+
+    # Accepts a :printer => [:call_tree|:graph_html|:graph|:flat] option
+    # defaulting to :call_tree.
+    def initialize(app, options = {})
+      @app = app
+      @printer = parse_printer(options[:printer])
+      @times = (options[:times] || 1).to_i
+    end
+
+    def call(env)
+      if mode = profiling?(env)
+        profile(env, mode)
+      else
+        @app.call(env)
+      end
+    end
+
+    private
+      def profiling?(env)
+        unless RubyProf.running?
+          request = Rack::Request.new(env)
+          if mode = request.params.delete('profile')
+            if RubyProf.const_defined?(mode.upcase)
+              mode
+            else
+              env['rack.errors'].write "Invalid RubyProf measure_mode: " +
+                "#{mode}. Use one of #{MODES.to_a.join(', ')}"
+              false
+            end
+          end
+        end
+      end
+
+      def profile(env, mode)
+        RubyProf.measure_mode = RubyProf.const_get(mode.upcase)
+
+        result = RubyProf.profile do
+          @times.times { @app.call(env) }
+        end
+
+        [200, headers(@printer, env, mode), print(@printer, result)]
+      end
+
+      def print(printer, result)
+        body = StringIO.new
+        printer.new(result).print(body, :min_percent => 0.01)
+        body.rewind
+        body
+      end
+
+      def headers(printer, env, mode)
+        headers = { 'Content-Type' => PRINTER_CONTENT_TYPE[printer] || DEFAULT_CONTENT_TYPE }
+        if printer == RubyProf::CallTreePrinter
+          filename = ::File.basename(env['PATH_INFO'])
+          headers['Content-Disposition'] =
+            %(attachment; filename="#{filename}.#{mode}.tree")
+        end
+        headers
+      end
+
+      def parse_printer(printer)
+        if printer.nil?
+          DEFAULT_PRINTER
+        elsif printer.is_a?(Class)
+          printer
+        else
+          name = "#{camel_case(printer)}Printer"
+          if RubyProf.const_defined?(name)
+            RubyProf.const_get(name)
+          else
+            DEFAULT_PRINTER
+          end
+        end
+      end
+
+      def camel_case(word)
+        word.to_s.gsub(/(?:^|_)(.)/) { $1.upcase }
+      end
+  end
+end

data/lib/rack/contrib/route_exceptions.rb

@@ -0,0 +1,48 @@
+module Rack
+  class RouteExceptions
+    ROUTES = [
+      [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
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env, try_again = true)
+      status, header, body = response = @app.call(env)
+
+      response
+    rescue Exception => exception
+      raise(exception) unless try_again
+
+      ROUTES.each do |klass, to|
+        next unless klass === exception
+        return route(to, env, response, 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)
+
+      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/sendfile.rb

@@ -0,0 +1,142 @@
+require 'rack/file'
+
+module Rack
+  class File #:nodoc:
+    alias :to_path :path
+  end
+
+  # = Sendfile
+  #
+  # The Sendfile middleware intercepts responses whose body is being
+  # served from a file and replaces it with a server specific X-Sendfile
+  # header. The web server is then responsible for writing the file contents
+  # to the client. This can dramatically reduce the amount of work required
+  # by the Ruby backend and takes advantage of the web servers optimized file
+  # delivery code.
+  #
+  # In order to take advantage of this middleware, the response body must
+  # respond to +to_path+ and the request must include an X-Sendfile-Type
+  # header. Rack::File and other components implement +to_path+ so there's
+  # rarely anything you need to do in your application. The X-Sendfile-Type
+  # header is typically set in your web servers configuration. The following
+  # sections attempt to document
+  #
+  # === Nginx
+  #
+  # Nginx supports the X-Accel-Redirect header. This is similar to X-Sendfile
+  # but requires parts of the filesystem to be mapped into a private URL
+  # hierarachy.
+  #
+  # The following example shows the Nginx configuration required to create
+  # a private "/files/" area, enable X-Accel-Redirect, and pass the special
+  # X-Sendfile-Type and X-Accel-Mapping headers to the backend:
+  #
+  #   location /files/ {
+  #     internal;
+  #     alias /var/www/;
+  #   }
+  #
+  #   location / {
+  #     proxy_redirect     false;
+  #
+  #     proxy_set_header   Host                $host;
+  #     proxy_set_header   X-Real-IP           $remote_addr;
+  #     proxy_set_header   X-Forwarded-For     $proxy_add_x_forwarded_for;
+  #
+  #     proxy_set_header   X-Sendfile-Type     X-Accel-Redirect
+  #     proxy_set_header   X-Accel-Mapping     /files/=/var/www/;
+  #
+  #     proxy_pass         http://127.0.0.1:8080/;
+  #   }
+  #
+  # Note that the X-Sendfile-Type header must be set exactly as shown above. The
+  # X-Accel-Mapping header should specify the name of the private URL pattern,
+  # followed by an equals sign (=), followed by the location on the file system
+  # that it maps to. The middleware performs a simple substitution on the
+  # resulting path.
+  #
+  # See Also: http://wiki.codemongers.com/NginxXSendfile
+  #
+  # === lighttpd
+  #
+  # Lighttpd has supported some variation of the X-Sendfile header for some
+  # time, although only recent version support X-Sendfile in a reverse proxy
+  # configuration.
+  #
+  #   $HTTP["host"] == "example.com" {
+  #      proxy-core.protocol = "http"
+  #      proxy-core.balancer = "round-robin"
+  #      proxy-core.backends = (
+  #        "127.0.0.1:8000",
+  #        "127.0.0.1:8001",
+  #        ...
+  #      )
+  #
+  #      proxy-core.allow-x-sendfile = "enable"
+  #      proxy-core.rewrite-request = (
+  #        "X-Sendfile-Type" => (".*" => "X-Sendfile")
+  #      )
+  #    }
+  #
+  # See Also: http://redmine.lighttpd.net/wiki/lighttpd/Docs:ModProxyCore
+  #
+  # === Apache
+  #
+  # X-Sendfile is supported under Apache 2.x using a separate module:
+  #
+  # http://tn123.ath.cx/mod_xsendfile/
+  #
+  # Once the module is compiled and installed, you can enable it using
+  # XSendFile config directive:
+  #
+  #   RequestHeader Set X-Sendfile-Type X-Sendfile
+  #   ProxyPassReverse / http://localhost:8001/
+  #   XSendFile on
+
+  class Sendfile
+    F = ::File
+
+    def initialize(app, variation=nil)
+      @app = app
+      @variation = variation
+    end
+
+    def call(env)
+      status, headers, body = @app.call(env)
+      if body.respond_to?(:to_path)
+        case type = variation(env)
+        when 'X-Accel-Redirect'
+          path = F.expand_path(body.to_path)
+          if url = map_accel_path(env, path)
+            headers[type] = url
+            body = []
+          else
+            env['rack.errors'] << "X-Accel-Mapping header missing"
+          end
+        when 'X-Sendfile', 'X-Lighttpd-Send-File'
+          path = F.expand_path(body.to_path)
+          headers[type] = path
+          body = []
+        when '', nil
+        else
+          env['rack.errors'] << "Unknown x-sendfile variation: '#{variation}'.\n"
+        end
+      end
+      [status, headers, body]
+    end
+
+  private
+    def variation(env)
+      @variation ||
+        env['sendfile.type'] ||
+        env['HTTP_X_SENDFILE_TYPE']
+    end
+
+    def map_accel_path(env, file)
+      if mapping = env['HTTP_X_ACCEL_MAPPING']
+        internal, external = mapping.split('=', 2).map{ |p| p.strip }
+        file.sub(/^#{internal}/i, external)
+      end
+    end
+  end
+end

data/lib/rack/contrib/time_zone.rb

@@ -0,0 +1,25 @@
+module Rack
+  class TimeZone
+    Javascript = <<-EOJ
+    function setTimezoneCookie() {
+      var offset = (new Date()).getTimezoneOffset()
+      var date = new Date();
+      date.setTime(date.getTime()+3600000);
+      document.cookie = "utc_offset="+offset+"; expires="+date.toGMTString();+"; path=/";
+    }
+EOJ
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      request = Rack::Request.new(env)
+      if utc_offset = request.cookies["utc_offset"]
+        env["rack.timezone.utc_offset"] = -(utc_offset.to_i * 60)
+      end
+
+      @app.call(env)
+    end
+  end
+end

data/lib/rack/contrib.rb

@@ -0,0 +1,25 @@
+require 'rack'
+
+module Rack
+  module Contrib
+    def self.release
+      "0.9"
+    end
+  end
+
+  autoload :BounceFavicon,              "rack/contrib/bounce_favicon"
+  autoload :ETag,                       "rack/contrib/etag"
+  autoload :GarbageCollector,           "rack/contrib/garbagecollector"
+  autoload :JSONP,                      "rack/contrib/jsonp"
+  autoload :LighttpdScriptNameFix,      "rack/contrib/lighttpd_script_name_fix"
+  autoload :Locale,                     "rack/contrib/locale"
+  autoload :MailExceptions,             "rack/contrib/mailexceptions"
+  autoload :PostBodyContentTypeParser,  "rack/contrib/post_body_content_type_parser"
+  autoload :ProcTitle,                  "rack/contrib/proctitle"
+  autoload :Profiler,                   "rack/contrib/profiler"
+  autoload :Sendfile,                   "rack/contrib/sendfile"
+  autoload :TimeZone,                   "rack/contrib/time_zone"
+  autoload :Evil,                       "rack/contrib/evil"
+  autoload :Callbacks,                  "rack/contrib/callbacks"
+  autoload :NestedParams,               "rack/contrib/nested_params"
+end

data/rack-contrib.gemspec

@@ -0,0 +1,68 @@
+Gem::Specification.new do |s|
+  s.specification_version = 2 if s.respond_to? :specification_version=
+  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.description = "Contributed Rack Middleware and Utilities"
+  s.summary     = "Contributed Rack Middleware and Utilities"
+
+  s.authors = ["rack-devel"]
+  s.email = "rack-devel@googlegroups.com"
+
+  # = MANIFEST =
+  s.files = %w[
+    COPYING
+    README.rdoc
+    Rakefile
+    lib/rack/contrib.rb
+    lib/rack/contrib/bounce_favicon.rb
+    lib/rack/contrib/callbacks.rb
+    lib/rack/contrib/etag.rb
+    lib/rack/contrib/evil.rb
+    lib/rack/contrib/garbagecollector.rb
+    lib/rack/contrib/jsonp.rb
+    lib/rack/contrib/lighttpd_script_name_fix.rb
+    lib/rack/contrib/locale.rb
+    lib/rack/contrib/mailexceptions.rb
+    lib/rack/contrib/nested_params.rb
+    lib/rack/contrib/post_body_content_type_parser.rb
+    lib/rack/contrib/proctitle.rb
+    lib/rack/contrib/profiler.rb
+    lib/rack/contrib/route_exceptions.rb
+    lib/rack/contrib/sendfile.rb
+    lib/rack/contrib/time_zone.rb
+    rack-contrib.gemspec
+    test/mail_settings.rb
+    test/spec_rack_callbacks.rb
+    test/spec_rack_contrib.rb
+    test/spec_rack_etag.rb
+    test/spec_rack_evil.rb
+    test/spec_rack_garbagecollector.rb
+    test/spec_rack_jsonp.rb
+    test/spec_rack_lighttpd_script_name_fix.rb
+    test/spec_rack_mailexceptions.rb
+    test/spec_rack_nested_params.rb
+    test/spec_rack_post_body_content_type_parser.rb
+    test/spec_rack_proctitle.rb
+    test/spec_rack_profiler.rb
+    test/spec_rack_sendfile.rb
+  ]
+  # = MANIFEST =
+
+  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 'test-spec', '~> 0.9.0'
+  s.add_development_dependency 'tmail', '>= 1.2'
+  s.add_development_dependency 'json', '>= 1.1'
+
+  s.has_rdoc = true
+  s.homepage = "http://github.com/rack/rack-contrib/"
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "rack-contrib", "--main", "README"]
+  s.require_paths = %w[lib]
+  s.rubygems_version = '1.1.1'
+end

data/test/mail_settings.rb

@@ -0,0 +1,12 @@
+TEST_SMTP = nil
+
+# Enable SMTP tests by providing the following for your SMTP server.
+#
+# TEST_SMTP = {
+#   :server         => 'localhost',
+#   :domain         => 'localhost',
+#   :port           => 25,
+#   :authentication => :login,
+#   :user_name      => nil,
+#   :password       => nil
+# }

data/test/spec_rack_callbacks.rb

@@ -0,0 +1,65 @@
+require 'test/spec'
+require 'rack/mock'
+
+class Flame
+  def call(env)
+    env['flame'] = 'F Lifo..'
+  end
+end
+
+class Pacify
+  def initialize(with)
+    @with = with
+  end
+
+  def call(env)
+    env['peace'] = @with
+  end
+end
+
+class Finale
+  def call(response)
+    status, headers, body = response
+
+    headers['last'] = 'Finale'
+    $old_status = status
+
+    [201, headers, body]
+  end
+end
+
+class TheEnd
+  def call(response)
+    status, headers, body = response
+
+    headers['last'] = 'TheEnd'
+    [201, headers, body]
+  end
+end
+
+context "Rack::Callbacks" do
+  specify "works for love and small stack trace" do
+    callback_app = Rack::Callbacks.new do
+      before Flame
+      before Pacify, "with love"
+
+      run lambda {|env| [200, {}, env['flame'] + env['peace']] }
+
+      after Finale
+      after TheEnd
+    end
+
+    app = Rack::Builder.new do
+      run callback_app
+    end.to_app
+
+    response = Rack::MockRequest.new(app).get("/")
+
+    response.body.should.equal 'F Lifo..with love'
+
+    $old_status.should.equal 200
+    response.status.should.equal 201
+
+    response.headers['last'].should.equal 'TheEnd'
+  end
+end

data/test/spec_rack_contrib.rb

@@ -0,0 +1,8 @@
+require 'test/spec'
+require 'rack/contrib'
+
+context "Rack::Contrib" do
+  specify "should expose release" do
+    Rack::Contrib.should.respond_to :release
+  end
+end

data/test/spec_rack_etag.rb

@@ -0,0 +1,23 @@
+require 'test/spec'
+require 'rack/mock'
+require 'rack/contrib/etag'
+
+context "Rack::ETag" do
+  specify "sets ETag if none is set" do
+    app = lambda { |env| [200, {'Content-Type' => 'text/plain'}, "Hello, World!"] }
+    response = Rack::ETag.new(app).call({})
+    response[1]['ETag'].should.equal "\"65a8e27d8879283831b664bd8b7f0ad4\""
+  end
+
+  specify "does not change ETag if it is already set" do
+    app = lambda { |env| [200, {'Content-Type' => 'text/plain', 'ETag' => '"abc"'}, "Hello, World!"] }
+    response = Rack::ETag.new(app).call({})
+    response[1]['ETag'].should.equal "\"abc\""
+  end
+
+  specify "does not set ETag if steaming body" do
+    app = lambda { |env| [200, {'Content-Type' => 'text/plain'}, ["Hello", "World"]] }
+    response = Rack::ETag.new(app).call({})
+    response[1]['ETag'].should.equal nil
+  end
+end

data/test/spec_rack_evil.rb

@@ -0,0 +1,19 @@
+require 'test/spec'
+require 'rack/mock'
+require 'rack/contrib/evil'
+require 'erb'
+
+context "Rack::Evil" do
+  app = lambda do |env|
+    template = ERB.new("<%= throw :response, [404, {'Content-Type' => 'text/html'}, 'Never know where it comes from'] %>")
+    [200, {'Content-Type' => 'text/plain'}, template.result(binding)]
+  end
+
+  specify "should enable the app to return the response from anywhere" do
+    status, headers, body = Rack::Evil.new(app).call({})
+
+    status.should.equal 404
+    headers['Content-Type'].should.equal 'text/html'
+    body.should.equal 'Never know where it comes from'
+  end
+end

data/test/spec_rack_garbagecollector.rb

@@ -0,0 +1,13 @@
+require 'test/spec'
+require 'rack/mock'
+require 'rack/contrib/garbagecollector'
+
+context 'Rack::GarbageCollector' do
+
+  specify 'starts the garbage collector after each request' do
+    app = lambda { |env|
+      [200, {'Content-Type'=>'text/plain'}, ['Hello World']] }
+    Rack::GarbageCollector.new(app).call({})
+  end
+
+end

data/test/spec_rack_jsonp.rb

@@ -0,0 +1,21 @@
+require 'test/spec'
+require 'rack/mock'
+require 'rack/contrib/jsonp'
+
+context "Rack::JSONP" do
+  
+  specify "should wrap the response body in the Javascript callback when provided" do
+    app = lambda { |env| [200, {'Content-Type' => 'text/plain'}, '{"bar":"foo"}'] }
+    request = Rack::MockRequest.env_for("/", :input => "foo=bar&callback=foo")
+    body = Rack::JSONP.new(app).call(request).last
+    body.should == 'foo({"bar":"foo"})'
+  end
+  
+  specify "should not change anything if no :callback param is provided" do
+    app = lambda { |env| [200, {'Content-Type' => 'text/plain'}, '{"bar":"foo"}'] }
+    request = Rack::MockRequest.env_for("/", :input => "foo=bar")
+    body = Rack::JSONP.new(app).call(request).last
+    body.should == '{"bar":"foo"}'
+  end
+  
+end

data/test/spec_rack_lighttpd_script_name_fix.rb

@@ -0,0 +1,16 @@
+require 'test/spec'
+require 'rack/mock'
+require 'rack/contrib/lighttpd_script_name_fix'
+
+context "Rack::LighttpdScriptNameFix" do
+  specify "corrects SCRIPT_NAME and PATH_INFO set by lighttpd " do
+    env = {
+      "PATH_INFO" => "/foo/bar/baz",
+      "SCRIPT_NAME" => "/hello"
+    }
+    app = lambda { |env| [200, {'Content-Type' => 'text/plain'}, "Hello, World!"] }
+    response = Rack::LighttpdScriptNameFix.new(app).call(env)
+    env['SCRIPT_NAME'].should.be.empty
+    env['PATH_INFO'].should.equal '/hello/foo/bar/baz'
+  end
+end