RubyGems - homura-runtime - Versions diffs - 0.3.2 → 0.3.4 - Mend

homura-runtime 0.3.2 → 0.3.4

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 (82) hide show

checksums.yaml +4 -4
data/CHANGELOG.md +18 -0
data/exe/compile-assets +2 -2
data/exe/compile-erb +5 -7
data/lib/homura/runtime/build_support.rb +19 -2
data/lib/homura/runtime/version.rb +1 -1
data/vendor/rack/auth/abstract/handler.rb +41 -0
data/vendor/rack/auth/abstract/request.rb +51 -0
data/vendor/rack/auth/basic.rb +58 -0
data/vendor/rack/bad_request.rb +8 -0
data/vendor/rack/body_proxy.rb +63 -0
data/vendor/rack/builder.rb +315 -0
data/vendor/rack/cascade.rb +67 -0
data/vendor/rack/common_logger.rb +94 -0
data/vendor/rack/conditional_get.rb +87 -0
data/vendor/rack/config.rb +22 -0
data/vendor/rack/constants.rb +68 -0
data/vendor/rack/content_length.rb +34 -0
data/vendor/rack/content_type.rb +33 -0
data/vendor/rack/deflater.rb +159 -0
data/vendor/rack/directory.rb +210 -0
data/vendor/rack/etag.rb +71 -0
data/vendor/rack/events.rb +172 -0
data/vendor/rack/files.rb +224 -0
data/vendor/rack/head.rb +25 -0
data/vendor/rack/headers.rb +238 -0
data/vendor/rack/lint.rb +1000 -0
data/vendor/rack/lock.rb +29 -0
data/vendor/rack/media_type.rb +42 -0
data/vendor/rack/method_override.rb +56 -0
data/vendor/rack/mime.rb +694 -0
data/vendor/rack/mock.rb +3 -0
data/vendor/rack/mock_request.rb +161 -0
data/vendor/rack/mock_response.rb +147 -0
data/vendor/rack/multipart/generator.rb +99 -0
data/vendor/rack/multipart/parser.rb +586 -0
data/vendor/rack/multipart/uploaded_file.rb +82 -0
data/vendor/rack/multipart.rb +77 -0
data/vendor/rack/null_logger.rb +48 -0
data/vendor/rack/protection/authenticity_token.rb +256 -0
data/vendor/rack/protection/base.rb +140 -0
data/vendor/rack/protection/content_security_policy.rb +80 -0
data/vendor/rack/protection/cookie_tossing.rb +77 -0
data/vendor/rack/protection/escaped_params.rb +93 -0
data/vendor/rack/protection/form_token.rb +25 -0
data/vendor/rack/protection/frame_options.rb +39 -0
data/vendor/rack/protection/http_origin.rb +43 -0
data/vendor/rack/protection/ip_spoofing.rb +27 -0
data/vendor/rack/protection/json_csrf.rb +60 -0
data/vendor/rack/protection/path_traversal.rb +45 -0
data/vendor/rack/protection/referrer_policy.rb +27 -0
data/vendor/rack/protection/remote_referrer.rb +22 -0
data/vendor/rack/protection/remote_token.rb +24 -0
data/vendor/rack/protection/session_hijacking.rb +37 -0
data/vendor/rack/protection/strict_transport.rb +41 -0
data/vendor/rack/protection/version.rb +7 -0
data/vendor/rack/protection/xss_header.rb +27 -0
data/vendor/rack/protection.rb +58 -0
data/vendor/rack/query_parser.rb +261 -0
data/vendor/rack/recursive.rb +66 -0
data/vendor/rack/reloader.rb +112 -0
data/vendor/rack/request.rb +818 -0
data/vendor/rack/response.rb +403 -0
data/vendor/rack/rewindable_input.rb +116 -0
data/vendor/rack/runtime.rb +35 -0
data/vendor/rack/sendfile.rb +197 -0
data/vendor/rack/session/abstract/id.rb +533 -0
data/vendor/rack/session/constants.rb +13 -0
data/vendor/rack/session/cookie.rb +292 -0
data/vendor/rack/session/encryptor.rb +415 -0
data/vendor/rack/session/pool.rb +76 -0
data/vendor/rack/session/version.rb +10 -0
data/vendor/rack/session.rb +12 -0
data/vendor/rack/show_exceptions.rb +433 -0
data/vendor/rack/show_status.rb +121 -0
data/vendor/rack/static.rb +188 -0
data/vendor/rack/tempfile_reaper.rb +44 -0
data/vendor/rack/urlmap.rb +99 -0
data/vendor/rack/utils.rb +631 -0
data/vendor/rack/version.rb +17 -0
data/vendor/rack.rb +66 -0
metadata +76 -1

data/vendor/rack/directory.rb ADDED Viewed

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+require 'time'
+require_relative 'constants'
+require_relative 'utils'
+require_relative 'head'
+require_relative 'mime'
+require_relative 'files'
+module Rack
+  # Rack::Directory serves entries below the +root+ given, according to the
+  # path info of the Rack request. If a directory is found, the file's contents
+  # 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::Files of the same +root+ will be used.
+  #
+  # Be aware that just like the default behavior of most webservers, Rack::Directory
+  # will follow symbolic links encountered under the root. If a symlink points to
+  # a location outside of the root, that target will still be served as part of
+  # the response.
+  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>\n"
+    DIR_PAGE_HEADER = <<-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>
+<hr />
+<table>
+  <tr>
+    <th class='name'>Name</th>
+    <th class='size'>Size</th>
+    <th class='type'>Type</th>
+    <th class='mtime'>Last Modified</th>
+  </tr>
+    PAGE
+    DIR_PAGE_FOOTER = <<-PAGE
+</table>
+<hr />
+</body></html>
+    PAGE
+    # 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
+      # Escape each element in the array of html strings.
+      def DIR_FILE_escape(htmls)
+        htmls.map { |e| Utils.escape_html(e) }
+      end
+    end
+    # 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
+    def call(env)
+      # strip body if this is a HEAD call
+      @head.call env
+    end
+    # 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 client_error_response = check_bad_request(path_info) || check_forbidden(path_info)
+        client_error_response
+      else
+        path = ::File.join(@root, path_info)
+        list_path(env, path, path_info, script_name)
+      end
+    end
+    # 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 = "Bad Request\n"
+      [400, { CONTENT_TYPE => "text/plain",
+        CONTENT_LENGTH => body.bytesize.to_s,
+        "x-cascade" => "pass" }, [body]]
+    end
+    # 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)
+      body = "Forbidden\n"
+      [403, { CONTENT_TYPE => "text/plain",
+        CONTENT_LENGTH => body.bytesize.to_s,
+        "x-cascade" => "pass" }, [body]]
+    end
+    # 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
+      # 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
+    # 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
+    # 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
+      entity_not_found(path_info)
+    end
+    # 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],
+      ['%.1fM', 1 << 20],
+      ['%.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}B"
+    end
+  end
+end

data/vendor/rack/etag.rb ADDED Viewed

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+require 'digest/sha2'
+require_relative 'constants'
+require_relative 'utils'
+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 = response = @app.call(env)
+      if etag_status?(status) && body.respond_to?(:to_ary) && !skip_caching?(headers)
+        body = body.to_ary
+        digest = digest_body(body)
+        headers[ETAG_STRING] = %(W/"#{digest}") if digest
+        # Body was modified, so we need to re-assign it:
+        response[2] = body
+      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
+      response
+    end
+    private
+      def etag_status?(status)
+        status == 200 || status == 201
+      end
+      def skip_caching?(headers)
+        headers.key?(ETAG_STRING) || headers.key?('last-modified')
+      end
+      def digest_body(body)
+        digest = nil
+        body.each do |part|
+          (digest ||= Digest::SHA256.new) << part unless part.empty?
+        end
+        digest && digest.hexdigest.byteslice(0,32)
+      end
+  end
+end

data/vendor/rack/events.rb ADDED Viewed

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+require_relative 'body_proxy'
+require_relative 'request'
+require_relative 'response'
+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, or has called
+  #   the streaming 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
+      def call(stream)
+        @handlers.reverse_each { |handler| handler.on_send request, response }
+        super
+      end
+      def respond_to?(method_name, include_all = false)
+        case method_name
+        when :each, :call
+          @body.respond_to?(method_name, include_all)
+        else
+          super
+        end
+      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/vendor/rack/files.rb ADDED Viewed

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+require 'time'
+require_relative 'constants'
+require_relative 'head'
+require_relative 'utils'
+require_relative 'request'
+require_relative 'mime'
+module Rack
+  # Rack::Files serves files below the +root+ directory given, according to the
+  # path info of the Rack request.
+  # e.g. when Rack::Files.new("/etc") is used, you can access 'passwd' file
+  # as http://localhost:9292/passwd
+  #
+  # Handlers can detect if bodies are a Rack::Files, and use mechanisms
+  # like sendfile on the +path+.
+  #
+  # Be aware that just like the default behavior of most webservers, Rack::Files
+  # will follow symbolic links encountered under the root. If a symlink points to
+  # a location outside of the root, that target will still be served as part of
+  # the response.
+  class Files
+    ALLOWED_VERBS = %w[GET HEAD OPTIONS]
+    ALLOW_HEADER = ALLOWED_VERBS.join(', ')
+    MULTIPART_BOUNDARY = 'AaB03x'
+    attr_reader :root
+    def initialize(root, headers = {}, default_mime = 'text/plain')
+      @root = (::File.expand_path(root) if root)
+      @headers = headers
+      @default_mime = default_mime
+      @head = Rack::Head.new(lambda { |env| get env })
+    end
+    def call(env)
+      # HEAD requests drop the response body, including 4xx error messages.
+      @head.call env
+    end
+    def get(env)
+      request = Rack::Request.new env
+      unless ALLOWED_VERBS.include? request.request_method
+        return fail(405, "Method Not Allowed", { 'allow' => ALLOW_HEADER })
+      end
+      path_info = Utils.unescape_path request.path_info
+      return fail(400, "Bad Request") unless Utils.valid_path?(path_info)
+      clean_path_info = Utils.clean_path_info(path_info)
+      path = ::File.join(@root, clean_path_info)
+      available = begin
+        ::File.file?(path) && ::File.readable?(path)
+      rescue SystemCallError
+        # Not sure in what conditions this exception can occur, but this
+        # is a safe way to handle such an error.
+        # :nocov:
+        false
+        # :nocov:
+      end
+      if available
+        serving(request, path)
+      else
+        fail(404, "File not found: #{path_info}")
+      end
+    end
+    def serving(request, path)
+      if request.options?
+        return [200, { 'allow' => ALLOW_HEADER, CONTENT_LENGTH => '0' }, []]
+      end
+      last_modified = ::File.mtime(path).httpdate
+      return [304, {}, []] if request.get_header('HTTP_IF_MODIFIED_SINCE') == last_modified
+      headers = { "last-modified" => last_modified }
+      mime_type = mime_type path, @default_mime
+      headers[CONTENT_TYPE] = mime_type if mime_type
+      assign_headers(headers, request)
+      status = 200
+      size = filesize path
+      ranges = Rack::Utils.get_byte_ranges(request.get_header('HTTP_RANGE'), size)
+      if ranges.nil?
+        # No ranges:
+        ranges = [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
+        # Partial content
+        partial_content = true
+        if ranges.size == 1
+          range = ranges[0]
+          headers["content-range"] = "bytes #{range.begin}-#{range.end}/#{size}"
+        else
+          headers[CONTENT_TYPE] = "multipart/byteranges; boundary=#{MULTIPART_BOUNDARY}"
+        end
+        status = 206
+        body = BaseIterator.new(path, ranges, mime_type: mime_type, size: size)
+        size = body.bytesize
+      end
+      headers[CONTENT_LENGTH] = size.to_s
+      if request.head?
+        body = []
+      elsif !partial_content
+        body = Iterator.new(path, ranges, mime_type: mime_type, size: size)
+      end
+      [status, headers, body]
+    end
+    def assign_headers(headers, request)
+      headers.merge!(@headers) if @headers
+    end
+    class BaseIterator
+      attr_reader :path, :ranges, :options
+      def initialize(path, ranges, options)
+        @path = path
+        @ranges = ranges
+        @options = options
+      end
+      def each
+        ::File.open(path, "rb") do |file|
+          ranges.each do |range|
+            yield multipart_heading(range) if multipart?
+            each_range_part(file, range) do |part|
+              yield part
+            end
+          end
+          yield "\r\n--#{MULTIPART_BOUNDARY}--\r\n" if multipart?
+        end
+      end
+      def bytesize
+        size = ranges.inject(0) do |sum, range|
+          sum += multipart_heading(range).bytesize if multipart?
+          sum += range.size
+        end
+        size += "\r\n--#{MULTIPART_BOUNDARY}--\r\n".bytesize if multipart?
+        size
+      end
+      def close; end
+      private
+      def multipart?
+        ranges.size > 1
+      end
+      def multipart_heading(range)
+<<-EOF
+\r
+--#{MULTIPART_BOUNDARY}\r
+content-type: #{options[:mime_type]}\r
+content-range: bytes #{range.begin}-#{range.end}/#{options[:size]}\r
+\r
+EOF
+      end
+      def each_range_part(file, range)
+        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
+    class Iterator < BaseIterator
+      alias :to_path :path
+    end
+    private
+    def fail(status, body, headers = {})
+      body += "\n"
+      [
+        status,
+        {
+          CONTENT_TYPE   => "text/plain",
+          CONTENT_LENGTH => body.size.to_s,
+          "x-cascade" => "pass"
+        }.merge!(headers),
+        [body]
+      ]
+    end
+    # The MIME type for the contents of the file located at @path
+    def mime_type(path, default_mime)
+      Mime.mime_type(::File.extname(path), default_mime)
+    end
+    def filesize(path)
+      #   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.
+      ::File.size?(path) || ::File.read(path).bytesize
+    end
+  end
+end

data/vendor/rack/head.rb ADDED Viewed

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+require_relative 'constants'
+require_relative 'body_proxy'
+module Rack
+  # Rack::Head returns an empty body for all HEAD requests. It leaves
+  # all other requests unchanged.
+  class Head
+    def initialize(app)
+      @app = app
+    end
+    def call(env)
+      _, _, body = response = @app.call(env)
+      if env[REQUEST_METHOD] == HEAD
+        body.close if body.respond_to?(:close)
+        response[2] = []
+      end
+      response
+    end
+  end
+end