lennarb 1.3.0 → 1.4.1

data/lib/lennarb/environment.rb

@@ -0,0 +1,76 @@
+module Lennarb
+  class Environment
+    NAMES = %i[development test production local]
+
+    # Returns the name of the environment.
+    # @parameter name [Symbol]
+    #
+    attr_reader :name
+
+    # Initialize the environment.
+    #  @parameter name [String, Symbol] The name of the environment.
+    #
+    def initialize(name)
+      @name = name.to_sym
+
+      return if NAMES.include?(@name)
+
+      raise ArgumentError, "Invalid environment: #{@name.inspect}"
+    end
+
+    # Returns true if the environment is development.
+    #
+    def development? = name == :development
+
+    # Returns true if the environment is test.
+    #
+    def test? = name == :test
+
+    # Returns true if the environment is production.
+    #
+    def production? = name == :production
+
+    # Returns true if the environment is local (either `test` or `development`).
+    #
+    def local? = test? || development?
+
+    # Implements equality for the environment.
+    #
+    def ==(other) = name == other || name.to_s == other
+    alias_method :eql?, :==
+    alias_method :equal?, :==
+    alias_method :===, :==
+
+    # Returns the name of the environment as a symbol.
+    # @returns [Symbol]
+    #
+    def to_sym = name
+
+    # Returns the name of the environment as a string.
+    # @returns [String]
+    #
+    def to_s = name.to_s
+
+    # Returns the name of the environment as a string.
+    # @returns [String]
+    def inspect = to_s.inspect
+
+    # Yields a block if the environment is the same as the given environment.
+    # - To match all environments use `:any` or `:all`.
+    # - To match local environments use `:local`.
+    # @param envs [Array<Symbol>] The environment(s) to check.
+    #
+    # @example
+    #   app.env.on(:development) do
+    #     # Code to run in development
+    #   end
+    def on(*envs)
+      matched = envs.include?(:any) ||
+        envs.include?(:all) ||
+        envs.include?(name) ||
+        (envs.include?(:local) && local?)
+
+      yield if matched
+    end
+  end
+end

data/lib/lennarb/request.rb

@@ -1,14 +1,8 @@
-# frozen_string_literal: true
-
-# Released under the MIT License.
-# Copyright, 2023-2024, by Aristóteles Coutinho.
-
-class Lennarb
+module Lennarb
   class Request < Rack::Request
     # The environment variables of the request
     #
     # @returns [Hash]
-    #
     attr_reader :env
 
     # Initialize the request object
@@ -20,64 +14,241 @@ class Lennarb
     #
     def initialize(env, route_params = {})
       super(env)
-      @route_params = route_params
+      @route_params = route_params || {}
     end
 
-    # Get the request body
+    # Get the request parameters merged with route parameters
     #
-    # @returns [String]
+    # @returns [Hash]
     #
-    def params = @params ||= super.merge(@route_params)&.transform_keys(&:to_sym)
+    def params
+      @params ||= super.merge(@route_params)&.transform_keys(&:to_sym)
+    end
 
-    # Get the request path
+    # Get the request path without query string
     #
     # @returns [String]
     #
-    def path = @path ||= super.split('?').first
+    def path
+      @path ||= super.split("?").first
+    end
 
     # Read the body of the request
     #
     # @returns [String]
     #
-    def body = @body ||= super.read
+    def body
+      @body ||= super.read
+    end
 
     # Get the query parameters
     #
     # @returns [Hash]
     #
     def query_params
-      @query_params ||= Rack::Utils.parse_nested_query(query_string).transform_keys(&:to_sym)
+      @query_params ||= Rack::Utils.parse_nested_query(query_string || "").transform_keys(&:to_sym)
+    end
+
+    # Set a value in the environment
+    #
+    # @parameter [String] key
+    # @parameter [Object] value
+    # @returns [Object] the value
+    #
+    def []=(key, value)
+      env[key] = value
+    end
+
+    # Get a value from the environment
+    #
+    # @parameter [String] key
+    # @returns [Object]
+    #
+    def [](key)
+      env[key]
     end
 
     # Get the headers of the request
     #
+    # @returns [Hash]
+    #
     def headers
-      @headers ||= env.select { |key, _| key.start_with?('HTTP_') }
+      @headers ||= env.select { |key, _| key.start_with?("HTTP_") }
+    end
+
+    # Get the client IP address
+    #
+    # @returns [String]
+    #
+    def ip
+      ip_address
     end
 
-    def ip             = ip_address
-    def secure?        = scheme == 'https'
-    def user_agent     = headers['HTTP_USER_AGENT']
-    def accept         = headers['HTTP_ACCEPT']
-    def referer        = headers['HTTP_REFERER']
-    def host           = headers['HTTP_HOST']
-    def content_length = headers['HTTP_CONTENT_LENGTH']
-    def content_type   = headers['HTTP_CONTENT_TYPE']
-    def xhr?           = headers['HTTP_X_REQUESTED_WITH']&.casecmp('XMLHttpRequest')&.zero?
+    # Check if the request is secure (HTTPS)
+    #
+    # @returns [Boolean]
+    #
+    def secure?
+      scheme == "https"
+    end
 
-    def []=(key, value)
-      env[key] = value
+    # Shorthand methods for common headers
+
+    # Get the user agent
+    #
+    # @returns [String, nil]
+    #
+    def user_agent
+      env["HTTP_USER_AGENT"]
     end
 
-    def [](key)
-      env[key]
+    # Get the accept header
+    #
+    # @returns [String, nil]
+    #
+    def accept
+      env["HTTP_ACCEPT"]
+    end
+
+    # Get the referer header
+    #
+    # @returns [String, nil]
+    #
+    def referer
+      env["HTTP_REFERER"]
+    end
+
+    # Get the host header
+    #
+    # @returns [String, nil]
+    #
+    def host
+      env["HTTP_HOST"]
+    end
+
+    # Get the content length header
+    #
+    # @returns [String, nil]
+    #
+    def content_length
+      env["HTTP_CONTENT_LENGTH"]
+    end
+
+    # Get the content type header
+    #
+    # @returns [String, nil]
+    #
+    def content_type
+      env["HTTP_CONTENT_TYPE"]
+    end
+
+    # Check if the request is an XHR request
+    #
+    # @returns [Boolean]
+    #
+    def xhr?
+      env["HTTP_X_REQUESTED_WITH"]&.casecmp("XMLHttpRequest")&.zero? || false
+    end
+
+    # Check if the request is a JSON request
+    #
+    # @returns [Boolean]
+    #
+    def json?
+      content_type&.include?("application/json")
+    end
+
+    # Parse JSON body if content type is application/json
+    #
+    # @returns [Hash, nil]
+    #
+    def json_body
+      return nil unless json?
+      @json_body ||= begin
+        require "json"
+        JSON.parse(body, symbolize_names: true)
+      rescue JSON::ParserError
+        nil
+      end
+    end
+
+    # Check if the request is an AJAX request (alias for xhr?)
+    #
+    # @returns [Boolean]
+    #
+    def ajax?
+      xhr?
+    end
+
+    # Get the requested format (.html, .json, etc)
+    #
+    # @returns [Symbol, nil]
+    #
+    def format
+      path_info = env["PATH_INFO"]
+      return nil unless path_info.include?(".")
+
+      extension = File.extname(path_info).delete(".")
+      extension.empty? ? nil : extension.to_sym
+    end
+
+    # Check if the request is a GET request
+    #
+    # @returns [Boolean]
+    #
+    def get?
+      request_method == "GET"
+    end
+
+    # Check if the request is a POST request
+    #
+    # @returns [Boolean]
+    #
+    def post?
+      request_method == "POST"
+    end
+
+    # Check if the request is a PUT request
+    #
+    # @returns [Boolean]
+    #
+    def put?
+      request_method == "PUT"
+    end
+
+    # Check if the request is a DELETE request
+    #
+    # @returns [Boolean]
+    #
+    def delete?
+      request_method == "DELETE"
+    end
+
+    # Check if the request is a HEAD request
+    #
+    # @returns [Boolean]
+    #
+    def head?
+      request_method == "HEAD"
+    end
+
+    # Check if the request is a PATCH request
+    #
+    # @returns [Boolean]
+    #
+    def patch?
+      request_method == "PATCH"
     end
 
     private
 
+    # Get the client IP address
+    #
+    # @returns [String]
+    #
     def ip_address
-      forwarded_for = headers['HTTP_X_FORWARDED_FOR']
-      forwarded_for ? forwarded_for.split(',').first.strip : env['REMOTE_ADDR']
+      forwarded_for = env["HTTP_X_FORWARDED_FOR"]
+      forwarded_for ? forwarded_for.split(",").first.strip : env["REMOTE_ADDR"]
     end
   end
 end

data/lib/lennarb/request_handler.rb

@@ -0,0 +1,31 @@
+module Lennarb
+  class RequestHandler
+    Lennarb::Error = Class.new(StandardError)
+
+    attr_reader :app
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      http_method = env[Rack::REQUEST_METHOD].to_sym
+      parts = env[Rack::PATH_INFO].split("/").reject(&:empty?)
+      block, params = app.routes.match_route(parts, http_method)
+
+      unless block
+        return [404, {"content-type" => CONTENT_TYPE[:TEXT]}, ["Not Found"]]
+      end
+
+      req = Request.new(env, params)
+      res = Response.new
+
+      catch(:halt) do
+        block.call(req, res)
+        res.finish
+      rescue Lennarb::Error => error
+        [500, {"content-type" => CONTENT_TYPE[:TEXT]}, ["Internal Server Error (#{error.message})"]]
+      end
+    end
+  end
+end

data/lib/lennarb/response.rb

@@ -1,9 +1,4 @@
-# frozen_string_literal: true
-
-# Released under the MIT License.
-# Copyright, 2023-2024, by Aristóteles Coutinho.
-
-class Lennarb
+module Lennarb
   class Response
     # @!attribute [rw] status
     #  @returns [Integer]
@@ -27,27 +22,24 @@ class Lennarb
 
     # Constants
     #
-    LOCATION = 'location'
+    LOCATION = "location"
     private_constant :LOCATION
 
-    CONTENT_TYPE = 'content-type'
+    CONTENT_TYPE = "content-type"
     private_constant :CONTENT_TYPE
 
-    CONTENT_LENGTH = 'content-length'
+    CONTENT_LENGTH = "content-length"
     private_constant :CONTENT_LENGTH
 
-    ContentType = { HTML: 'text/html', TEXT: 'text/plain', JSON: 'application/json' }.freeze
-    private_constant :ContentType
-
     # Initialize the response object
     #
     # @returns [Response]
     #
     def initialize
-      @status  = 404
+      @status = 200
       @headers = {}
-      @body    = []
-      @length  = 0
+      @body = []
+      @length = 0
     end
 
     # Set the response header
@@ -91,7 +83,7 @@ class Lennarb
     # @returns [String] str
     #
     def text(str)
-      @headers[CONTENT_TYPE] = ContentType[:TEXT]
+      @headers[CONTENT_TYPE] = Lennarb::CONTENT_TYPE[:TEXT]
       write(str)
     end
 
@@ -102,7 +94,7 @@ class Lennarb
     # @returns [String] str
     #
     def html(str)
-      @headers[CONTENT_TYPE] = ContentType[:HTML]
+      @headers[CONTENT_TYPE] = Lennarb::CONTENT_TYPE[:HTML]
       write(str)
     end
 
@@ -113,8 +105,13 @@ class Lennarb
     # @returns [String] str
     #
     def json(str)
-      @headers[CONTENT_TYPE] = ContentType[:JSON]
-      write(str)
+      json_str = JSON.generate(str)
+      @headers[CONTENT_TYPE] = Lennarb::CONTENT_TYPE[:JSON]
+      write(json_str)
+    rescue JSON::GeneratorError => e
+      @status = 500
+      @headers[CONTENT_TYPE] = Lennarb::CONTENT_TYPE[:TEXT]
+      write("JSON generation error: #{e.message}")
     end
 
     # Redirect the response

data/lib/lennarb/route_node.rb

@@ -1,24 +1,28 @@
-# frozen_string_literal: true
-
-# Released under the MIT License.
-# Copyright, 2023-2024, by Aristóteles Coutinho.
-
-class Lennarb
+module Lennarb
   class RouteNode
+    DuplicateRouteError = Class.new(StandardError)
     attr_accessor :static_children, :dynamic_children, :blocks, :param_key
 
     def initialize
-      @blocks           = {}
-      @param_key        = nil
-      @static_children  = {}
+      @blocks = {}
+      @param_key = nil
+      @static_children = {}
       @dynamic_children = {}
     end
 
+    # Add a route to the route node.
+    #
+    # @param parts [Array<String>] The parts of the route.
+    # @param http_method [String] The HTTP method.
+    # @param block [Proc] The block to be executed when the route is matched.
+    #
+    # @returns [void]
+    #
     def add_route(parts, http_method, block)
       current_node = self
 
       parts.each do |part|
-        if part.start_with?(':')
+        if part.start_with?(":")
           param_sym = part[1..].to_sym
           current_node.dynamic_children[param_sym] ||= RouteNode.new
           dynamic_node = current_node.dynamic_children[param_sym]
@@ -33,6 +37,14 @@ class Lennarb
       current_node.blocks[http_method] = block
     end
 
+    # Match a route.
+    #
+    # @param parts [Array<String>] The parts of the route.
+    # @param http_method [String] The HTTP method.
+    # @param params [Hash] The parameters of the route.
+    #
+    # @returns [Array<Proc, Hash>]
+    #
     def match_route(parts, http_method, params: {})
       if parts.empty?
         return [blocks[http_method], params] if blocks[http_method]
@@ -57,10 +69,35 @@ class Lennarb
       [nil, nil]
     end
 
+    # Merge another route node into this one.
+    #
+    # @param other [RouteNode] The other route node.
+    #
+    # @returns [void|DuplicateRouteError]
+    #
     def merge!(other)
-      static_children.merge!(other.static_children)
-      dynamic_children.merge!(other.dynamic_children)
-      blocks.merge!(other.blocks)
+      other.blocks.each do |http_method, block|
+        if @blocks[http_method]
+          raise DuplicateRouteError, "Duplicate route for HTTP method: #{http_method}"
+        end
+        @blocks[http_method] = block
+      end
+
+      other.static_children.each do |path, node|
+        if @static_children[path]
+          @static_children[path].merge!(node)
+        else
+          @static_children[path] = node
+        end
+      end
+
+      other.dynamic_children.each do |param, node|
+        if @dynamic_children[param]
+          @dynamic_children[param].merge!(node)
+        else
+          @dynamic_children[param] = node
+        end
+      end
     end
   end
 end

data/lib/lennarb/routes.rb

@@ -0,0 +1,71 @@
+module Lennarb
+  class Routes
+    attr_reader :store
+    # RouteNode is a trie data structure that stores routes.
+    # see {Lennarb::RouteNode} for more details.
+    #
+    # @example
+    #   node = RouteNode.new
+    #   node.add_route(["foo", "bar"], :GET, -> {})
+    #
+    def initialize(&)
+      @store = RouteNode.new
+      instance_eval(&) if block_given?
+    end
+
+    # Define the HTTP methods.
+    #
+    # get, post, put, delete, patch, options, head
+    #
+    HTTP_METHODS.each do |http_method|
+      define_method(http_method.downcase) do |path, &block|
+        register_route(http_method, path, &block)
+      end
+    end
+
+    # Define the root route.
+    #
+    # @param [String] path
+    #
+    # @param [Proc] block
+    #
+    # @returns [void]
+    #
+    def root(&block) = register_route(:GET, "/", &block)
+
+    # Match the route.
+    #
+    # @param [Array<String>] parts
+    #
+    # @param [Symbol] http_method
+    #
+    def match_route(...) = @store.match_route(...)
+
+    # Freeze store object.
+    #
+    # @returns [void]
+    #
+    def freeze = @store.freeze
+
+    private def register_route(http_method, path, &block)
+      parts = path.split("/").reject(&:empty?)
+      @store.add_route(parts, http_method, block)
+    end
+
+    module Mixin
+      extend self
+
+      def routes(&block)
+        @routes ||= Routes.new(&block)
+      end
+
+      HTTP_METHODS.each do |http_method|
+        define_method(http_method.downcase) do |path, &block|
+          routes.send(http_method.downcase, path, &block)
+        end
+      end
+
+      def root(&) = routes.root(&)
+    end
+  end
+end

data/lib/lennarb/version.rb

@@ -1,10 +1,3 @@
-# frozen_string_literal: true
-
-# Released under the MIT License.
-# Copyright, 2023-2024, by Aristóteles Coutinho.
-
-class Lennarb
-  VERSION = '1.3.0'
-
-  public_constant :VERSION
+module Lennarb
+  VERSION = "1.4.1"
 end