File Manager

X7ROOT File Manager

Current Path: /opt/alt/ruby18/lib64/ruby/gems/1.8/gems/rack-1.6.1/lib/rack

opt / alt / ruby18 / lib64 / ruby / gems / 1.8 / gems / rack-1.6.1 / lib / rack /

?? ..
?? auth
?? backports
?? body_proxy.rb(958 B)
?? builder.rb(4.27 KB)
?? cascade.rb(1.34 KB)
?? chunked.rb(1.58 KB)
?? commonlogger.rb(2.28 KB)
?? conditionalget.rb(2.5 KB)
?? config.rb(379 B)
?? content_length.rb(840 B)
?? content_type.rb(670 B)
?? deflater.rb(4.57 KB)
?? directory.rb(4.2 KB)
?? etag.rb(2.11 KB)
?? file.rb(4.09 KB)
?? handler
?? handler.rb(3.24 KB)
?? head.rb(484 B)
?? lint.rb(29.26 KB)
?? lobster.rb(1.97 KB)
?? lock.rb(601 B)
?? logger.rb(357 B)
?? methodoverride.rb(972 B)
?? mime.rb(30.89 KB)
?? mock.rb(5.68 KB)
?? multipart
?? multipart.rb(1.14 KB)
?? nulllogger.rb(951 B)
?? recursive.rb(1.73 KB)
?? reloader.rb(2.97 KB)
?? request.rb(12.45 KB)
?? response.rb(4.33 KB)
?? rewindable_input.rb(3.19 KB)
?? runtime.rb(961 B)
?? sendfile.rb(5.18 KB)
?? server.rb(10.8 KB)
?? session
?? showexceptions.rb(11.7 KB)
?? showstatus.rb(3.46 KB)
?? static.rb(4.87 KB)
?? tempfile_reaper.rb(670 B)
?? urlmap.rb(2.46 KB)
?? utils
?? utils.rb(20.55 KB)

Editing: deflater.rb

require "zlib"
require "time"  # for Time.httpdate
require 'rack/utils'

module Rack
  # This middleware enables compression of http responses.
  #
  # Currently supported compression algorithms:
  #
  #   * gzip
  #   * deflate
  #   * identity (no transformation)
  #
  # The middleware automatically detects when compression is supported
  # and allowed. For example no transformation is made when a cache
  # directive of 'no-transform' is present, or when the response status
  # code is one that doesn't allow an entity body.
  class Deflater
    ##
    # Creates Rack::Deflater middleware.
    #
    # [app] rack app instance
    # [options] hash of deflater options, i.e.
    #           'if' - a lambda enabling / disabling deflation based on returned boolean value
    #                  e.g use Rack::Deflater, :if => lambda { |env, status, headers, body| body.length > 512 }
    #           'include' - a list of content types that should be compressed
    def initialize(app, options = {})
      @app = app

@condition = options[:if]
      @compressible_types = options[:include]
    end

def call(env)
      status, headers, body = @app.call(env)
      headers = Utils::HeaderHash.new(headers)

unless should_deflate?(env, status, headers, body)
        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."
        bp = Rack::BodyProxy.new([message]) { body.close if body.respond_to?(:close) }
        [406, {CONTENT_TYPE => "text/plain", CONTENT_LENGTH => message.length.to_s}, bp]
      end
    end

class GzipStream
      def initialize(body, mtime)
        @body = body
        @mtime = mtime
        @closed = false
      end

def each(&block)
        @writer = block
        gzip  =::Zlib::GzipWriter.new(self)
        gzip.mtime = @mtime
        @body.each { |part|
          gzip.write(part)
          gzip.flush
        }
      ensure
        gzip.close
        @writer = nil
      end

def write(data)
        @writer.call(data)
      end

def close
        return if @closed
        @closed = true
        @body.close if @body.respond_to?(:close)
      end
    end

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
        @closed = false
      end

def each
        deflator = ::Zlib::Deflate.new(*DEFLATE_ARGS)
        @body.each { |part| yield deflator.deflate(part, Zlib::SYNC_FLUSH) }
        yield deflator.finish
        nil
      ensure
        deflator.close
      end

def close
        return if @closed
        @closed = true
        @body.close if @body.respond_to?(:close)
      end
    end

private

def should_deflate?(env, status, headers, body)
      # 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/ ||
         (headers['Content-Encoding'] && headers['Content-Encoding'] !~ /\bidentity\b/)
        return false
      end

# Skip if @compressible_types are given and does not include request's content type
      return false if @compressible_types && !(headers.has_key?('Content-Type') && @compressible_types.include?(headers['Content-Type'][/[^;]*/]))

# Skip if @condition lambda is given and evaluates to false
      return false if @condition && !@condition.call(env, status, headers, body)

true
    end
  end
end

X7ROOT File Manager

Editing: deflater.rb

Upload File

Create Folder