rack 0.4.0 → 0.9.0

data/lib/rack/builder.rb

@@ -13,6 +13,13 @@ module Rack
   #    end
   #  }
   #
+  # Or
+  #
+  #  app = Rack::Builder.app do
+  #    use Rack::CommonLogger
+  #    lambda { |env| [200, {'Content-Type' => 'text/plain'}, 'OK'] }
+  #  end
+  #
   # +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.
 
@@ -22,6 +29,10 @@ module Rack
       instance_eval(&block) if block_given?
     end
 
+    def self.app(&block)
+      self.new(&block).to_app
+    end
+
     def use(middleware, *args, &block)
       @ins << if block_given?
         lambda { |app| middleware.new(app, *args, &block) }
@@ -36,7 +47,7 @@ module Rack
 
     def map(path, &block)
       if @ins.last.kind_of? Hash
-        @ins.last[path] = Rack::Builder.new(&block).to_app
+        @ins.last[path] = self.class.new(&block).to_app
       else
         @ins << {}
         map(path, &block)

data/lib/rack/conditionalget.rb

@@ -0,0 +1,43 @@
+module Rack
+
+  # Middleware that enables conditional GET using If-None-Match and
+  # If-Modified-Since. The application should set either or both of the
+  # Last-Modified or Etag response headers according to RFC 2616. When
+  # either of the conditions is met, the response body is set to be zero
+  # length and the response status is set to 304 Not Modified.
+  #
+  # Applications that defer response body generation until the body's each
+  # message is received will avoid response body generation completely when
+  # a conditional GET matches.
+  #
+  # Adapted from Michael Klishin's Merb implementation:
+  # http://github.com/wycats/merb-core/tree/master/lib/merb-core/rack/middleware/conditional_get.rb
+  class ConditionalGet
+    def initialize(app)
+      @app = app
+    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
+        body = []
+      end
+      [status, headers, body]
+    end
+
+  private
+    def etag_matches?(env, headers)
+      etag = headers['Etag'] and etag == env['HTTP_IF_NONE_MATCH']
+    end
+
+    def modified_since?(env, headers)
+      last_modified = headers['Last-Modified'] and
+        last_modified == env['HTTP_IF_MODIFIED_SINCE']
+    end
+  end
+
+end

data/lib/rack/content_length.rb

@@ -0,0 +1,25 @@
+module Rack
+  # Sets the Content-Length header on responses with fixed-length bodies.
+  class ContentLength
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      status, headers, body = @app.call(env)
+      headers = Utils::HeaderHash.new(headers)
+
+      if !Utils::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 }
+        headers['Content-Length'] = length.to_s
+      end
+
+      [status, headers, body]
+    end
+  end
+end

data/lib/rack/deflater.rb

@@ -1,5 +1,6 @@
 require "zlib"
 require "stringio"
+require "time"  # for Time.httpdate
 
 module Rack
 
@@ -10,21 +11,44 @@ class Deflater
 
   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)
+    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"
-      mtime = headers["Last-Modified"] || Time.now
-      [status, headers.merge("Content-Encoding" => "gzip"), self.class.gzip(body, mtime)]
+      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)]
+      [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."
+      message = ["An acceptable encoding for the requested resource #{request.fullpath} could not be found."]
       [406, {"Content-Type" => "text/plain"}, message]
     end
   end

data/lib/rack/directory.rb

@@ -1,4 +1,5 @@
 require 'time'
+require 'rack/mime'
 
 module Rack
   # Rack::Directory serves entries below the +root+ given, according to the
@@ -13,10 +14,13 @@ module Rack
     DIR_PAGE = <<-PAGE
 <html><head>
   <title>%s</title>
+  <meta http-equiv="content-type" content="text/html; charset=utf-8" />
   <style type='text/css'>
 table { width:100%%; }
 .name { text-align:left; }
 .size, .mtime { text-align:right; }
+.type { width:11em; }
+.mtime { width:15em; }
   </style>
 </head><body>
 <h1>%s</h1>
@@ -38,11 +42,8 @@ table { width:100%%; }
     attr_accessor :root, :path
 
     def initialize(root, app=nil)
-      @root = root
-      @app = app
-      unless defined? @app
-        @app = Rack::File.new(@root)
-      end
+      @root = F.expand_path(root)
+      @app = app || Rack::File.new(@root)
     end
 
     def call(env)
@@ -52,36 +53,71 @@ table { width:100%%; }
     F = ::File
 
     def _call(env)
-      if env["PATH_INFO"].include? ".."
-        body = "Forbidden\n"
-        size = body.respond_to?(:bytesize) ? body.bytesize : body.size
-        return [403, {"Content-Type" => "text/plain","Content-Length" => size.to_s}, [body]]
+      @env = env
+      @path_info, @script_name = env.values_at('PATH_INFO', 'SCRIPT_NAME')
+
+      if forbidden = check_forbidden
+        forbidden
+      else
+        @path = F.join(@root, Utils.unescape(@path_info))
+        list_path
+      end
+    end
+
+    def check_forbidden
+      return unless @path_info.include? ".."
+
+      body = "Forbidden\n"
+      size = body.respond_to?(:bytesize) ? body.bytesize : body.size
+      return [403, {"Content-Type" => "text/plain","Content-Length" => size.to_s}, [body]]
+    end
+
+    def list_directory
+      @files = [['../','Parent Directory','','','']]
+      glob = F.join(@path, '*')
+
+      Dir[glob].sort.each do |node|
+        stat = stat(node)
+        next  unless stat
+        basename = F.basename(node)
+        ext = F.extname(node)
+
+        url = F.join(@script_name, @path_info, basename)
+        size = stat.size
+        type = stat.directory? ? 'directory' : Mime.mime_type(ext)
+        size = stat.directory? ? '-' : filesize_format(size)
+        mtime = stat.mtime.httpdate
+
+        @files << [ url, basename, size, type, mtime ]
       end
 
-      @path = F.join(@root, Utils.unescape(env['PATH_INFO']))
-
-      if F.exist?(@path) and F.readable?(@path)
-        if F.file?(@path)
-          return @app.call(env)
-        elsif F.directory?(@path)
-          @files = [['../','Parent Directory','','','']]
-          sName, pInfo = env.values_at('SCRIPT_NAME', 'PATH_INFO')
-          Dir.entries(@path).sort.each do |file|
-            next if file[0] == ?.
-            fl    = F.join(@path, file)
-            sz    = F.size(fl)
-            url   = F.join(sName, pInfo, file)
-            type  = F.directory?(fl) ? 'directory' :
-              MIME_TYPES.fetch(F.extname(file)[1..-1],'unknown')
-            size  = (type!='directory' ? (sz<10240 ? "#{sz}B" : "#{sz/1024}KB") : '-')
-            mtime = F.mtime(fl).httpdate
-            @files << [ url, file, size, type, mtime ]
-          end
-          return [ 200, {'Content-Type'=>'text/html'}, self ]
-        end
+      return [ 200, {'Content-Type'=>'text/html; charset=utf-8'}, self ]
+    end
+
+    def stat(node, max = 10)
+      F.stat(node)
+    rescue Errno::ENOENT, Errno::ELOOP
+      return nil
+    end
+
+    # TODO: add correct response if not readable, not sure if 404 is the best
+    #       option
+    def list_path
+      @stat = F.stat(@path)
+
+      if @stat.readable?
+        return @app.call(@env) if @stat.file?
+        return list_directory if @stat.directory?
+      else
+        raise Errno::ENOENT, 'No such file or directory'
       end
 
-      body = "Entity not found: #{env["PATH_INFO"]}\n"
+    rescue Errno::ENOENT, Errno::ELOOP
+      return entity_not_found
+    end
+
+    def entity_not_found
+      body = "Entity not found: #{@path_info}\n"
       size = body.respond_to?(:bytesize) ? body.bytesize : body.size
       return [404, {"Content-Type" => "text/plain", "Content-Length" => size.to_s}, [body]]
     end
@@ -93,66 +129,21 @@ table { width:100%%; }
       page.each_line{|l| yield l }
     end
 
-    def each_entry
-      @files.each{|e| yield e }
-    end
+    # Stolen from Ramaze
+
+    FILESIZE_FORMAT = [
+      ['%.1fT', 1 << 40],
+      ['%.1fG', 1 << 30],
+      ['%.1fM', 1 << 20],
+      ['%.1fK', 1 << 10],
+    ]
 
-    # From WEBrick.
-    MIME_TYPES = {
-      "ai"    => "application/postscript",
-      "asc"   => "text/plain",
-      "avi"   => "video/x-msvideo",
-      "bin"   => "application/octet-stream",
-      "bmp"   => "image/bmp",
-      "class" => "application/octet-stream",
-      "cer"   => "application/pkix-cert",
-      "crl"   => "application/pkix-crl",
-      "crt"   => "application/x-x509-ca-cert",
-     #"crl"   => "application/x-pkcs7-crl",
-      "css"   => "text/css",
-      "dms"   => "application/octet-stream",
-      "doc"   => "application/msword",
-      "dvi"   => "application/x-dvi",
-      "eps"   => "application/postscript",
-      "etx"   => "text/x-setext",
-      "exe"   => "application/octet-stream",
-      "gif"   => "image/gif",
-      "htm"   => "text/html",
-      "html"  => "text/html",
-      "jpe"   => "image/jpeg",
-      "jpeg"  => "image/jpeg",
-      "jpg"   => "image/jpeg",
-      "js"    => "text/javascript",
-      "lha"   => "application/octet-stream",
-      "lzh"   => "application/octet-stream",
-      "mov"   => "video/quicktime",
-      "mpe"   => "video/mpeg",
-      "mpeg"  => "video/mpeg",
-      "mpg"   => "video/mpeg",
-      "pbm"   => "image/x-portable-bitmap",
-      "pdf"   => "application/pdf",
-      "pgm"   => "image/x-portable-graymap",
-      "png"   => "image/png",
-      "pnm"   => "image/x-portable-anymap",
-      "ppm"   => "image/x-portable-pixmap",
-      "ppt"   => "application/vnd.ms-powerpoint",
-      "ps"    => "application/postscript",
-      "qt"    => "video/quicktime",
-      "ras"   => "image/x-cmu-raster",
-      "rb"    => "text/plain",
-      "rd"    => "text/plain",
-      "rtf"   => "application/rtf",
-      "sgm"   => "text/sgml",
-      "sgml"  => "text/sgml",
-      "tif"   => "image/tiff",
-      "tiff"  => "image/tiff",
-      "txt"   => "text/plain",
-      "xbm"   => "image/x-xbitmap",
-      "xls"   => "application/vnd.ms-excel",
-      "xml"   => "text/xml",
-      "xpm"   => "image/x-xpixmap",
-      "xwd"   => "image/x-xwindowdump",
-      "zip"   => "application/zip",
-    }
+    def filesize_format(int)
+      FILESIZE_FORMAT.each do |format, size|
+        return format % (int.to_f / size) if int >= size
+      end
+
+      int.to_s + 'B'
+    end
   end
 end

data/lib/rack/file.rb

@@ -1,4 +1,5 @@
 require 'time'
+require 'rack/mime'
 
 module Rack
   # Rack::File serves files below the +root+ given, according to the
@@ -22,26 +23,55 @@ module Rack
     F = ::File
 
     def _call(env)
-      if env["PATH_INFO"].include? ".."
-        body = "Forbidden\n"
-        size = body.respond_to?(:bytesize) ? body.bytesize : body.size
-        return [403, {"Content-Type" => "text/plain","Content-Length" => size.to_s}, [body]]
+      return forbidden  if env["PATH_INFO"].include? ".."
+
+      @path_info = Utils.unescape(env["PATH_INFO"])
+      @path = F.join(@root, @path_info)
+
+      begin
+        if F.file?(@path) && F.readable?(@path)
+          serving
+        else
+          raise Errno::EPERM
+        end
+      rescue SystemCallError
+        not_found
       end
+    end
+
+    def forbidden
+      body = "Forbidden\n"
+      [403, {"Content-Type" => "text/plain",
+             "Content-Length" => body.size.to_s},
+       [body]]
+    end
 
-      @path = F.join(@root, Utils.unescape(env["PATH_INFO"]))
-      ext = F.extname(@path)[1..-1]
+    # 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.
 
-      if F.file?(@path) && F.readable?(@path)
-        [200, {
-           "Last-Modified"  => F.mtime(@path).httpdate,
-           "Content-Type"   => MIME_TYPES[ext] || "text/plain",
-           "Content-Length" => F.size(@path).to_s
-         }, self]
+    def serving
+      if size = F.size?(@path)
+        body = self
       else
-        body = "File not found: #{env["PATH_INFO"]}\n"
-        size = body.respond_to?(:bytesize) ? body.bytesize : body.size
-        [404, {"Content-Type" => "text/plain", "Content-Length" => size.to_s}, [body]]
+        body = [F.read(@path)]
+        size = body.first.size
       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},
+       [body]]
     end
 
     def each
@@ -51,66 +81,5 @@ module Rack
         end
       }
     end
-
-    # :stopdoc:
-    # From WEBrick with some additions.
-    MIME_TYPES = {
-      "ai"    => "application/postscript",
-      "asc"   => "text/plain",
-      "avi"   => "video/x-msvideo",
-      "bin"   => "application/octet-stream",
-      "bmp"   => "image/bmp",
-      "class" => "application/octet-stream",
-      "cer"   => "application/pkix-cert",
-      "crl"   => "application/pkix-crl",
-      "crt"   => "application/x-x509-ca-cert",
-     #"crl"   => "application/x-pkcs7-crl",
-      "css"   => "text/css",
-      "dms"   => "application/octet-stream",
-      "doc"   => "application/msword",
-      "dvi"   => "application/x-dvi",
-      "eps"   => "application/postscript",
-      "etx"   => "text/x-setext",
-      "exe"   => "application/octet-stream",
-      "gif"   => "image/gif",
-      "htm"   => "text/html",
-      "html"  => "text/html",
-      "jpe"   => "image/jpeg",
-      "jpeg"  => "image/jpeg",
-      "jpg"   => "image/jpeg",
-      "js"    => "text/javascript",
-      "lha"   => "application/octet-stream",
-      "lzh"   => "application/octet-stream",
-      "mov"   => "video/quicktime",
-      "mp3"   => "audio/mpeg",
-      "mpe"   => "video/mpeg",
-      "mpeg"  => "video/mpeg",
-      "mpg"   => "video/mpeg",
-      "pbm"   => "image/x-portable-bitmap",
-      "pdf"   => "application/pdf",
-      "pgm"   => "image/x-portable-graymap",
-      "png"   => "image/png",
-      "pnm"   => "image/x-portable-anymap",
-      "ppm"   => "image/x-portable-pixmap",
-      "ppt"   => "application/vnd.ms-powerpoint",
-      "ps"    => "application/postscript",
-      "qt"    => "video/quicktime",
-      "ras"   => "image/x-cmu-raster",
-      "rb"    => "text/plain",
-      "rd"    => "text/plain",
-      "rtf"   => "application/rtf",
-      "sgm"   => "text/sgml",
-      "sgml"  => "text/sgml",
-      "tif"   => "image/tiff",
-      "tiff"  => "image/tiff",
-      "txt"   => "text/plain",
-      "xbm"   => "image/x-xbitmap",
-      "xls"   => "application/vnd.ms-excel",
-      "xml"   => "text/xml",
-      "xpm"   => "image/x-xpixmap",
-      "xwd"   => "image/x-xwindowdump",
-      "zip"   => "application/zip",
-    }
-    # :startdoc:
   end
 end