lennarb 1.4.1 → 1.5.0

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

@@ -28,7 +28,7 @@ Create a new file named `config.ru`:
 require 'lennarb'
 
 MyApp = Lennarb::App.new do
-  routes
+  routes do
     get '/' do |req, res|
       res.status = 200
       res.html('<h1>Welcome to Lennarb!</h1>')
@@ -37,7 +37,7 @@ MyApp = Lennarb::App.new do
 end
 
 MyApp.initialize!
-run App
+run MyApp
 ```
 
 Start the server:
@@ -71,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
 ```
 
@@ -94,7 +94,7 @@ Lennarb::App.new do
 
     get '/users/:id' do |req, res|
       user_id = req.params[:id]
-      res.json("{\"id\": #{user_id}}")
+      res.json({ id: user_id })
     end
   end
 end
@@ -124,7 +124,7 @@ Lennarb is thread-safe by design:
 ### Initialization
 
 ```ruby
-Myapp = Lennarb::App.new do
+MyApp = Lennarb::App.new do
   # Define routes
   routes do
   end
@@ -189,7 +189,7 @@ Default error responses:
    ```ruby
    get '/api' do |req, res|
      res.status = 200
-     res.json('{"status": "ok"}')
+     res.json({ status: "ok" })
    end
    ```
 
@@ -200,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')
@@ -213,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/lennarb.gemspec

@@ -31,10 +31,11 @@ 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_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"
@@ -42,6 +43,5 @@ Gem::Specification.new do |spec|
   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"
+  spec.add_development_dependency "debug" if RUBY_ENGINE == "ruby"
 end

data/lib/lennarb/app.rb

@@ -1,171 +1,252 @@
 module Lennarb
+  # Main application class with hooks and helpers support
   class App
-    # This error is raised whenever the app is initialized more than once.
-    AlreadyInitializedError = Class.new(StandardError)
+    class << self
+      attr_writer :app
+      # Rack environment variable name
+      #
+      # @return [String] The environment variable name
+      def app
+        @app ||= self
+      end
 
-    # The root app directory of the app.
-    #
-    # @returns [Pathname]
-    #
-    attr_accessor :root
+      # 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
 
-    # 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
+      # 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
 
-    def initialize(&)
-      @initialized = false
-      self.root = Pathname.pwd
-      self.env = compute_env
-      instance_eval(&) if block_given?
-    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
 
-    # Set the current environment. See {Lennarb::Environment} for more details.
-    #
-    # @parameter [Hash] env
-    #
-    def env=(env)
-      raise AlreadyInitializedError if initialized?
+      # Get routes for this app class
+      #
+      # @return [Routes] The routes instance
+      def routes
+        @routes ||= Routes.new
+      end
 
-      @env = Environment.new(env)
-    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
 
-    # 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)
+      # 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
 
-        self.controllers << controller
+      # 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
 
-    # 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
+    # Instance methods
+
+    # Initialize a new app
     #
-    def config(*envs, &)
-      @config ||= Config.new
+    # @yield [self] Configuration block
+    def initialize(&block)
+      @initialized = false
+      @root = Pathname.pwd
+      @env = Environment.new(compute_env)
 
-      write = block_given? &&
-        (envs.map(&:to_sym).include?(env.to_sym) || envs.empty?)
+      instance_eval(&block) if block_given?
+    end
 
-      @config.instance_eval(&) if write
+    # The current environment
+    attr_reader :env
 
-      @config
-    end
+    # The root directory
+    attr_accessor :root
 
-    # Define the app's route. See {Lennarb::RouteNode} for more details.
+    # Set environment
     #
-    # @returns [Lennarb::RouteNode]
-    #
-    def routes(&)
-      @routes ||= Routes.new
-      @routes.instance_eval(&) if block_given?
-      @routes
+    # @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
 
-    # The Rack app.
+    # Get the Rack app with middleware
     #
+    # @return [#call] The Rack app
     def app
       @app ||= begin
-        request_handler = RequestHandler.new(self)
+        handler = build_request_handler
+        stack = middleware.to_a
 
         Rack::Builder.app do
-          run request_handler
+          stack.each { |middleware, args, block| use(middleware, *args, &block) }
+          run handler
         end
       end
     end
 
-    # Store mounted app's
+    # Rack interface method
     #
-    def controllers
-      @controllers ||= []
+    # @param [Hash] env Rack environment
+    # @return [Array] Rack response
+    def call(env)
+      env[RACK_LENNA_APP] = self
+      app.call(env)
     end
-    alias_method :mounted_apps, :controllers
 
-    # Check if the app is initialized.
+    # Define middleware
     #
-    # @returns [Boolean]
+    # @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)
     #
-    def initialized? = @initialized
+    # @yield Block with helper definitions
+    # @return [Module] The helpers module
+    def helpers(&block)
+      self.class.helpers(&block)
+    end
 
-    # Initialize the app.
+    # Define before hook (instance method)
     #
-    # @returns [void]
+    # @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)
     #
-    def initialize!
-      raise AlreadyInitializedError if initialized?
+    # @yield [req, res] After hook block
+    # @return [Array] The after hooks array
+    def after(&block)
+      self.class.after(&block)
+    end
 
-      controllers.each do
-        routes.store.merge!(it.routes.store)
+    # 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
 
-      @initialized = true
-
-      app.freeze
-      routes.freeze
+      self.class.routes
     end
 
-    # Call the app.
+    # Get/define configuration
     #
-    # @parameter [Hash] env
+    # @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
     #
-    def call(env)
-      env[RACK_LENNA_APP] = self
-      Dir.chdir(root) { return app.call(env) }
+    # @return [self] The initialized app
+    # @raise [AlreadyInitializedError] If already initialized
+    def initialize!
+      raise AlreadyInitializedError if @initialized
+
+      @initialized = true
+      routes.freeze
+      self
     end
 
-    # Compute the current environment.
+    # Check if initialized
     #
-    # @returns [String]
+    # @return [Boolean] true if initialized
+    def initialized?
+      @initialized
+    end
+
+    # Error for already initialized app
+    AlreadyInitializedError = Class.new(StandardError)
+
+    protected
+
+    # Build the request handler
     #
-    # @private
+    # @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 { ENV[_1] }.compact.first.to_s
-
+      env = ENV_NAMES.map { |name| ENV[name] }.compact.first.to_s
       env.empty? ? "development" : env
     end
   end