rack 1.6.13 → 2.0.0.alpha

data/lib/rack/response.rb

@@ -1,6 +1,7 @@
 require 'rack/request'
 require 'rack/utils'
 require 'rack/body_proxy'
+require 'rack/media_type'
 require 'time'
 
 module Rack
@@ -8,7 +9,7 @@ module Rack
   # response.
   #
   # It allows setting of headers and cookies, and provides useful
-  # defaults (a OK response containing HTML).
+  # defaults (an OK response with empty headers and body).
   #
   # You can use Response#write to iteratively generate your response,
   # but note that this is buffered by Rack::Response until you call
@@ -18,15 +19,16 @@ module Rack
   # Your application's +call+ should end returning Response#finish.
 
   class Response
-    attr_accessor :length
+    attr_accessor :length, :status, :body
+    attr_reader :header
+    alias headers header
 
     CHUNKED = 'chunked'.freeze
-    TRANSFER_ENCODING = 'Transfer-Encoding'.freeze
+
     def initialize(body=[], status=200, header={})
       @status = status.to_i
       @header = Utils::HeaderHash.new.merge(header)
 
-      @chunked = CHUNKED == @header[TRANSFER_ENCODING]
       @writer  = lambda { |x| @body << x }
       @block   = nil
       @length  = 0
@@ -46,36 +48,21 @@ module Rack
       yield self  if block_given?
     end
 
-    attr_reader :header
-    attr_accessor :status, :body
-
-    def [](key)
-      header[key]
-    end
-
-    def []=(key, value)
-      header[key] = value
-    end
-
-    def set_cookie(key, value)
-      Utils.set_cookie_header!(header, key, value)
-    end
-
-    def delete_cookie(key, value={})
-      Utils.delete_cookie_header!(header, key, value)
-    end
-
     def redirect(target, status=302)
       self.status = status
-      self["Location"] = target
+      self.location = target
+    end
+
+    def chunked?
+      CHUNKED == get_header(TRANSFER_ENCODING)
     end
 
     def finish(&block)
       @block = block
 
       if [204, 205, 304].include?(status.to_i)
-        header.delete CONTENT_TYPE
-        header.delete CONTENT_LENGTH
+        delete_header CONTENT_TYPE
+        delete_header CONTENT_LENGTH
         close
         [status.to_i, header, []]
       else
@@ -97,10 +84,10 @@ module Rack
     #
     def write(str)
       s = str.to_s
-      @length += Rack::Utils.bytesize(s) unless @chunked
+      @length += s.bytesize unless chunked?
       @writer.call s
 
-      header[CONTENT_LENGTH] = @length.to_s unless @chunked
+      set_header(CONTENT_LENGTH, @length.to_s) unless chunked?
       str
     end
 
@@ -112,51 +99,137 @@ module Rack
       @block == nil && @body.empty?
     end
 
-    alias headers header
+    def has_header?(key);   headers.key? key;   end
+    def get_header(key);    headers[key];       end
+    def set_header(key, v); headers[key] = v;   end
+    def delete_header(key); headers.delete key; end
+
+    alias :[] :get_header
+    alias :[]= :set_header
 
     module Helpers
-      def invalid?;            status < 100 || status >= 600;        end
-
-      def informational?;      status >= 100 && status < 200;        end
-      def successful?;         status >= 200 && status < 300;        end
-      def redirection?;        status >= 300 && status < 400;        end
-      def client_error?;       status >= 400 && status < 500;        end
-      def server_error?;       status >= 500 && status < 600;        end
-
-      def ok?;                 status == 200;                        end
-      def created?;            status == 201;                        end
-      def accepted?;           status == 202;                        end
-      def bad_request?;        status == 400;                        end
-      def unauthorized?;       status == 401;                        end
-      def forbidden?;          status == 403;                        end
-      def not_found?;          status == 404;                        end
-      def method_not_allowed?; status == 405;                        end
-      def i_m_a_teapot?;       status == 418;                        end
-      def unprocessable?;      status == 422;                        end
-
-      def redirect?;           [301, 302, 303, 307].include? status; end
-
-      # Headers
-      attr_reader :headers, :original_headers
+      def invalid?;             status < 100 || status >= 600;        end
+
+      def informational?;       status >= 100 && status < 200;        end
+      def successful?;          status >= 200 && status < 300;        end
+      def redirection?;         status >= 300 && status < 400;        end
+      def client_error?;        status >= 400 && status < 500;        end
+      def server_error?;        status >= 500 && status < 600;        end
+
+      def ok?;                  status == 200;                        end
+      def created?;             status == 201;                        end
+      def accepted?;            status == 202;                        end
+      def no_content?;          status == 204;                        end
+      def moved_permanently?;   status == 301;                        end
+      def bad_request?;         status == 400;                        end
+      def unauthorized?;        status == 401;                        end
+      def forbidden?;           status == 403;                        end
+      def not_found?;           status == 404;                        end
+      def method_not_allowed?;  status == 405;                        end
+      def precondition_failed?; status == 412;                        end
+      def unprocessable?;       status == 422;                        end
+
+      def redirect?;            [301, 302, 303, 307, 308].include? status; end
 
       def include?(header)
-        !!headers[header]
+        has_header? header
+      end
+
+      # Add a header that may have multiple values.
+      #
+      # Example:
+      #   response.add_header 'Vary', 'Accept-Encoding'
+      #   response.add_header 'Vary', 'Cookie'
+      #
+      #   assert_equal 'Accept-Encoding,Cookie', response.get_header('Vary')
+      #
+      # http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.2
+      def add_header key, v
+        if v.nil?
+          get_header key
+        elsif has_header? key
+          set_header key, "#{get_header key},#{v}"
+        else
+          set_header key, v
+        end
       end
 
       def content_type
-        headers[CONTENT_TYPE]
+        get_header CONTENT_TYPE
+      end
+
+      def media_type
+        MediaType.type(content_type)
+      end
+
+      def media_type_params
+        MediaType.params(content_type)
       end
 
       def content_length
-        cl = headers[CONTENT_LENGTH]
+        cl = get_header CONTENT_LENGTH
         cl ? cl.to_i : cl
       end
 
       def location
-        headers["Location"]
+        get_header "Location"
+      end
+
+      def location=(location)
+        set_header "Location", location
+      end
+
+      def set_cookie(key, value)
+        cookie_header = get_header SET_COOKIE
+        set_header SET_COOKIE, ::Rack::Utils.add_cookie_to_header(cookie_header, key, value)
+      end
+
+      def delete_cookie(key, value={})
+        set_header SET_COOKIE, ::Rack::Utils.add_remove_cookie_to_header(get_header(SET_COOKIE), key, value)
+      end
+
+      def set_cookie_header
+        get_header SET_COOKIE
+      end
+
+      def set_cookie_header= v
+        set_header SET_COOKIE, v
+      end
+
+      def cache_control
+        get_header CACHE_CONTROL
+      end
+
+      def cache_control= v
+        set_header CACHE_CONTROL, v
+      end
+
+      def etag
+        get_header ETAG
+      end
+
+      def etag= v
+        set_header ETAG, v
       end
     end
 
     include Helpers
+
+    class Raw
+      include Helpers
+
+      attr_reader :headers
+      attr_accessor :status
+
+      def initialize status, headers
+        @status = status
+        @headers = headers
+      end
+
+      def has_header?(key);   headers.key? key;   end
+      def get_header(key);    headers[key];       end
+      def set_header(key, v); headers[key] = v;   end
+      def delete_header(key); headers.delete key; end
+    end
   end
 end

data/lib/rack/rewindable_input.rb

@@ -57,15 +57,6 @@ module Rack
 
     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
@@ -77,8 +68,6 @@ module Rack
       @rewindable_io.set_encoding(Encoding::BINARY) if @rewindable_io.respond_to?(:set_encoding)
       @rewindable_io.binmode
       if filesystem_has_posix_semantics?
-        # Use ::File.unlink as 1.9.1 Tempfile has a bug where unlink closes the file!
-        ::File.unlink @rewindable_io.path
         raise 'Unlink failed. IO closed.' if @rewindable_io.closed?
         @unlinked = true
       end
@@ -88,7 +77,7 @@ module Rack
         entire_buffer_written_out = false
         while !entire_buffer_written_out
           written = @rewindable_io.write(buffer)
-          entire_buffer_written_out = written == Rack::Utils.bytesize(buffer)
+          entire_buffer_written_out = written == buffer.bytesize
           if !entire_buffer_written_out
             buffer.slice!(0 .. written - 1)
           end

data/lib/rack/runtime.rb

@@ -1,3 +1,5 @@
+require 'rack/utils'
+
 module Rack
   # Sets an "X-Runtime" response header, indicating the response
   # time of the request, in seconds
@@ -6,35 +8,25 @@ module Rack
   # time, or before all the other middlewares to include time for them,
   # too.
   class Runtime
+    FORMAT_STRING = "%0.6f".freeze # :nodoc:
+    HEADER_NAME = "X-Runtime".freeze # :nodoc:
+
     def initialize(app, name = nil)
       @app = app
-      @header_name = "X-Runtime"
-      @header_name << "-#{name}" if name
+      @header_name = HEADER_NAME
+      @header_name += "-#{name}" if name
     end
 
-    FORMAT_STRING = "%0.6f"
     def call(env)
-      start_time = clock_time
+      start_time = Utils.clock_time
       status, headers, body = @app.call(env)
-      request_time = clock_time - start_time
+      request_time = Utils.clock_time - start_time
 
-      if !headers.has_key?(@header_name)
+      unless headers.has_key?(@header_name)
         headers[@header_name] = FORMAT_STRING % request_time
       end
 
       [status, headers, body]
     end
-
-    private
-
-    if defined?(Process::CLOCK_MONOTONIC)
-      def clock_time
-        Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-    else
-      def clock_time
-        Time.now.to_f
-      end
-    end
   end
 end

data/lib/rack/sendfile.rb

@@ -99,8 +99,6 @@ module Rack
   # will be matched with case indifference.
 
   class Sendfile
-    F = ::File
-
     def initialize(app, variation=nil, mappings=[])
       @app = app
       @variation = variation
@@ -114,7 +112,7 @@ module Rack
       if body.respond_to?(:to_path)
         case type = variation(env)
         when 'X-Accel-Redirect'
-          path = F.expand_path(body.to_path)
+          path = ::File.expand_path(body.to_path)
           if url = map_accel_path(env, path)
             headers[CONTENT_LENGTH] = '0'
             headers[type] = url
@@ -123,10 +121,10 @@ module Rack
               obody.close if obody.respond_to?(:close)
             end
           else
-            env['rack.errors'].puts "X-Accel-Mapping header missing"
+            env[RACK_ERRORS].puts "X-Accel-Mapping header missing"
           end
         when 'X-Sendfile', 'X-Lighttpd-Send-File'
-          path = F.expand_path(body.to_path)
+          path = ::File.expand_path(body.to_path)
           headers[CONTENT_LENGTH] = '0'
           headers[type] = path
           obody = body
@@ -135,7 +133,7 @@ module Rack
           end
         when '', nil
         else
-          env['rack.errors'].puts "Unknown x-sendfile variation: '#{type}'.\n"
+          env[RACK_ERRORS].puts "Unknown x-sendfile variation: '#{type}'.\n"
         end
       end
       [status, headers, body]
@@ -152,7 +150,7 @@ module Rack
       if mapping = @mappings.find { |internal,_| internal =~ path }
         path.sub(*mapping)
       elsif mapping = env['HTTP_X_ACCEL_MAPPING']
-        internal, external = mapping.split('=', 2).map{ |p| p.strip }
+        internal, external = mapping.split('=', 2).map(&:strip)
         path.sub(/^#{internal}/i, external)
       end
     end

data/lib/rack/server.rb

@@ -1,5 +1,4 @@
 require 'optparse'
-require 'fileutils'
 
 
 module Rack
@@ -100,14 +99,14 @@ module Rack
           abort opt_parser.to_s
         end
 
-        options[:config] = args.last if args.last
+        options[:config] = args.last if args.last && !args.last.empty?
         options
       end
 
       def handler_opts(options)
         begin
           info = []
-          server = Rack::Handler.get(options[:server]) || Rack::Handler.default(options)
+          server = Rack::Handler.get(options[:server]) || Rack::Handler.default
           if server && server.respond_to?(:valid_options)
             info << ""
             info << "Server-specific options for #{server.name}:"
@@ -183,12 +182,22 @@ module Rack
     # * :require
     #     require the given libraries
     def initialize(options = nil)
-      @options = options
-      @app = options[:app] if options && options[:app]
+      @ignore_options = []
+
+      if options
+        @use_default_options = false
+        @options = options
+        @app = options[:app] if options[:app]
+      else
+        argv = defined?(SPEC_ARGV) ? SPEC_ARGV : ARGV
+        @use_default_options = true
+        @options = parse_options(argv)
+      end
     end
 
     def options
-      @options ||= parse_options(ARGV)
+      merged_options = @use_default_options ? default_options.merge(@options) : @options
+      merged_options.reject { |k, v| @ignore_options.include?(k) }
     end
 
     def default_options
@@ -288,7 +297,16 @@ module Rack
     end
 
     def server
-      @_server ||= Rack::Handler.get(options[:server]) || Rack::Handler.default(options)
+      @_server ||= Rack::Handler.get(options[:server])
+
+      unless @_server
+        @_server = Rack::Handler.default
+
+        # We already speak FastCGI
+        @ignore_options = [:File, :Port] if @_server.to_s == 'Rack::Handler::FastCGI'
+      end
+
+      @_server
     end
 
     private
@@ -298,7 +316,7 @@ module Rack
         end
 
         app, options = Rack::Builder.parse_file(self.options[:config], opt_parser)
-        self.options.merge! options
+        @options.merge!(options) { |key, old, new| old }
         app
       end
 
@@ -307,16 +325,14 @@ module Rack
       end
 
       def parse_options(args)
-        options = default_options
-
         # Don't evaluate CGI ISINDEX parameters.
         # http://www.meb.uni-bonn.de/docs/cgi/cl.html
         args.clear if ENV.include?(REQUEST_METHOD)
 
-        options.merge! opt_parser.parse!(args)
-        options[:config] = ::File.expand_path(options[:config])
+        @options = opt_parser.parse!(args)
+        @options[:config] = ::File.expand_path(options[:config])
         ENV["RACK_ENV"] = options[:environment]
-        options
+        @options
       end
 
       def opt_parser
@@ -338,22 +354,12 @@ module Rack
       end
 
       def daemonize_app
-        if RUBY_VERSION < "1.9"
-          exit if fork
-          Process.setsid
-          exit if fork
-          Dir.chdir "/"
-          STDIN.reopen "/dev/null"
-          STDOUT.reopen "/dev/null", "a"
-          STDERR.reopen "/dev/null", "a"
-        else
-          Process.daemon
-        end
+        Process.daemon
       end
 
       def write_pid
         ::File.open(options[:pid], ::File::CREAT | ::File::EXCL | ::File::WRONLY ){ |f| f.write("#{Process.pid}") }
-        at_exit { ::FileUtils.rm_f(options[:pid]) }
+        at_exit { ::File.delete(options[:pid]) if ::File.exist?(options[:pid]) }
       rescue Errno::EEXIST
         check_pid!
         retry