lennarb 1.4.0 → 1.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fb597d27bfaffebc72a4b7aa52f74dd0c5e94c60d401c4f8c30558246509a59d
-  data.tar.gz: 0a49adeeb50aee3f5d09a641535d9e230aadeb40d69dc9a1883551641f045999
+  metadata.gz: cd39c745c65bf722a7075f57bbd36a2a603b659ddecb23bac33b7733c0b912e2
+  data.tar.gz: 723a60bc0e9cf0ed60c3f548e8e9004310a29c3c36c63b6ab55308ca99c83da3
 SHA512:
-  metadata.gz: 4a682640f80f02dc84fba9e1f9aa7f666b68b08101c19e2ab406dc9e5367352be25bf7f9f91b26b39ff2f92f9a2c472cc7ba1c306679970fa510fbca73806a04
-  data.tar.gz: cb431441f0481b65774ed39f83bf12bb19a2316e3815bfba88388cefc7a641c712777727de51a3a03f60fde4a6de078b2c34d4abb25481835958cc9bb4eb2377
+  metadata.gz: 901cfe54fe27ea6addd4b48690f3cd12b73a9f85e05066f9382f6467e65e537760509958bfb4ffd23cc2ab523168428dd3c2b50027c523b8cfb15b3c1af1b4a0
+  data.tar.gz: c877fb10d4a3f918016390b43fcc54ed3b70fb8c38577b23a4c34b1820f3c2d898c685f738de1f6c7ff6e2c25066b2fb95e8020ef7a00c22a02f0c5f847fa76b

data/.github/workflows/test.yaml

@@ -21,7 +21,6 @@ jobs:
           - macos
 
         ruby:
-          - '3.3'
           - '3.4'
 
         experimental: [false]
@@ -47,3 +46,5 @@ jobs:
       - name: Run tests
         timeout-minutes: 10
         run: bundle exec rake test
+      - name: Run linter
+        run: bundle exec rake standard

data/Rakefile

@@ -1,10 +1,12 @@
 require "bundler/gem_tasks"
+require "standard/rake"
 require "rake/testtask"
 
-Rake::TestTask.new(:test) do |t|
+Rake::TestTask.new do |t|
   t.libs << "test"
   t.libs << "lib"
   t.test_files = FileList["test/**/*_test.rb"]
+  t.verbose = true
 end
 
-task default: %i[test]
+task default: :test

data/changelog.md

@@ -7,6 +7,43 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.4.1] - 2025-02-23
+
+### Added
+
+- Add support to mount routes. Now, you can centralize the routes in a single file and mount them in the main application. Ex.
+
+```rb
+class PostsController
+  extend Lennarb::Routes::Mixin
+
+  get '/posts' do |req, res|
+    res.html('Posts')
+  end
+end
+
+SampleApp = Lennarb.new do |router|
+  mount PostsController
+end
+```
+
+The `mount` method will add the routes from the `PostsController` class to the main application. You can use the `mount` method with multiple classes, ex. `mount PostsController, CommentsController`.
+
+- Add `Lennarb::Environment` module to manage the environment variables in the project. Now, the `Lennarb` class is the main class of the project.
+- Add `Lennarb::Config` module to manage the configuration in the project. Now, the `Lennarb` class is the main class of the project.
+- Add `Lennarb::App` class.
+- Lint the code with `standard` gem on the CI/CD pipeline.
+
+### Changed
+
+- Convert the `Lennarb` class to a module. Now, the `App` class is the main class of the project.
+- Move the request process to `Lennarb::RequestHandler` class.
+- Improve the method `merge!` from `Lennarb::RouterNode` to prevent the duplication of the routes.
+
+### Fixed
+
+- Software design issues.
+
 ## [1.4.0] - 2025-02-09
 
 ### Changed
@@ -177,6 +214,7 @@ end
 - Add `console` gem to print the logs in the console.
 
 - Add CLI module to:
+
   - Create a new project with `lennarb new` command.
   - Run the server with `lennarb server` command.
 

data/guides/getting-started/readme.md

@@ -27,15 +27,17 @@ Create a new file named `config.ru`:
 ```ruby
 require 'lennarb'
 
-app = Lennarb.new do |app|
-  app.get '/' do |req, res|
-    res.status = 200
-    res.html('<h1>Welcome to Lennarb!</h1>')
+MyApp = Lennarb::App.new do
+  routes
+    get '/' do |req, res|
+      res.status = 200
+      res.html('<h1>Welcome to Lennarb!</h1>')
+    end
   end
 end
 
-app.initializer!
-run app
+MyApp.initialize!
+run App
 ```
 
 Start the server:
@@ -84,16 +86,16 @@ end
 Routes are defined using HTTP method helpers:
 
 ```ruby
-app = Lennarb.new do |l|
-  # Basic route
-  l.get '/' do |req, res|
-    res.html('Home page')
-  end
-
-  # Route with parameters
-  l.get '/users/:id' do |req, res|
-    user_id = req.params[:id]
-    res.json("{\"id\": #{user_id}}")
+Lennarb::App.new do
+  routes do
+    get '/' do |req, res|
+      res.html('Home page')
+    end
+
+    get '/users/:id' do |req, res|
+      user_id = req.params[:id]
+      res.json("{\"id\": #{user_id}}")
+    end
   end
 end
 ```
@@ -103,7 +105,7 @@ end
 Parameters from dynamic route segments are available in `req.params`:
 
 ```ruby
-app.get '/hello/:name' do |req, res|
+get '/hello/:name' do |req, res|
   name = req.params[:name]
   res.text("Hello, #{name}!")
 end
@@ -117,20 +119,26 @@ Lennarb is thread-safe by design:
 - The router tree is frozen after initialization
 - Response objects are created per-request
 
-## Application Lifecycle
+## Application Life-cycle
 
 ### Initialization
 
 ```ruby
-app = Lennarb.new do |l|
-  # Define routes and configuration
+Myapp = Lennarb::App.new do
+  # Define routes
+  routes do
+  end
+
+  # Define Configurations
+  config do
+  end
 end
 
 # Initialize and freeze the application
-app.initializer!
+MyApp.initialize!
 ```
 
-The `initializer!` method:
+The `initialize!` method:
 
 - Loads environment-specific dependencies
 - Freezes the route tree
@@ -140,6 +148,12 @@ The `initializer!` method:
 
 Lennarb uses the `LENNA_ENV` environment variable (defaults to "development"):
 
+It can be set using the following environment variables:
+
+- `LENNA_ENV`
+- `APP_ENV`
+- `RACK_ENV`
+
 ```bash
 LENNA_ENV=production rackup
 ```
@@ -149,7 +163,7 @@ LENNA_ENV=production rackup
 Lennarb provides basic error handling:
 
 ```ruby
-app.get '/api' do |req, res|
+get '/api' do |req, res|
   # Errors are caught and return 500 with error message
   raise "Something went wrong"
 end
@@ -162,18 +176,18 @@ Default error responses:
 
 ## Best Practices
 
-1. **Always call initializer!**
+1. **Always call initialize!**
 
    ```ruby
-   app = Lennarb.new { |l| ... }
-   app.initializer!
+   app = Lennarb::App.new
+   app.initialize!
    run app
    ```
 
 2. **Set response status**
 
    ```ruby
-   app.get '/api' do |req, res|
+   get '/api' do |req, res|
      res.status = 200
      res.json('{"status": "ok"}')
    end

data/guides/response/readme.md

@@ -10,19 +10,19 @@ You can use the `res` object to send a response to the client.
 ```ruby
 # app.rb
 
-app.get '/' do |req, res|
+get '/' do |req, res|
  res.html 'Hello World'
 end
 ```
 
 ## Content Types
 
-Lenna supports the following content types:
+Lennarb supports the following content types:
 
 ```ruby
 # app.rb
 
-app.get '/' do |req, res|
+get '/' do |req, res|
  res.html 'Hello World'
  res.json '{"message": "Hello World"}'
  res.text 'Hello World'
@@ -43,7 +43,7 @@ You can use the `res.write` method to write to the response body:
 ```ruby
 # app.rb
 
-app.get '/' do |req, res|
+get '/' do |req, res|
  res.write 'Hello World'
 end
 ```
@@ -53,7 +53,7 @@ JSON example:
 ```ruby
 # app.rb
 
-app.post '/posts' do |req, res|
+post '/posts' do |req, res|
  req.params # => { name: 'Lenna' }
  name = req.params[:name]
 
@@ -76,7 +76,7 @@ You can redirect the client using the `res.redirect` method:
 ```ruby
 # app.ruby
 
-app.get '/' do |req, res|
+get '/' do |req, res|
   # Stuff code here...
  res.redirect '/hello'
 end

data/lennarb.gemspec

@@ -31,14 +31,17 @@ Gem::Specification.new do |spec|
   spec.add_dependency "bigdecimal"
   spec.add_dependency "colorize", "~> 1.1"
   spec.add_dependency "rack", "~> 3.1"
+  spec.add_dependency "superconfig"
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "covered"
   spec.add_development_dependency "simplecov"
   spec.add_development_dependency "minitest"
+  spec.add_development_dependency "minitest-utils"
   spec.add_development_dependency "rack-test"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "standard"
   spec.add_development_dependency "standard-custom"
   spec.add_development_dependency "standard-performance"
   spec.add_development_dependency "m"
+  spec.add_development_dependency "debug"
 end

data/lib/lennarb/app.rb

@@ -0,0 +1,172 @@
+module Lennarb
+  class App
+    # This error is raised whenever the app is initialized more than once.
+    AlreadyInitializedError = Class.new(StandardError)
+
+    # The root app directory of the app.
+    #
+    # @returns [Pathname]
+    #
+    attr_accessor :root
+
+    # The current environment. Defaults to "development".
+    # It can be set using the following environment variables:
+    #
+    # - `LENNA_ENV`
+    # - `APP_ENV`
+    # - `RACK_ENV`
+    #
+    # @returns [Lennarb::Environment]
+    #
+    attr_reader :env
+
+    def initialize(&)
+      @initialized = false
+      self.root = Pathname.pwd
+      self.env = compute_env
+      instance_eval(&) if block_given?
+    end
+
+    # Set the current environment. See {Lennarb::Environment} for more details.
+    #
+    # @parameter [Hash] env
+    #
+    def env=(env)
+      raise AlreadyInitializedError if initialized?
+
+      @env = Environment.new(env)
+    end
+
+    # Mount an app at a specific path.
+    #
+    # @parameter [Object] The controller|app to mount.
+    #
+    # @returns [void]
+    #
+    # @example
+    #
+    #   class PostController
+    #     extend Lennarb::Routes::Mixin
+    #
+    #     get "/post/:id" do |req, res|
+    #       res.text("Post ##{req.params[:id]}")
+    #     end
+    #   end
+    #
+    #  MyApp = Lennarb::App.new do
+    #    routes do
+    #      mount PostController
+    #    end
+    #
+    def mount(*controllers)
+      controllers.each do |controller|
+        raise ArgumentError, "Controller must respond to :routes" unless controller.respond_to?(:routes)
+
+        self.controllers << controller
+      end
+    end
+
+    # Define the app's configuration. See {Lennarb::Config}.
+    #
+    # @returns [Lennarb::Config]
+    #
+    # @example Run config on every environment
+    #   app.config do
+    #     mandatory :database_url, string
+    #   end
+    #
+    # @example Run config on every a specific environment
+    #   app.config :development do
+    #     set :domain, "example.dev"
+    #   end
+    #
+    # @example Run config on every a specific environment
+    #   app.config :development, :test do
+    #     set :domain, "example.dev"
+    #   end
+    #
+    def config(*envs, &)
+      @config ||= Config.new
+
+      write = block_given? &&
+        (envs.map(&:to_sym).include?(env.to_sym) || envs.empty?)
+
+      @config.instance_eval(&) if write
+
+      @config
+    end
+
+    # Define the app's route. See {Lennarb::RouteNode} for more details.
+    #
+    # @returns [Lennarb::RouteNode]
+    #
+    def routes(&)
+      @routes ||= Routes.new
+      @routes.instance_eval(&) if block_given?
+      @routes
+    end
+
+    # The Rack app.
+    #
+    def app
+      @app ||= begin
+        request_handler = RequestHandler.new(self)
+
+        Rack::Builder.app do
+          run request_handler
+        end
+      end
+    end
+
+    # Store mounted app's
+    #
+    def controllers
+      @controllers ||= []
+    end
+    alias_method :mounted_apps, :controllers
+
+    # Check if the app is initialized.
+    #
+    # @returns [Boolean]
+    #
+    def initialized? = @initialized
+
+    # Initialize the app.
+    #
+    # @returns [void]
+    #
+    def initialize!
+      raise AlreadyInitializedError if initialized?
+
+      controllers.each do
+        routes.store.merge!(it.routes.store)
+      end
+
+      @initialized = true
+
+      app.freeze
+      routes.freeze
+    end
+
+    # Call the app.
+    #
+    # @parameter [Hash] env
+    #
+    def call(env)
+      env[RACK_LENNA_APP] = self
+      Dir.chdir(root) { return app.call(env) }
+    end
+
+    # Compute the current environment.
+    #
+    # @returns [String]
+    #
+    # @private
+    #
+    private def compute_env
+      env = ENV_NAMES.map { ENV[_1] }.compact.first.to_s
+
+      env.empty? ? "development" : env
+    end
+  end
+end

data/lib/lennarb/config.rb

@@ -0,0 +1,34 @@
+module Lennarb
+  # The configuration for the application.
+  # It uses {https://rubygems.org/gems/superconfig SuperConfig} to define the
+  # configuration.
+  class Config < SuperConfig::Base
+    MissingEnvironmentVariable = Class.new(StandardError)
+    MissingCallable = Class.new(StandardError)
+
+    undef_method :credential
+
+    def initialize(**)
+      block = proc { true }
+      super(**, &block)
+    end
+
+    # @private
+    def to_s = "#<Lennarb::Config>"
+
+    # @private
+    def mandatory(*, **)
+      super
+    rescue SuperConfig::MissingEnvironmentVariable => error
+      raise MissingEnvironmentVariable, error.message
+    end
+
+    # @private
+    def property(*, **, &)
+      super
+    rescue SuperConfig::MissingCallable
+      raise MissingCallable,
+        "arg[1] must respond to #call or a block must be provided"
+    end
+  end
+end

data/lib/lennarb/constansts.rb

@@ -1 +1,6 @@
-HTTP_METHODS = %i[GET POST PUT PATCH DELETE HEAD OPTIONS].freeze
+module Lennarb
+  RACK_LENNA_APP = "lennarb.app"
+  ENV_NAMES = %w[LENNA_ENV APP_ENV RACK_ENV]
+  HTTP_METHODS = %i[GET POST PUT PATCH DELETE HEAD OPTIONS]
+  CONTENT_TYPE = {HTML: "text/html", TEXT: "text/plain", JSON: "application/json"}
+end

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,9 +1,8 @@
-class Lennarb
+module Lennarb
   class Request < Rack::Request
     # The environment variables of the request
     #
     # @returns [Hash]
-    #
     attr_reader :env
 
     # Initialize the request object
@@ -15,71 +14,240 @@ 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_") }
     end
 
-    def ip = ip_address
+    # Get the client IP address
+    #
+    # @returns [String]
+    #
+    def ip
+      ip_address
+    end
 
-    def secure? = scheme == "https"
+    # Check if the request is secure (HTTPS)
+    #
+    # @returns [Boolean]
+    #
+    def secure?
+      scheme == "https"
+    end
 
-    def user_agent = headers["HTTP_USER_AGENT"]
+    # Shorthand methods for common headers
 
-    def accept = headers["HTTP_ACCEPT"]
+    # Get the user agent
+    #
+    # @returns [String, nil]
+    #
+    def user_agent
+      env["HTTP_USER_AGENT"]
+    end
 
-    def referer = headers["HTTP_REFERER"]
+    # Get the accept header
+    #
+    # @returns [String, nil]
+    #
+    def accept
+      env["HTTP_ACCEPT"]
+    end
 
-    def host = headers["HTTP_HOST"]
+    # Get the referer header
+    #
+    # @returns [String, nil]
+    #
+    def referer
+      env["HTTP_REFERER"]
+    end
 
-    def content_length = headers["HTTP_CONTENT_LENGTH"]
+    # Get the host header
+    #
+    # @returns [String, nil]
+    #
+    def host
+      env["HTTP_HOST"]
+    end
 
-    def content_type = headers["HTTP_CONTENT_TYPE"]
+    # Get the content length header
+    #
+    # @returns [String, nil]
+    #
+    def content_length
+      env["HTTP_CONTENT_LENGTH"]
+    end
 
-    def xhr? = headers["HTTP_X_REQUESTED_WITH"]&.casecmp("XMLHttpRequest")&.zero?
+    # Get the content type header
+    #
+    # @returns [String, nil]
+    #
+    def content_type
+      env["HTTP_CONTENT_TYPE"]
+    end
 
-    def []=(key, value)
-      env[key] = value
+    # Check if the request is an XHR request
+    #
+    # @returns [Boolean]
+    #
+    def xhr?
+      env["HTTP_X_REQUESTED_WITH"]&.casecmp("XMLHttpRequest")&.zero? || false
     end
 
-    def [](key)
-      env[key]
+    # 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 = env["HTTP_X_FORWARDED_FOR"]
       forwarded_for ? forwarded_for.split(",").first.strip : env["REMOTE_ADDR"]
     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,4 +1,4 @@
-class Lennarb
+module Lennarb
   class Response
     # @!attribute [rw] status
     #  @returns [Integer]
@@ -31,13 +31,12 @@ class Lennarb
     CONTENT_LENGTH = "content-length"
     private_constant :CONTENT_LENGTH
 
-    ContentType = {HTML: "text/html", TEXT: "text/plain", JSON: "application/json"}.freeze
     # Initialize the response object
     #
     # @returns [Response]
     #
     def initialize
-      @status = 404
+      @status = 200
       @headers = {}
       @body = []
       @length = 0
@@ -84,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
 
@@ -95,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
 
@@ -106,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,5 +1,6 @@
-class Lennarb
+module Lennarb
   class RouteNode
+    DuplicateRouteError = Class.new(StandardError)
     attr_accessor :static_children, :dynamic_children, :blocks, :param_key
 
     def initialize
@@ -9,6 +10,14 @@ class Lennarb
       @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
 
@@ -28,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]
@@ -52,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,5 +1,3 @@
-class Lennarb
-  VERSION = "1.4.0"
-
-  public_constant :VERSION
+module Lennarb
+  VERSION = "1.4.1"
 end

data/lib/lennarb.rb

@@ -1,72 +1,20 @@
 # Core extensions
 #
-require "pathname"
-require "rack"
 require "bundler"
-
-require_relative "lennarb/request"
-require_relative "lennarb/response"
-require_relative "lennarb/route_node"
-require_relative "lennarb/version"
-require_relative "lennarb/constansts"
-
-class Lennarb
-  class LennarbError < StandardError; end
-
-  def initialize
-    @_mutex ||= Mutex.new
-    yield self if block_given?
-  end
-
-  HTTP_METHODS.each do |http_method|
-    define_method(http_method.downcase) do |path, &block|
-      add_route(path, http_method, block)
-    end
-  end
-
-  def root
-    @root ||= RouteNode.new
-  end
-
-  def app
-    @app ||= begin
-      request_handler = ->(env) { process_request(env) }
-
-      Rack::Builder.app do
-        run request_handler
-      end
-    end
-  end
-
-  def initializer!
-    Bundler.require(:default, ENV["LENNA_ENV"] || "development")
-
-    root.freeze
-    app.freeze
-  end
-
-  def call(env) = @_mutex.synchronize { app.call(env) }
-
-  def add_route(path, http_method, block)
-    parts = path.split("/").reject(&:empty?)
-    root.add_route(parts, http_method, block)
-  end
-
-  private def process_request(env)
-    http_method = env[Rack::REQUEST_METHOD].to_sym
-    parts = env[Rack::PATH_INFO].split("/").reject(&:empty?)
-
-    block, params = root.match_route(parts, http_method)
-    return [404, {"content-type" => Response::ContentType[:TEXT]}, ["Not Found"]] unless block
-
-    res = Response.new
-    req = Request.new(env, params)
-
-    catch(:halt) do
-      instance_exec(req, res, &block)
-      res.finish
-    end
-  rescue => e
-    [500, {"content-type" => Response::ContentType[:TEXT]}, ["Internal Server Error - #{e.message}"]]
-  end
+require "rack"
+require "json"
+require "pathname"
+require "superconfig"
+
+module Lennarb
+  require_relative "lennarb/constansts"
+  require_relative "lennarb/environment"
+  require_relative "lennarb/version"
+  require_relative "lennarb/request_handler"
+  require_relative "lennarb/request"
+  require_relative "lennarb/response"
+  require_relative "lennarb/route_node"
+  require_relative "lennarb/routes"
+  require_relative "lennarb/config"
+  require_relative "lennarb/app"
 end

data/readme.md

@@ -7,10 +7,11 @@
 
 A lightweight, fast, and modular web framework for Ruby based on Rack. The **Lennarb** supports Ruby (MRI) 3.4+
 
-[![Tests](https://github.com/aristotelesbr/lennarb/workflows/rubyby-tests/badge.svg)](https://github.com/aristotelesbr/lennarb)
+[![Test](https://github.com/aristotelesbr/lennarb/actions/workflows/test.yaml/badge.svg)](https://github.com/aristotelesbr/lennarb/actions/workflows/test.yaml)
 [![Gem](https://img.shields.io/gem/v/lennarb.svg)](https://rubygems.org/gems/lennarb)
 [![Gem](https://img.shields.io/gem/dt/lennarb.svg)](https://rubygems.org/gems/lennarb)
 [![MIT License](https://img.shields.io/:License-MIT-blue.svg)](https://tldrlegal.com/license/mit-license)
+
 </div>
 
 ## Basic Usage
@@ -18,10 +19,17 @@ A lightweight, fast, and modular web framework for Ruby based on Rack. The **Len
 ```ruby
 require "lennarb"
 
-Lennarb.new do |router|
-  router.get("/hello/:name") do |req, res|
-    name = req.params[:name]
-    res.html("Hello, #{name}!")
+Lennarb::App.new do
+  config do
+    optional :env, string, "prodcution"
+    optional :port, int, 9292
+  end
+
+  routes do
+    get("/hello/:name") do |req, res|
+      name = req.params[:name]
+      res.html("Hello, #{name}!")
+    end
   end
 end
 ```
@@ -43,7 +51,7 @@ See all [graphs](https://github.com/aristotelesbr/lennarb/blob/main/benchmark)
 
 This table ranks the routers by the number of requests they can process per second. Higher numbers indicate better performance.
 
-Plese see [Performance](https://aristotelesbr.github.io/lennarb/guides/performance/index.html) for more information.
+Please see [Performance](https://aristotelesbr.github.io/lennarb/guides/performance/index.html) for more information.
 
 ## Usage
 
@@ -51,10 +59,10 @@ Plese see [Performance](https://aristotelesbr.github.io/lennarb/guides/performan
 
 - [Performance](https://aristotelesbr.github.io/lennarb/guides/performance/index.html) - The **Lennarb** is very fast. The following benchmarks were performed on a MacBook Pro (Retina, 13-inch, Early 2013) with 2,7 GHz Intel Core i7 and 8 GB 1867 MHz DDR3. Based on [jeremyevans/r10k](https://github.com/jeremyevans/r10k) using the following [template build](static/r10k/build/lennarb.rb).
 
-- [Plugin](https://aristotelesbr.github.io/lennarb/guides/plugin/index.html) - You can create your plugins to extend the functionality of the framework.
+- [Request]() - TODO
 
 - [Response](https://aristotelesbr.github.io/lennarb/guides/response/index.html) - This is the response guide.
-    The `res` object is used to send a response to the client. The Lennarb use a custom response object to send responses to the client. The `res` object is an instance of `Lennarb::Response`.
+  The `res` object is used to send a response to the client. The Lennarb use a custom response object to send responses to the client. The `res` object is an instance of `Lennarb::Response`.
 
 ### Developer Certificate of Origin
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: lennarb
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.4.1
 platform: ruby
 authors:
 - Aristóteles Coutinho
 bindir: exe
 cert_chain: []
-date: 2025-02-09 00:00:00.000000000 Z
+date: 2025-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -51,6 +51,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: superconfig
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -107,6 +121,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-utils
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rack-test
   requirement: !ruby/object:Gem::Requirement
@@ -191,6 +219,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: debug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 executables:
 - lenna
 extensions: []
@@ -223,10 +265,15 @@ files:
 - guides/response/readme.md
 - lennarb.gemspec
 - lib/lennarb.rb
+- lib/lennarb/app.rb
+- lib/lennarb/config.rb
 - lib/lennarb/constansts.rb
+- lib/lennarb/environment.rb
 - lib/lennarb/request.rb
+- lib/lennarb/request_handler.rb
 - lib/lennarb/response.rb
 - lib/lennarb/route_node.rb
+- lib/lennarb/routes.rb
 - lib/lennarb/version.rb
 - license.md
 - logo/lennarb.png