rack 1.1.6 → 1.2.0

data/lib/rack/handler/fastcgi.rb

@@ -36,7 +36,7 @@ module Rack
 
         rack_input = RewindableInput.new(request.in)
 
-        env.update({"rack.version" => [1,1],
+        env.update({"rack.version" => Rack::VERSION,
                      "rack.input" => rack_input,
                      "rack.errors" => request.err,
 

data/lib/rack/handler/lsws.rb

@@ -20,7 +20,7 @@ module Rack
         rack_input = RewindableInput.new($stdin.read.to_s)
 
         env.update(
-          "rack.version" => [1,1],
+          "rack.version" => Rack::VERSION,
           "rack.input" => rack_input,
           "rack.errors" => $stderr,
           "rack.multithread" => false,

data/lib/rack/handler/mongrel.rb

@@ -52,7 +52,7 @@ module Rack
         rack_input = request.body || StringIO.new('')
         rack_input.set_encoding(Encoding::BINARY) if rack_input.respond_to?(:set_encoding)
 
-        env.update({"rack.version" => [1,1],
+        env.update({"rack.version" => Rack::VERSION,
                      "rack.input" => rack_input,
                      "rack.errors" => $stderr,
 

data/lib/rack/handler/scgi.rb

@@ -17,9 +17,6 @@ module Rack
 
       def initialize(settings = {})
         @app = Rack::Chunked.new(Rack::ContentLength.new(settings[:app]))
-        @log = Object.new
-        def @log.info(*args); end
-        def @log.error(*args); end
         super(settings)
       end
 
@@ -36,7 +33,7 @@ module Rack
         rack_input = StringIO.new(input_body)
         rack_input.set_encoding(Encoding::BINARY) if rack_input.respond_to?(:set_encoding)
 
-        env.update({"rack.version" => [1,1],
+        env.update({"rack.version" => Rack::VERSION,
                      "rack.input" => rack_input,
                      "rack.errors" => $stderr,
                      "rack.multithread" => true,

data/lib/rack/handler/webrick.rb

@@ -7,11 +7,15 @@ module Rack
     class WEBrick < ::WEBrick::HTTPServlet::AbstractServlet
       def self.run(app, options={})
         options[:BindAddress] = options.delete(:Host) if options[:Host]
-        server = ::WEBrick::HTTPServer.new(options)
-        server.mount "/", Rack::Handler::WEBrick, app
-        trap(:INT) { server.shutdown }
-        yield server  if block_given?
-        server.start
+        @server = ::WEBrick::HTTPServer.new(options)
+        @server.mount "/", Rack::Handler::WEBrick, app
+        yield @server  if block_given?
+        @server.start
+      end
+
+      def self.shutdown
+        @server.shutdown
+        @server = nil
       end
 
       def initialize(server, app)
@@ -26,7 +30,7 @@ module Rack
         rack_input = StringIO.new(req.body.to_s)
         rack_input.set_encoding(Encoding::BINARY) if rack_input.respond_to?(:set_encoding)
 
-        env.update({"rack.version" => [1,1],
+        env.update({"rack.version" => Rack::VERSION,
                      "rack.input" => rack_input,
                      "rack.errors" => $stderr,
 

data/lib/rack/lint.rb

@@ -7,6 +7,7 @@ module Rack
   class Lint
     def initialize(app)
       @app = app
+      @content_length = nil
     end
 
     # :stopdoc:
@@ -51,15 +52,16 @@ module Rack
       check_headers headers
       ## and the *body*.
       check_content_type status, headers
-      check_content_length status, headers, env
+      check_content_length status, headers
+      @head_request = env["REQUEST_METHOD"] == "HEAD"
       [status, headers, self]
     end
 
     ## == The Environment
     def check_env(env)
-      ## The environment must be an true instance of Hash (no
-      ## subclassing allowed) that includes CGI-like headers.
-      ## The application is free to modify the environment.
+      ## The environment must be an instance of Hash that includes
+      ## CGI-like headers.  The application is free to modify the
+      ## environment.
       assert("env #{env.inspect} is not a Hash, but #{env.class}") {
         env.kind_of? Hash
       }
@@ -288,10 +290,6 @@ module Rack
         @input = input
       end
 
-      def size
-        @input.size
-      end
-
       ## * +gets+ must be called without arguments and return a string,
       ##   or +nil+ on EOF.
       def gets(*args)
@@ -481,7 +479,7 @@ module Rack
     end
 
     ## === The Content-Length
-    def check_content_length(status, headers, env)
+    def check_content_length(status, headers)
       headers.each { |key, value|
         if key.downcase == 'content-length'
           ## There must not be a <tt>Content-Length</tt> header when the
@@ -489,49 +487,43 @@ module Rack
           assert("Content-Length header found in #{status} response, not allowed") {
             not Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.include? status.to_i
           }
-
-          bytes = 0
-          string_body = true
-
-          if @body.respond_to?(:to_ary)
-            @body.each { |part|
-              unless part.kind_of?(String)
-                string_body = false
-                break
-              end
-
-              bytes += Rack::Utils.bytesize(part)
-            }
-
-            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
+          @content_length = value
         end
       }
     end
 
+    def verify_content_length(bytes)
+      if @head_request
+        assert("Response body was given for HEAD request, but should be empty") {
+          bytes == 0
+        }
+      elsif @content_length
+        assert("Content-Length header was #{@content_length}, but should be #{bytes}") {
+          @content_length == bytes.to_s
+        }
+      end
+    end
+
     ## === The Body
     def each
       @closed = false
+      bytes = 0
+
       ## The Body must respond to +each+
+      assert("Response body must respond to each") do
+        @body.respond_to?(:each)
+      end
+
       @body.each { |part|
         ## and must only yield String values.
         assert("Body yielded non-string value #{part.inspect}") {
           part.kind_of? String
         }
+        bytes += Rack::Utils.bytesize(part)
         yield part
       }
+      verify_content_length(bytes)
+
       ##
       ## The Body itself should not be an instance of String, as this will
       ## break in Ruby 1.9.

data/lib/rack/mime.rb

@@ -87,6 +87,7 @@ module Rack
       ".gif"     => "image/gif",
       ".gz"      => "application/x-gzip",
       ".h"       => "text/x-c",
+      ".htc"     => "text/x-component",
       ".hh"      => "text/x-c",
       ".htm"     => "text/html",
       ".html"    => "text/html",
@@ -186,6 +187,7 @@ module Rack
       ".vrml"    => "model/vrml",
       ".war"     => "application/java-archive",
       ".wav"     => "audio/x-wav",
+      ".webm"    => "video/webm",
       ".wma"     => "audio/x-ms-wma",
       ".wmv"     => "video/x-ms-wmv",
       ".wmx"     => "video/x-ms-wmx",

data/lib/rack/mock.rb

@@ -1,5 +1,6 @@
 require 'uri'
 require 'stringio'
+require 'rack'
 require 'rack/lint'
 require 'rack/utils'
 require 'rack/response'
@@ -40,7 +41,7 @@ module Rack
     end
 
     DEFAULT_ENV = {
-      "rack.version" => [1,1],
+      "rack.version" => Rack::VERSION,
       "rack.input" => StringIO.new,
       "rack.errors" => StringIO.new,
       "rack.multithread" => true,

data/lib/rack/recursive.rb

@@ -35,6 +35,10 @@ module Rack
     end
 
     def call(env)
+      dup._call(env)
+    end
+
+    def _call(env)
       @script_name = env["SCRIPT_NAME"]
       @app.call(env.merge('rack.recursive.include' => method(:include)))
     rescue ForwardRequest => req

data/lib/rack/request.rb

@@ -80,11 +80,13 @@ module Rack
     def script_name=(s); @env["SCRIPT_NAME"] = s.to_s             end
     def path_info=(s);   @env["PATH_INFO"] = s.to_s               end
 
-    def get?;            request_method == "GET"                  end
-    def post?;           request_method == "POST"                 end
-    def put?;            request_method == "PUT"                  end
-    def delete?;         request_method == "DELETE"               end
-    def head?;           request_method == "HEAD"                 end
+    def delete?;  request_method == "DELETE"  end
+    def get?;     request_method == "GET"     end
+    def head?;    request_method == "HEAD"    end
+    def options?; request_method == "OPTIONS" end
+    def post?;    request_method == "POST"    end
+    def put?;     request_method == "PUT"     end
+    def trace?;   request_method == "TRACE"   end
 
     # The set of form-data media-types. Requests that do not indicate
     # one of the media types presents in this list will not be eligible
@@ -253,7 +255,7 @@ module Rack
 
     def ip
       if addr = @env['HTTP_X_FORWARDED_FOR']
-        addr.split(',').last.strip
+        (addr.split(',').grep(/\d\./).first || @env['REMOTE_ADDR']).to_s.strip
       else
         @env['REMOTE_ADDR']
       end

data/lib/rack/response.rb

@@ -1,5 +1,6 @@
 require 'rack/request'
 require 'rack/utils'
+require 'time'
 
 module Rack
   # Rack::Response provides a convenient interface to create a Rack

data/lib/rack/rewindable_input.rb

@@ -1,4 +1,6 @@
+# -*- encoding: binary -*-
 require 'tempfile'
+require 'rack/utils'
 
 module Rack
   # Class which can make any IO object rewindable, including non-rewindable ones. It does
@@ -16,27 +18,27 @@ module Rack
       @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.
@@ -52,9 +54,9 @@ module Rack
         @rewindable_io = nil
       end
     end
-    
+
     private
-    
+
     # Ruby's Tempfile class has a bug. Subclass it and fix it.
     class Tempfile < ::Tempfile
       def _close
@@ -76,15 +78,16 @@ module Rack
       @rewindable_io.binmode
       if filesystem_has_posix_semantics?
         @rewindable_io.unlink
+        raise 'Unlink failed. IO closed.' if @rewindable_io.closed?
         @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
+          entire_buffer_written_out = written == Rack::Utils.bytesize(buffer)
           if !entire_buffer_written_out
             buffer.slice!(0 .. written - 1)
           end
@@ -92,7 +95,7 @@ module Rack
       end
       @rewindable_io.rewind
     end
-    
+
     def filesystem_has_posix_semantics?
       RUBY_PLATFORM !~ /(mswin|mingw|cygwin|java)/
     end

data/lib/rack/sendfile.rb

@@ -2,7 +2,9 @@ require 'rack/file'
 
 module Rack
   class File #:nodoc:
-    alias :to_path :path
+    unless instance_methods(false).include?('to_path')
+      alias :to_path :path
+    end
   end
 
   # = Sendfile
@@ -11,7 +13,7 @@ module Rack
   # 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
+  # by the Ruby backend and takes advantage of the web server's optimized file
   # delivery code.
   #
   # In order to take advantage of this middleware, the response body must
@@ -31,19 +33,19 @@ module Rack
   # 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/ {
+  #   location ~ /files/(.*) {
   #     internal;
-  #     alias /var/www/;
+  #     alias /var/www/$1;
   #   }
   #
   #   location / {
-  #     proxy_redirect     false;
+  #     proxy_redirect     off;
   #
   #     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-Sendfile-Type     X-Accel-Redirect;
   #     proxy_set_header   X-Accel-Mapping     /files/=/var/www/;
   #
   #     proxy_pass         http://127.0.0.1:8080/;

data/lib/rack/server.rb

@@ -57,7 +57,7 @@ module Rack
           }
 
           opts.on("-P", "--pid FILE", "file to store PID (default: rack.pid)") { |f|
-            options[:pid] = ::File.expand_path(f, Dir.pwd)
+            options[:pid] = f
           }
 
           opts.separator ""
@@ -79,12 +79,61 @@ module Rack
       end
     end
 
-    def self.start
-      new.start
+    # Start a new rack server (like running rackup). This will parse ARGV and
+    # provide standard ARGV rackup options, defaulting to load 'config.ru'.
+    #
+    # Providing an options hash will prevent ARGV parsing and will not include
+    # any default options.
+    #
+    # This method can be used to very easily launch a CGI application, for
+    # example:
+    #
+    #  Rack::Server.start(
+    #    :app => lambda do |e|
+    #      [200, {'Content-Type' => 'text/html'}, ['hello world']]
+    #    end,
+    #    :server => 'cgi'
+    #  )
+    #
+    # Further options available here are documented on Rack::Server#initialize
+    def self.start(options = nil)
+      new(options).start
     end
 
-    attr_accessor :options
-
+    attr_writer :options
+
+    # Options may include:
+    # * :app
+    #     a rack application to run (overrides :config)
+    # * :config
+    #     a rackup configuration file path to load (.ru)
+    # * :environment
+    #     this selects the middleware that will be wrapped around
+    #     your application. Default options available are:
+    #       - development: CommonLogger, ShowExceptions, and Lint
+    #       - deployment: CommonLogger
+    #       - none: no extra middleware
+    #     note: when the server is a cgi server, CommonLogger is not included.
+    # * :server
+    #     choose a specific Rack::Handler, e.g. cgi, fcgi, webrick
+    # * :daemonize
+    #     if true, the server will daemonize itself (fork, detach, etc)
+    # * :pid
+    #     path to write a pid file after daemonize
+    # * :Host
+    #     the host address to bind to (used by supporting Rack::Handler)
+    # * :Port
+    #     the port to bind to (used by supporting Rack::Handler)
+    # * :AccessLog
+    #     webrick acess log options (or supporting Rack::Handler)
+    # * :debug
+    #     turn on debug output ($DEBUG = true)
+    # * :warn
+    #     turn on warnings ($-w = true)
+    # * :include
+    #     add given paths to $LOAD_PATH
+    # * :require
+    #     require the given libraries
     def initialize(options = nil)
       @options = options
     end
@@ -100,7 +149,7 @@ module Rack
         :Port        => 9292,
         :Host        => "0.0.0.0",
         :AccessLog   => [],
-        :config      => ::File.expand_path("config.ru", Dir.pwd)
+        :config      => "config.ru"
       }
     end
 
@@ -119,7 +168,7 @@ module Rack
     def self.middleware
       @middleware ||= begin
         m = Hash.new {|h,k| h[k] = []}
-        m["deployment"].concat  [lambda {|server| server.server =~ /CGI/ ? nil : [Rack::CommonLogger, $stderr] }]
+        m["deployment"].concat  [lambda {|server| server.server.name =~ /CGI/ ? nil : [Rack::CommonLogger, $stderr] }]
         m["development"].concat m["deployment"] + [[Rack::ShowExceptions], [Rack::Lint]]
         m
       end
@@ -143,7 +192,7 @@ module Rack
       end
 
       if includes = options[:include]
-        $LOAD_PATH.unshift *includes
+        $LOAD_PATH.unshift(*includes)
       end
 
       if library = options[:require]
@@ -152,11 +201,20 @@ module Rack
 
       daemonize_app if options[:daemonize]
       write_pid if options[:pid]
+
+      trap(:INT) do
+        if server.respond_to?(:shutdown)
+          server.shutdown
+        else
+          exit
+        end
+      end
+
       server.run wrapped_app, options
     end
 
     def server
-      @_server ||= Rack::Handler.get(options[:server]) || Rack::Handler.default
+      @_server ||= Rack::Handler.get(options[:server]) || Rack::Handler.default(options)
     end
 
     private
@@ -168,6 +226,7 @@ module Rack
         args.clear if ENV.include?("REQUEST_METHOD")
 
         options.merge! opt_parser.parse! args
+        ENV["RACK_ENV"] = options[:environment]
         options
       end