stir_fry 0.1.0

data/lib/stir_fry/middleware/logger.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "json"
+
+module StirFry
+  module Middleware
+    # Logger is our custom logger for a better format using a shared logger
+    class Logger
+      # Create the new middleware for logging
+      def initialize(app, logger = ::Logger.new($stdout))
+        @app = app
+        @logger = logger
+      end
+
+      # Middleware call that logs the request and it's response.
+      def call(env)
+        began_at = Time.now.to_f
+        content = @app.call(env)
+        log(env, Time.now.to_f - began_at)
+        content
+      end
+
+      private
+
+      def log(env, elapsed)
+        req = env.fetch(App::REQUEST_ENV_KEY, Rack::Request.new(env))
+        resp = env.fetch(App::RESPONSE_ENV_KEY, Rack::Response.new(env))
+        log_method(resp).call(log_line(req, resp, elapsed))
+      end
+
+      def log_method(resp)
+        if resp.status.between?(100, 299)
+          @logger.method(:info)
+        elsif resp.status.between?(300, 499)
+          @logger.method(:warn)
+        else
+          @logger.method(:error)
+        end
+      end
+
+      def log_line(req, resp, elapsed)
+        {
+          method: req.request_method,
+          path: req.path_info,
+          query: req.query_string,
+          status: resp.status,
+          user: client_log(req),
+          request: req_log(req),
+          response: resp_log(resp, elapsed)
+        }.compact
+      end
+
+      def client_log(req)
+        {
+          ip: req.ip,
+          remote_user: req.get_header("REMOTE_USER")
+        }.compact
+      end
+
+      def req_log(req)
+        {
+          accept_encoding: req.get_header("HTTP_ACCEPT"),
+          scheme: req.scheme,
+          server_authority: req.server_authority,
+          referer: req.referer,
+          script_name: req.script_name,
+          media_type: req.media_type,
+          proto: req.get_header("SERVER_PROTOCOL")
+        }.compact
+      end
+
+      def resp_log(resp, elapsed)
+        line = {
+          content_type: resp.headers["Content-Type"],
+          content_length: resp.headers["Content-Length"],
+          elapsed: elapsed % 60
+        }
+
+        if resp.respond_to?(:request_error)
+          line[:error] = resp.request_error&.message&.to_s
+          line[:error_stacktrace] = resp.request_error&.backtrace
+        end
+
+        line.compact
+      end
+    end
+  end
+end

data/lib/stir_fry/middleware.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module StirFry
+  # Module containing middleware that makes this framework nicer to use.
+  module Middleware
+    autoload :Logger, "stir_fry/middleware/logger"
+  end
+end

data/lib/stir_fry/pages/error_page.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module StirFry
+  module Pages
+    # ErrorPage is a custom component and main handler for server errors. It will
+    # respond with a specific mime type depending on what was requested.
+    class ErrorPage < Component
+      # error is the error raised during the request cycle.
+      attr_reader :error
+
+      # Create a new error page that will display the message and status.
+      def initialize(error: "", **args)
+        super
+        @error = error
+      end
+
+      # format a message from the error
+      def message = error.message == error.class.name ? "" : error.message
+
+      # status will derive a response status from the error raised.
+      def status
+        @status ||= case error
+                    when NotFound then :not_found
+                    when BadRequest then :bad_request
+                    when Unauthorized then :unauthorized
+                    when PreconditionFailed then :precondition_failed
+                    else :internal_server_error
+                    end
+      end
+
+      # Overrides Component#call to customize the output based on mime.
+      def call
+        if request.json? then response.json(render_json, status)
+        elsif request.html? then response.html(render, status)
+        else response.text(message, status)
+        end
+      end
+
+      def title # :nodoc:
+        Rack::Utils::HTTP_STATUS_CODES[response.status].to_s
+      end
+
+      private
+
+      def render_json
+        {
+          error: title.downcase.tr(" ", "_"),
+          message: message
+        }
+      end
+    end
+  end
+end
+
+__END__
+<StirFry.Pages.Layout>
+  <section>
+    <header><h1>{title}</h1></header>
+    <section class="error-page">
+      <p class="error-page__code">{response.status}</p>
+      <p class="error-page__path">{ "[#{request.request_method.upcase}] #{request.host_with_port}#{request.path_info}" }</p>
+      <p class="error-page__message">{message}</p>
+      <ul class="error-page__backtrace">
+        {error.backtrace.map {|t| <li>{t.to_s}</li> }.join }
+      </ul>
+    </section>
+  </section>
+</StirFry.Pages.Layout>

data/lib/stir_fry/pages/layout.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module StirFry
+  module Pages
+    # Layout is the layout of the frameworks pages that it serves.
+    class Layout < Component; end
+  end
+end
+
+__END__
+<!DOCTYPE html>
+<html>
+  <head><link rel="stylesheet" href="/stir_fry/stir_fry.css" /></head>
+  <body>{ yield }</body>
+</html>

data/lib/stir_fry/pages/not_found_page.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module StirFry
+  module Pages
+    # NotFoundPage is a simple page to display 404 errors appropriate for the
+    # request mime type
+    class NotFoundPage < Component
+      # Overrides Component#call to customize the output based on mime.
+      def call
+        if request.json? then response.json({ error: "not_found", message: "Not Found" }, :not_found)
+        elsif request.html? then response.html(render, :not_found)
+        else response.text("Not Found", :not_found)
+        end
+      end
+    end
+  end
+end
+
+__END__
+<StirFry.Pages.Layout>
+  <section>
+    <header><h1>Not Found</h1></header>
+    <section class="error-page">
+      <p class="error-page__code">404</p>
+      <p class="error-page__message">Request path did not match any registered routes.</p>
+      <ul class="error-page__backtrace">
+        {application.all_routes.map { |route| <li>{route}</li> }.join }
+      </ul>
+    </section>
+  </section>
+</StirFry.Pages.Layout>

data/lib/stir_fry/pages/routes_page.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module StirFry
+  module Pages
+    # Displays routes that are defined by the app. This is only enabled in development
+    # and the route will not be define otherwise.
+    class RoutesPage < Component; end
+  end
+end
+
+__END__
+<StirFry.Pages.Layout>
+  <section>
+    <header><h1>Routes</h1></header>
+    <section>
+      <ul class="error-page__backtrace">
+        {application.all_routes.map { |route| <li>{route}</li> }.join }
+      </ul>
+    </section>
+  </section>
+</StirFry.Pages.Layout>

data/lib/stir_fry/pages.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module StirFry
+  module Pages # :nodoc:
+    autoload :Layout, "stir_fry/pages/layout"
+    autoload :ErrorPage, "stir_fry/pages/error_page"
+    autoload :RoutesPage, "stir_fry/pages/routes_page"
+    autoload :NotFoundPage, "stir_fry/pages/not_found_page"
+  end
+end

data/lib/stir_fry/request.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "rack"
+require "json"
+
+module StirFry
+  # Request expands Rack::Request to include url args
+  class Request < Rack::Request
+    # args are the parameters that were parsed from the url path such as resource ids.
+    attr_accessor :args
+
+    # The unescaped path from the request.
+    def path = @path ||= Rack::Utils.unescape_path(path_info)
+    # Returns true if the request accepts json
+    def json? = accept?("application/json")
+    # Returns true if the request accepts html
+    def html? = accept?("text/html")
+    # Returns true if the request accepts text
+    def text? = accept?("text/plain")
+    # Returns true if the request accepts xml
+    def xml? = accept?("application/xml")
+    # Returns true if the request accepts csv
+    def csv? = accept?("text/csv")
+    # Returns true if the request accepts header matches a mime type string
+    def accept?(mime) = accept_types.include?(mime)
+
+    # params wraps rack:request params and captures common errors. This is copied
+    # from Sinatra's handling of params.
+    def params
+      super
+    rescue Rack::Utils::ParameterTypeError, Rack::Utils::InvalidParameterError => e
+      raise BadRequest, "Invalid query parameters: #{Rack::Utils.escape_html(e.message)}"
+    rescue EOFError => e
+      raise BadRequest, "Invalid multipart/form-data: #{Rack::Utils.escape_html(e.message)}"
+    end
+
+    private
+
+    def accept_types
+      @accept_types ||= get_header("HTTP_ACCEPT").to_s.split(",").filter_map { |part| part.split(";", 2).first&.strip }
+    end
+  end
+end

data/lib/stir_fry/response.rb

@@ -0,0 +1,351 @@
+# frozen_string_literal: true
+
+require "rack"
+require "json"
+
+module StirFry
+  # Response is a wrapper around Rack::Response that makes it easier to generate
+  # rich responses easily.
+  class Response
+    # the corresponding reqest to this reponse.
+    attr_reader :req
+    # the inner Rack::Response that we are building.
+    attr_reader :resp
+    # the rack request env.
+    attr_reader :env
+    # if there was an error during the request it will be set here.
+    attr_accessor :request_error
+
+    MULTIPART_BOUNDARY = "AaB03x" # :nodoc:
+    MULTIPART_FORM_DATA_REPLACEMENT_TABLE = { # :nodoc:
+      '"' => "%22",
+      "\r" => "%0D",
+      "\n" => "%0A"
+    }.freeze
+
+    # create a new Reponse
+    def initialize(env)
+      @env = env
+      @req = StirFry::Request.new(env)
+      @resp = Rack::Response.new
+      content_type(Rack::MediaType.type(env["HTTP_ACCEPT"]))
+    end
+
+    # whether or not the status is set to 1xx
+    def informational? = status.between?(100, 199)
+    # whether or not the status is set to 2xx
+    def success? = status.between?(200, 299)
+    # whether or not the status is set to 3xx
+    def redirect? = status.between?(300, 399)
+    # whether or not the status is set to 4xx
+    def client_error? = status.between?(400, 499)
+    # whether or not the status is set to 5xx
+    def server_error? = status.between?(500, 599)
+    # whether or not the status is set to 404
+    def not_found? = status == 404
+    # whether or not the status is set to 400
+    def bad_request? = status == 400
+
+    # sugar for `respond(body, :ok)`
+    def ok(body) = respond(body, :ok)
+    # sugar for `respond(body, :not_found)`
+    def not_found(body) = respond(body, :not_found)
+    # sugar for `respond(body, :bad_request)`
+    def bad_request(body) = respond(body, :bad_request)
+    # sugar for `respond(body, :unauthorized)`
+    def unauthorized(body) = respond(body, :unauthorized)
+    # sugar for `respond(body, :internal_error)`
+    def internal_error(body) = respond(body, :internal_server_error)
+
+    # immediately return okay status without running any following middleware.
+    def ok!(msg = "") = raise OKAY, msg
+    # immediately return not found status without running any following middleware.
+    def not_found!(msg = "") = raise NotFound, msg
+    # immediately return bad request status without running any following middleware.
+    def bad_request!(msg = "") = raise BadRequest, msg
+    # immediately return unauthorized status without running any following middleware.
+    def unauthorized!(msg = "") = raise Unauthorized, msg
+    # immediately return internal error status without running any following middleware.
+    def internal_error!(msg = "") = raise InternalError, msg
+
+    # respond with text content
+    def text(body, stat = :ok) = answer(stat, :text, body)
+    # respond with json content
+    def json(body, stat = :ok) = answer(stat, :json, JSON.dump(body))
+    # respond with html content
+    def html(body, stat = :ok) = answer(stat, :html, body)
+    # respond with a rendered component. sugar for `html(view.render)`
+    def render(klass, stat = :ok) = html(klass.render, stat)
+    # start a streaming body that doesn't immeadiately close the connection.
+    def stream(&block) = resp.body = block.to_proc
+
+    # 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
+    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
+
+    # redirect the request to a uri
+    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
+
+    # Build and format a link with the current host and port.
+    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
+
+    # Sugar for redirect(request.referer)
+    def redirect_back = redirect(req.referer)
+    # 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.
+    def body = resp.body
+    # Response headers.
+    def headers = resp.headers
+
+    # Set the response status, and return the current status.
+    def status(value = nil)
+      resp.status = Rack::Utils.status_code(value) if value
+      resp.status
+    end
+
+    # Set the content type header on the response
+    def content_type(kind = nil)
+      headers["Content-Type"] = mime_type(kind) if kind
+      headers["Content-Type"]
+    end
+
+    # Set the content length header on the response
+    def content_length(len = nil)
+      headers["Content-Length"] = len.to_s if len
+      headers["Content-Length"]
+    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
+    #
+    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
+
+    # 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.
+    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 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
+    #
+    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 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.
+    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
+
+    # Responde directly with a file.
+    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
+
+    def finish # :nodoc:
+      clear_body_headers if informational? || [204, 304].include?(status)
+      resp.body = [] if [204, 304].include?(status)
+      content_length(resp.body.sum(&:bytesize)) if resp.body.is_a?(Array) && !content_length
+      resp.to_a
+    end
+
+    private
+
+    def answer(stat, contenttype, value)
+      status(stat)
+      content_type(contenttype)
+      resp.body = value.is_a?(String) ? [value.to_str] : value
+    end
+
+    def request_safe?
+      req.get? || req.head? || req.options? || req.trace?
+    end
+
+    def mime_type(type)
+      return type      if type.nil?
+      return type.to_s if type.to_s.include?("/")
+
+      type = ".#{type}" unless type.to_s[0] == "."
+      Rack::Mime.mime_type(type, nil)
+    end
+
+    def etag_matches?(list, new_resource = req.post?)
+      return !new_resource if list == "*"
+
+      list.to_s.split(",").map(&:strip).include?(headers["ETag"])
+    end
+
+    def etag_header_value(value, weak) = format('%<weak>s"%<value>s"', weak: weak ? "W/" : "", value: value)
+
+    def extract_cache_control_hash(values)
+      return {} unless values.last.is_a?(Hash)
+
+      hash = values.pop
+      hash.reject! { |_k, v| v == false }
+      hash.reject! { |k, v| values << k if v == true }
+      hash
+    end
+
+    def cache_control_pair(key, value)
+      key = key.to_s.tr("_", "-")
+      value = value.to_i if %w[max-age s-maxage].include? key
+      "#{key}=#{value}"
+    end
+
+    def expires_time_and_max_age(amount)
+      return [Time.now + amount.to_i, amount] if amount.is_a? Integer
+
+      time = time_for(amount)
+      [time, time - Time.now]
+    end
+
+    def check_if_modified_since(time)
+      return unless (status == 200) && env["HTTP_IF_MODIFIED_SINCE"]
+
+      since = Time.httpdate(env["HTTP_IF_MODIFIED_SINCE"]).to_i
+      raise NotModified if since >= time.to_i
+    end
+
+    def check_if_unmodified_since(time)
+      return unless (success? || (status == 412)) && env["HTTP_IF_UNMODIFIED_SINCE"]
+
+      since = Time.httpdate(env["HTTP_IF_UNMODIFIED_SINCE"]).to_i
+      raise PreconditionFailed if since < time.to_i
+    end
+
+    def time_for(value)
+      if value.is_a? Numeric
+        Time.at value
+      elsif value.respond_to? :to_s
+        Time.parse value.to_s
+      else
+        value.to_time
+      end
+    end
+
+    def serve_file(req, filename)
+      content_type(File.extname(filename))
+      last_modified(File.mtime(filename))
+      size = ::File.size?(filename) || ::File.read(filename).bytesize
+      ranges = Rack::Utils.get_byte_ranges(req.get_header("HTTP_RANGE"), size)
+      if ranges.nil? then send_full_file_content(filename, size)
+      elsif ranges.empty? then bad_file_send_range(size)
+      else send_partial_file(filename, ranges, size)
+      end
+    rescue Errno::ENOENT
+      raise NotFound
+    end
+
+    def send_full_file_content(filename, size)
+      content_length(size)
+      resp.body = if req.head?
+                    []
+                  else
+                    Rack::Files::Iterator.new(filename, [0..(size - 1)], mime_type: content_type,
+                                                                         size: size)
+                  end
+    end
+
+    def bad_file_send_range(size)
+      headers["content-range"] = "bytes */#{size}"
+      answer(416, :text, "Byte range unsatisfiable")
+    end
+
+    def send_partial_file(filename, ranges, size)
+      if ranges.size == 1
+        headers["content-range"] = "bytes #{ranges[0].begin}-#{ranges[0].end}/#{size}"
+      else
+        content_type("multipart/byteranges; boundary=#{MULTIPART_BOUNDARY}")
+      end
+      status(206)
+      body = Rack::Files::BaseIterator.new(filename, ranges, mime_type: content_type, size: size)
+      content_length(body.bytesize)
+      resp.body = req.head? ? [] : body
+    end
+
+    def clear_body_headers
+      headers.delete "content-length"
+      headers.delete "content-type"
+    end
+  end
+end