rack 1.2.8 → 1.3.0.beta

data/lib/rack/handler.rb

@@ -12,14 +12,18 @@ module Rack
       return unless server
       server = server.to_s
 
+      unless @handlers.include? server
+        load_error = try_require('rack/handler', server)
+      end
+
       if klass = @handlers[server]
-        obj = Object
-        klass.split("::").each { |x| obj = obj.const_get(x) }
-        obj
+        klass.split("::").inject(Object) { |o, x| o.const_get(x) }
       else
-        try_require('rack/handler', server)
         const_get(server)
       end
+
+    rescue NameError => name_error
+      raise load_error || name_error
     end
 
     def self.default(options = {})
@@ -35,7 +39,7 @@ module Rack
       else
         begin
           Rack::Handler::Mongrel
-        rescue LoadError => e
+        rescue LoadError
           Rack::Handler::WEBrick
         end
       end
@@ -57,12 +61,14 @@ module Rack
         gsub(/[A-Z]+[^A-Z]/, '_\&').downcase
 
       require(::File.join(prefix, file))
-    rescue LoadError
+      nil
+    rescue LoadError => error
+      error
     end
 
     def self.register(server, klass)
       @handlers ||= {}
-      @handlers[server] = klass
+      @handlers[server.to_s] = klass.to_s
     end
 
     autoload :CGI, "rack/handler/cgi"

data/lib/rack/handler/cgi.rb

@@ -10,8 +10,6 @@ module Rack
       end
 
       def self.serve(app)
-        app = ContentLength.new(app)
-
         env = ENV.to_hash
         env.delete "HTTP_CONTENT_LENGTH"
 

data/lib/rack/handler/fastcgi.rb

@@ -19,16 +19,25 @@ module Rack
   module Handler
     class FastCGI
       def self.run(app, options={})
-        file = options[:File] and STDIN.reopen(UNIXServer.new(file))
-        port = options[:Port] and STDIN.reopen(TCPServer.new(port))
+        if options[:File]
+          STDIN.reopen(UNIXServer.new(options[:File]))
+        elsif options[:Port]
+          STDIN.reopen(TCPServer.new(options[:Host], options[:Port]))
+        end
         FCGI.each { |request|
           serve request, app
         }
       end
+      
+      def self.valid_options
+        {
+          "Host=HOST" => "Hostname to listen on (default: localhost)",
+          "Port=PORT" => "Port to listen on (default: 8080)",
+          "File=PATH" => "Creates a Domain socket at PATH instead of a TCP socket. Ignores Host and Port if set.",
+        }
+      end
 
       def self.serve(request, app)
-        app = Rack::ContentLength.new(app)
-
         env = request.env
         env.delete "HTTP_CONTENT_LENGTH"
 

data/lib/rack/handler/lsws.rb

@@ -11,8 +11,6 @@ module Rack
         end
       end
       def self.serve(app)
-        app = Rack::ContentLength.new(app)
-
         env = ENV.to_hash
         env.delete "HTTP_CONTENT_LENGTH"
         env["SCRIPT_NAME"] = "" if env["SCRIPT_NAME"] == "/"

data/lib/rack/handler/mongrel.rb

@@ -38,8 +38,18 @@ module Rack
         server.run.join
       end
 
+      def self.valid_options
+        {
+          "Host=HOST" => "Hostname to listen on (default: localhost)",
+          "Port=PORT" => "Port to listen on (default: 8080)",
+          "Processors=N" => "Number of concurrent processors to accept (default: 950)",
+          "Timeout=N" => "Time before a request is dropped for inactivity (default: 60)",
+          "Throttle=N" => "Throttle time between socket.accept calls in hundredths of a second (default: 0)",
+        }
+      end
+
       def initialize(app)
-        @app = Rack::Chunked.new(Rack::ContentLength.new(app))
+        @app = app
       end
 
       def process(request, response)
@@ -60,7 +70,7 @@ module Rack
                      "rack.multiprocess" => false, # ???
                      "rack.run_once" => false,
 
-                     "rack.url_scheme" => "http",
+                     "rack.url_scheme" => ["yes", "on", "1"].include?(env["HTTPS"]) ? "https" : "http"
                    })
         env["QUERY_STRING"] ||= ""
 

data/lib/rack/handler/scgi.rb

@@ -9,14 +9,22 @@ module Rack
       attr_accessor :app
 
       def self.run(app, options=nil)
+        options[:Socket] = UNIXServer.new(options[:File]) if options[:File]
         new(options.merge(:app=>app,
                           :host=>options[:Host],
                           :port=>options[:Port],
                           :socket=>options[:Socket])).listen
       end
+      
+      def self.valid_options
+        {
+          "Host=HOST" => "Hostname to listen on (default: localhost)",
+          "Port=PORT" => "Port to listen on (default: 8080)",
+        }
+      end
 
       def initialize(settings = {})
-        @app = Rack::Chunked.new(Rack::ContentLength.new(settings[:app]))
+        @app = settings[:app]
         super(settings)
       end
 

data/lib/rack/handler/thin.rb

@@ -6,13 +6,19 @@ module Rack
   module Handler
     class Thin
       def self.run(app, options={})
-        app = Rack::Chunked.new(Rack::ContentLength.new(app))
         server = ::Thin::Server.new(options[:Host] || '0.0.0.0',
                                     options[:Port] || 8080,
                                     app)
         yield server if block_given?
         server.start
       end
+
+      def self.valid_options
+        {
+          "Host=HOST" => "Hostname to listen on (default: localhost)",
+          "Port=PORT" => "Port to listen on (default: 8080)",
+        }
+      end
     end
   end
 end

data/lib/rack/handler/webrick.rb

@@ -12,6 +12,13 @@ module Rack
         yield @server  if block_given?
         @server.start
       end
+      
+      def self.valid_options
+        {
+          "Host=HOST" => "Hostname to listen on (default: localhost)",
+          "Port=PORT" => "Port to listen on (default: 8080)",
+        }
+      end
 
       def self.shutdown
         @server.shutdown
@@ -20,7 +27,7 @@ module Rack
 
       def initialize(server, app)
         super server
-        @app = Rack::ContentLength.new(app)
+        @app = app
       end
 
       def service(req, res)
@@ -43,11 +50,11 @@ module Rack
 
         env["HTTP_VERSION"] ||= env["SERVER_PROTOCOL"]
         env["QUERY_STRING"] ||= ""
-        env["REQUEST_PATH"] ||= "/"
         unless env["PATH_INFO"] == ""
           path, n = req.request_uri.path, env["SCRIPT_NAME"].length
           env["PATH_INFO"] = path[n, path.length-n]
         end
+        env["REQUEST_PATH"] ||= [env["SCRIPT_NAME"], env["PATH_INFO"]].join
 
         status, headers, body = @app.call(env)
         begin
@@ -56,9 +63,9 @@ module Rack
             if k.downcase == "set-cookie"
               res.cookies.concat vs.split("\n")
             else
-              vs.split("\n").each { |v|
-                res[k] = v
-              }
+              # Since WEBrick won't accept repeated headers,
+              # merge the values per RFC 1945 section 4.2.
+              res[k] = vs.split("\n").join(", ")
             end
           }
           body.each { |part|

data/lib/rack/lint.rb

@@ -30,7 +30,7 @@ module Rack
 
     ## = Rack applications
 
-    ## A Rack application is a Ruby object (not a class) that
+    ## A Rack application is an Ruby object (not a class) that
     ## responds to +call+.
     def call(env=nil)
       dup._call(env)
@@ -302,7 +302,7 @@ module Rack
       end
 
       ## * +read+ behaves like IO#read. Its signature is <tt>read([length, [buffer]])</tt>.
-      ##   If given, +length+ must be a non-negative Integer (>= 0) or +nil+, and +buffer+ must
+      ##   If given, +length+ must be an non-negative Integer (>= 0) or +nil+, and +buffer+ must
       ##   be a String and may not be nil. If +length+ is given and not nil, then this method
       ##   reads at most +length+ bytes from the input stream. If +length+ is not given or nil,
       ##   then this method reads all data until EOF.

data/lib/rack/lock.rb

@@ -2,15 +2,41 @@ require 'thread'
 
 module Rack
   class Lock
+    class Proxy < Struct.new(:target, :mutex) # :nodoc:
+      def each
+        target.each { |x| yield x }
+      end
+
+      def close
+        target.close if target.respond_to?(:close)
+      ensure
+        mutex.unlock
+      end
+
+      def to_path
+        target.to_path
+      end
+
+      def respond_to?(sym)
+        sym.to_sym == :close || target.respond_to?(sym)
+      end
+    end
+
     FLAG = 'rack.multithread'.freeze
 
-    def initialize(app, lock = Mutex.new)
-      @app, @lock = app, lock
+    def initialize(app, mutex = Mutex.new)
+      @app, @mutex = app, mutex
     end
 
     def call(env)
       old, env[FLAG] = env[FLAG], false
-      @lock.synchronize { @app.call(env) }
+      @mutex.lock
+      response = @app.call(env)
+      response[2] = Proxy.new(response[2], @mutex)
+      response
+    rescue Exception
+      @mutex.unlock
+      raise
     ensure
       env[FLAG] = old
     end

data/lib/rack/methodoverride.rb

@@ -1,6 +1,6 @@
 module Rack
   class MethodOverride
-    HTTP_METHODS = %w(GET HEAD PUT POST DELETE OPTIONS)
+    HTTP_METHODS = %w(GET HEAD PUT POST DELETE OPTIONS PATCH)
 
     METHOD_OVERRIDE_PARAM_KEY = "_method".freeze
     HTTP_METHOD_OVERRIDE_HEADER = "HTTP_X_HTTP_METHOD_OVERRIDE".freeze

data/lib/rack/mime.rb

@@ -70,7 +70,6 @@ module Rack
       ".dll"     => "application/x-msdownload",
       ".dmg"     => "application/octet-stream",
       ".doc"     => "application/msword",
-      ".docx"    => "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
       ".dot"     => "application/msword",
       ".dtd"     => "application/xml-dtd",
       ".dvi"     => "application/x-dvi",
@@ -182,6 +181,7 @@ module Rack
       ".tiff"    => "image/tiff",
       ".torrent" => "application/x-bittorrent",
       ".tr"      => "text/troff",
+      ".ttf"     => "application/octet-stream",
       ".txt"     => "text/plain",
       ".vcf"     => "text/x-vcard",
       ".vcs"     => "text/x-vcalendar",
@@ -192,12 +192,12 @@ module Rack
       ".wma"     => "audio/x-ms-wma",
       ".wmv"     => "video/x-ms-wmv",
       ".wmx"     => "video/x-ms-wmx",
+      ".woff"    => "application/octet-stream",
       ".wrl"     => "model/vrml",
       ".wsdl"    => "application/wsdl+xml",
       ".xbm"     => "image/x-xbitmap",
       ".xhtml"   => "application/xhtml+xml",
       ".xls"     => "application/vnd.ms-excel",
-      ".xlsx"    => "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
       ".xml"     => "application/xml",
       ".xpm"     => "image/x-xpixmap",
       ".xsl"     => "application/xml",

data/lib/rack/mock.rb

@@ -141,50 +141,45 @@ module Rack
   # Usually, you don't create the MockResponse on your own, but use
   # MockRequest.
 
-  class MockResponse
-    def initialize(status, headers, body, errors=StringIO.new(""))
-      @status = status.to_i
-
-      @original_headers = headers
-      @headers = Rack::Utils::HeaderHash.new
-      headers.each { |field, values|
-        @headers[field] = values
-        @headers[field] = ""  if values.empty?
-      }
-
-      @body = ""
-      body.each { |part| @body << part }
-
-      @errors = errors.string if errors.respond_to?(:string)
-    end
-
-    # Status
-    attr_reader :status
-
+  class MockResponse < Rack::Response
     # Headers
-    attr_reader :headers, :original_headers
+    attr_reader :original_headers
 
-    def [](field)
-      headers[field]
-    end
+    # Errors
+    attr_accessor :errors
 
+    def initialize(status, headers, body, errors=StringIO.new(""))
+      @original_headers = headers
+      @errors           = errors.string if errors.respond_to?(:string)
+      @body_string      = nil
 
-    # Body
-    attr_reader :body
+      super(body, status, headers)
+    end
 
     def =~(other)
-      @body =~ other
+      body =~ other
     end
 
     def match(other)
-      @body.match other
+      body.match other
     end
 
+    def body
+      # FIXME: apparently users of MockResponse expect the return value of
+      # MockResponse#body to be a string.  However, the real response object
+      # returns the body as a list.
+      #
+      # See spec_showstatus.rb:
+      #
+      #   should "not replace existing messages" do
+      #     ...
+      #     res.body.should == "foo!"
+      #   end
+      super.join
+    end
 
-    # Errors
-    attr_accessor :errors
-
-
-    include Response::Helpers
+    def empty?
+      [201, 204, 304].include? status
+    end
   end
 end

data/lib/rack/multipart.rb

@@ -0,0 +1,34 @@
+module Rack
+  # A multipart form data parser, adapted from IOWA.
+  #
+  # Usually, Rack::Request#POST takes care of calling this.
+  module Multipart
+    autoload :UploadedFile, 'rack/multipart/uploaded_file'
+    autoload :Parser, 'rack/multipart/parser'
+    autoload :Generator, 'rack/multipart/generator'
+
+    EOL = "\r\n"
+    MULTIPART_BOUNDARY = "AaB03x"
+    MULTIPART = %r|\Amultipart/.*boundary=\"?([^\";,]+)\"?|n
+    TOKEN = /[^\s()<>,;:\\"\/\[\]?=]+/
+    CONDISP = /Content-Disposition:\s*#{TOKEN}\s*/i
+    DISPPARM = /;\s*(#{TOKEN})=("(?:\\"|[^"])*"|#{TOKEN})*/
+    RFC2183 = /^#{CONDISP}(#{DISPPARM})+$/i
+    BROKEN_QUOTED = /^#{CONDISP}.*;\sfilename="(.*?)"(?:\s*$|\s*;\s*#{TOKEN}=)/i
+    BROKEN_UNQUOTED = /^#{CONDISP}.*;\sfilename=(#{TOKEN})/i
+    MULTIPART_CONTENT_TYPE = /Content-Type: (.*)#{EOL}/ni
+    MULTIPART_CONTENT_DISPOSITION = /Content-Disposition:.*\s+name="?([^\";]*)"?/ni
+    MULTIPART_CONTENT_ID = /Content-ID:\s*([^#{EOL}]*)/ni
+
+    class << self
+      def parse_multipart(env)
+        Parser.new(env).parse
+      end
+
+      def build_multipart(params, first = true)
+        Generator.new(params, first).dump
+      end
+    end
+
+  end
+end

data/lib/rack/multipart/generator.rb

@@ -0,0 +1,93 @@
+module Rack
+  module Multipart
+    class Generator
+      def initialize(params, first = true)
+        @params, @first = params, first
+
+        if @first && !@params.is_a?(Hash)
+          raise ArgumentError, "value must be a Hash"
+        end
+      end
+
+      def dump
+        return nil if @first && !multipart?
+        return flattened_params if !@first
+
+        flattened_params.map do |name, file|
+          if file.respond_to?(:original_filename)
+            ::File.open(file.path, "rb") do |f|
+              f.set_encoding(Encoding::BINARY) if f.respond_to?(:set_encoding)
+              content_for_tempfile(f, file, name)
+            end
+          else
+            content_for_other(file, name)
+          end
+        end.join + "--#{MULTIPART_BOUNDARY}--\r"
+      end
+
+      private
+      def multipart?
+        multipart = false
+
+        query = lambda { |value|
+          case value
+          when Array
+            value.each(&query)
+          when Hash
+            value.values.each(&query)
+          when Rack::Multipart::UploadedFile
+            multipart = true
+          end
+        }
+        @params.values.each(&query)
+
+        multipart
+      end
+
+      def flattened_params
+        @flattened_params ||= begin
+          h = Hash.new
+          @params.each do |key, value|
+            k = @first ? key.to_s : "[#{key}]"
+
+            case value
+            when Array
+              value.map { |v|
+                Multipart.build_multipart(v, false).each { |subkey, subvalue|
+                  h["#{k}[]#{subkey}"] = subvalue
+                }
+              }
+            when Hash
+              Multipart.build_multipart(value, false).each { |subkey, subvalue|
+                h[k + subkey] = subvalue
+              }
+            else
+              h[k] = value
+            end
+          end
+          h
+        end
+      end
+   
+      def content_for_tempfile(io, file, name)
+<<-EOF
+--#{MULTIPART_BOUNDARY}\r
+Content-Disposition: form-data; name="#{name}"; filename="#{Utils.escape(file.original_filename)}"\r
+Content-Type: #{file.content_type}\r
+Content-Length: #{::File.stat(file.path).size}\r
+\r
+#{io.read}\r
+EOF
+      end
+
+      def content_for_other(file, name)
+<<-EOF
+--#{MULTIPART_BOUNDARY}\r
+Content-Disposition: form-data; name="#{name}"\r
+\r
+#{file}\r
+EOF
+      end
+    end
+  end
+end