class Rack::Deflater

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.

Public Class Methods

new(app, options = {}) click to toggle source

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

# File lib/rack/deflater.rb, line 27
def initialize(app, options = {})
  @app = app

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

Public Instance Methods

call(env) click to toggle source
# File lib/rack/deflater.rb, line 34
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(&: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

Private Instance Methods

should_deflate?(env, status, headers, body) click to toggle source
# File lib/rack/deflater.rb, line 136
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