RubyGems - rack - Versions diffs - 1.0.1 → 2.2.21 - Mend

rack 1.0.1 → 2.2.21

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (147) hide show

checksums.yaml +7 -0
data/CHANGELOG.md +829 -0
data/CONTRIBUTING.md +136 -0
data/{COPYING → MIT-LICENSE} +4 -2
data/README.rdoc +355 -0
data/Rakefile +64 -98
data/SPEC.rdoc +292 -0
data/bin/rackup +3 -174
data/contrib/rack.png +0 -0
data/contrib/rack.svg +150 -0
data/contrib/rack_logo.svg +164 -111
data/contrib/rdoc.css +412 -0
data/example/lobster.ru +2 -0
data/example/protectedlobster.rb +4 -2
data/example/protectedlobster.ru +3 -1
data/lib/rack/auth/abstract/handler.rb +7 -5
data/lib/rack/auth/abstract/request.rb +12 -2
data/lib/rack/auth/basic.rb +6 -4
data/lib/rack/auth/digest/md5.rb +20 -13
data/lib/rack/auth/digest/nonce.rb +6 -4
data/lib/rack/auth/digest/params.rb +11 -12
data/lib/rack/auth/digest/request.rb +15 -12
data/lib/rack/body_proxy.rb +45 -0
data/lib/rack/builder.rb +213 -19
data/lib/rack/cascade.rb +50 -18
data/lib/rack/chunked.rb +95 -27
data/lib/rack/common_logger.rb +84 -0
data/lib/rack/conditional_get.rb +83 -0
data/lib/rack/config.rb +22 -0
data/lib/rack/content_length.rb +19 -10
data/lib/rack/content_type.rb +12 -5
data/lib/rack/core_ext/regexp.rb +14 -0
data/lib/rack/deflater.rb +90 -42
data/lib/rack/directory.rb +118 -72
data/lib/rack/etag.rb +77 -0
data/lib/rack/events.rb +153 -0
data/lib/rack/file.rb +4 -85
data/lib/rack/files.rb +218 -0
data/lib/rack/handler/cgi.rb +22 -24
data/lib/rack/handler/fastcgi.rb +34 -24
data/lib/rack/handler/lsws.rb +16 -15
data/lib/rack/handler/scgi.rb +38 -29
data/lib/rack/handler/thin.rb +23 -7
data/lib/rack/handler/webrick.rb +95 -37
data/lib/rack/handler.rb +49 -14
data/lib/rack/head.rb +19 -13
data/lib/rack/lint.rb +466 -217
data/lib/rack/lobster.rb +19 -14
data/lib/rack/lock.rb +24 -8
data/lib/rack/logger.rb +20 -0
data/lib/rack/media_type.rb +53 -0
data/lib/rack/method_override.rb +52 -0
data/lib/rack/mime.rb +652 -171
data/lib/rack/mock.rb +203 -64
data/lib/rack/multipart/generator.rb +97 -0
data/lib/rack/multipart/parser.rb +440 -0
data/lib/rack/multipart/uploaded_file.rb +41 -0
data/lib/rack/multipart.rb +64 -0
data/lib/rack/null_logger.rb +39 -0
data/lib/rack/query_parser.rb +266 -0
data/lib/rack/recursive.rb +18 -11
data/lib/rack/reloader.rb +13 -5
data/lib/rack/request.rb +607 -191
data/lib/rack/response.rb +245 -110
data/lib/rack/rewindable_input.rb +15 -21
data/lib/rack/runtime.rb +34 -0
data/lib/rack/sendfile.rb +192 -0
data/lib/rack/server.rb +466 -0
data/lib/rack/session/abstract/id.rb +449 -68
data/lib/rack/session/cookie.rb +159 -47
data/lib/rack/session/memcache.rb +4 -103
data/lib/rack/session/pool.rb +39 -49
data/lib/rack/show_exceptions.rb +390 -0
data/lib/rack/{showstatus.rb → show_status.rb} +21 -14
data/lib/rack/static.rb +164 -14
data/lib/rack/tempfile_reaper.rb +22 -0
data/lib/rack/urlmap.rb +60 -18
data/lib/rack/utils.rb +508 -277
data/lib/rack/version.rb +29 -0
data/lib/rack.rb +85 -34
data/rack.gemspec +43 -51
metadata +119 -207
data/KNOWN-ISSUES +0 -18
data/RDOX +0 -428
data/README +0 -364
data/SPEC +0 -164
data/lib/rack/adapter/camping.rb +0 -22
data/lib/rack/auth/openid.rb +0 -480
data/lib/rack/commonlogger.rb +0 -61
data/lib/rack/conditionalget.rb +0 -47
data/lib/rack/handler/evented_mongrel.rb +0 -8
data/lib/rack/handler/mongrel.rb +0 -87
data/lib/rack/handler/swiftiplied_mongrel.rb +0 -8
data/lib/rack/methodoverride.rb +0 -27
data/lib/rack/showexceptions.rb +0 -349
data/test/cgi/lighttpd.conf +0 -20
data/test/cgi/test +0 -9
data/test/cgi/test.fcgi +0 -8
data/test/cgi/test.ru +0 -7
data/test/multipart/binary +0 -0
data/test/multipart/empty +0 -10
data/test/multipart/ie +0 -6
data/test/multipart/nested +0 -10
data/test/multipart/none +0 -9
data/test/multipart/semicolon +0 -6
data/test/multipart/text +0 -10
data/test/spec_rack_auth_basic.rb +0 -73
data/test/spec_rack_auth_digest.rb +0 -226
data/test/spec_rack_auth_openid.rb +0 -84
data/test/spec_rack_builder.rb +0 -84
data/test/spec_rack_camping.rb +0 -51
data/test/spec_rack_cascade.rb +0 -50
data/test/spec_rack_cgi.rb +0 -89
data/test/spec_rack_chunked.rb +0 -62
data/test/spec_rack_commonlogger.rb +0 -32
data/test/spec_rack_conditionalget.rb +0 -41
data/test/spec_rack_content_length.rb +0 -43
data/test/spec_rack_content_type.rb +0 -30
data/test/spec_rack_deflater.rb +0 -127
data/test/spec_rack_directory.rb +0 -61
data/test/spec_rack_fastcgi.rb +0 -89
data/test/spec_rack_file.rb +0 -75
data/test/spec_rack_handler.rb +0 -43
data/test/spec_rack_head.rb +0 -30
data/test/spec_rack_lint.rb +0 -521
data/test/spec_rack_lobster.rb +0 -45
data/test/spec_rack_lock.rb +0 -38
data/test/spec_rack_methodoverride.rb +0 -60
data/test/spec_rack_mock.rb +0 -157
data/test/spec_rack_mongrel.rb +0 -189
data/test/spec_rack_recursive.rb +0 -77
data/test/spec_rack_request.rb +0 -504
data/test/spec_rack_response.rb +0 -218
data/test/spec_rack_rewindable_input.rb +0 -118
data/test/spec_rack_session_cookie.rb +0 -82
data/test/spec_rack_session_memcache.rb +0 -240
data/test/spec_rack_session_pool.rb +0 -172
data/test/spec_rack_showexceptions.rb +0 -21
data/test/spec_rack_showstatus.rb +0 -72
data/test/spec_rack_static.rb +0 -37
data/test/spec_rack_thin.rb +0 -91
data/test/spec_rack_urlmap.rb +0 -185
data/test/spec_rack_utils.rb +0 -387
data/test/spec_rack_webrick.rb +0 -130
data/test/testrequest.rb +0 -57
data/test/unregistered_handler/rack/handler/unregistered.rb +0 -7
data/test/unregistered_handler/rack/handler/unregistered_long_one.rb +0 -7

data/lib/rack/directory.rb CHANGED Viewed

@@ -1,6 +1,6 @@
+# frozen_string_literal: true
 require 'time'
-require 'rack/utils'
-require 'rack/mime'
 module Rack
   # Rack::Directory serves entries below the +root+ given, according to the
@@ -8,11 +8,11 @@ module Rack
   # will be presented in an html based index. If a file is found, the env will
   # be passed to the specified +app+.
   #
-  # If +app+ is not specified, a Rack::File of the same +root+ will be used.
+  # If +app+ is not specified, a Rack::Files of the same +root+ will be used.
   class Directory
-    DIR_FILE = "<tr><td class='name'><a href='%s'>%s</a></td><td class='size'>%s</td><td class='type'>%s</td><td class='mtime'>%s</td></tr>"
-    DIR_PAGE = <<-PAGE
+    DIR_FILE = "<tr><td class='name'><a href='%s'>%s</a></td><td class='size'>%s</td><td class='type'>%s</td><td class='mtime'>%s</td></tr>\n"
+    DIR_PAGE_HEADER = <<-PAGE
 <html><head>
   <title>%s</title>
   <meta http-equiv="content-type" content="text/html; charset=utf-8" />
@@ -33,108 +33,153 @@ table { width:100%%; }
     <th class='type'>Type</th>
     <th class='mtime'>Last Modified</th>
   </tr>
-%s
+    PAGE
+    DIR_PAGE_FOOTER = <<-PAGE
 </table>
 <hr />
 </body></html>
     PAGE
-    attr_reader :files
-    attr_accessor :root, :path
+    # Body class for directory entries, showing an index page with links
+    # to each file.
+    class DirectoryBody < Struct.new(:root, :path, :files)
+      # Yield strings for each part of the directory entry
+      def each
+        show_path = Utils.escape_html(path.sub(/^#{root}/, ''))
+        yield(DIR_PAGE_HEADER % [ show_path, show_path ])
+        unless path.chomp('/') == root
+          yield(DIR_FILE % DIR_FILE_escape(files.call('..')))
+        end
+        Dir.foreach(path) do |basename|
+          next if basename.start_with?('.')
+          next unless f = files.call(basename)
+          yield(DIR_FILE % DIR_FILE_escape(f))
+        end
+        yield(DIR_PAGE_FOOTER)
+      end
+      private
-    def initialize(root, app=nil)
-      @root = F.expand_path(root)
-      @app = app || Rack::File.new(@root)
+      # Escape each element in the array of html strings.
+      def DIR_FILE_escape(htmls)
+        htmls.map { |e| Utils.escape_html(e) }
+      end
     end
-    def call(env)
-      dup._call(env)
+    # The root of the directory hierarchy.  Only requests for files and
+    # directories inside of the root directory are supported.
+    attr_reader :root
+    # Set the root directory and application for serving files.
+    def initialize(root, app = nil)
+      @root = ::File.expand_path(root)
+      @app = app || Files.new(@root)
+      @head = Head.new(method(:get))
     end
-    F = ::File
+    def call(env)
+      # strip body if this is a HEAD call
+      @head.call env
+    end
-    def _call(env)
-      @env = env
-      @script_name = env['SCRIPT_NAME']
-      @path_info = Utils.unescape(env['PATH_INFO'])
+    # Internals of request handling.  Similar to call but does
+    # not remove body for HEAD requests.
+    def get(env)
+      script_name = env[SCRIPT_NAME]
+      path_info = Utils.unescape_path(env[PATH_INFO])
-      if forbidden = check_forbidden
-        forbidden
+      if client_error_response = check_bad_request(path_info) || check_forbidden(path_info)
+        client_error_response
       else
-        @path = F.join(@root, @path_info)
-        list_path
+        path = ::File.join(@root, path_info)
+        list_path(env, path, path_info, script_name)
       end
     end
-    def check_forbidden
-      return unless @path_info.include? ".."
+    # Rack response to use for requests with invalid paths, or nil if path is valid.
+    def check_bad_request(path_info)
+      return if Utils.valid_path?(path_info)
-      body = "Forbidden\n"
-      size = Rack::Utils.bytesize(body)
-      return [403, {"Content-Type" => "text/plain","Content-Length" => size.to_s}, [body]]
+      body = "Bad Request\n"
+      [400, { CONTENT_TYPE => "text/plain",
+        CONTENT_LENGTH => body.bytesize.to_s,
+        "X-Cascade" => "pass" }, [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)
+    # Rack response to use for requests with paths outside the root, or nil if path is inside the root.
+    def check_forbidden(path_info)
+      return unless path_info.include? ".."
+      return if ::File.expand_path(::File.join(@root, path_info)).start_with?(@root)
-        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
-        url << '/'  if stat.directory?
-        basename << '/'  if stat.directory?
+      body = "Forbidden\n"
+      [403, { CONTENT_TYPE => "text/plain",
+        CONTENT_LENGTH => body.bytesize.to_s,
+        "X-Cascade" => "pass" }, [body]]
+    end
-        @files << [ url, basename, size, type, mtime ]
+    # Rack response to use for directories under the root.
+    def list_directory(path_info, path, script_name)
+      url_head = (script_name.split('/') + path_info.split('/')).map do |part|
+        Utils.escape_path part
       end
-      return [ 200, {'Content-Type'=>'text/html; charset=utf-8'}, self ]
+      # Globbing not safe as path could contain glob metacharacters
+      body = DirectoryBody.new(@root, path, ->(basename) do
+        stat = stat(::File.join(path, basename))
+        next unless stat
+        url = ::File.join(*url_head + [Utils.escape_path(basename)])
+        mtime = stat.mtime.httpdate
+        if stat.directory?
+          type = 'directory'
+          size = '-'
+          url << '/'
+          if basename == '..'
+            basename = 'Parent Directory'
+          else
+            basename << '/'
+          end
+        else
+          type = Mime.mime_type(::File.extname(basename))
+          size = filesize_format(stat.size)
+        end
+        [ url, basename, size, type, mtime ]
+      end)
+      [ 200, { CONTENT_TYPE => 'text/html; charset=utf-8' }, body ]
     end
-    def stat(node, max = 10)
-      F.stat(node)
+    # File::Stat for the given path, but return nil for missing/bad entries.
+    def stat(path)
+      ::File.stat(path)
     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'
+    # Rack response to use for files and directories under the root.
+    # Unreadable and non-file, non-directory entries will get a 404 response.
+    def list_path(env, path, path_info, script_name)
+      if (stat = stat(path)) && stat.readable?
+        return @app.call(env) if stat.file?
+        return list_directory(path_info, path, script_name) if stat.directory?
       end
-    rescue Errno::ENOENT, Errno::ELOOP
-      return entity_not_found
+      entity_not_found(path_info)
     end
-    def entity_not_found
-      body = "Entity not found: #{@path_info}\n"
-      size = Rack::Utils.bytesize(body)
-      return [404, {"Content-Type" => "text/plain", "Content-Length" => size.to_s}, [body]]
-    end
-    def each
-      show_path = @path.sub(/^#{@root}/,'')
-      files = @files.map{|f| DIR_FILE % f }*"\n"
-      page  = DIR_PAGE % [ show_path, show_path , files ]
-      page.each_line{|l| yield l }
+    # Rack response to use for unreadable and non-file, non-directory entries.
+    def entity_not_found(path_info)
+      body = "Entity not found: #{path_info}\n"
+      [404, { CONTENT_TYPE => "text/plain",
+        CONTENT_LENGTH => body.bytesize.to_s,
+        "X-Cascade" => "pass" }, [body]]
     end
     # Stolen from Ramaze
     FILESIZE_FORMAT = [
       ['%.1fT', 1 << 40],
       ['%.1fG', 1 << 30],
@@ -142,12 +187,13 @@ table { width:100%%; }
       ['%.1fK', 1 << 10],
     ]
+    # Provide human readable file sizes
     def filesize_format(int)
       FILESIZE_FORMAT.each do |format, size|
         return format % (int.to_f / size) if int >= size
       end
-      int.to_s + 'B'
+      "#{int}B"
     end
   end
 end

data/lib/rack/etag.rb ADDED Viewed

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+require_relative '../rack'
+require 'digest/sha2'
+module Rack
+  # 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, private, must-revalidate"
+  class ETag
+    ETAG_STRING = Rack::ETAG
+    DEFAULT_CACHE_CONTROL = "max-age=0, private, must-revalidate"
+    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)
+      headers = Utils::HeaderHash[headers]
+      if etag_status?(status) && etag_body?(body) && !skip_caching?(headers)
+        original_body = body
+        digest, new_body = digest_body(body)
+        body = Rack::BodyProxy.new(new_body) do
+          original_body.close if original_body.respond_to?(:close)
+        end
+        headers[ETAG_STRING] = %(W/"#{digest}") if digest
+      end
+      unless headers[CACHE_CONTROL]
+        if digest
+          headers[CACHE_CONTROL] = @cache_control if @cache_control
+        else
+          headers[CACHE_CONTROL] = @no_cache_control if @no_cache_control
+        end
+      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.key?(ETAG_STRING) || headers.key?('Last-Modified')
+      end
+      def digest_body(body)
+        parts = []
+        digest = nil
+        body.each do |part|
+          parts << part
+          (digest ||= Digest::SHA256.new) << part unless part.empty?
+        end
+        [digest && digest.hexdigest.byteslice(0, 32), parts]
+      end
+  end
+end

data/lib/rack/events.rb ADDED Viewed

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+module Rack
+  ### This middleware provides hooks to certain places in the request /
+  # response lifecycle.  This is so that middleware that don't need to filter
+  # the response data can safely leave it alone and not have to send messages
+  # down the traditional "rack stack".
+  #
+  # The events are:
+  #
+  # * on_start(request, response)
+  #
+  #   This event is sent at the start of the request, before the next
+  #   middleware in the chain is called.  This method is called with a request
+  #   object, and a response object.  Right now, the response object is always
+  #   nil, but in the future it may actually be a real response object.
+  #
+  # * on_commit(request, response)
+  #
+  #   The response has been committed.  The application has returned, but the
+  #   response has not been sent to the webserver yet.  This method is always
+  #   called with a request object and the response object.  The response
+  #   object is constructed from the rack triple that the application returned.
+  #   Changes may still be made to the response object at this point.
+  #
+  # * on_send(request, response)
+  #
+  #   The webserver has started iterating over the response body and presumably
+  #   has started sending data over the wire. This method is always called with
+  #   a request object and the response object.  The response object is
+  #   constructed from the rack triple that the application returned.  Changes
+  #   SHOULD NOT be made to the response object as the webserver has already
+  #   started sending data.  Any mutations will likely result in an exception.
+  #
+  # * on_finish(request, response)
+  #
+  #   The webserver has closed the response, and all data has been written to
+  #   the response socket.  The request and response object should both be
+  #   read-only at this point.  The body MAY NOT be available on the response
+  #   object as it may have been flushed to the socket.
+  #
+  # * on_error(request, response, error)
+  #
+  #   An exception has occurred in the application or an `on_commit` event.
+  #   This method will get the request, the response (if available) and the
+  #   exception that was raised.
+  #
+  # ## Order
+  #
+  # `on_start` is called on the handlers in the order that they were passed to
+  # the constructor.  `on_commit`, on_send`, `on_finish`, and `on_error` are
+  # called in the reverse order.  `on_finish` handlers are called inside an
+  # `ensure` block, so they are guaranteed to be called even if something
+  # raises an exception.  If something raises an exception in a `on_finish`
+  # method, then nothing is guaranteed.
+  class Events
+    module Abstract
+      def on_start(req, res)
+      end
+      def on_commit(req, res)
+      end
+      def on_send(req, res)
+      end
+      def on_finish(req, res)
+      end
+      def on_error(req, res, e)
+      end
+    end
+    class EventedBodyProxy < Rack::BodyProxy # :nodoc:
+      attr_reader :request, :response
+      def initialize(body, request, response, handlers, &block)
+        super(body, &block)
+        @request  = request
+        @response = response
+        @handlers = handlers
+      end
+      def each
+        @handlers.reverse_each { |handler| handler.on_send request, response }
+        super
+      end
+    end
+    class BufferedResponse < Rack::Response::Raw # :nodoc:
+      attr_reader :body
+      def initialize(status, headers, body)
+        super(status, headers)
+        @body = body
+      end
+      def to_a; [status, headers, body]; end
+    end
+    def initialize(app, handlers)
+      @app      = app
+      @handlers = handlers
+    end
+    def call(env)
+      request = make_request env
+      on_start request, nil
+      begin
+        status, headers, body = @app.call request.env
+        response = make_response status, headers, body
+        on_commit request, response
+      rescue StandardError => e
+        on_error request, response, e
+        on_finish request, response
+        raise
+      end
+      body = EventedBodyProxy.new(body, request, response, @handlers) do
+        on_finish request, response
+      end
+      [response.status, response.headers, body]
+    end
+    private
+    def on_error(request, response, e)
+      @handlers.reverse_each { |handler| handler.on_error request, response, e }
+    end
+    def on_commit(request, response)
+      @handlers.reverse_each { |handler| handler.on_commit request, response }
+    end
+    def on_start(request, response)
+      @handlers.each { |handler| handler.on_start request, nil }
+    end
+    def on_finish(request, response)
+      @handlers.reverse_each { |handler| handler.on_finish request, response }
+    end
+    def make_request(env)
+      Rack::Request.new env
+    end
+    def make_response(status, headers, body)
+      BufferedResponse.new status, headers, body
+    end
+  end
+end

data/lib/rack/file.rb CHANGED Viewed

@@ -1,88 +1,7 @@
-require 'time'
-require 'rack/utils'
-require 'rack/mime'
+# frozen_string_literal: true
-module Rack
-  # Rack::File serves files below the +root+ given, according to the
-  # path info of the Rack request.
-  #
-  # Handlers can detect if bodies are a Rack::File, and use mechanisms
-  # like sendfile on the +path+.
-  class File
-    attr_accessor :root
-    attr_accessor :path
-    alias :to_path :path
-    def initialize(root)
-      @root = root
-    end
-    def call(env)
-      dup._call(env)
-    end
-    F = ::File
-    def _call(env)
-      @path_info = Utils.unescape(env["PATH_INFO"])
-      return forbidden  if @path_info.include? ".."
-      @path = F.join(@root, @path_info)
+require_relative 'files'
-      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
-    # 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
-      if size = F.size?(@path)
-        body = self
-      else
-        body = [F.read(@path)]
-        size = Utils.bytesize(body.first)
-      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
-      F.open(@path, "rb") { |file|
-        while part = file.read(8192)
-          yield part
-        end
-      }
-    end
-  end
+module Rack
+  File = Files
 end