lennarb 0.1.0

data/lib/lenna/router/cache.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Lenna
+  class Router
+    # @api public
+    # @note This class is used to cache the routes.
+    class Cache
+      def initialize = @cache = {}
+
+      # @api public
+      # @param [String] method
+      # @param [String] path
+      # @return [String]
+      # @note This method is used to generate a key for the cache.
+      def cache_key(method, path) = "#{method} #{path}"
+
+      # @api public
+      # @param route_key [String] The key for the route.
+      # @param node      [Lenna::Route::Node] The node for the route.
+      # @return          [Lenna::Route::Node]
+      # @note            This method is used to add a route to the cache.
+      def add(route_key, node) = @cache[route_key] = node
+
+      # @api public
+      # @param route_key [String] The key for the route.
+      # @return          [Lenna::Route::Node]
+      # @note            This method is used to get a route from the cache.
+      def get(route_key) = @cache[route_key]
+
+      # @api public
+      # @param route_key [String] The key for the route.
+      # @return          [Boolean]
+      # @note            This method is used to check if a route exists
+      #                  in the cache.
+      def exist?(route_key) = @cache.key?(route_key)
+    end
+  end
+end

data/lib/lenna/router/namespace_stack.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Lenna
+  class Router
+    # This class is used to manage the namespaces.
+    #
+    # @api private
+    class NamespaceStack
+      # @return [Array] The stack of namespaces
+      #
+      # @api private
+      attr_reader :stack
+
+      # @return [void]
+      #
+      # @api private
+      def initialize = @stack = ['']
+
+      # This method is used to push a prefix to the stack.
+      #
+      # @param prefix [String] The prefix to be pushed
+      # @return       [void]
+      #
+      # @example:
+      #
+      #  stack = NamespaceStack.new
+      #  stack.push('/users')
+      #  stack.current_prefix # => '/users'
+      #
+      # @see #resolve_prefix
+      #
+      # @api private
+      def push(prefix)
+        @stack.push(resolve_prefix(prefix))
+      end
+
+      # @return [String] The popped prefix
+      #
+      # @api private
+      def pop
+        @stack.pop unless @stack.size == 1
+      end
+
+      # @return [String] The current prefix
+      #
+      # @api private
+      #
+      # @since 0.1.0
+      def current_prefix = @stack.last
+
+      # The to_s method is used to return the current prefix.
+      #
+      # @return [String] The current prefix
+      #
+      # @api private
+      def to_s = current_prefix
+
+      private
+
+      # The resolve_prefix method is used to resolve the prefix.
+      #
+      # @param prefix [String] The prefix to be resolved
+      # @return       [String] The resolved prefix
+      #
+      # @see #current_prefix
+      #
+      # @since 0.1.0
+      def resolve_prefix(prefix)
+        current_prefix + prefix
+      end
+    end
+  end
+end

data/lib/lenna/router/request.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Lenna
+  class Router
+    # The Request class is responsible for managing the request.
+    #
+    # @attr headers [Hash] the request headers
+    # @attr body    [Hash] the request body
+    # @attr params  [Hash] the request params
+    class Request < ::Rack::Request
+      # This method is used to parse the body params.
+      #
+      # @return [Hash] the request params
+      #
+      # @public
+      def params = super.merge(parse_body_params)
+
+      # This method rewinds the body
+      #
+      # @return [String] the request body content
+      #
+      # @api public
+      #
+      # @since 0.1.0
+      def body_content
+        body.rewind
+        body.read
+      end
+
+      # This method returns the headers in a normalized way.
+      #
+      # @return [Hash] the request headers
+      #
+      # @api public
+      #
+      # @example:
+      # Turn this:
+      # HTTP_FOO=bar Foo=bar
+      def headers
+        @headers ||= env.select { |k, _| k.start_with?('HTTP_') }
+                        .transform_keys { |k| format_header_name(k) }
+      end
+
+      # This method returns the request body in a normalized way.
+      #
+      # @return [Hash] the request body
+      #
+      # @api public
+      def json_body = @json_body ||= parse_body_params
+
+      private
+
+      def json_request? = media_type == 'application/json'
+
+      def parse_json_body
+        @parsed_json_body ||= ::JSON.parse(body_content) if json_request?
+      rescue ::JSON::ParserError
+        {}
+      end
+
+      def parse_body_params
+        case media_type
+        when 'application/json'
+          parse_json_body
+        when 'application/x-www-form-urlencoded', 'multipart/form-data'
+          post_params
+        else
+          {}
+        end
+      end
+
+      def format_header_name(name)
+        name.sub(/^HTTP_/, '').split('_').map(&:capitalize).join('-')
+      end
+    end
+  end
+end

data/lib/lenna/router/response.rb

@@ -0,0 +1,357 @@
+# frozen_string_literal: true
+
+module Lenna
+  class Router
+    # The Response class is responsible for managing the response.
+    #
+    # @attr _headers [Hash]          the response headers
+    # @attr _body    [Array(String)] the response body
+    # @attr _status  [Integer]       the response status
+    # @attr params   [Hash]          the response params
+    class Response
+      public  attr_reader :params
+      private attr_accessor :_headers, :_body, :_status
+
+      # Initialize the Response
+      def initialize(headers = {}, status = 200, body = [])
+        self._headers = headers
+        self._status  = status
+        self._body    = body
+        @params       = {}
+      end
+
+      # @api public
+      # @return [Integer] the response status
+      def status = fetch_status
+
+      # @api public
+      # @param status [Integer] the response status
+      # @return       [void]
+      def put_status(value) = status!(value)
+
+      # @api public
+      # @return [Array(String)] the body value
+      def body = fetch_body
+
+      # @api public
+      # @param value [Array(String)] the body value
+      # @return      [void]
+      def put_body(value) = body!(value)
+
+      # @api public
+      # @param header [String] the header name
+      # @return       [String] the header value
+      # @note                  This method will get the header value.
+      def header(key) = fetch_header(key)
+
+      # @api public
+      # @return [Hash] the response headers
+      def headers = fetch_headers
+
+      # @api public
+      # @param header [String] the header name
+      # @param value  [String] the header value
+      # @return       [void]
+      # @note                  This method will set the header value.
+      #                        If the header already exists, then the value will
+      #                        be appended to the header.
+      #
+      # @example
+      #   put_header('X-Request-Id', '123')
+      #   # => '123'
+      #
+      #   put_header('X-Request-Id', '456')
+      #   # => ['123', '456']
+      #
+      #   put_header('X-Request-Id', ['456', '789'])
+      #   # => ['123', '456', '789']
+      def put_header(key, value) = header!(key, value)
+
+      # Add multiple headers.
+      # @param headers [Hash] the headers
+      # @return        [void]
+      # @note                 This method will add the headers.
+      #                       The headers are a hash where the key is the
+      #                       header name and the value is the header value.
+      #
+      # @example
+      #   headers = {
+      #     'Content-Type' => 'application/json',
+      #     'X-Request-Id' => '123'
+      #   }
+      #
+      def put_headers(headers)
+        headers => ::Hash
+
+        headers.each { |key, value| put_header(key, value) }
+      end
+
+      # @api public
+      # @param header [String] the header name
+      # @return       [void]
+      # @note                 This method will delete the header.
+      def remove_header(key) = delete_header(key)
+
+      # @api public
+      # @param value [String] the key of the cookie
+      # @return      [String] the cookie
+      # @note                 This method will get the cookie.
+      def cookie(value)
+        value => ::String
+
+        fetch_header('Set-Cookie')
+          .then { |cookie| cookie.split('; ') }
+          .then { |cookie| cookie.find { |c| c.start_with?("#{value}=") } }
+          .then { |cookie| cookie.split('=').last }
+      end
+
+      # @api public
+      # @param key   [String] the key of the cookie
+      # @param value [String] the value of the cookie
+      # @return      [void]
+      # @note                 This method will set the cookie.
+      def put_cookie(key, value)
+        key   => ::String
+        value => ::String
+
+        cookie = "#{key}=#{value}"
+
+        header!('Set-Cookie', cookie)
+      end
+
+      # @api public
+      # @return [Hash] the cookies
+      def cookies
+        fetch_header('Set-Cookie')
+          .then { |cookie| cookie.split('; ') }
+          .each_with_object({}) do |cookie, acc|
+          key, value = cookie.split('=')
+
+          acc[key] = value
+        end
+      end
+
+      # @api public
+      # @param location [String] the redirect location
+      # @param status   [Integer] the redirect status
+      # @return         [void]
+      # @note                   This method will set the redirect location and
+      #                         status and finish the response.
+      def redirect(location, status: 302)
+        location => ::String
+
+        header!('Location', location)
+        status!(status)
+
+        finish!
+      rescue ::NoMatchingPatternError
+        raise ::ArgumentError, 'location must be a string'
+      end
+
+      # @api public
+      # @return [void]
+      # @note        This method will finish the response.
+      def finish = finish!
+
+      # @api public
+      # @return             [String] the response content type
+      # @note                        This method will set
+      #                              the response content type.
+      def content_type = header('Content-Type')
+
+      # @api public
+      # @param type    [String] the response content type
+      # @param charset [Hash]   the response charset
+      # @return        [void]
+      def put_content_type(type, charset: nil)
+        type => ::String
+
+        case charset
+        in ::String then header!('Content-Type', "#{type}; charset=#{charset}")
+        else             header!('Content-Type', type)
+        end
+      rescue ::NoMatchingPatternError
+        raise ::ArgumentError, 'type must be a string'
+      end
+
+      # @api public
+      # @param data [Hash, Array] the response data
+      # @return     [void]
+      # @note                      This method will set the response data and
+      #                            finish the response.
+      def json(data:, status: 200)
+        data => ::Array | ::Hash
+
+        status!(status)
+        header!('Content-Type', 'application/json')
+        body!(data.to_json)
+
+        finish!
+      end
+
+      # Set the response content type to text/html.
+      # @param str [String] the response body
+      # @return    [void]
+      def html(str = nil, status: 200)
+        status!(status)
+        header!('Content-Type', 'text/html')
+        body!(str)
+
+        finish!
+      end
+
+      # @param template_nam [String] the template name
+      # @param path         [String] the template path, default is 'views'
+      # @param locals       [Hash]   the template locals
+      # @return             [void | Exception]
+      # @note                        This method will render the template.
+      #                              The template engine is determined by the
+      #                              file extension.
+      #
+      # @example
+      #   render('index')
+      #   # => Render the template `views/index.html.erb`
+      #
+      #   render('users/index')
+      #   # => Render the template `views/users/index.html.erb`
+      #
+      #   render('index', path: 'app/views/users')
+      #   # => Render the template `app/views/users/index.html.erb`
+      #
+      #   render('index', locals: { name: 'John' })
+      #   # => Render the template `views/index.html.erb` with the local
+      #   #    variable `name` set to 'John'
+      def render(template_name, path: 'views', locals: {}, status: 200)
+        template_path = ::File.join(path, "#{template_name}.html.erb")
+
+        # Check if the template exists
+        unless File.exist?(template_path)
+          msg = "Template not found: #{template_path} 🤷‍♂️."
+
+          # Oops! The template doesn't exist or the path is wrong.
+          #
+          # The template exists? 🤔
+          # If you want to render a template from a custom path, then you
+          # can pass the full path though the path: keyword argument instead
+          # of just the name. For example:
+          # render('index', path: 'app/views/users')
+          raise msg
+        end
+
+        ::File
+          .read(template_path)
+          .then { |template| ::ERB.new(template).result_with_hash(locals) }
+          .then { |erb_template| html(erb_template, status:) }
+      end
+
+      # Helper methods for the response.
+      # @api public
+      # @return [void]
+      # @note          This method will finish the response with a 404 status.
+      def not_found
+        body!(['Not Found'])
+        status!(404)
+        finish!
+      end
+
+      private
+
+      # @api private
+      # @return [Integer] the response status
+      # @note             This method will get the response status.
+      def fetch_status = _status
+
+      # @api private
+      # @return [Integer] the response status
+      # @note             This method will get the response status.
+      def status!(value)
+        value => ::Integer
+
+        self._status = value
+      rescue ::NoMatchingPatternError
+        raise ::ArgumentError, 'status must be an integer'
+      end
+
+      # @api private
+      # @return [Array(String)] the body value
+      def fetch_body = _body
+
+      # @api private
+      # @param body [Array(String)] the body to be used
+      # @return     [void]
+      # @note                       This method will set the body.
+      def body!(value)
+        body => ::String | ::Array
+
+        case value
+        in ::String then self._body = [value]
+        in ::Array  then self._body = value
+        end
+      rescue ::NoMatchingPatternError
+        raise ::ArgumentError, 'body must be a string or an array'
+      end
+
+      # @api private
+      # @param header [String] the header name
+      # @return       [String] the header value
+      # @note                  This method will get the header value.
+      def fetch_header(header) = _headers[header]
+
+      # @api private
+      # @return [Hash] the response headers
+      def fetch_headers = _headers
+
+      # @api private
+      # @param key   [String] the header name
+      # @param value [String] the value to be used
+      # @return      [void]
+      # @note                 This method will set the header value.
+      #                       If the header already exists, then the value will
+      #                       be appended to the header.
+      def header!(key, value)
+        key   => ::String
+        value => ::String | ::Array
+
+        header_value = fetch_header(key)
+
+        case value
+        in ::String then _headers[key] = [*header_value, value].uniq.join(', ')
+        in ::Array  then _headers[key] = [*header_value, *value].uniq.join(', ')
+        end
+      rescue ::NoMatchingPatternError
+        raise ::ArgumentError, 'header must be a string or an array'
+      end
+
+      # @api private
+      # @param key [String] the header name
+      # @return    [void]
+      # @note      This method will delete the header.
+      def delete_header(key) = _headers.delete(key)
+
+      # @api private
+      # @param value [String] the redirect location
+      # @return      [void]
+      def location!(value)
+        value => ::String
+
+        header!('Location', value)
+      end
+
+      # @api private
+      # @param value [String] the content value
+      # @return      [String] the size of the content
+      # @note                 This method will get the size of the content.
+      def content_length!(value) = header!('Content-Length', value)
+
+      # @api private
+      # @return [void]
+      # @note   This method will finish the response.
+      def finish!
+        put_content_type('text/html')        unless header('Content-Type')
+        content_length!(body.join.size.to_s) unless header('Content-Length')
+
+        [_status, _headers, _body]
+      end
+    end
+  end
+end

data/lib/lenna/router/route_matcher.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Lenna
+  class Router
+    # @note This class is responsible for matching the request path
+    #   to an endpoint and executing the endpoint action.
+    #
+    # @api private
+    #
+    # @since 0.1.0
+    #
+    # This will match the request path to an endpoint and execute
+    # the endpoint action.
+    class RouteMatcher
+      # @param root_node [Lenna::Node] The root node
+      def initialize(root_node) = @root_node = root_node
+
+      # This method will match the request path to an endpoint and execute
+      # the endpoint action.
+      #
+      # @param req [Lenna::Request]  The request object
+      # @param res [Lenna::Response] The response object
+      # @return    [Lenna::Response] The response object
+      #
+      # @see #split_path
+      # @see #find_endpoint
+      # @see Lenna::Response#not_found
+      def match_and_execute_route(req, res)
+        params     = {}
+        path_parts = split_path(req.path_info)
+        endpoint   = find_endpoint(@root_node, path_parts, params)
+
+        if endpoint && (action = endpoint[req.request_method])
+          req.params.merge!(params)
+          action.call(req, res)
+        else
+          res.not_found
+        end
+      end
+
+      private
+
+      # @todo: Refactor this method to a module.
+      def split_path(path) = path.split('/').reject(&:empty?)
+
+      # @param node   [Lenna::Node] The node to search
+      # @param parts  [Array]       The path parts
+      # @param params [Hash]        The params hash
+      # @return       [Lenna::Node] The node that matches the path
+      #
+      # @note This method is recursive.
+      #
+      # @since 0.1.0
+      def find_endpoint(node, parts, params)
+        return node.endpoint if parts.empty?
+
+        part = parts.shift
+        child_node = node.children[part]
+
+        if child_node.nil? && (placeholder_node = node.children[:placeholder])
+          params[placeholder_node.placeholder_name] = part
+          child_node = placeholder_node
+        end
+
+        find_endpoint(child_node, parts, params) if child_node
+      end
+    end
+  end
+end