corntrace-rack-contrib 1.0.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/response_headers.rb

@@ -0,0 +1,24 @@
+module Rack
+  # Allows you to tap into the response headers. Yields a Rack::Utils::HeaderHash
+  # of current response headers to the block. Example:
+  #
+  #   use Rack::ResponseHeaders do |headers|
+  #     headers['X-Foo'] = 'bar'
+  #     headers.delete('X-Baz')
+  #   end
+  #
+  class ResponseHeaders
+    def initialize(app, &block)
+      @app = app
+      @block = block
+    end
+
+    def call(env)
+      response = @app.call(env)
+      headers = Utils::HeaderHash.new(response[1])
+      @block.call(headers)
+      response[1] = headers
+      response
+    end
+  end
+end

data/lib/rack/contrib/route_exceptions.rb

@@ -0,0 +1,49 @@
+module Rack
+  class RouteExceptions
+    ROUTES = [
+      [Exception, '/error/internal']
+    ]
+
+    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)
+      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, returned, exception)
+      end
+
+      raise(exception)
+    end
+
+    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
+  end
+end

data/lib/rack/contrib/runtime.rb

@@ -0,0 +1,31 @@
+
+module Rack
+  # Sets an "X-Runtime" response header, indicating the response
+  # time of the request, in seconds
+  #
+  # You can put it right before the application to see the processing
+  # time, or before all the other middlewares to include time for them,
+  # too.
+  class Runtime
+    def initialize(app, name = nil)
+      @app = app
+      @header_name = "X-Runtime"
+      @header_name << "-#{name}" if name
+    end
+
+    def call(env)
+      start_time = Time.now
+      status, headers, body = @app.call(env)
+      request_time = Time.now - start_time
+
+      if !headers.has_key?(@header_name)
+        headers[@header_name] = "%0.6f" % request_time
+      end
+
+      [status, headers, body]
+    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/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/lib/rack/contrib/simple_endpoint.rb

@@ -0,0 +1,81 @@
+module Rack
+  # Create simple endpoints with routing rules, similar to Sinatra actions.
+  #
+  # Simplest example:
+  #
+  #   use Rack::SimpleEndpoint, '/ping_monitor' do
+  #     'pong'
+  #   end
+  #
+  # The value returned from the block will be written to the response body, so
+  # the above example will return "pong" when the request path is /ping_monitor.
+  #
+  # HTTP verb requirements can optionally be specified:
+  #
+  #   use Rack::SimpleEndpoint, '/foo' => :get do
+  #     'only GET requests will match'
+  #   end
+  #
+  #   use Rack::SimpleEndpoint, '/bar' => [:get, :post] do
+  #     'only GET and POST requests will match'
+  #   end
+  #
+  # Rack::Request and Rack::Response objects are yielded to block:
+  #
+  #   use Rack::SimpleEndpoint, '/json' do |req, res|
+  #     res['Content-Type'] = 'application/json'
+  #     %({"foo": "#{req[:foo]}"})
+  #   end
+  #
+  # When path is a Regexp, match data object is yielded as third argument to block
+  #
+  #   use Rack::SimpleEndpoint, %r{^/(john|paul|george|ringo)} do |req, res, match|
+  #     "Hello, #{match[1]}"
+  #   end
+  #
+  # A :pass symbol returned from block will not return a response; control will continue down the
+  # Rack stack:
+  #
+  #   use Rack::SimpleEndpoint, '/api_key' do |req, res|
+  #     req.env['myapp.user'].authorized? ? '12345' : :pass
+  #   end
+  #
+  #   # Unauthorized access to /api_key will be handled by PublicApp
+  #   run PublicApp
+  class SimpleEndpoint
+    def initialize(app, arg, &block)
+      @app    = app
+      @path   = extract_path(arg)
+      @verbs  = extract_verbs(arg)
+      @block  = block
+    end
+
+    def call(env)
+      match = match_path(env['PATH_INFO'])
+      if match && valid_method?(env['REQUEST_METHOD'])
+        req, res = Request.new(env), Response.new
+        body = @block.call(req, res, (match unless match == true))
+        body == :pass ? @app.call(env) : (res.write(body); res.finish)
+      else
+        @app.call(env)
+      end
+    end
+    
+    private
+      def extract_path(arg)
+        arg.is_a?(Hash) ? arg.keys.first : arg
+      end
+      
+      def extract_verbs(arg)
+        arg.is_a?(Hash) ? [arg.values.first].flatten.map {|verb| verb.to_s.upcase} : []
+      end
+      
+      def match_path(path)
+        @path.is_a?(Regexp) ? @path.match(path.to_s) : @path == path.to_s
+      end
+      
+      def valid_method?(method)
+        @verbs.empty? || @verbs.include?(method)
+      end
+  end
+end

data/lib/rack/contrib/static_cache.rb

@@ -0,0 +1,93 @@
+module Rack
+
+  #
+  # The Rack::StaticCache middleware automatically adds, removes and modifies
+  # stuffs in response headers to facilitiate client and proxy caching for static files
+  # that minimizes http requests and improves overall load times for second time visitors.
+  #
+  # Once a static content is stored in a client/proxy the only way to enforce the browser
+  # to fetch the latest content and ignore the cache is to rename the static file.
+  #
+  # Alternatively, we can add a version number into the URL to the content to bypass
+  # the caches. Rack::StaticCache by default handles version numbers in the filename.
+  # As an example,
+  # http://yoursite.com/images/test-1.0.0.png and http://yoursite.com/images/test-2.0.0.png
+  # both reffers to the same image file http://yoursite.com/images/test.png
+  #
+  # Another way to bypass the cache is adding the version number in a field-value pair in the
+  # URL query string. As an example, http://yoursite.com/images/test.png?v=1.0.0
+  # In that case, set the option :versioning to false to avoid unneccessary regexp calculations.
+  #
+  # It's better to keep the current version number in some config file and use it in every static
+  # content's URL. So each time we modify our static contents, we just have to change the version
+  # number to enforce the browser to fetch the latest content.
+  #
+  # You can use Rack::Deflater along with Rack::StaticCache for further improvements in page loading time.
+  #
+  # Examples:
+  #     use Rack::StaticCache, :urls => ["/images", "/css", "/js", "/documents*"], :root => "statics"
+  #     will serve all requests beginning with /images, /csss or /js from the
+  #     directory "statics/images",  "statics/css",  "statics/js".
+  #     All the files from these directories will have modified headers to enable client/proxy caching,
+  #     except the files from the directory "documents". Append a * (star) at the end of the pattern
+  #     if you want to disable caching for any pattern . In that case, plain static contents will be served with
+  #     default headers.
+  #
+  #     use Rack::StaticCache, :urls => ["/images"], :duration => 2, :versioning => false
+  #     will serve all requests begining with /images under the current directory (default for the option :root
+  #     is current directory). All the contents served will have cache expiration duration set to 2 years in headers
+  #     (default for :duration is 1 year), and StaticCache will not compute any versioning logics (default for
+  #     :versioning is true)
+  #
+
+
+  class StaticCache
+
+    def initialize(app, options={})
+      @app = app
+      @urls = options[:urls]
+      @no_cache = {}
+      @urls.collect! do |url|
+        if url  =~ /\*$/
+          url.sub!(/\*$/, '')
+          @no_cache[url] = 1
+        end
+        url
+      end
+      root = options[:root] || Dir.pwd
+      @file_server = Rack::File.new(root)
+      @cache_duration = options[:duration] || 1
+      @versioning_enabled = true
+      @versioning_enabled = options[:versioning] unless options[:versioning].nil?
+      @duration_in_seconds = self.duration_in_seconds
+      @duration_in_words    = self.duration_in_words
+    end
+
+    def call(env)
+      path = env["PATH_INFO"]
+      url = @urls.detect{ |u| path.index(u) == 0 }
+      unless url.nil?
+        path.sub!(/-[\d.]+([.][a-zA-Z][\w]+)?$/, '\1') if @versioning_enabled
+        status, headers, body = @file_server.call(env)
+        if @no_cache[url].nil?
+          headers['Cache-Control'] ="max-age=#{@duration_in_seconds}, public"
+          headers['Expires'] = @duration_in_words
+          headers.delete 'Etag'
+          headers.delete 'Pragma'
+          headers.delete 'Last-Modified'
+        end
+        [status, headers, body]
+      else
+        @app.call(env)
+      end
+    end
+
+    def duration_in_words
+      (Time.now + self.duration_in_seconds).strftime '%a, %d %b %Y %H:%M:%S GMT'
+    end
+
+    def duration_in_seconds
+      60 * 60 * 24 * 365 * @cache_duration
+    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,39 @@
+require 'rack'
+
+module Rack
+  module Contrib
+    def self.release
+      "1.0.2"
+    end
+  end
+
+  autoload :AcceptFormat,               "rack/contrib/accept_format"
+  autoload :Access,                     "rack/contrib/access"
+  autoload :BounceFavicon,              "rack/contrib/bounce_favicon"
+  autoload :Cookies,                    "rack/contrib/cookies"
+  autoload :CSSHTTPRequest,             "rack/contrib/csshttprequest"
+  autoload :Deflect,                    "rack/contrib/deflect"
+  autoload :ExpectationCascade,         "rack/contrib/expectation_cascade"
+  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 :ResponseHeaders,            "rack/contrib/response_headers"
+  autoload :Runtime,                    "rack/contrib/runtime"
+  autoload :Sendfile,                   "rack/contrib/sendfile"
+  autoload :Signals,                    "rack/contrib/signals"
+  autoload :SimpleEndpoint,             "rack/contrib/simple_endpoint"
+  autoload :TimeZone,                   "rack/contrib/time_zone"
+  autoload :Evil,                       "rack/contrib/evil"
+  autoload :Callbacks,                  "rack/contrib/callbacks"
+  autoload :NestedParams,               "rack/contrib/nested_params"
+  autoload :Config,                     "rack/contrib/config"
+  autoload :NotFound,                   "rack/contrib/not_found"
+  autoload :ResponseCache,              "rack/contrib/response_cache"
+  autoload :RelativeRedirect,           "rack/contrib/relative_redirect"
+  autoload :StaticCache,                "rack/contrib/static_cache"
+end