rackr 0.0.64 → 0.0.67

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7b2ba418e1314ee479ecaa958fe3b88b8a59f43360f3411011cc24c70576ed57
-  data.tar.gz: fefd0f17b2d1b935b80606f9c12a99b4d866e1ed9b57038a74e3b157ee2933fa
+  metadata.gz: a2c53919b2365343fd55636d5d3a29b41e93975a60ef3d2af74416e12808f27a
+  data.tar.gz: 32f5c5da65e14bf318c07427fd5bb0f9c978c04d75e94877ddab0793da4a8005
 SHA512:
-  metadata.gz: 4dd390660b33e36ee89c535433a6ffaadc8e669fb9f4a3d05cd1edecf85f62d4fec4d0c6c130959225d7b08e37f0621878b2d92df54ec9dee777cc2e153be0fc
-  data.tar.gz: 8b7eb721d13f69adac0a46d98a21e4159fd69265ecdea1c5c3400f1ecc8e90dadbf91996e4add09b5d0a8b66635ffb9d6b1d69f5bd6dc9580b84dd35380a9bb4
+  metadata.gz: 8e0decd638c32afe394950c7b45bf44539704b136bde9d9e9dfc2a698e37c427317e16fb310bb6515d0f4a339fd224228d9d5ee424ddbaca7f191ec8f40f4b27
+  data.tar.gz: 04117f475a16165a813cac337f72880e6d461ffe41e3ce085ab06690fbc4b21a85f1f22d343fa4a4b070f4a7d9898f26eec29d231df7c8b9469b4d2d60f34848

data/lib/rackr/action.rb

@@ -3,76 +3,259 @@
 require 'erubi'
 require 'oj'
 require 'rack'
+require_relative 'action/callbacks'
 
 class Rackr
+  # This module provides the action functions available inside the routes context or
+  # specific action class that included the Rackr::Action.
   module Action
+    MIME_TYPES = {
+      text: 'text/plain',
+      html: 'text/html',
+      json: 'application/json',
+      manifest: 'text/cache-manifest',
+      atom: 'application/atom+xml',
+      avi: 'video/x-msvideo',
+      bmp: 'image/bmp',
+      bz: 'application/x-bzip',
+      bz2: 'application/x-bzip2',
+      chm: 'application/vnd.ms-htmlhelp',
+      css: 'text/css',
+      csv: 'text/csv',
+      flv: 'video/x-flv',
+      gif: 'image/gif',
+      gz: 'application/x-gzip',
+      h264: 'video/h264',
+      ico: 'image/vnd.microsoft.icon',
+      ics: 'text/calendar',
+      jpg: 'image/jpeg',
+      js: 'application/javascript',
+      mp4: 'video/mp4',
+      mov: 'video/quicktime',
+      mp3: 'audio/mpeg',
+      mp4a: 'audio/mp4',
+      mpg: 'video/mpeg',
+      oga: 'audio/ogg',
+      ogg: 'application/ogg',
+      ogv: 'video/ogg',
+      pdf: 'application/pdf',
+      pgp: 'application/pgp-encrypted',
+      png: 'image/png',
+      psd: 'image/vnd.adobe.photoshop',
+      rss: 'application/rss+xml',
+      rtf: 'application/rtf',
+      sh: 'application/x-sh',
+      svg: 'image/svg+xml',
+      swf: 'application/x-shockwave-flash',
+      tar: 'application/x-tar',
+      torrent: 'application/x-bittorrent',
+      tsv: 'text/tab-separated-values',
+      uri: 'text/uri-list',
+      vcs: 'text/x-vcalendar',
+      wav: 'audio/x-wav',
+      webm: 'video/webm',
+      wmv: 'video/x-ms-wmv',
+      woff: 'application/font-woff',
+      woff2: 'application/font-woff2',
+      wsdl: 'application/wsdl+xml',
+      xhtml: 'application/xhtml+xml',
+      xml: 'application/xml',
+      xslt: 'application/xslt+xml',
+      yml: 'text/yaml',
+      zip: 'application/zip'
+    }.freeze
+
+    DEFAULT_CSP_HEADERS = {
+      base_uri: "'self'",
+      child_src: "'self'",
+      connect_src: "'self'",
+      default_src: "'none'",
+      font_src: "'self'",
+      form_action: "'self'",
+      frame_ancestors: "'self'",
+      frame_src: "'self'",
+      img_src: "'self' https: data:",
+      media_src: "'self'",
+      object_src: "'none'",
+      script_src: "'self'",
+      style_src: "'self' 'unsafe-inline' https:"
+    }.freeze
+
+    # These are constant (not methods) for better performance
+
+    DEFAULT_HEADERS = (proc do |content_type, headers, content|
+      {
+        'content-type' => content_type,
+        'content-length' => content.bytesize.to_s
+      }.merge(headers)
+    end).freeze
+
     RENDER = {
-      html: lambda do |val, status: 200, headers: {}, html: nil|
-        [status, { 'content-type' => 'text/html', 'content-length' => val.bytesize.to_s }.merge(headers), [val]]
+      json: proc do |content, status, headers, charset|
+        content = Oj.dump(content, mode: :compat) unless content.is_a?(String)
+        [status || 200, DEFAULT_HEADERS.call("application/json; charset=#{charset}", headers, content), [content]]
       end,
-      text: lambda do |val, status: 200, headers: {}, text: nil|
-        [status, { 'content-type' => 'text/plain', 'content-length' => val.bytesize.to_s }.merge(headers), [val]]
+      html: proc do |content, status, headers, charset, content_security_policy|
+        headers['content-security-policy'] = content_security_policy
+        [status || 200, DEFAULT_HEADERS.call("text/html; charset=#{charset}", headers, content), [content]]
       end,
-      json: lambda do |val, status: 200, headers: {}, json: nil|
-        val = Oj.dump(val, mode: :compat) unless val.is_a?(String)
-        [status, { 'content-type' => 'application/json', 'content-length' => val.bytesize.to_s }.merge(headers), [val]]
+      res: proc do |content, status, _headers, charset|
+        content.status = status if status
+        if charset
+          content.content_type =
+            (content.content_type || 'charset=utf-8').sub(/charset=\S+/, "charset=#{charset}")
+        end
+        content.headers['content-length'] ||= content.body.join.bytesize.to_s
+        content.finish
       end,
-      res: lambda do |val, status: nil, headers: nil, res: nil|
-        val.status = status if status
-        headers.each { |h, v| val.set_header(h, v) } if headers
-        val.finish
+      response: proc do |content, status, _headers, charset|
+        content.status = status if status
+        if charset
+          content.content_type =
+            (content.content_type || 'charset=utf-8').sub(/charset=\S+/, "charset=#{charset}")
+        end
+        content.headers['content-length'] ||= content.body.join.bytesize.to_s
+        content.finish
+      end
+    }.freeze
+
+    BUILD_RESPONSE = {
+      json: proc do |content, status, headers, charset|
+        content = Oj.dump(content, mode: :compat) unless content.is_a?(String)
+        Rack::Response.new(content, status,
+                           DEFAULT_HEADERS.call("application/json; charset=#{charset}", headers, content))
+      end,
+      html: proc do |content, status, headers, charset, content_security_policy|
+        headers['content-security-policy'] = content_security_policy
+        Rack::Response.new(content, status, DEFAULT_HEADERS.call("text/html; charset=#{charset}", headers, content))
       end,
-      response: lambda do |val, status: nil, headers: nil, response: nil|
-        val.status = status if status
-        headers.each { |h, v| val.set_header(h, v) } if headers
-        val.finish
+      head: proc do |status, _empty, headers|
+        Rack::Response.new(nil, status, headers)
+      end,
+      redirect_to: proc do |content, _status, headers|
+        Rack::Response.new(
+          nil,
+          302,
+          { 'location' => content }.merge(headers)
+        )
       end
     }.freeze
 
     def self.included(base)
       base.class_eval do
-        attr_reader :routes, :config, :deps, :db if self != Rackr
+        if self != Rackr
+          attr_reader :routes, :config, :deps, :db, :log, :cache
+
+          include Callbacks unless included_modules.include?(Rackr::Callback)
+        end
+
+        include HtmlSlice if Object.const_defined?('HtmlSlice')
+        include Stimulux if Object.const_defined?('Stimulux')
 
         def initialize(routes: nil, config: nil)
           @routes = routes
           @config = config
-          @deps = config[:deps]
-          @db = config.dig(:deps, :db)
+          @deps = config&.dig(:deps)
+          @db = config&.dig(:deps, :db)
+          @log = config&.dig(:deps, :log)
+          @cache = config&.dig(:deps, :cache)
+        end
+
+        def url_for(method, name)
+          "#{config&.dig(:host)}#{path_for(method, name)}"
+        end
+
+        def path_for(method, name)
+          routes.send(method)&.dig(name)
         end
 
         def render(**opts)
           type = opts.keys.first
           content = opts[type]
 
-          Rackr::Action::RENDER[type]&.call(content, **opts) || _render_view(content, **opts)
+          if (renderer = RENDER[type])
+            return renderer.call(
+              content,
+              opts[:status],
+              opts[:headers] || {},
+              opts[:charset] || 'utf-8',
+              content_security_policy
+            )
+          end
+
+          if (mime = MIME_TYPES[type])
+            return [
+              opts[:status] || 200,
+              DEFAULT_HEADERS.call(
+                "#{mime}; charset=#{opts[:charset] || 'utf-8'}",
+                opts[:headers] || {},
+                content
+              ),
+              [content]
+            ]
+          end
+
+          _render_view(
+            content,
+            status: opts[:status] || 200,
+            headers: opts[:headers] || {},
+            layout_path: opts[:layout_path] || 'layout',
+            view: opts[:view],
+            response_instance: opts[:response_instance] || false,
+            charset: opts[:charset] || 'utf-8'
+          )
         end
 
-        def view_response(
-          paths,
-          status: 200,
-          headers: {},
-          layout_path: 'layout'
-        )
+        def build_response(**opts)
+          type = opts.keys.first
+          content = opts[type]
+
+          if (builder = BUILD_RESPONSE[type])
+            return builder.call(
+              content,
+              opts[:status] || 200,
+              opts[:headers] || {},
+              opts[:charset] || 'utf-8',
+              content_security_policy
+            )
+          end
+
+          if (mime = MIME_TYPES[type])
+            return Rack::Response.new(
+              content,
+              opts[:status] || 200,
+              DEFAULT_HEADERS.call(
+                "#{mime}; charset=#{opts[:charset] || 'utf-8'}",
+                opts[:headers] || {},
+                content
+              )
+            )
+          end
+
           _render_view(
-            paths,
-            status: status,
-            headers: headers,
-            layout_path: layout_path,
-            response_instance: true
+            content,
+            status: opts[:status] || 200,
+            headers: opts[:headers] || {},
+            layout_path: opts[:layout_path] || 'layout',
+            view: opts[:view],
+            response_instance: true,
+            charset: opts[:charset] || 'utf-8'
           )
         end
 
         def _render_view(
           paths,
-          status: 200,
-          headers: {},
-          layout_path: 'layout',
-          response_instance: false,
-          view: nil
+          status:,
+          headers:,
+          layout_path:,
+          response_instance:,
+          view:,
+          charset:
         )
           base_path = config.dig(:views, :path) || 'views'
+          headers['content-security-policy'] ||= content_security_policy
 
-          file_or_nil = lambda do |path|
+          file_or_nil = proc do |path|
             ::File.read(path)
           rescue Errno::ENOENT
             nil
@@ -99,62 +282,31 @@ class Rackr
             return Rack::Response.new(
               parsed_erb,
               status,
-              { 'content-type' => 'text/html' }.merge(headers)
+              DEFAULT_HEADERS.call("text/html; charset=#{charset}", headers, parsed_erb)
             )
           end
 
-          [status, { 'content-type' => 'text/html', 'content-length' => parsed_erb.bytesize.to_s }.merge(headers),
-           [parsed_erb]]
+          [status, DEFAULT_HEADERS.call("text/html; charset=#{charset}", headers, parsed_erb), [parsed_erb]]
         end
 
-        def load_json(val)
-          return Oj.load(val.body.read) if val.is_a?(Rack::Request)
-
-          Oj.load(val)
+        def d(content)
+          raise Rackr::Dump, content
         end
 
-        def html_response(content = '', status: 200, headers: {})
-          Rack::Response.new(content, status,
-                             { 'content-type' => 'text/html', 'content-length' => content.bytesize.to_s }.merge(headers))
-        end
-
-        def json_response(content = {}, status: 200, headers: {})
-          content = Oj.dump(content, mode: :compat) unless content.is_a?(String)
-          Rack::Response.new(
-            content,
-            status,
-            { 'content-type' => 'application/json', 'content-length' => content.bytesize.to_s }.merge(headers)
-          )
-        end
-
-        def text_response(content, status: 200, headers: {})
-          Rack::Response.new(
-            content,
-            status,
-            { 'content-type' => 'text/plain', 'content-length' => content.bytesize.to_s }.merge(headers)
-          )
+        def not_found!
+          raise Rackr::NotFound
         end
 
+        # rubocop:disable Security/Eval
         def load_erb(content, binding_context: nil)
           eval(Erubi::Engine.new(content).src, binding_context)
         end
+        # rubocop:enable Security/Eval
 
         def head(status, headers: {})
           [status, headers, []]
         end
 
-        def head_response(status, headers: {})
-          Rack::Response.new(nil, status, headers)
-        end
-
-        def redirect_response(url, headers: {})
-          Rack::Response.new(
-            nil,
-            302,
-            { 'location' => url }.merge(headers)
-          )
-        end
-
         def redirect_to(url, headers: {})
           [302, { 'location' => url }.merge(headers), []]
         end
@@ -162,7 +314,17 @@ class Rackr
         def response(body = nil, status = 200, headers = {})
           Rack::Response.new(body, status, headers)
         end
+
+        def content_security_policy
+          @content_security_policy ||=
+            DEFAULT_CSP_HEADERS
+            .merge(config&.dig(:csp_headers) || {})
+            .map { |k, v| "#{k.to_s.tr('_', '-')} #{v}" }
+            .join('; ')
+        end
       end
     end
   end
+  # rubocop:enable Metrics/PerceivedComplexity
+  # rubocop:enable Metrics/MethodLength
 end

data/lib/rackr/callback.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 class Rackr
+  # A callback is just a Rackr::Action with the assign method
   module Callback
     def self.included(base)
       base.class_eval do

data/lib/rackr/router/build_request.rb

@@ -2,6 +2,7 @@
 
 class Rackr
   class Router
+    # This class is responsible for initialize the Rack::Request object and give it the path params
     class BuildRequest
       def initialize(env, spplited_request_path)
         @env = env

data/lib/rackr/router/dev_html/dump.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'rack/utils'
+
+class Rackr
+  class Router
+    module DevHtml
+      # Pretty print the content of the dump
+      class PrettyPrint
+        def self.call(content, level = 0)
+          content = content.inspect if content.instance_of?(String)
+          content = 'nil' if content.instance_of?(nil)
+          content = 'false' if content.instance_of?(false)
+
+          return "<pre>#{Rack::Utils.escape_html(content)}</pre>" if level >= 2
+
+          case content
+          when String, Symbol, Numeric, TrueClass, FalseClass, NilClass
+            "<pre>#{Rack::Utils.escape_html(content)}</pre>"
+          when Array
+            pretty_print_array(content, level)
+          when Hash
+            pretty_print_hash(content, level)
+          else
+            pretty_print_object(content, level)
+          end
+        end
+
+        def self.pretty_print_array(array, level)
+          list_items = array.map do |item|
+            "<li>#{call(item, level + 1)}</li>"
+          end.join
+
+          "<ul>#{list_items}</ul>"
+        end
+
+        def self.pretty_print_hash(hash, level)
+          list_items = hash.map do |key, value|
+            "<li><strong>#{key.inspect} =></strong> #{call(value, level + 1)}</li>"
+          end.join
+
+          "<ul>#{list_items}</ul>"
+        end
+
+        def self.pretty_print_object(content, level)
+          instance_vars = content.instance_variables.map do |var|
+            value = content.instance_variable_get(var)
+            "<li><strong>#{var}:</strong> #{call(value, level + 1)}</li>"
+          end.join
+
+          "<h3>#{content.class}</h3><ul>#{instance_vars}</ul>"
+        end
+      end
+
+      # This is the action that is called when a dump is raised
+      class Dump
+        include Rackr::Action
+
+        def call(env)
+          res = response(<<-HTML
+            <!DOCTYPE html>
+            <html>
+            <head>
+              <title>Application dump</title>
+              <style>
+                body {
+                  padding: 0px;
+                  margin: 0px;
+                  font:small sans-serif;
+                  background-color: #2b2b2b;
+                  color: white;
+                }
+                h2 {
+                  margin: 0px;
+                  padding: 0.2em;
+                  background-color: #353535;
+                }
+                li {
+                  padding: 0px;
+                }
+                div {
+                  margin: 1em;
+                }
+              </style>
+            </head>
+            <body>
+              <h2>#{env['dump'].content.class}</h2>
+              <div>
+                <h3>Methods</h3>
+                #{env['dump'].content.methods}
+                <h3>Content</h3>
+                #{PrettyPrint.call(env['dump'].content)}
+              </div>
+            </body>
+            </html>
+          HTML
+                        )
+          res.status = 200
+          res.headers['content-type'] = 'text/html'
+          render res:
+        end
+      end
+    end
+  end
+end

data/lib/rackr/router/{errors/dev_html.rb → dev_html/errors.rb}

@@ -2,12 +2,13 @@
 
 class Rackr
   class Router
-    module Errors
-      class DevHtml
+    module DevHtml
+      # This is the action that is called when an error is raised
+      class Errors
         include Rackr::Action
 
         def call(env)
-          render(html: <<-HTML
+          res = build_response(html: <<-HTML
             <!DOCTYPE html>
             <html>
             <head>
@@ -20,9 +21,9 @@ class Rackr
                 body>div { border-bottom:1px solid #ddd; }
                 h1 { font-weight:normal; }
                 h2 { margin-bottom:.8em; }
-                h2 span { font-size:80%; color:#666; font-weight:normal; }
+                h2 span { font-size:80%; color:#555; font-weight:normal; }
                 #summary { background: #ffc; }
-                #summary h2 { font-weight: normal; color: #666; }
+                #summary h2 { font-weight: normal; color: #555; }
                 #backtrace { background: #eee; }
                 pre {
                   background: #ddd;
@@ -45,12 +46,14 @@ class Rackr
             </body>
             </html>
           HTML
-                )
+                              )
+          res.status = 500
+          render res:
         end
 
         def backtrace(env)
           first, *tail = env['error'].backtrace
-          traceback = String.new("<h2>Traceback <span>(innermost first)</span></h2>")
+          traceback = +'<h2>Traceback <span>(innermost first)</span></h2>'
           traceback << "<p class=\"first-p\">#{first}</p><br/>"
 
           line_number = extract_line_number(first)
@@ -58,10 +61,10 @@ class Rackr
           file_path = (match ? match[1] : nil)
           unless file_path.nil?
             lines = File.readlines(file_path).map.with_index { |line, i| "#{i + 1}: #{line}" }
-            traceback << "<pre>#{slice_around_index(lines, line_number).join('')}</pre>"
+            traceback << "<pre>#{slice_around_index(lines, line_number).join}</pre>"
           end
 
-          traceback << "<p>#{tail.join("<br>")}</p>"
+          traceback << "<p>#{tail.join('<br>')}</p>"
           traceback
         end
 

data/lib/rackr/router/endpoint.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class Rackr
+  class Router
+    # A endpoint in Rackr is all objects that respond do .call, or .new.call
+    module Endpoint
+      def self.call(endpoint, content, routes = nil, config = nil, error = nil)
+        instance =
+          if endpoint.respond_to?(:call)
+            endpoint
+          elsif endpoint < Rackr::Action || endpoint < Rackr::Callback
+            endpoint.new(routes:, config:)
+          else
+            endpoint.new
+          end
+
+        return instance.call(content, error) if error
+
+        instance.call(content)
+      end
+    end
+  end
+end

data/lib/rackr/router/errors.rb

@@ -2,6 +2,7 @@
 
 class Rackr
   class Router
+    # Errors for the router
     module Errors
       class Error < StandardError; end
       class InvalidNamedRouteError < Error; end
@@ -10,8 +11,15 @@ class Rackr
       class InvalidCallbackError < Error; end
       class InvalidPathError < Error; end
       class InvalidBranchNameError < Error; end
+      class InvalidRackResponseError < StandardError; end
 
       class << self
+        def check_rack_response(response, where)
+          return if response.is_a?(Array)
+
+          raise(InvalidRackResponseError, "Invalid Rack response in #{where}, received: #{response}")
+        end
+
         def check_scope_name(path)
           return if path.is_a?(String) || path.is_a?(Symbol) || path.nil?
 
@@ -39,7 +47,7 @@ class Rackr
 
         def check_callbacks(callbacks, path)
           check = lambda { |callback|
-            unless callback.nil? || callback.respond_to?(:call) || (callback.respond_to?(:new) && callback.instance_methods.include?(:call))
+            unless callback.nil? || callback.respond_to?(:call) || (callback.respond_to?(:new) && callback.method_defined?(:call))
               raise(InvalidCallbackError,
                     "Callbacks must respond to a `call` method or be a class with a `call` instance method, got: '#{callback.inspect}' for '#{path}'")
             end
@@ -49,9 +57,7 @@ class Rackr
         end
 
         def check_endpoint(endpoint, path)
-          if endpoint.respond_to?(:call) || (endpoint.respond_to?(:new) && endpoint.instance_methods.include?(:call))
-            return
-          end
+          return if endpoint.respond_to?(:call) || (endpoint.respond_to?(:new) && endpoint.method_defined?(:call))
 
           raise(InvalidEndpointError,
                 "Endpoints must respond to a `call` method or be a class with a `call` instance method, got: '#{endpoint.inspect}' for '#{path}'")

data/lib/rackr/router/path_route.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+class Rackr
+  class Router
+    # Path route is a route that has a path value that can be matched, and may have path params
+    class PathRoute < Route
+      attr_reader :splitted_path,
+                  :has_params
+
+      def initialize(path, endpoint, befores: [], afters: [], wildcard: false)
+        super(endpoint, befores:, afters:)
+
+        @path = path
+        @splitted_path = @path.split('/')
+        @params = fetch_params
+        @has_params = @params != []
+        @path_regex = /\A#{path.gsub(/(:\w+)/, '([^/]+)')}\z/
+        @wildcard = wildcard
+      end
+
+      def match?(path_info)
+        return path_info.match?(@path_regex) if @has_params
+        return true if @wildcard
+
+        path_info == @path
+      end
+
+      private
+
+      def fetch_params
+        @splitted_path.select { |value| value.start_with? ':' }
+      end
+    end
+  end
+end