passenger 2.2.1 → 2.2.2

data/vendor/rack-1.0.0-git/lib/rack/lock.rb

@@ -0,0 +1,16 @@
+module Rack
+  class Lock
+    FLAG = 'rack.multithread'.freeze
+
+    def initialize(app, lock = Mutex.new)
+      @app, @lock = app, lock
+    end
+
+    def call(env)
+      old, env[FLAG] = env[FLAG], false
+      @lock.synchronize { @app.call(env) }
+    ensure
+      env[FLAG] = old
+    end
+  end
+end

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

@@ -8,10 +8,10 @@ module Rack
     # Also see the documentation for MIME_TYPES
     #
     # Usage:
-    #     Rack::Utils.mime_type('.foo')
+    #     Rack::Mime.mime_type('.foo')
     #
     # This is a shortcut for:
-    #     Rack::Utils::MIME_TYPES.fetch('.foo', 'application/octet-stream')
+    #     Rack::Mime::MIME_TYPES.fetch('.foo', 'application/octet-stream')
 
     def mime_type(ext, fallback='application/octet-stream')
       MIME_TYPES.fetch(ext, fallback)
@@ -26,12 +26,12 @@ module Rack
     #
     #     require 'webrick/httputils'
     #     list = WEBrick::HTTPUtils.load_mime_types('/etc/mime.types')
-    #     Rack::Utils::MIME_TYPES.merge!(list)
+    #     Rack::Mime::MIME_TYPES.merge!(list)
     #
     # To add the list mongrel provides, use:
     #
     #     require 'mongrel/handlers'
-    #     Rack::Utils::MIME_TYPES.merge!(Mongrel::DirHandler::MIME_TYPES)
+    #     Rack::Mime::MIME_TYPES.merge!(Mongrel::DirHandler::MIME_TYPES)
 
     MIME_TYPES = {
       ".3gp"     => "video/3gpp",

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

@@ -40,7 +40,7 @@ module Rack
     end
 
     DEFAULT_ENV = {
-      "rack.version" => [0,1],
+      "rack.version" => [1,0],
       "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,6 +93,40 @@ module Rack
         env["rack.errors"] = StringIO.new
       end
 
+      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)
+            multipart = false
+            query = lambda { |value|
+              case value
+              when Array
+                value.each(&query)
+              when Hash
+                value.values.each(&query)
+              when Utils::Multipart::UploadedFile
+                multipart = true
+              end
+            }
+            opts[:params].values.each(&query)
+
+            if multipart
+              opts[:input] = Utils::Multipart.build_multipart(params)
+              opts["CONTENT_LENGTH"] ||= opts[:input].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
+
       opts[:input] ||= ""
       if String === opts[:input]
         env["rack.input"] = StringIO.new(opts[:input])
@@ -97,6 +134,8 @@ module Rack
         env["rack.input"] = opts[:input]
       end
 
+      env["CONTENT_LENGTH"] ||= env["rack.input"].length.to_s
+
       opts.each { |field, value|
         env[field] = value  if String === field
       }
@@ -116,9 +155,7 @@ module Rack
       @original_headers = headers
       @headers = Rack::Utils::HeaderHash.new
       headers.each { |field, values|
-        values.each { |value|
-          @headers[field] = value
-        }
+        @headers[field] = values
         @headers[field] = ""  if values.empty?
       }
 

data/vendor/rack-1.0.0-git/lib/rack/reloader.rb

@@ -0,0 +1,106 @@
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'pathname'
+
+module Rack
+
+  # High performant source reloader
+  #
+  # This class acts as Rack middleware.
+  #
+  # What makes it especially suited for use in a production environment is that
+  # any file will only be checked once and there will only be made one system
+  # call stat(2).
+  #
+  # Please note that this will not reload files in the background, it does so
+  # only when actively called.
+  #
+  # It is performing a check/reload cycle at the start of every request, but
+  # also respects a cool down time, during which nothing will be done.
+  class Reloader
+    def initialize(app, cooldown = 10, backend = Stat)
+      @app = app
+      @cooldown = cooldown
+      @last = (Time.now - cooldown)
+      @cache = {}
+      @mtimes = {}
+
+      extend backend
+    end
+
+    def call(env)
+      if @cooldown and Time.now > @last + @cooldown
+        if Thread.list.size > 1
+          Thread.exclusive{ reload! }
+        else
+          reload!
+        end
+
+        @last = Time.now
+      end
+
+      @app.call(env)
+    end
+
+    def reload!(stderr = $stderr)
+      rotation do |file, mtime|
+        previous_mtime = @mtimes[file] ||= mtime
+        safe_load(file, mtime, stderr) if mtime > previous_mtime
+      end
+    end
+
+    # A safe Kernel::load, issuing the hooks depending on the results
+    def safe_load(file, mtime, stderr = $stderr)
+      load(file)
+      stderr.puts "#{self.class}: reloaded `#{file}'"
+      file
+    rescue LoadError, SyntaxError => ex
+      stderr.puts ex
+    ensure
+      @mtimes[file] = mtime
+    end
+
+    module Stat
+      def rotation
+        files = [$0, *$LOADED_FEATURES].uniq
+        paths = ['./', *$LOAD_PATH].uniq
+
+        files.map{|file|
+          next if file =~ /\.(so|bundle)$/ # cannot reload compiled files
+
+          found, stat = figure_path(file, paths)
+          next unless found and stat and mtime = stat.mtime
+
+          @cache[file] = found
+
+          yield(found, mtime)
+        }.compact
+      end
+
+      # Takes a relative or absolute +file+ name, a couple possible +paths+ that
+      # the +file+ might reside in. Returns the full path and File::Stat for the
+      # path.
+      def figure_path(file, paths)
+        found = @cache[file]
+        found = file if !found and Pathname.new(file).absolute?
+        found, stat = safe_stat(found)
+        return found, stat if found
+
+        paths.each do |possible_path|
+          path = ::File.join(possible_path, file)
+          found, stat = safe_stat(path)
+          return ::File.expand_path(found), stat if found
+        end
+      end
+
+      def safe_stat(file)
+        return unless file
+        stat = ::File.stat(file)
+        return file, stat if stat.file?
+      rescue Errno::ENOENT, Errno::ENOTDIR
+        @cache.delete(file) and false
+      end
+    end
+  end
+end

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

@@ -8,11 +8,23 @@ module Rack
   #   req = Rack::Request.new(env)
   #   req.post?
   #   req.params["data"]
+  #
+  # The environment hash passed will store a reference to the Request object
+  # instantiated so that it will only instantiate if an instance of the Request
+  # object doesn't already exist.
 
   class Request
     # The environment of the request.
     attr_reader :env
 
+    def self.new(env, *args)
+      if self == Rack::Request
+        env["rack.request"] ||= super
+      else
+        super
+      end
+    end
+
     def initialize(env)
       @env = env
     end
@@ -26,6 +38,8 @@ module Rack
     def query_string;    @env["QUERY_STRING"].to_s                end
     def content_length;  @env['CONTENT_LENGTH']                   end
     def content_type;    @env['CONTENT_TYPE']                     end
+    def session;         @env['rack.session'] ||= {}              end
+    def session_options; @env['rack.session.options'] ||= {}      end
 
     # The media type (type/subtype) portion of the CONTENT_TYPE header
     # without any media type parameters. e.g., when CONTENT_TYPE is
@@ -34,7 +48,7 @@ module Rack
     # For more information on the use of media types in HTTP, see:
     # http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.7
     def media_type
-      content_type && content_type.split(/\s*[;,]\s*/, 2)[0].downcase
+      content_type && content_type.split(/\s*[;,]\s*/, 2).first.downcase
     end
 
     # The media type parameters provided in CONTENT_TYPE as a Hash, or
@@ -80,6 +94,14 @@ module Rack
       'multipart/form-data'
     ]
 
+    # The set of media-types. Requests that do not indicate
+    # one of the media types presents in this list will not be eligible
+    # for param parsing like soap attachments or generic multiparts
+    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
@@ -89,6 +111,12 @@ module Rack
       FORM_DATA_MEDIA_TYPES.include?(media_type)
     end
 
+    # Determine whether the request body contains data by checking
+    # the request media_type against registered parse-data media-types
+    def parseable_data?
+      PARSEABLE_DATA_MEDIA_TYPES.include?(media_type)
+    end
+
     # Returns the data recieved in the query string.
     def GET
       if @env["rack.request.query_string"] == query_string
@@ -96,7 +124,7 @@ module Rack
       else
         @env["rack.request.query_string"] = query_string
         @env["rack.request.query_hash"]   =
-          Utils.parse_query(query_string)
+          Utils.parse_nested_query(query_string)
       end
     end
 
@@ -107,13 +135,19 @@ module Rack
     def POST
       if @env["rack.request.form_input"].eql? @env["rack.input"]
         @env["rack.request.form_hash"]
-      elsif form_data?
+      elsif form_data? || parseable_data?
         @env["rack.request.form_input"] = @env["rack.input"]
         unless @env["rack.request.form_hash"] =
             Utils::Multipart.parse_multipart(env)
-          @env["rack.request.form_vars"] = @env["rack.input"].read
-          @env["rack.request.form_hash"] = Utils.parse_query(@env["rack.request.form_vars"])
-          @env["rack.input"].rewind if @env["rack.input"].respond_to?(:rewind)
+          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.input"].rewind
         end
         @env["rack.request.form_hash"]
       else
@@ -188,11 +222,13 @@ module Rack
 
       url
     end
-
+    
+    def path
+      script_name + path_info
+    end
+    
     def fullpath
-      path = script_name + path_info
-      path << "?" << query_string  unless query_string.empty?
-      path
+      query_string.empty? ? path : "#{path}?#{query_string}"
     end
 
     def accept_encoding

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

@@ -16,6 +16,8 @@ module Rack
   # Your application's +call+ should end returning Response#finish.
 
   class Response
+    attr_accessor :length
+
     def initialize(body=[], status=200, header={}, &block)
       @status = status
       @header = Utils::HeaderHash.new({"Content-Type" => "text/html"}.
@@ -61,12 +63,13 @@ module Rack
         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}"
+        "#{domain}#{path}#{expires}#{secure}#{httponly}"
 
       case self["Set-Cookie"]
       when Array
@@ -92,6 +95,10 @@ module Rack
                    :expires => Time.at(0) }.merge(value))
     end
 
+    def redirect(target, status=302)
+      self.status = status
+      self["Location"] = target
+    end
 
     def finish(&block)
       @block = block
@@ -100,7 +107,6 @@ module Rack
         header.delete "Content-Type"
         [status.to_i, header.to_hash, []]
       else
-        header["Content-Length"] ||= @length.to_s
         [status.to_i, header.to_hash, self]
       end
     end
@@ -112,10 +118,16 @@ module Rack
       @block.call(self)  if @block
     end
 
+    # Append to body and update Content-Length.
+    #
+    # NOTE: Do not mix #write and direct #body access!
+    #
     def write(str)
       s = str.to_s
-      @length += s.size
+      @length += Rack::Utils.bytesize(s)
       @writer.call s
+
+      header["Content-Length"] = @length.to_s
       str
     end
 

data/vendor/rack-1.0.0-git/lib/rack/rewindable_input.rb

@@ -0,0 +1,98 @@
+require 'tempfile'
+
+module Rack
+  # Class which can make any IO object rewindable, including non-rewindable ones. It does
+  # this by buffering the data into a tempfile, which is rewindable.
+  #
+  # rack.input is required to be rewindable, so if your input stream IO is non-rewindable
+  # by nature (e.g. a pipe or a socket) then you can wrap it in an object of this class
+  # to easily make it rewindable.
+  #
+  # Don't forget to call #close when you're done. This frees up temporary resources that
+  # RewindableInput uses, though it does *not* close the original IO object.
+  class RewindableInput
+    def initialize(io)
+      @io = io
+      @rewindable_io = nil
+      @unlinked = false
+    end
+    
+    def gets
+      make_rewindable unless @rewindable_io
+      @rewindable_io.gets
+    end
+    
+    def read(*args)
+      make_rewindable unless @rewindable_io
+      @rewindable_io.read(*args)
+    end
+    
+    def each(&block)
+      make_rewindable unless @rewindable_io
+      @rewindable_io.each(&block)
+    end
+    
+    def rewind
+      make_rewindable unless @rewindable_io
+      @rewindable_io.rewind
+    end
+    
+    # Closes this RewindableInput object without closing the originally
+    # wrapped IO oject. Cleans up any temporary resources that this RewindableInput
+    # has created.
+    #
+    # This method may be called multiple times. It does nothing on subsequent calls.
+    def close
+      if @rewindable_io
+        if @unlinked
+          @rewindable_io.close
+        else
+          @rewindable_io.close!
+        end
+        @rewindable_io = nil
+      end
+    end
+    
+    private
+    
+    # Ruby's Tempfile class has a bug. Subclass it and fix it.
+    class Tempfile < ::Tempfile
+      def _close
+        @tmpfile.close if @tmpfile
+        @data[1] = nil if @data
+        @tmpfile = nil
+      end
+    end
+
+    def make_rewindable
+      # Buffer all data into a tempfile. Since this tempfile is private to this
+      # RewindableInput object, we chmod it so that nobody else can read or write
+      # it. On POSIX filesystems we also unlink the file so that it doesn't
+      # even have a file entry on the filesystem anymore, though we can still
+      # access it because we have the file handle open.
+      @rewindable_io = Tempfile.new('RackRewindableInput')
+      @rewindable_io.chmod(0000)
+      if filesystem_has_posix_semantics?
+        @rewindable_io.unlink
+        @unlinked = true
+      end
+      
+      buffer = ""
+      while @io.read(1024 * 4, buffer)
+        entire_buffer_written_out = false
+        while !entire_buffer_written_out
+          written = @rewindable_io.write(buffer)
+          entire_buffer_written_out = written == buffer.size
+          if !entire_buffer_written_out
+            buffer.slice!(0 .. written - 1)
+          end
+        end
+      end
+      @rewindable_io.rewind
+    end
+    
+    def filesystem_has_posix_semantics?
+      RUBY_PLATFORM !~ /(mswin|mingw|cygwin|java)/
+    end
+  end
+end