tricycle-rack-contrib 0.9.0

data/lib/rack/contrib/not_found.rb

@@ -0,0 +1,18 @@
+module Rack
+  # Rack::NotFound is a default endpoint. Initialize with the path to
+  # your 404 page.
+
+  class NotFound
+    F = ::File
+
+    def initialize(path)
+      file = F.expand_path(path)
+      @content = F.read(file)
+      @length = @content.size.to_s
+    end
+
+    def call(env)
+      [404, {'Content-Type' => 'text/html', 'Content-Length' => @length}, [@content]]
+    end
+  end
+end

data/lib/rack/contrib/post_body_content_type_parser.rb

@@ -0,0 +1,40 @@
+begin
+  require 'json'
+rescue LoadError => e
+  require 'json/pure'
+end
+
+module Rack
+
+  # A Rack middleware for parsing POST/PUT body data when Content-Type is
+  # not one of the standard supported types, like <tt>application/json</tt>.
+  #
+  # TODO: Find a better name.
+  #
+  class PostBodyContentTypeParser
+
+    # Constants
+    #
+    CONTENT_TYPE = 'CONTENT_TYPE'.freeze
+    POST_BODY = 'rack.input'.freeze
+    FORM_INPUT = 'rack.request.form_input'.freeze
+    FORM_HASH = 'rack.request.form_hash'.freeze
+
+    # Supported Content-Types
+    #
+    APPLICATION_JSON = 'application/json'.freeze
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      case env[CONTENT_TYPE]
+      when APPLICATION_JSON
+        env.update(FORM_HASH => JSON.parse(env[POST_BODY].read), FORM_INPUT => env[POST_BODY])
+      end
+      @app.call(env)
+    end
+
+  end
+end

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,108 @@
+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)
+
+        GC.enable_stats if GC.respond_to?(:enable_stats)
+        result = RubyProf.profile do
+          @times.times { @app.call(env) }
+        end
+        GC.disable_stats if GC.respond_to?(:disable_stats)
+
+        [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/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,116 @@
+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
+  # Doesn't cache unless path does not contain '..', Content-Type is
+  # whitelisted, and path agrees with Content-Type
+  # Inserts appropriate extension if no extension in path
+  # Uses /index.html if path ends in /
+  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
+    
+    if !path.include?('..') and extensions = 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
+        path = nil
+      else
+        # do nothing, path is alright
+      end
+    else
+      path = nil
+    end
+    
+    path
+  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, did not have a 'no-cache' cache control directive 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)
+    @env = env
+    @res = @app.call(@env)
+    if cacheable? 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
+  
+  private 
+  def cacheable?
+    get and !query_string and success and !no_cache and !private_cache
+  end
+  
+  def get
+    @env['REQUEST_METHOD'] == 'GET'
+  end
+  
+  def query_string
+    @env['QUERY_STRING'] != ''
+  end
+  
+  def success
+    @res[0] == 200
+  end
+  
+  def private_cache
+    cache_control_directives.include? 'private'
+  end
+  
+  def no_cache
+    cache_control_directives.include? 'no-cache'
+  end
+  
+  def cache_control_directives
+    (@res[1]["Cache-Control"] || "").split(',').collect {|d| d.strip}
+  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/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