lennarb 1.4.0 → 1.5.0

data/changelog.md

@@ -7,6 +7,81 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- Add `Lennarb::Application` class to be the base class of the "standard" implementation of the Lennarb framework.
+- Add middleware support to Lennarb::App class.
+- Add `middleware` support to the `Lennarb::Application` with default middlewares.
+- Add files to centralize the errors of the project.
+- Add CODE_OF_CONDUCT.md in English and Portuguese
+- Add CONTRIBUTING.md in English and Portuguese
+- Add `Lennarb::Logger` class for structured logging with support for tags and colorization
+- Add logger dependency to enhance logging capabilities in the framework
+- Add `Lennarb::ParameterFilter` for sensitive parameter filtering in logs and exceptions
+- Add `Lennarb::RequestLogger` middleware for detailed HTTP request logging
+- Add `Lennarb::Hooks` module for implementing hooks in the framework
+- Add improved request handling and configuration options
+- Add `RoutesFrozenError` for improved route modification handling
+- Add support for defining helpers with both modules and blocks in `Lennarb::App`.
+- Add `Lennarb::Helpers.define` method to handle modules and blocks for helper definitions.
+- Add tests for `Lennarb::Helpers` to validate module inclusion and block evaluation.
+- Add `Lennarb::Hooks` tests to validate hook initialization, addition, and execution.
+
+### Changed
+
+- Lennarb Logo
+- Migrate from utopiaproject to yard for documentation
+- Fix logo SVG display in yard documentation
+- Restructure App class to enhance routing, middleware, and initialization processes
+- Simplify Routes class by removing unnecessary comments and enhancing route definitions
+- Introduce Helpers module for managing application-specific helper methods
+- Update logger tag to use symbol for consistency
+- Enhance logging functionality with improved request logging details
+- Simplify config method by removing block parameter and improving readability
+- Update `Lennarb::App.helpers` to accept a module or block for defining helpers.
+
+### Fixed
+
+- Fix typo in require_relative statement for constants file
+- Fix conditional debug dependency based on Ruby engine
+
+## [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 +252,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/gems.rb

@@ -4,26 +4,7 @@ source "https://rubygems.org"
 gemspec
 
 group :maintenance, optional: true do
-  # [https://rubygems.org/gems/bake]
-  # Bake is a Ruby library that helps you to create a new project.
-  gem "bake"
-  # [https://rubygems.org/gems/covered]
-  # Covered is a Ruby library that helps you to test your project.
-  gem "covered"
-  # [https://rubygems.org/gems/bake-gem]
-  # Bake Gem is a Bake extension that helps you to create a new Ruby
-  # gem.
-  gem "bake-gem"
-  # [https://rubygems.org/gems/bake-modernize]
-  # Bake Modernize is a Bake extension that helps you to modernize your
-  # Ruby code.
-  gem "bake-modernize"
-  # [https://rubygems.org/gems/bake-github-pages]
-  # Bake Github Pages is a Bake extension that helps you to publish your
-  # project documentation to Github Pages.
-  gem "bake-github-pages"
-  # [https://rubygems.org/gems/utpia-project]
-  # Utopia Project is a Bake extension that helps you to create a new
-  # project.
-  gem "utopia-project"
+  # Yard is a documentation generation tool for the Ruby programming language.
+  # [https://rubygems.org/gems/yard]
+  gem "yard"
 end

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 do
+    get '/' do |req, res|
+      res.status = 200
+      res.html('<h1>Welcome to Lennarb!</h1>')
+    end
   end
 end
 
-app.initializer!
-run app
+MyApp.initialize!
+run MyApp
 ```
 
 Start the server:
@@ -69,7 +71,7 @@ app.get '/html' do |req, res|
 end
 
 app.get '/json' do |req, res|
-  res.json('{"message": "JSON response"}')
+  res.json({ message: "JSON response" })
 end
 ```
 
@@ -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,20 +176,20 @@ 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"}')
+     res.json({ status: "ok" })
    end
    ```
 
@@ -186,7 +200,7 @@ Default error responses:
    res.html('<h1>Web Page</h1>')
 
    # JSON for APIs
-   res.json('{"data": "value"}')
+   res.json({ data: "value" })
 
    # Text for simple responses
    res.text('Hello')
@@ -199,3 +213,7 @@ For help and bug reports, please visit:
 - GitHub Issues: [lennarb/issues](https://github.com/aristotelesbr/lennarb/issues)
 
 Now you can run your app!
+
+```
+
+```

data/guides/mounting-applications/readme.md

@@ -0,0 +1,38 @@
+## Mounting Applications
+
+You can mount other applications at specific paths using the `mount` method. The component to be mounted must be a subclass of `Lennarb::App`.
+
+```ruby
+class Blog < Lennarb::App
+  get "/" do |req, res|
+    res.html("<h1>Welcome to my blog</h1>")
+  end
+end
+
+class Admin < Lennarb::App
+  get "/" do |req, res|
+    res.html("<h1>Admin Dashboard</h1>")
+  end
+end
+
+class Application < Lennarb::Base
+  mount(Blog, at: "/blog")
+  mount(Admin, at: "/admin")
+end
+```
+
+## Middleware Configuration
+
+Middleware can be configured at both the base application level and within individual mounted applications. This allows for flexible and modular application design.
+
+```ruby
+class Blog < Lennarb::App
+  middleware do
+    use MyCustomMiddleware
+  end
+end
+```
+
+## Conclusion
+
+By using the `Base` class and the `mount` method, Lennarb provides a powerful way to structure your applications into modular components, each with its own routes and middleware.

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", "~> 3.0"
+  spec.add_dependency "logger", "~> 1.7"
   spec.add_development_dependency "bundler"
-  spec.add_development_dependency "covered"
   spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "simplecov-json"
   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" if RUBY_ENGINE == "ruby"
 end

data/lib/lennarb/app.rb

@@ -0,0 +1,253 @@
+module Lennarb
+  # Main application class with hooks and helpers support
+  class App
+    class << self
+      attr_writer :app
+      # Rack environment variable name
+      #
+      # @return [String] The environment variable name
+      def app
+        @app ||= self
+      end
+
+      # Define helper methods for the application
+      #
+      # @yield Block containing helper definitions
+      # @return [Module] The helpers module
+      def helpers(mod_or_block = nil, &block)
+        Helpers.define(self, mod_or_block, &block)
+      end
+
+      # Define a before hook
+      #
+      # @yield [req, res] Block to execute before route
+      # @return [Array] The before hooks array
+      def before(&block)
+        Hooks.add(self, :before, &block)
+      end
+
+      # Define an after hook
+      #
+      # @yield [req, res] Block to execute after route
+      # @return [Array] The after hooks array
+      def after(&block)
+        Hooks.add(self, :after, &block)
+      end
+
+      # Get routes for this app class
+      #
+      # @return [Routes] The routes instance
+      def routes
+        @routes ||= Routes.new
+      end
+
+      # Set up subclass
+      #
+      # @param [Class] subclass The new subclass
+      # @return [void]
+      def inherited(subclass)
+        super
+        # Each subclass gets its own routes
+        subclass.instance_variable_set(:@routes, Routes.new)
+      end
+
+      # Define route methods for all HTTP methods
+      HTTP_METHODS.each do |http_method|
+        define_method(http_method.downcase) do |path, &block|
+          routes.send(http_method.downcase, path, &block)
+        end
+      end
+
+      # Define root route (GET /)
+      #
+      # @yield [req, res, params] Route block
+      # @return [void]
+      def root(&block)
+        get("/", &block)
+      end
+
+      # Define configuration
+      #
+      # @param [Array<Symbol>] envs Environments
+      # @yield Configuration block
+      # @return [Config] The config instance
+      def config(*envs, &)
+        @config ||= Config.new(self)
+
+        if block_given?
+          write = envs.empty? || envs.map(&:to_sym).include?(env.name)
+          @config.instance_eval(&) if write
+        end
+
+        @config
+      end
+    end
+
+    # Instance methods
+
+    # Initialize a new app
+    #
+    # @yield [self] Configuration block
+    def initialize(&block)
+      @initialized = false
+      @root = Pathname.pwd
+      @env = Environment.new(compute_env)
+
+      instance_eval(&block) if block_given?
+    end
+
+    # The current environment
+    attr_reader :env
+
+    # The root directory
+    attr_accessor :root
+
+    # Set environment
+    #
+    # @param [String, Symbol] value Environment name
+    # @raise [AlreadyInitializedError] If already initialized
+    # @return [Environment] The new environment
+    def env=(value)
+      raise AlreadyInitializedError if initialized?
+      @env = Environment.new(value)
+    end
+
+    # Get the Rack app with middleware
+    #
+    # @return [#call] The Rack app
+    def app
+      @app ||= begin
+        handler = build_request_handler
+        stack = middleware.to_a
+
+        Rack::Builder.app do
+          stack.each { |middleware, args, block| use(middleware, *args, &block) }
+          run handler
+        end
+      end
+    end
+
+    # Rack interface method
+    #
+    # @param [Hash] env Rack environment
+    # @return [Array] Rack response
+    def call(env)
+      env[RACK_LENNA_APP] = self
+      app.call(env)
+    end
+
+    # Define middleware
+    #
+    # @yield Block to configure middleware
+    # @return [MiddlewareStack] The middleware stack
+    def middleware(&block)
+      @middleware_stack ||= default_middleware_stack
+      @middleware_stack.instance_eval(&block) if block_given?
+      @middleware_stack
+    end
+
+    # Define helpers (instance method)
+    #
+    # @yield Block with helper definitions
+    # @return [Module] The helpers module
+    def helpers(&block)
+      self.class.helpers(&block)
+    end
+
+    # Define before hook (instance method)
+    #
+    # @yield [req, res] Before hook block
+    # @return [Array] The before hooks array
+    def before(&block)
+      self.class.before(&block)
+    end
+
+    # Define after hook (instance method)
+    #
+    # @yield [req, res] After hook block
+    # @return [Array] The after hooks array
+    def after(&block)
+      self.class.after(&block)
+    end
+
+    # Get/define routes
+    #
+    # @yield Block to define routes
+    # @return [Routes] The routes instance
+    def routes(&block)
+      if block_given?
+        self.class.instance_exec(&block)
+      end
+
+      self.class.routes
+    end
+
+    # Get/define configuration
+    #
+    # @param [Array<Symbol>] envs Environments
+    # @yield Configuration block
+    # @return [Config] The config instance
+    def config(*envs, &)
+      @config ||= self.class.config
+
+      if block_given?
+        write = envs.empty? || envs.map(&:to_sym).include?(env.name)
+        @config.instance_eval(&) if write
+      end
+
+      @config
+    end
+
+    # Initialize the app
+    #
+    # @return [self] The initialized app
+    # @raise [AlreadyInitializedError] If already initialized
+    def initialize!
+      raise AlreadyInitializedError if @initialized
+
+      @initialized = true
+      routes.freeze
+      self
+    end
+
+    # Check if initialized
+    #
+    # @return [Boolean] true if initialized
+    def initialized?
+      @initialized
+    end
+
+    # Error for already initialized app
+    AlreadyInitializedError = Class.new(StandardError)
+
+    protected
+
+    # Build the request handler
+    #
+    # @return [RequestHandler] The request handler
+    def build_request_handler
+      RequestHandler.new(self)
+    end
+
+    # Create default middleware stack
+    #
+    # @return [MiddlewareStack] The middleware stack
+    private def default_middleware_stack
+      stack = MiddlewareStack.new
+      stack.use(Lennarb::Middleware::RequestLogger)
+      stack.use(Rack::Runtime)
+      stack.use(Rack::Head)
+      stack.use(Rack::ETag)
+      stack.use(Rack::ShowExceptions) if env.development?
+      stack
+    end
+
+    # Compute environment from ENV variables
+    #
+    # @return [String] Environment name
+    private def compute_env
+      env = ENV_NAMES.map { |name| ENV[name] }.compact.first.to_s
+      env.empty? ? "development" : env
+    end
+  end
+end