passenger 2.2.1 → 2.2.2

data/vendor/{rack-0.9.1 → rack-1.0.0-git}/lib/rack/handler/lsws.rb

@@ -1,5 +1,6 @@
 require 'lsapi'
-#require 'cgi'
+require 'rack/content_length'
+
 module Rack
   module Handler
     class LSWS
@@ -9,12 +10,14 @@ 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"] == "/"
         env.update({"rack.version" => [0,1],
-                     "rack.input" => STDIN,
-                     "rack.errors" => STDERR,
+                     "rack.input" => StringIO.new($stdin.read.to_s),
+                     "rack.errors" => $stderr,
                      "rack.multithread" => false,
                      "rack.multiprocess" => true,
                      "rack.run_once" => false,
@@ -34,7 +37,7 @@ module Rack
       def self.send_headers(status, headers)
         print "Status: #{status}\r\n"
         headers.each { |k, vs|
-          vs.each { |v|
+          vs.split("\n").each { |v|
             print "#{k}: #{v}\r\n"
           }
         }

data/vendor/{rack-0.9.1 → rack-1.0.0-git}/lib/rack/handler/mongrel.rb

@@ -1,5 +1,7 @@
 require 'mongrel'
 require 'stringio'
+require 'rack/content_length'
+require 'rack/chunked'
 
 module Rack
   module Handler
@@ -33,7 +35,7 @@ module Rack
       end
 
       def initialize(app)
-        @app = app
+        @app = Rack::Chunked.new(Rack::ContentLength.new(app))
       end
 
       def process(request, response)
@@ -45,7 +47,7 @@ module Rack
 
         env.update({"rack.version" => [0,1],
                      "rack.input" => request.body || StringIO.new(""),
-                     "rack.errors" => STDERR,
+                     "rack.errors" => $stderr,
 
                      "rack.multithread" => true,
                      "rack.multiprocess" => false, # ???
@@ -63,7 +65,7 @@ module Rack
           response.send_status(nil)
 
           headers.each { |k, vs|
-            vs.each { |v|
+            vs.split("\n").each { |v|
               response.header[k] = v
             }
           }

data/vendor/{rack-0.9.1 → rack-1.0.0-git}/lib/rack/handler/scgi.rb

@@ -1,5 +1,7 @@
 require 'scgi'
 require 'stringio'
+require 'rack/content_length'
+require 'rack/chunked'
 
 module Rack
   module Handler
@@ -14,7 +16,7 @@ module Rack
       end
       
       def initialize(settings = {})
-        @app = settings[:app]
+        @app = Rack::Chunked.new(Rack::ContentLength.new(settings[:app]))
         @log = Object.new
         def @log.info(*args); end
         def @log.error(*args); end
@@ -32,7 +34,7 @@ module Rack
         env["SCRIPT_NAME"] = ""
         env.update({"rack.version" => [0,1],
                      "rack.input" => StringIO.new(input_body),
-                     "rack.errors" => STDERR,
+                     "rack.errors" => $stderr,
 
                      "rack.multithread" => true,
                      "rack.multiprocess" => true,
@@ -44,7 +46,7 @@ module Rack
         begin
           socket.write("Status: #{status}\r\n")
           headers.each do |k, vs|
-            vs.each {|v| socket.write("#{k}: #{v}\r\n")}
+            vs.split("\n").each { |v| socket.write("#{k}: #{v}\r\n")}
           end
           socket.write("\r\n")
           body.each {|s| socket.write(s)}

data/vendor/{rack-0.9.1 → rack-1.0.0-git}/lib/rack/handler/thin.rb

@@ -1,9 +1,12 @@
 require "thin"
+require "rack/content_length"
+require "rack/chunked"
 
 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)

data/vendor/{rack-0.9.1 → rack-1.0.0-git}/lib/rack/handler/webrick.rb

@@ -1,5 +1,6 @@
 require 'webrick'
 require 'stringio'
+require 'rack/content_length'
 
 module Rack
   module Handler
@@ -14,7 +15,7 @@ module Rack
 
       def initialize(server, app)
         super server
-        @app = app
+        @app = Rack::ContentLength.new(app)
       end
 
       def service(req, res)
@@ -23,7 +24,7 @@ module Rack
 
         env.update({"rack.version" => [0,1],
                      "rack.input" => StringIO.new(req.body.to_s),
-                     "rack.errors" => STDERR,
+                     "rack.errors" => $stderr,
 
                      "rack.multithread" => true,
                      "rack.multiprocess" => false,
@@ -35,16 +36,21 @@ module Rack
         env["HTTP_VERSION"] ||= env["SERVER_PROTOCOL"]
         env["QUERY_STRING"] ||= ""
         env["REQUEST_PATH"] ||= "/"
-        env.delete "PATH_INFO"  if env["PATH_INFO"] == ""
+        if env["PATH_INFO"] == ""
+          env.delete "PATH_INFO"
+        else
+          path, n = req.request_uri.path, env["SCRIPT_NAME"].length
+          env["PATH_INFO"] = path[n, path.length-n]
+        end
 
         status, headers, body = @app.call(env)
         begin
           res.status = status.to_i
           headers.each { |k, vs|
             if k.downcase == "set-cookie"
-              res.cookies.concat vs.to_a
+              res.cookies.concat vs.split("\n")
             else
-              vs.each { |v|
+              vs.split("\n").each { |v|
                 res[k] = v
               }
             end

data/vendor/{rack-0.9.1 → rack-1.0.0-git}/lib/rack/lint.rb

@@ -1,3 +1,5 @@
+require 'rack/utils'
+
 module Rack
   # Rack::Lint validates your application and the requests and
   # responses according to the Rack spec.
@@ -86,7 +88,9 @@ module Rack
       ##                      within the application. This may be an
       ##                      empty string, if the request URL targets
       ##                      the application root and does not have a
-      ##                      trailing slash.
+      ##                      trailing slash. This value may be
+      ##                      percent-encoded when I originating from
+      ##                      a URL.
 
       ## <tt>QUERY_STRING</tt>:: The portion of the request URL that
       ##                         follows the <tt>?</tt>, if any. May be
@@ -107,19 +111,48 @@ module Rack
       ## In addition to this, the Rack environment must include these
       ## Rack-specific variables:
 
-      ## <tt>rack.version</tt>:: The Array [0,1], representing this version of Rack.
+      ## <tt>rack.version</tt>:: The Array [1,0], representing this version of Rack.
       ## <tt>rack.url_scheme</tt>:: +http+ or +https+, depending on the request URL.
       ## <tt>rack.input</tt>:: See below, the input stream.
       ## <tt>rack.errors</tt>:: See below, the error stream.
       ## <tt>rack.multithread</tt>:: true if the application object may be simultaneously invoked by another thread in the same process, false otherwise.
       ## <tt>rack.multiprocess</tt>:: true if an equivalent application object may be simultaneously invoked by another process, false otherwise.
       ## <tt>rack.run_once</tt>:: true if the server expects (but does not guarantee!) that the application will only be invoked this one time during the life of its containing process. Normally, this will only be true for a server based on CGI (or something similar).
+      ##
+
+      ## Additional environment specifications have approved to
+      ## standardized middleware APIs.  None of these are required to
+      ## be implemented by the server.
+
+      ## <tt>rack.session</tt>:: A hash like interface for storing request session data.
+      ##                         The store must implement:
+      if session = env['rack.session']
+        ##                         store(key, value)         (aliased as []=);
+        assert("session #{session.inspect} must respond to store and []=") {
+          session.respond_to?(:store) && session.respond_to?(:[]=)
+        }
+
+        ##                         fetch(key, default = nil) (aliased as []);
+        assert("session #{session.inspect} must respond to fetch and []") {
+          session.respond_to?(:fetch) && session.respond_to?(:[])
+        }
+
+        ##                         delete(key);
+        assert("session #{session.inspect} must respond to delete") {
+          session.respond_to?(:delete)
+        }
+
+        ##                         clear;
+        assert("session #{session.inspect} must respond to clear") {
+          session.respond_to?(:clear)
+        }
+      end
 
       ## The server or the application can store their own data in the
       ## environment, too.  The keys must contain at least one dot,
       ## and should be prefixed uniquely.  The prefix <tt>rack.</tt>
-      ## is reserved for use with the Rack core distribution and must
-      ## not be used otherwise.
+      ## is reserved for use with the Rack core distribution and other
+      ## accepted specifications and must not be used otherwise.
       ##
 
       %w[REQUEST_METHOD SERVER_NAME SERVER_PORT
@@ -198,9 +231,12 @@ module Rack
     end
 
     ## === The Input Stream
+    ##
+    ## The input stream is an IO-like object which contains the raw HTTP
+    ## POST data. If it is a file then it must be opened in binary mode.
     def check_input(input)
-      ## The input stream must respond to +gets+, +each+ and +read+.
-      [:gets, :each, :read].each { |method|
+      ## The input stream must respond to +gets+, +each+, +read+ and +rewind+.
+      [:gets, :each, :read, :rewind].each { |method|
         assert("rack.input #{input} does not respond to ##{method}") {
           input.respond_to? method
         }
@@ -218,10 +254,6 @@ module Rack
         @input.size
       end
 
-      def rewind
-        @input.rewind
-      end
-
       ## * +gets+ must be called without arguments and return a string,
       ##   or +nil+ on EOF.
       def gets(*args)
@@ -233,21 +265,44 @@ module Rack
         v
       end
 
-      ## * +read+ must be called without or with one integer argument
-      ##   and return a string, or +nil+ on EOF.
+      ## * +read+ behaves like IO#read. Its signature is <tt>read([length, [buffer]])</tt>.
+      ##   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.
+      ##   When EOF is reached, this method returns nil if +length+ is given and not nil, or ""
+      ##   if +length+ is not given or is nil.
+      ##   If +buffer+ is given, then the read data will be placed into +buffer+ instead of a
+      ##   newly created String object.
       def read(*args)
         assert("rack.input#read called with too many arguments") {
-          args.size <= 1
+          args.size <= 2
         }
-        if args.size == 1
-          assert("rack.input#read called with non-integer argument") {
-            args.first.kind_of? Integer
+        if args.size >= 1
+          assert("rack.input#read called with non-integer and non-nil length") {
+            args.first.kind_of?(Integer) || args.first.nil?
+          }
+          assert("rack.input#read called with a negative length") {
+            args.first.nil? || args.first >= 0
           }
         end
+        if args.size >= 2
+          assert("rack.input#read called with non-String buffer") {
+            args[1].kind_of?(String)
+          }
+        end
+        
         v = @input.read(*args)
-        assert("rack.input#read didn't return a String") {
+        
+        assert("rack.input#read didn't return nil or a String") {
           v.nil? or v.instance_of? String
         }
+        if args[0].nil?
+          assert("rack.input#read(nil) returned nil on EOF") {
+            !v.nil?
+          }
+        end
+        
         v
       end
 
@@ -261,6 +316,23 @@ module Rack
           yield line
         }
       end
+      
+      ## * +rewind+ must be called without arguments. It rewinds the input
+      ##   stream back to the beginning. It must not raise Errno::ESPIPE:
+      ##   that is, it may not be a pipe or a socket. Therefore, handler
+      ##   developers must buffer the input data into some rewindable object
+      ##   if the underlying input stream is not rewindable.
+      def rewind(*args)
+        assert("rack.input#rewind called with arguments") { args.size == 0 }
+        assert("rack.input#rewind raised Errno::ESPIPE") {
+          begin
+            @input.rewind
+            true
+          rescue Errno::ESPIPE
+            false
+          end
+        }
+      end
 
       ## * +close+ must never be called on the input stream.
       def close(*args)
@@ -312,13 +384,14 @@ module Rack
 
     ## === The Status
     def check_status(status)
-      ## The status, if parsed as integer (+to_i+), must be greater than or equal to 100.
+      ## This is an HTTP status. When parsed as integer (+to_i+), it must be
+      ## greater than or equal to 100.
       assert("Status must be >=100 seen as integer") { status.to_i >= 100 }
     end
 
     ## === The Headers
     def check_headers(header)
-      ## The header must respond to each, and yield values of key and value.
+      ## The header must respond to +each+, and yield values of key and value.
       assert("headers object should respond to #each, but doesn't (got #{header.class} as headers)") {
          header.respond_to? :each
       }
@@ -336,16 +409,14 @@ module Rack
         ## but only contain keys that consist of
         ## letters, digits, <tt>_</tt> or <tt>-</tt> and start with a letter.
         assert("invalid header name: #{key}") { key =~ /\A[a-zA-Z][a-zA-Z0-9_-]*\z/ }
-        ##
-        ## The values of the header must respond to #each.
-        assert("header values must respond to #each, but the value of " +
-          "'#{key}' doesn't (is #{value.class})") { value.respond_to? :each }
-        value.each { |item|
-          ## The values passed on #each must be Strings
-          assert("header values must consist of Strings, but '#{key}' also contains a #{item.class}") {
-            item.instance_of?(String)
-          }
-          ## and not contain characters below 037.
+
+        ## The values of the header must be Strings,
+        assert("a header value must be a String, but the value of " +
+          "'#{key}' is a #{value.class}") { value.kind_of? String }
+        ## consisting of lines (for multiple header values, e.g. multiple
+        ## <tt>Set-Cookie</tt> values) seperated by "\n".
+        value.split("\n").each { |item|
+          ## The lines must not contain characters below 037.
           assert("invalid header value #{key}: #{item.inspect}") {
             item !~ /[\000-\037]/
           }
@@ -373,65 +444,49 @@ module Rack
 
     ## === The Content-Length
     def check_content_length(status, headers, env)
-      chunked_response = false
-      headers.each { |key, value|
-        if key.downcase == 'transfer-encoding'
-          chunked_response = value.downcase != 'identity'
-        end
-      }
-
       headers.each { |key, value|
         if key.downcase == 'content-length'
-          ## There must be a <tt>Content-Length</tt>, except when the
-          ## +Status+ is 1xx, 204 or 304, in which case there must be none
-          ## given.
+          ## There must not be a <tt>Content-Length</tt> header when the
+          ## +Status+ is 1xx, 204 or 304.
           assert("Content-Length header found in #{status} response, not allowed") {
             not Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.include? status.to_i
           }
 
-          assert('Content-Length header should not be used if body is chunked') {
-            not chunked_response
-          }
-
           bytes = 0
           string_body = true
 
-          @body.each { |part|
-            unless part.kind_of?(String)
-              string_body = false
-              break
-            end
-
-            bytes += (part.respond_to?(:bytesize) ? part.bytesize : part.size)
-          }
+          if @body.respond_to?(:to_ary)
+            @body.each { |part|
+              unless part.kind_of?(String)
+                string_body = false
+                break
+              end
 
-          if env["REQUEST_METHOD"] == "HEAD"
-            assert("Response body was given for HEAD request, but should be empty") {
-              bytes == 0
+              bytes += Rack::Utils.bytesize(part)
             }
-          else
-            if string_body
-              assert("Content-Length header was #{value}, but should be #{bytes}") {
-                value == bytes.to_s
+
+            if env["REQUEST_METHOD"] == "HEAD"
+              assert("Response body was given for HEAD request, but should be empty") {
+                bytes == 0
               }
+            else
+              if string_body
+                assert("Content-Length header was #{value}, but should be #{bytes}") {
+                  value == bytes.to_s
+                }
+              end
             end
           end
 
           return
         end
       }
-
-      if [ String, Array ].include?(@body.class) && !chunked_response
-        assert('No Content-Length header found') {
-          Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.include? status.to_i
-        }
-      end
     end
 
     ## === The Body
     def each
       @closed = false
-      ## The Body must respond to #each
+      ## The Body must respond to +each+
       @body.each { |part|
         ## and must only yield String values.
         assert("Body yielded non-string value #{part.inspect}") {
@@ -440,9 +495,26 @@ module Rack
         yield part
       }
       ##
-      ## If the Body responds to #close, it will be called after iteration.
+      ## The Body itself should not be an instance of String, as this will
+      ## break in Ruby 1.9.
+      ##
+      ## If the Body responds to +close+, it will be called after iteration.
       # XXX howto: assert("Body has not been closed") { @closed }
 
+
+      ##
+      ## If the Body responds to +to_path+, it must return a String
+      ## identifying the location of a file whose contents are identical
+      ## to that produced by calling +each+; this may be used by the
+      ## server as an alternative, possibly more efficient way to
+      ## transport the response.
+
+      if @body.respond_to?(:to_path)
+        assert("The file identified by body.to_path does not exist") {
+          ::File.exist? @body.to_path
+        }
+      end
+
       ##
       ## The Body commonly is an Array of Strings, the application
       ## instance itself, or a File-like object.