rack 1.0.1 → 1.1.0

data/lib/rack/mock.rb

@@ -40,7 +40,7 @@ module Rack
     end
 
     DEFAULT_ENV = {
-      "rack.version" => [1,0],
+      "rack.version" => [1,1],
       "rack.input" => StringIO.new,
       "rack.errors" => StringIO.new,
       "rack.multithread" => true,
@@ -73,14 +73,17 @@ module Rack
     # Return the Rack environment used for a request to +uri+.
     def self.env_for(uri="", opts={})
       uri = URI(uri)
+      uri.path = "/#{uri.path}" unless uri.path[0] == ?/
+
       env = DEFAULT_ENV.dup
 
-      env["REQUEST_METHOD"] = opts[:method] || "GET"
+      env["REQUEST_METHOD"] = opts[:method] ? opts[:method].to_s.upcase : "GET"
       env["SERVER_NAME"] = uri.host || "example.org"
       env["SERVER_PORT"] = uri.port ? uri.port.to_s : "80"
       env["QUERY_STRING"] = uri.query.to_s
       env["PATH_INFO"] = (!uri.path || uri.path.empty?) ? "/" : uri.path
       env["rack.url_scheme"] = uri.scheme || "http"
+      env["HTTPS"] = env["rack.url_scheme"] == "https" ? "on" : "off"
 
       env["SCRIPT_NAME"] = opts[:script_name] || ""
 
@@ -90,7 +93,30 @@ module Rack
         env["rack.errors"] = StringIO.new
       end
 
-      opts[:input] ||= ""
+      if params = opts[:params]
+        if env["REQUEST_METHOD"] == "GET"
+          params = Utils.parse_nested_query(params) if params.is_a?(String)
+          params.update(Utils.parse_nested_query(env["QUERY_STRING"]))
+          env["QUERY_STRING"] = Utils.build_nested_query(params)
+        elsif !opts.has_key?(:input)
+          opts["CONTENT_TYPE"] = "application/x-www-form-urlencoded"
+          if params.is_a?(Hash)
+            if data = Utils::Multipart.build_multipart(params)
+              opts[:input] = data
+              opts["CONTENT_LENGTH"] ||= data.length.to_s
+              opts["CONTENT_TYPE"] = "multipart/form-data; boundary=#{Utils::Multipart::MULTIPART_BOUNDARY}"
+            else
+              opts[:input] = Utils.build_nested_query(params)
+            end
+          else
+            opts[:input] = params
+          end
+        end
+      end
+
+      empty_str = ""
+      empty_str.force_encoding("ASCII-8BIT") if empty_str.respond_to? :force_encoding
+      opts[:input] ||= empty_str
       if String === opts[:input]
         rack_input = StringIO.new(opts[:input])
       else
@@ -128,7 +154,7 @@ module Rack
       @body = ""
       body.each { |part| @body << part }
 
-      @errors = errors.string
+      @errors = errors.string if errors.respond_to?(:string)
     end
 
     # Status

data/lib/rack/nulllogger.rb

@@ -0,0 +1,18 @@
+module Rack
+  class NullLogger
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      env['rack.logger'] = self
+      @app.call(env)
+    end
+
+    def info(progname = nil, &block);  end
+    def debug(progname = nil, &block); end
+    def warn(progname = nil, &block);  end
+    def error(progname = nil, &block); end
+    def fatal(progname = nil, &block); end
+  end
+end

data/lib/rack/reloader.rb

@@ -1,5 +1,6 @@
 #          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
+#       Rack::Reloader is subject to the terms of an MIT-style license.
+#      See COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 require 'pathname'
 
@@ -92,6 +93,8 @@ module Rack
           found, stat = safe_stat(path)
           return ::File.expand_path(found), stat if found
         end
+
+        return false, false
       end
 
       def safe_stat(file)

data/lib/rack/request.rb

@@ -32,6 +32,7 @@ module Rack
     def content_type;    @env['CONTENT_TYPE']                     end
     def session;         @env['rack.session'] ||= {}              end
     def session_options; @env['rack.session.options'] ||= {}      end
+    def logger;          @env['rack.logger']                      end
 
     # The media type (type/subtype) portion of the CONTENT_TYPE header
     # without any media type parameters. e.g., when CONTENT_TYPE is
@@ -63,9 +64,17 @@ module Rack
       media_type_params['charset']
     end
 
+    def host_with_port
+      if forwarded = @env["HTTP_X_FORWARDED_HOST"]
+        forwarded.split(/,\s?/).last
+      else
+        @env['HTTP_HOST'] || "#{@env['SERVER_NAME'] || @env['SERVER_ADDR']}:#{@env['SERVER_PORT']}"
+      end
+    end
+
     def host
       # Remove port number.
-      (@env["HTTP_HOST"] || @env["SERVER_NAME"]).to_s.gsub(/:\d+\z/, '')
+      host_with_port.to_s.gsub(/:\d+\z/, '')
     end
 
     def script_name=(s); @env["SCRIPT_NAME"] = s.to_s             end
@@ -81,7 +90,6 @@ module Rack
     # one of the media types presents in this list will not be eligible
     # for form-data / param parsing.
     FORM_DATA_MEDIA_TYPES = [
-      nil,
       'application/x-www-form-urlencoded',
       'multipart/form-data'
     ]
@@ -92,15 +100,20 @@ module Rack
     PARSEABLE_DATA_MEDIA_TYPES = [
       'multipart/related',
       'multipart/mixed'
-    ]  
+    ]
 
     # Determine whether the request body contains form-data by checking
-    # the request media_type against registered form-data media-types:
-    # "application/x-www-form-urlencoded" and "multipart/form-data". The
+    # the request Content-Type for one of the media-types:
+    # "application/x-www-form-urlencoded" or "multipart/form-data". The
     # list of form-data media types can be modified through the
     # +FORM_DATA_MEDIA_TYPES+ array.
+    #
+    # A request body is also assumed to contain form-data when no
+    # Content-Type header is provided and the request_method is POST.
     def form_data?
-      FORM_DATA_MEDIA_TYPES.include?(media_type)
+      type = media_type
+      meth = env["rack.methodoverride.original_method"] || env['REQUEST_METHOD']
+      (meth == 'POST' && type.nil?) || FORM_DATA_MEDIA_TYPES.include?(type)
     end
 
     # Determine whether the request body contains data by checking
@@ -115,8 +128,7 @@ module Rack
         @env["rack.request.query_hash"]
       else
         @env["rack.request.query_string"] = query_string
-        @env["rack.request.query_hash"]   =
-          Utils.parse_nested_query(query_string)
+        @env["rack.request.query_hash"]   = parse_query(query_string)
       end
     end
 
@@ -125,19 +137,20 @@ module Rack
     # This method support both application/x-www-form-urlencoded and
     # multipart/form-data.
     def POST
-      if @env["rack.request.form_input"].eql? @env["rack.input"]
+      if @env["rack.input"].nil?
+        raise "Missing rack.input"
+      elsif @env["rack.request.form_input"].eql? @env["rack.input"]
         @env["rack.request.form_hash"]
       elsif form_data? || parseable_data?
         @env["rack.request.form_input"] = @env["rack.input"]
-        unless @env["rack.request.form_hash"] =
-            Utils::Multipart.parse_multipart(env)
+        unless @env["rack.request.form_hash"] = parse_multipart(env)
           form_vars = @env["rack.input"].read
 
           # Fix for Safari Ajax postings that always append \0
           form_vars.sub!(/\0\z/, '')
 
           @env["rack.request.form_vars"] = form_vars
-          @env["rack.request.form_hash"] = Utils.parse_nested_query(form_vars)
+          @env["rack.request.form_hash"] = parse_query(form_vars)
 
           @env["rack.input"].rewind
         end
@@ -149,7 +162,7 @@ module Rack
 
     # The union of GET and POST data.
     def params
-      self.put? ? self.GET : self.GET.update(self.POST)
+      self.GET.update(self.POST)
     rescue EOFError => e
       self.GET
     end
@@ -175,6 +188,9 @@ module Rack
     end
     alias referrer referer
 
+    def user_agent
+      @env['HTTP_USER_AGENT']
+    end
 
     def cookies
       return {}  unless @env["HTTP_COOKIE"]
@@ -214,11 +230,11 @@ module Rack
 
       url
     end
-    
+
     def path
       script_name + path_info
     end
-    
+
     def fullpath
       query_string.empty? ? path : "#{path}?#{query_string}"
     end
@@ -242,5 +258,14 @@ module Rack
         @env['REMOTE_ADDR']
       end
     end
+
+    protected
+      def parse_query(qs)
+        Utils.parse_nested_query(qs)
+      end
+
+      def parse_multipart(env)
+        Utils::Multipart.parse_multipart(env)
+      end
   end
 end

data/lib/rack/response.rb

@@ -19,7 +19,7 @@ module Rack
     attr_accessor :length
 
     def initialize(body=[], status=200, header={}, &block)
-      @status = status
+      @status = status.to_i
       @header = Utils::HeaderHash.new({"Content-Type" => "text/html"}.
                                       merge(header))
 
@@ -54,45 +54,11 @@ module Rack
     end
 
     def set_cookie(key, value)
-      case value
-      when Hash
-        domain  = "; domain="  + value[:domain]    if value[:domain]
-        path    = "; path="    + value[:path]      if value[:path]
-        # According to RFC 2109, we need dashes here.
-        # N.B.: cgi.rb uses spaces...
-        expires = "; expires=" + value[:expires].clone.gmtime.
-          strftime("%a, %d-%b-%Y %H:%M:%S GMT")    if value[:expires]
-        secure = "; secure"  if value[:secure]
-        httponly = "; HttpOnly" if value[:httponly]
-        value = value[:value]
-      end
-      value = [value]  unless Array === value
-      cookie = Utils.escape(key) + "=" +
-        value.map { |v| Utils.escape v }.join("&") +
-        "#{domain}#{path}#{expires}#{secure}#{httponly}"
-
-      case self["Set-Cookie"]
-      when Array
-        self["Set-Cookie"] << cookie
-      when String
-        self["Set-Cookie"] = [self["Set-Cookie"], cookie]
-      when nil
-        self["Set-Cookie"] = cookie
-      end
+      Utils.set_cookie_header!(header, key, value)
     end
 
     def delete_cookie(key, value={})
-      unless Array === self["Set-Cookie"]
-        self["Set-Cookie"] = [self["Set-Cookie"]].compact
-      end
-
-      self["Set-Cookie"].reject! { |cookie|
-        cookie =~ /\A#{Utils.escape(key)}=/
-      }
-
-      set_cookie(key,
-                 {:value => '', :path => nil, :domain => nil,
-                   :expires => Time.at(0) }.merge(value))
+      Utils.delete_cookie_header!(header, key, value)
     end
 
     def redirect(target, status=302)
@@ -105,9 +71,9 @@ module Rack
 
       if [204, 304].include?(status.to_i)
         header.delete "Content-Type"
-        [status.to_i, header.to_hash, []]
+        [status.to_i, header, []]
       else
-        [status.to_i, header.to_hash, self]
+        [status.to_i, header, self]
       end
     end
     alias to_a finish           # For *response

data/lib/rack/runtime.rb

@@ -0,0 +1,27 @@
+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/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