class StirFry::Response

Response is a wrapper around Rack::Response that makes it easier to generate rich responses easily.

Attributes

env [R]

the rack request env.

req [R]

the corresponding reqest to this reponse.

request_error [RW]

if there was an error during the request it will be set here.

resp [R]

the inner Rack::Response that we are building.

Public Instance Methods

bad_request (body)

Source

# File lib/stir_fry/response.rb, line 54
def bad_request(body) = respond(body, :bad_request)

sugar for respond(body, :bad_request)

bad_request! (msg = "")

Source

# File lib/stir_fry/response.rb, line 65
def bad_request!(msg = "") = raise BadRequest, msg

immediately return bad request status without running any following middleware.

bad_request? ()

Source

# File lib/stir_fry/response.rb, line 47
def bad_request? = status == 400

whether or not the status is set to 400

body ()

Source

# File lib/stir_fry/response.rb, line 124
def body = resp.body

Readonly body content. To change the content you should use one of the response methods text, html, render, json, stream or other methods available to set the body in a valid way.

cache_control (*values)

Source

# File lib/stir_fry/response.rb, line 154
def cache_control(*values)
  hash = extract_cache_control_hash(values)
  values.map! { |value| value.to_s.tr("_", "-") }
  hash.each { |key, value| values << cache_control_pair(key, value) }

  headers["Cache-Control"] = values.join(", ") if values.any?
end

Specify response freshness policy for HTTP caches (Cache-Control header). Any number of non-value directives (:public, :private, :no_cache, :no_store, :must_revalidate, :proxy_revalidate) may be passed along with a Hash of value directives (:max_age, :s_maxage).

cache_control :public, :must_revalidate, :max_age => 60 => Cache-Control: public, must-revalidate, max-age=60

client_error? ()

Source

# File lib/stir_fry/response.rb, line 41
def client_error? = status.between?(400, 499)

whether or not the status is set to 4xx

content_length (len = nil)

Source

# File lib/stir_fry/response.rb, line 141
def content_length(len = nil)
  headers["Content-Length"] = len.to_s if len
  headers["Content-Length"]
end

Set the content length header on the response

content_type (kind = nil)

Source

# File lib/stir_fry/response.rb, line 135
def content_type(kind = nil)
  headers["Content-Type"] = mime_type(kind) if kind
  headers["Content-Type"]
end

Set the content type header on the response

etag (value, weak: false, new_resource: req.post?)

Source

# File lib/stir_fry/response.rb, line 170
def etag(value, weak: false, new_resource: req.post?)
  headers["ETag"] = etag_header_value(value, weak)
  return unless success? || status == 304

  raise(request_safe? ? NotModified : PreconditionFailed) if etag_matches?(env["HTTP_IF_NONE_MATCH"], new_resource)
  raise PreconditionFailed if env["HTTP_IF_MATCH"] && !etag_matches?(env["HTTP_IF_MATCH"], new_resource)
end

Set the response entity tag (HTTP ‘ETag’ header) and halt if conditional GET matches. The +value+ argument is an identifier that uniquely identifies the current version of the resource. The weak argument will allow a weak value but defaults to strong.

When the current request includes an ‘If-None-Match’ header with a matching etag, execution is immediately halted. If the request method is GET or HEAD, a ‘304 Not Modified’ response is sent.

expires (amount, *values)

Source

# File lib/stir_fry/response.rb, line 187
def expires(amount, *values)
  values << {} unless values.last.is_a?(Hash)
  time, max_age = expires_time_and_max_age(amount)

  values.last.merge!(max_age: max_age) { |_key, v1, v2| v1 || v2 }
  cache_control(*values)

  headers["Expires"] = time.httpdate
end

Set the Expires header and Cache-Control/max-age directive. Amount can be an integer number of seconds in the future or a Time object indicating when the response should be considered “stale”. The remaining “values” arguments are passed to the cache_control helper:

expires 500, :public, :must_revalidate => Cache-Control: public, must-revalidate, max-age=500 => Expires: Mon, 08 Jun 2009 08:50:17 GMT

headers ()

Source

# File lib/stir_fry/response.rb, line 126
def headers = resp.headers

Response headers.

html (body, stat = :ok)

Source

# File lib/stir_fry/response.rb, line 76
def html(body, stat = :ok) = answer(stat, :html, body)

respond with html content

informational? ()

Source

# File lib/stir_fry/response.rb, line 35
def informational? = status.between?(100, 199)

whether or not the status is set to 1xx

internal_error (body)

Source

# File lib/stir_fry/response.rb, line 58
def internal_error(body) = respond(body, :internal_server_error)

sugar for respond(body, :internal_error)

internal_error! (msg = "")

Source

# File lib/stir_fry/response.rb, line 69
def internal_error!(msg = "") = raise InternalError, msg

immediately return internal error status without running any following middleware.

json (body, stat = :ok)

Source

# File lib/stir_fry/response.rb, line 74
def json(body, stat = :ok) = answer(stat, :json, JSON.dump(body))

respond with json content

last_modified (time)

Source

# File lib/stir_fry/response.rb, line 204
def last_modified(time)
  return unless time

  time = time_for(time)
  headers["Last-Modified"] = time.httpdate
  return if env["HTTP_IF_NONE_MATCH"]

  check_if_modified_since(time)
  check_if_unmodified_since(time)
end

Set the last modified time of the resource (HTTP ‘Last-Modified’ header) and halt if conditional GET matches. The +time+ argument is a Time, DateTime, or other object that responds to +to_time+.

When the current request includes an ‘If-Modified-Since’ header that is equal or later than the time specified, execution is immediately halted with a ‘304 Not Modified’ response.

not_found (body)

Source

# File lib/stir_fry/response.rb, line 52
def not_found(body) = respond(body, :not_found)

sugar for respond(body, :not_found)

not_found! (msg = "")

Source

# File lib/stir_fry/response.rb, line 63
def not_found!(msg = "") = raise NotFound, msg

immediately return not found status without running any following middleware.

not_found? ()

Source

# File lib/stir_fry/response.rb, line 45
def not_found? = status == 404

whether or not the status is set to 404

ok (body)

Source

# File lib/stir_fry/response.rb, line 50
def ok(body) = respond(body, :ok)

sugar for respond(body, :ok)

ok! (msg = "")

Source

# File lib/stir_fry/response.rb, line 61
def ok!(msg = "") = raise OKAY, msg

immediately return okay status without running any following middleware.

redirect (uri)

Source

# File lib/stir_fry/response.rb, line 98
def redirect(uri)
  http_version = env["SERVER_PROTOCOL"]
  if (http_version == "HTTP/1.1") && (env["REQUEST_METHOD"] != "GET")
    status(303)
  else
    status(302)
  end
  headers["Location"] = uri.to_s
end

redirect the request to a uri

redirect? ()

Source

# File lib/stir_fry/response.rb, line 39
def redirect? = status.between?(300, 399)

whether or not the status is set to 3xx

redirect_back ()

Source

# File lib/stir_fry/response.rb, line 120
def redirect_back = redirect(req.referer)

Sugar for redirect(request.referer)

render (klass, stat = :ok)

Source

# File lib/stir_fry/response.rb, line 78
def render(klass, stat = :ok) = html(klass.render, stat)

respond with a rendered component. sugar for html(view.render)

respond (obj, stat = :ok)

Source

# File lib/stir_fry/response.rb, line 88
def respond(obj, stat = :ok)
  case obj
  when Hash then json(obj, stat)
  when StirFry::Component then render(obj, stat)
  when String then text(obj, stat)
  else status(stat)
  end
end

respond will choose what kind of content to respond with depending on what kind of data you give it.

respond({message: "hi"}, :ok) => application/json JSON response respond(AppView, :ok) => text/html HTML Component response respond("OKAY", :ok) => text/plain response

send_file (req, filename, attachment: false)

Source

# File lib/stir_fry/response.rb, line 216
def send_file(req, filename, attachment: false)
  if attachment
    headers["Content-Disposition"] =
      format('attachment; filename="%s"',
             File.basename(filename).gsub(/["\r\n]/, MULTIPART_FORM_DATA_REPLACEMENT_TABLE))
  end
  serve_file(req, filename)
end

Responde directly with a file.

server_error? ()

Source

# File lib/stir_fry/response.rb, line 43
def server_error? = status.between?(500, 599)

whether or not the status is set to 5xx

status (value = nil)

Source

# File lib/stir_fry/response.rb, line 129
def status(value = nil)
  resp.status = Rack::Utils.status_code(value) if value
  resp.status
end

Set the response status, and return the current status.

stream (&block)

Source

# File lib/stir_fry/response.rb, line 80
def stream(&block) = resp.body = block.to_proc

start a streaming body that doesn’t immeadiately close the connection.

success? ()

Source

# File lib/stir_fry/response.rb, line 37
def success? = status.between?(200, 299)

whether or not the status is set to 2xx

text (body, stat = :ok)

Source

# File lib/stir_fry/response.rb, line 72
def text(body, stat = :ok) = answer(stat, :text, body)

respond with text content

unauthorized (body)

Source

# File lib/stir_fry/response.rb, line 56
def unauthorized(body) = respond(body, :unauthorized)

sugar for respond(body, :unauthorized)

unauthorized! (msg = "")

Source

# File lib/stir_fry/response.rb, line 67
def unauthorized!(msg = "") = raise Unauthorized, msg

immediately return unauthorized status without running any following middleware.

uri (addr = nil, absolute: true)

Source

# File lib/stir_fry/response.rb, line 109
def uri(addr = nil, absolute: true)
  port_required = !req.forwarded_authority.nil? || (req.port != (req.ssl? ? 443 : 80))
  uri = [host = String.new]
  if absolute
    host.concat("http#{"s" if req.ssl?}://", port_required ? req.host_with_port : req.host)
  end
  uri << (addr || req.path_info).to_s
  File.join uri
end

Build and format a link with the current host and port.