rack 1.2.8 → 1.3.0.beta

data/lib/rack/builder.rb

@@ -4,14 +4,17 @@ module Rack
   #
   # Example:
   #
-  #  app = Rack::Builder.new {
+  #  require 'rack/lobster'
+  #  app = Rack::Builder.new do
   #    use Rack::CommonLogger
   #    use Rack::ShowExceptions
   #    map "/lobster" do
   #      use Rack::Lint
   #      run Rack::Lobster.new
   #    end
-  #  }
+  #  end
+  #
+  #  run app
   #
   # Or
   #
@@ -20,6 +23,8 @@ module Rack
   #    lambda { |env| [200, {'Content-Type' => 'text/plain'}, 'OK'] }
   #  end
   #
+  #  run app
+  #
   # +use+ adds a middleware to the stack, +run+ dispatches to an application.
   # You can use +map+ to construct a Rack::URLMap in a convenient way.
 
@@ -32,7 +37,7 @@ module Rack
           options = opts.parse! $1.split(/\s+/)
         end
         cfgfile.sub!(/^__END__\n.*/, '')
-        app = eval "Rack::Builder.new {( " + cfgfile + "\n )}.to_app",
+        app = eval "Rack::Builder.new {\n" + cfgfile + "\n}.to_app",
           TOPLEVEL_BINDING, config
       else
         require config
@@ -50,14 +55,66 @@ module Rack
       self.new(&block).to_app
     end
 
+    # Specifies a middleware to use in a stack.
+    #
+    #   class Middleware
+    #     def initialize(app)
+    #       @app = app
+    #     end
+    #
+    #     def call(env)
+    #       env["rack.some_header"] = "setting an example"
+    #       @app.call(env)
+    #     end
+    #   end
+    #
+    #   use Middleware
+    #   run lambda { |env| [200, { "Content-Type => "text/plain" }, ["OK"]] }
+    #
+    # All requests through to this application will first be processed by the middleware class.
+    # The +call+ method in this example sets an additional environment key which then can be
+    # referenced in the application if required.
     def use(middleware, *args, &block)
       @ins << lambda { |app| middleware.new(app, *args, &block) }
     end
 
+    # Takes an argument that is an object that responds to #call and returns a Rack response.
+    # The simplest form of this is a lambda object:
+    #
+    #   run lambda { |env| [200, { "Content-Type" => "text/plain" }, ["OK"]] }
+    #
+    # However this could also be a class:
+    #
+    #   class Heartbeat
+    #     def self.call(env)
+    #      [200, { "Content-Type" => "text/plain" }, ["OK"]]
+    #    end
+    #   end
+    #
+    #   run Heartbeat
     def run(app)
       @ins << app #lambda { |nothing| app }
     end
 
+    # Creates a route within the application.
+    #
+    #   Rack::Builder.app do
+    #     map '/' do
+    #       run Heartbeat
+    #     end
+    #   end
+    #
+    # The +use+ method can also be used here to specify middleware to run under a specific path:
+    #
+    #   Rack::Builder.app do
+    #     map '/' do
+    #       use Middleware
+    #       run Heartbeat
+    #     end
+    #   end
+    #
+    # This example includes a piece of middleware which will run before requests hit +Heartbeat+. 
+    #
     def map(path, &block)
       if @ins.last.kind_of? Hash
         @ins.last[path] = self.class.new(&block).to_app

data/lib/rack/chunked.rb

@@ -7,6 +7,32 @@ module Rack
   class Chunked
     include Rack::Utils
 
+    # A body wrapper that emits chunked responses
+    class Body
+      TERM = "\r\n"
+      TAIL = "0#{TERM}#{TERM}"
+
+      include Rack::Utils
+
+      def initialize(body)
+        @body = body
+      end
+
+      def each
+        term = TERM
+        @body.each do |chunk|
+          size = bytesize(chunk)
+          next if size == 0
+          yield [size.to_s(16), term, chunk, term].join
+        end
+        yield TAIL
+      end
+
+      def close
+        @body.close if @body.respond_to?(:close)
+      end
+    end
+
     def initialize(app)
       @app = app
     end
@@ -21,29 +47,10 @@ module Rack
          headers['Transfer-Encoding']
         [status, headers, 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, 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
+        headers.delete('Content-Length')
+        headers['Transfer-Encoding'] = 'chunked'
+        [status, headers, Body.new(body)]
       end
-      yield ["0", term, "", term].join
-    end
-
-    def close
-      @body.close if @body.respond_to?(:close)
     end
   end
 end

data/lib/rack/conditionalget.rb

@@ -20,28 +20,47 @@ module Rack
     end
 
     def call(env)
-      return @app.call(env) unless %w[GET HEAD].include?(env['REQUEST_METHOD'])
-
-      status, headers, body = @app.call(env)
-      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 = []
+      case env['REQUEST_METHOD']
+      when "GET", "HEAD"
+        status, headers, body = @app.call(env)
+        headers = Utils::HeaderHash.new(headers)
+        if status == 200 && fresh?(env, headers)
+          status = 304
+          headers.delete('Content-Type')
+          headers.delete('Content-Length')
+          body = []
+        end
+        [status, headers, body]
+      else
+        @app.call(env)
       end
-      [status, headers, body]
     end
 
   private
-    def etag_matches?(env, headers)
-      etag = headers['Etag'] and etag == env['HTTP_IF_NONE_MATCH']
+
+    def fresh?(env, headers)
+      modified_since = env['HTTP_IF_MODIFIED_SINCE']
+      none_match     = env['HTTP_IF_NONE_MATCH']
+
+      return false unless modified_since || none_match
+
+      success = true
+      success &&= modified_since?(to_rfc2822(modified_since), headers) if modified_since
+      success &&= etag_matches?(none_match, headers) if none_match
+      success
     end
 
-    def modified_since?(env, headers)
-      last_modified = headers['Last-Modified'] and
-        last_modified == env['HTTP_IF_MODIFIED_SINCE']
+    def etag_matches?(none_match, headers)
+      etag = headers['ETag'] and etag == none_match
     end
-  end
 
+    def modified_since?(modified_since, headers)
+      last_modified = to_rfc2822(headers['Last-Modified']) and
+        modified_since >= last_modified
+    end
+
+    def to_rfc2822(since)
+      Time.rfc2822(since) rescue nil
+    end
+  end
 end

data/lib/rack/content_length.rb

@@ -16,10 +16,10 @@ module Rack
       if !STATUS_WITH_NO_ENTITY_BODY.include?(status.to_i) &&
          !headers['Content-Length'] &&
          !headers['Transfer-Encoding'] &&
-         (body.respond_to?(:to_ary) || body.respond_to?(:to_str))
+         body.respond_to?(:to_ary)
 
-        body = [body] if body.respond_to?(:to_str) # rack 0.4 compat
-        length = body.to_ary.inject(0) { |len, part| len + bytesize(part) }
+        length = 0
+        body.each { |part| length += bytesize(part) }
         headers['Content-Length'] = length.to_s
       end
 

data/lib/rack/deflater.rb

@@ -60,7 +60,10 @@ module Rack
         @writer = block
         gzip  =::Zlib::GzipWriter.new(self)
         gzip.mtime = @mtime
-        @body.each { |part| gzip.write(part) }
+        @body.each { |part|
+          gzip.write(part)
+          gzip.flush
+        }
         @body.close if @body.respond_to?(:close)
         gzip.close
         @writer = nil
@@ -86,7 +89,7 @@ module Rack
 
       def each
         deflater = ::Zlib::Deflate.new(*DEFLATE_ARGS)
-        @body.each { |part| yield deflater.deflate(part) }
+        @body.each { |part| yield deflater.deflate(part, Zlib::SYNC_FLUSH) }
         @body.close if @body.respond_to?(:close)
         yield deflater.finish
         nil

data/lib/rack/etag.rb

@@ -1,32 +1,60 @@
 require 'digest/md5'
 
 module Rack
-  # Automatically sets the ETag header on all String bodies
+  # Automatically sets the ETag header on all String bodies.
+  #
+  # The ETag header is skipped if ETag or Last-Modified headers are sent or if
+  # a sendfile body (body.responds_to :to_path) is given (since such cases
+  # should be handled by apache/nginx).
+  #
+  # On initialization, you can pass two parameters: a Cache-Control directive
+  # used when Etag is absent and a directive when it is present. The first
+  # defaults to nil, while the second defaults to "max-age=0, privaute, must-revalidate"
   class ETag
-    def initialize(app)
+    DEFAULT_CACHE_CONTROL = "max-age=0, private, must-revalidate".freeze
+
+    def initialize(app, no_cache_control = nil, cache_control = DEFAULT_CACHE_CONTROL)
       @app = app
+      @cache_control = cache_control
+      @no_cache_control = no_cache_control
     end
 
     def call(env)
       status, headers, body = @app.call(env)
 
-      if !headers.has_key?('ETag')
+      if etag_status?(status) && etag_body?(body) && !skip_caching?(headers)
         digest, body = digest_body(body)
-        headers['ETag'] = %("#{digest}")
+        headers['ETag'] = %("#{digest}") if digest
+      end
+
+      unless headers['Cache-Control']
+        headers['Cache-Control'] = digest ? @cache_control : @no_cache_control
       end
 
       [status, headers, body]
     end
 
     private
+
+      def etag_status?(status)
+        status == 200 || status == 201
+      end
+
+      def etag_body?(body)
+        !body.respond_to?(:to_path)
+      end
+
+      def skip_caching?(headers)
+        headers['Cache-Control'] == 'no-cache' ||
+          headers.key?('ETag') || headers.key?('Last-Modified')
+      end
+
       def digest_body(body)
-        digest = Digest::MD5.new
         parts = []
-        body.each do |part|
-          digest << part
-          parts << part
-        end
-        [digest.hexdigest, parts]
+        body.each { |part| parts << part }
+        string_body = parts.join
+        digest = Digest::MD5.hexdigest(string_body) unless string_body.empty?
+        [digest, parts]
       end
   end
 end

data/lib/rack/file.rb

@@ -12,13 +12,17 @@ module Rack
   # like sendfile on the +path+.
 
   class File
+    SEPS = Regexp.union(*[::File::SEPARATOR, ::File::ALT_SEPARATOR].compact)
+
     attr_accessor :root
     attr_accessor :path
+    attr_accessor :cache_control
 
     alias :to_path :path
 
-    def initialize(root)
+    def initialize(root, cache_control = nil)
       @root = root
+      @cache_control = cache_control
     end
 
     def call(env)
@@ -29,64 +33,93 @@ module Rack
 
     def _call(env)
       @path_info = Utils.unescape(env["PATH_INFO"])
-      return forbidden  if @path_info.include? ".."
+      parts = @path_info.split SEPS
 
-      @path = F.join(@root, @path_info)
+      return fail(403, "Forbidden")  if parts.include? ".."
 
-      begin
-        if F.file?(@path) && F.readable?(@path)
-          serving
-        else
-          raise Errno::EPERM
-        end
+      @path = F.join(@root, *parts)
+
+      available = begin
+        F.file?(@path) && F.readable?(@path)
       rescue SystemCallError
-        not_found
+        false
       end
-    end
 
-    def forbidden
-      body = "Forbidden\n"
-      [403, {"Content-Type" => "text/plain",
-             "Content-Length" => body.size.to_s,
-             "X-Cascade" => "pass"},
-       [body]]
+      if available
+        serving(env)
+      else
+        fail(404, "File not found: #{@path_info}")
+      end
     end
 
-    # NOTE:
-    #   We check via File::size? whether this file provides size info
-    #   via stat (e.g. /proc files often don't), otherwise we have to
-    #   figure it out by reading the whole file into memory. And while
-    #   we're at it we also use this as body then.
+    def serving(env)
+      # NOTE:
+      #   We check via File::size? whether this file provides size info
+      #   via stat (e.g. /proc files often don't), otherwise we have to
+      #   figure it out by reading the whole file into memory.
+      size = F.size?(@path) || Utils.bytesize(F.read(@path))
 
-    def serving
-      if size = F.size?(@path)
-        body = self
+      response = [
+        200,
+        {
+          "Last-Modified"  => F.mtime(@path).httpdate,
+          "Content-Type"   => Mime.mime_type(F.extname(@path), 'text/plain')
+        },
+        self
+      ]
+      response[1].merge! 'Cache-Control' => @cache_control if @cache_control
+
+      ranges = Rack::Utils.byte_ranges(env, size)
+      if ranges.nil? || ranges.length > 1
+        # No ranges, or multiple ranges (which we don't support):
+        # TODO: Support multiple byte-ranges
+        response[0] = 200
+        @range = 0..size-1
+      elsif ranges.empty?
+        # Unsatisfiable. Return error, and file size:
+        response = fail(416, "Byte range unsatisfiable")
+        response[1]["Content-Range"] = "bytes */#{size}"
+        return response
       else
-        body = [F.read(@path)]
-        size = Utils.bytesize(body.first)
+        # Partial content:
+        @range = ranges[0]
+        response[0] = 206
+        response[1]["Content-Range"]  = "bytes #{@range.begin}-#{@range.end}/#{size}"
+        size = @range.end - @range.begin + 1
       end
 
-      [200, {
-        "Last-Modified"  => F.mtime(@path).httpdate,
-        "Content-Type"   => Mime.mime_type(F.extname(@path), 'text/plain'),
-        "Content-Length" => size.to_s
-      }, body]
-    end
-
-    def not_found
-      body = "File not found: #{@path_info}\n"
-      [404, {"Content-Type" => "text/plain",
-         "Content-Length" => body.size.to_s,
-         "X-Cascade" => "pass"},
-       [body]]
+      response[1]["Content-Length"] = size.to_s
+      response
     end
 
     def each
-      F.open(@path, "rb") { |file|
-        while part = file.read(8192)
+      F.open(@path, "rb") do |file|
+        file.seek(@range.begin)
+        remaining_len = @range.end-@range.begin+1
+        while remaining_len > 0
+          part = file.read([8192, remaining_len].min)
+          break unless part
+          remaining_len -= part.length
+
           yield part
         end
-      }
+      end
     end
+
+    private
+
+    def fail(status, body)
+      body += "\n"
+      [
+        status,
+        {
+          "Content-Type" => "text/plain",
+          "Content-Length" => body.size.to_s,
+          "X-Cascade" => "pass"
+        },
+        [body]
+      ]
+    end
+
   end
 end