rack 0.9.1 → 1.0.0

data/lib/rack/builder.rb

@@ -34,11 +34,7 @@ module Rack
     end
 
     def use(middleware, *args, &block)
-      @ins << if block_given?
-        lambda { |app| middleware.new(app, *args, &block) }
-      else
-        lambda { |app| middleware.new(app, *args) }
-      end
+      @ins << lambda { |app| middleware.new(app, *args, &block) }
     end
 
     def run(app)

data/lib/rack/chunked.rb

@@ -0,0 +1,49 @@
+require 'rack/utils'
+
+module Rack
+
+  # Middleware that applies chunked transfer encoding to response bodies
+  # when the response does not include a Content-Length header.
+  class Chunked
+    include Rack::Utils
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      status, headers, body = @app.call(env)
+      headers = HeaderHash.new(headers)
+
+      if env['HTTP_VERSION'] == 'HTTP/1.0' ||
+         STATUS_WITH_NO_ENTITY_BODY.include?(status) ||
+         headers['Content-Length'] ||
+         headers['Transfer-Encoding']
+        [status, headers.to_hash, body]
+      else
+        dup.chunk(status, headers, body)
+      end
+    end
+
+    def chunk(status, headers, body)
+      @body = body
+      headers.delete('Content-Length')
+      headers['Transfer-Encoding'] = 'chunked'
+      [status, headers.to_hash, self]
+    end
+
+    def each
+      term = "\r\n"
+      @body.each do |chunk|
+        size = bytesize(chunk)
+        next if size == 0
+        yield [size.to_s(16), term, chunk, term].join
+      end
+      yield ["0", term, "", term].join
+    end
+
+    def close
+      @body.close if @body.respond_to?(:close)
+    end
+  end
+end

data/lib/rack/conditionalget.rb

@@ -1,3 +1,5 @@
+require 'rack/utils'
+
 module Rack
 
   # Middleware that enables conditional GET using If-None-Match and
@@ -24,6 +26,8 @@ module Rack
       headers = Utils::HeaderHash.new(headers)
       if etag_matches?(env, headers) || modified_since?(env, headers)
         status = 304
+        headers.delete('Content-Type')
+        headers.delete('Content-Length')
         body = []
       end
       [status, headers, body]

data/lib/rack/content_length.rb

@@ -1,21 +1,25 @@
+require 'rack/utils'
+
 module Rack
   # Sets the Content-Length header on responses with fixed-length bodies.
   class ContentLength
+    include Rack::Utils
+
     def initialize(app)
       @app = app
     end
 
     def call(env)
       status, headers, body = @app.call(env)
-      headers = Utils::HeaderHash.new(headers)
+      headers = HeaderHash.new(headers)
 
-      if !Utils::STATUS_WITH_NO_ENTITY_BODY.include?(status) &&
+      if !STATUS_WITH_NO_ENTITY_BODY.include?(status) &&
          !headers['Content-Length'] &&
          !headers['Transfer-Encoding'] &&
          (body.respond_to?(:to_ary) || body.respond_to?(:to_str))
 
         body = [body] if body.respond_to?(:to_str) # rack 0.4 compat
-        length = body.to_ary.inject(0) { |len, part| len + part.length }
+        length = body.to_ary.inject(0) { |len, part| len + bytesize(part) }
         headers['Content-Length'] = length.to_s
       end
 

data/lib/rack/content_type.rb

@@ -0,0 +1,23 @@
+require 'rack/utils'
+
+module Rack
+
+  # Sets the Content-Type header on responses which don't have one.
+  #
+  # Builder Usage:
+  #   use Rack::ContentType, "text/plain"
+  #
+  # When no content type argument is provided, "text/html" is assumed.
+  class ContentType
+    def initialize(app, content_type = "text/html")
+      @app, @content_type = app, content_type
+    end
+
+    def call(env)
+      status, headers, body = @app.call(env)
+      headers = Utils::HeaderHash.new(headers)
+      headers['Content-Type'] ||= @content_type
+      [status, headers.to_hash, body]
+    end
+  end
+end

data/lib/rack/deflater.rb

@@ -1,87 +1,96 @@
 require "zlib"
 require "stringio"
 require "time"  # for Time.httpdate
+require 'rack/utils'
 
 module Rack
-
-class Deflater
-  def initialize(app)
-    @app = app
-  end
-
-  def call(env)
-    status, headers, body = @app.call(env)
-    headers = Utils::HeaderHash.new(headers)
-
-    # Skip compressing empty entity body responses and responses with
-    # no-transform set.
-    if Utils::STATUS_WITH_NO_ENTITY_BODY.include?(status) ||
-        headers['Cache-Control'].to_s =~ /\bno-transform\b/
-      return [status, headers, body]
+  class Deflater
+    def initialize(app)
+      @app = app
     end
 
-    request = Request.new(env)
-
-    encoding = Utils.select_best_encoding(%w(gzip deflate identity),
-                                          request.accept_encoding)
-
-    # Set the Vary HTTP header.
-    vary = headers["Vary"].to_s.split(",").map { |v| v.strip }
-    unless vary.include?("*") || vary.include?("Accept-Encoding")
-      headers["Vary"] = vary.push("Accept-Encoding").join(",")
+    def call(env)
+      status, headers, body = @app.call(env)
+      headers = Utils::HeaderHash.new(headers)
+
+      # Skip compressing empty entity body responses and responses with
+      # no-transform set.
+      if Utils::STATUS_WITH_NO_ENTITY_BODY.include?(status) ||
+          headers['Cache-Control'].to_s =~ /\bno-transform\b/
+        return [status, headers, body]
+      end
+
+      request = Request.new(env)
+
+      encoding = Utils.select_best_encoding(%w(gzip deflate identity),
+                                            request.accept_encoding)
+
+      # Set the Vary HTTP header.
+      vary = headers["Vary"].to_s.split(",").map { |v| v.strip }
+      unless vary.include?("*") || vary.include?("Accept-Encoding")
+        headers["Vary"] = vary.push("Accept-Encoding").join(",")
+      end
+
+      case encoding
+      when "gzip"
+        headers['Content-Encoding'] = "gzip"
+        headers.delete('Content-Length')
+        mtime = headers.key?("Last-Modified") ?
+          Time.httpdate(headers["Last-Modified"]) : Time.now
+        [status, headers, GzipStream.new(body, mtime)]
+      when "deflate"
+        headers['Content-Encoding'] = "deflate"
+        headers.delete('Content-Length')
+        [status, headers, DeflateStream.new(body)]
+      when "identity"
+        [status, headers, body]
+      when nil
+        message = "An acceptable encoding for the requested resource #{request.fullpath} could not be found."
+        [406, {"Content-Type" => "text/plain", "Content-Length" => message.length.to_s}, [message]]
+      end
     end
 
-    case encoding
-    when "gzip"
-      mtime = if headers.key?("Last-Modified") 
-                Time.httpdate(headers["Last-Modified"]) 
-              else 
-                Time.now
-              end
-      [status,
-       headers.merge("Content-Encoding" => "gzip"),
-       self.class.gzip(body, mtime)]
-    when "deflate"
-      [status,
-       headers.merge("Content-Encoding" => "deflate"),
-       self.class.deflate(body)]
-    when "identity"
-      [status, headers, body]
-    when nil
-      message = ["An acceptable encoding for the requested resource #{request.fullpath} could not be found."]
-      [406, {"Content-Type" => "text/plain"}, message]
+    class GzipStream
+      def initialize(body, mtime)
+        @body = body
+        @mtime = mtime
+      end
+
+      def each(&block)
+        @writer = block
+        gzip  =::Zlib::GzipWriter.new(self)
+        gzip.mtime = @mtime
+        @body.each { |part| gzip << part }
+        @body.close if @body.respond_to?(:close)
+        gzip.close
+        @writer = nil
+      end
+
+      def write(data)
+        @writer.call(data)
+      end
     end
-  end
-
-  def self.gzip(body, mtime)
-    io = StringIO.new
-    gzip = Zlib::GzipWriter.new(io)
-    gzip.mtime = mtime
-
-    # TODO: Add streaming
-    body.each { |part| gzip << part }
 
-    gzip.close
-    return io.string
-  end
-
-  DEFLATE_ARGS = [
-    Zlib::DEFAULT_COMPRESSION,
-    # drop the zlib header which causes both Safari and IE to choke
-   -Zlib::MAX_WBITS,
-    Zlib::DEF_MEM_LEVEL,
-    Zlib::DEFAULT_STRATEGY
-  ]
-
-  # Loosely based on Mongrel's Deflate handler
-  def self.deflate(body)
-    deflater = Zlib::Deflate.new(*DEFLATE_ARGS)
-
-    # TODO: Add streaming
-    body.each { |part| deflater << part }
-
-    return deflater.finish
+    class DeflateStream
+      DEFLATE_ARGS = [
+        Zlib::DEFAULT_COMPRESSION,
+        # drop the zlib header which causes both Safari and IE to choke
+        -Zlib::MAX_WBITS,
+        Zlib::DEF_MEM_LEVEL,
+        Zlib::DEFAULT_STRATEGY
+      ]
+
+      def initialize(body)
+        @body = body
+      end
+
+      def each
+        deflater = ::Zlib::Deflate.new(*DEFLATE_ARGS)
+        @body.each { |part| yield deflater.deflate(part) }
+        @body.close if @body.respond_to?(:close)
+        yield deflater.finish
+        nil
+      end
+    end
   end
 end
-
-end

data/lib/rack/directory.rb

@@ -1,4 +1,5 @@
 require 'time'
+require 'rack/utils'
 require 'rack/mime'
 
 module Rack
@@ -69,7 +70,7 @@ table { width:100%%; }
       return unless @path_info.include? ".."
 
       body = "Forbidden\n"
-      size = body.respond_to?(:bytesize) ? body.bytesize : body.size
+      size = Rack::Utils.bytesize(body)
       return [403, {"Content-Type" => "text/plain","Content-Length" => size.to_s}, [body]]
     end
 
@@ -88,6 +89,8 @@ table { width:100%%; }
         type = stat.directory? ? 'directory' : Mime.mime_type(ext)
         size = stat.directory? ? '-' : filesize_format(size)
         mtime = stat.mtime.httpdate
+        url << '/'  if stat.directory?
+        basename << '/'  if stat.directory?
 
         @files << [ url, basename, size, type, mtime ]
       end
@@ -119,7 +122,7 @@ table { width:100%%; }
 
     def entity_not_found
       body = "Entity not found: #{@path_info}\n"
-      size = body.respond_to?(:bytesize) ? body.bytesize : body.size
+      size = Rack::Utils.bytesize(body)
       return [404, {"Content-Type" => "text/plain", "Content-Length" => size.to_s}, [body]]
     end
 

data/lib/rack/file.rb

@@ -1,4 +1,5 @@
 require 'time'
+require 'rack/utils'
 require 'rack/mime'
 
 module Rack
@@ -12,6 +13,8 @@ module Rack
     attr_accessor :root
     attr_accessor :path
 
+    alias :to_path :path
+
     def initialize(root)
       @root = root
     end
@@ -57,7 +60,7 @@ module Rack
         body = self
       else
         body = [F.read(@path)]
-        size = body.first.size
+        size = Utils.bytesize(body.first)
       end
 
       [200, {

data/lib/rack/handler.rb

@@ -10,16 +10,37 @@ module Rack
   module Handler
     def self.get(server)
       return unless server
+      server = server.to_s
 
       if klass = @handlers[server]
         obj = Object
         klass.split("::").each { |x| obj = obj.const_get(x) }
         obj
       else
-        Rack::Handler.const_get(server.capitalize)
+        try_require('rack/handler', server)
+        const_get(server)
       end
     end
 
+    # Transforms server-name constants to their canonical form as filenames,
+    # then tries to require them but silences the LoadError if not found
+    #
+    # Naming convention:
+    #
+    #   Foo # => 'foo'
+    #   FooBar # => 'foo_bar.rb'
+    #   FooBAR # => 'foobar.rb'
+    #   FOObar # => 'foobar.rb'
+    #   FOOBAR # => 'foobar.rb'
+    #   FooBarBaz # => 'foo_bar_baz.rb'
+    def self.try_require(prefix, const_name)
+      file = const_name.gsub(/^[A-Z]+/) { |pre| pre.downcase }.
+        gsub(/[A-Z]+[^A-Z]/, '_\&').downcase
+
+      require(::File.join(prefix, file))
+    rescue LoadError
+    end
+
     def self.register(server, klass)
       @handlers ||= {}
       @handlers[server] = klass

data/lib/rack/handler/cgi.rb

@@ -1,3 +1,5 @@
+require 'rack/content_length'
+
 module Rack
   module Handler
     class CGI
@@ -6,14 +8,16 @@ module Rack
       end
 
       def self.serve(app)
+        app = 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" => $stdin,
+                     "rack.errors" => $stderr,
 
                      "rack.multithread" => false,
                      "rack.multiprocess" => true,
@@ -38,7 +42,7 @@ module Rack
       def self.send_headers(status, headers)
         STDOUT.print "Status: #{status}\r\n"
         headers.each { |k, vs|
-          vs.each { |v|
+          vs.split("\n").each { |v|
             STDOUT.print "#{k}: #{v}\r\n"
           }
         }

data/lib/rack/handler/fastcgi.rb

@@ -1,5 +1,17 @@
 require 'fcgi'
 require 'socket'
+require 'rack/content_length'
+require 'rack/rewindable_input'
+
+class FCGI::Stream
+  alias _rack_read_without_buffer read
+
+  def read(n, buffer=nil)
+    buf = _rack_read_without_buffer n
+    buffer.replace(buf.to_s)  if buffer
+    buf
+  end
+end
 
 module Rack
   module Handler
@@ -12,32 +24,18 @@ module Rack
         }
       end
 
-      module ProperStream       # :nodoc:
-        def each                # This is missing by default.
-          while line = gets
-            yield line
-          end
-        end
-
-        def read(*args)
-          if args.empty?
-            super || ""           # Empty string on EOF.
-          else
-            super
-          end
-        end
-      end
-
       def self.serve(request, app)
+        app = Rack::ContentLength.new(app)
+
         env = request.env
         env.delete "HTTP_CONTENT_LENGTH"
 
-        request.in.extend ProperStream
-
         env["SCRIPT_NAME"] = ""  if env["SCRIPT_NAME"] == "/"
+        
+        rack_input = RewindableInput.new(request.in)
 
         env.update({"rack.version" => [0,1],
-                     "rack.input" => request.in,
+                     "rack.input" => rack_input,
                      "rack.errors" => request.err,
 
                      "rack.multithread" => false,
@@ -54,12 +52,16 @@ module Rack
         env.delete "CONTENT_TYPE"  if env["CONTENT_TYPE"] == ""
         env.delete "CONTENT_LENGTH"  if env["CONTENT_LENGTH"] == ""
 
-        status, headers, body = app.call(env)
         begin
-          send_headers request.out, status, headers
-          send_body request.out, body
+          status, headers, body = app.call(env)
+          begin
+            send_headers request.out, status, headers
+            send_body request.out, body
+          ensure
+            body.close  if body.respond_to? :close
+          end
         ensure
-          body.close  if body.respond_to? :close
+          rack_input.close
           request.finish
         end
       end
@@ -67,7 +69,7 @@ module Rack
       def self.send_headers(out, status, headers)
         out.print "Status: #{status}\r\n"
         headers.each { |k, vs|
-          vs.each { |v|
+          vs.split("\n").each { |v|
             out.print "#{k}: #{v}\r\n"
           }
         }