lennarb 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd399f9aecbae5c09d1928317826fd82c62207a36d76ad6a1591a7757811d6e4
-  data.tar.gz: 3f1ecf28399eeb28a8d739e50ffc01ecd0ae7328057c4132f15e6a12b65cd1e9
+  metadata.gz: 0fafe6e0a4a4fcb12d0cb7d75187b89c5ff2a8f4847bdab4db666d670fd1d40e
+  data.tar.gz: 43739df71271e6410f691b19d0e31c64ea5e883ae79150a3d0055d17a200fe8a
 SHA512:
-  metadata.gz: b32f1d120bfd85de2512721631c90e95aa32622dfd69e41e90ce66f7d61b22db235b30c5de8329bfd1669dc4ca9b880bcb858068246362422e0c0b545b1e29af
-  data.tar.gz: 28e13690c911ddb81d97c9e4fab95c270eb7e0367d2a26ea89b959252b3a449d611cb9dc067d0428e8959aa2beb96a9e9f3240462c97fbe480aecfd47ae169fd
+  metadata.gz: 8015dceb914f8bf52ee77eff7faf3adca26cdb020a3acba0ce3cc58ecd7eec338e84afe87fcd691867e087a646875b06a9f278c220b25f4f627bc87ff7288306
+  data.tar.gz: c9a7b74731ac3fe4e607396647931656628e1df03968069891d65189b0f387df44d89054191a34a41bdaf7a3381ad6c2486f91fba13dfd4b5a3b04a79f299af7

data/changelog.md

@@ -7,6 +7,26 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.3.0] - 2024-11-21
+
+### Added
+
+- Add `Lennarb::Plugin` module to manage the plugins in the project. Now, the `Lennarb` class is the main class of the project.
+
+- Automatically loads plugins from the default directory
+
+- Supports custom plugin directories via `LENNARB_PLUGINS_PATH`
+
+- Configurable through environment variables
+
+### Changed
+
+- Change the `finish` method from `Lennarb` class to call `halt(@res.finish)` method to finish the response.
+
+### Removed
+
+- Remove `Lennarb::ApplicationBase` class from the project. Now, the `Lennarb` class is the main class of the project.
+
 ## [0.6.1] - 2024-05-17
 
 ### Added

data/lib/lennarb/plugin.rb

@@ -1,35 +1,49 @@
 # frozen_string_literal: true
 
-# Released under the MIT License.
-# Copyright, 2023-2024, by Aristóteles Coutinho.
-
 class Lennarb
-	module Plugin
-		@plugins = {}
-
-		# Register a plugin
-		#
-		# @parameter [String] name
-		# @parameter [Module] mod
-		#
-		# @returns [void]
-		#
-		def self.register(name, mod)
-			@plugins[name] = mod
-		end
-
-		# Load a plugin
-		#
-		# @parameter [String] name
-		#
-		# @returns [Module] plugin
-		#
-		def self.load(name)
-			@plugins[name] || raise(LennarbError, "Plugin #{name} did not register itself correctly")
-		end
-
-		# @returns [Hash] plugins
-		#
-		def self.plugins = @plugins
-	end
+  module Plugin
+    class Error < StandardError; end
+
+    @registry         = {}
+    @defaults_loaded  = false
+
+    class << self
+      attr_reader :registry
+
+      def register(name, mod)
+        registry[name.to_sym] = mod
+      end
+
+      def load(name)
+        registry[name.to_sym] || raise(Error, "Plugin #{name} not found")
+      end
+
+      def load_defaults!
+        return if @defaults_loaded
+
+        # 1. Register default plugins
+        plugins_path = File.expand_path('plugins', __dir__)
+        load_plugins_from_directory(plugins_path)
+
+        # # 2. Register custom plugins
+        ENV.fetch('LENNARB_PLUGINS_PATH', nil)&.split(File::PATH_SEPARATOR)&.each do |path|
+          load_plugins_from_directory(path)
+        end
+
+        @defaults_loaded = true
+      end
+
+      def load_defaults?
+        ENV.fetch('LENNARB_AUTO_LOAD_DEFAULTS', 'true') == 'true'
+      end
+
+      private
+
+      def load_plugins_from_directory(path)
+        raise Error, "Plugin directory '#{path}' does not exist" unless File.directory?(path)
+
+        Dir["#{path}/**/*.rb"].each { require _1 }
+      end
+    end
+  end
 end

data/lib/lennarb/plugins/hooks.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+class Lennarb
+  module Plugins
+    module Hooks
+      def self.configure(app)
+        app.instance_variable_set(:@_before_hooks, {})
+        app.instance_variable_set(:@_after_hooks, {})
+        app.extend(ClassMethods)
+        app.include(InstanceMethods)
+      end
+
+      module ClassMethods
+        def before(paths = '*', &block)
+          paths = Array(paths)
+          @_before_hooks ||= {}
+
+          paths.each do |path|
+            @_before_hooks[path] ||= []
+            @_before_hooks[path] << block
+          end
+        end
+
+        def after(paths = '*', &block)
+          paths = Array(paths)
+          @_after_hooks ||= {}
+
+          paths.each do |path|
+            @_after_hooks[path] ||= []
+            @_after_hooks[path] << block
+          end
+        end
+
+        def inherited(subclass)
+          super
+          subclass.instance_variable_set(:@_before_hooks, @_before_hooks&.dup || {})
+          subclass.instance_variable_set(:@_after_hooks, @_after_hooks&.dup || {})
+        end
+      end
+
+      module InstanceMethods
+        def call(env)
+          catch(:halt) do
+            req = Lennarb::Request.new(env)
+            res = Lennarb::Response.new
+
+            path = env[Rack::PATH_INFO]
+
+            execute_hooks(self.class.instance_variable_get(:@_before_hooks), '*', req, res)
+
+            execute_matching_hooks(self.class.instance_variable_get(:@_before_hooks), path, req, res)
+
+            status, headers, body = super
+            res.status = status
+            headers.each { |k, v| res[k] = v }
+            body.each { |chunk| res.write(chunk) }
+
+            execute_matching_hooks(self.class.instance_variable_get(:@_after_hooks), path, req, res)
+
+            execute_hooks(self.class.instance_variable_get(:@_after_hooks), '*', req, res)
+
+            res.finish
+          end
+        rescue StandardError => e
+          handle_error(e)
+        end
+
+        private
+
+        def execute_hooks(hooks, path, req, res)
+          return unless hooks&.key?(path)
+
+          hooks[path].each do |hook|
+            instance_exec(req, res, &hook)
+          end
+        end
+
+        def execute_matching_hooks(hooks, current_path, req, res)
+          return unless hooks
+
+          hooks.each do |pattern, pattern_hooks|
+            next if pattern == '*'
+
+            next unless matches_pattern?(pattern, current_path)
+
+            pattern_hooks.each do |hook|
+              instance_exec(req, res, &hook)
+            end
+          end
+        end
+
+        def matches_pattern?(pattern, path)
+          return true if pattern == path
+
+          pattern_parts = pattern.split('/')
+          path_parts = path.split('/')
+
+          return false if pattern_parts.length != path_parts.length
+
+          pattern_parts.zip(path_parts).all? do |pattern_part, path_part|
+            pattern_part.start_with?(':') || pattern_part == path_part
+          end
+        end
+
+        def handle_error(error)
+          case error
+          when ArgumentError
+            [400, { 'Content-Type' => 'text/plain' }, ["Bad Request: #{error.message}"]]
+          else
+            [500, { 'Content-Type' => 'text/plain' }, ['Internal Server Error']]
+          end
+        end
+      end
+    end
+    Lennarb::Plugin.register(:hooks, Hooks)
+  end
+end

data/lib/lennarb/plugins/mount.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+class Lennarb
+  module Plugins
+    module Mount
+      def self.configure(app)
+        app.instance_variable_set(:@_mounted_apps, {})
+        app.extend(ClassMethods)
+        app.include(InstanceMethods)
+      end
+
+      module ClassMethods
+        def mount(app_class, at:)
+          raise ArgumentError, 'Expected a Lennarb class' unless app_class.is_a?(Class) && app_class <= Lennarb
+          raise ArgumentError, 'Mount path must start with /' unless at.start_with?('/')
+
+          @_mounted_apps ||= {}
+          normalized_path = normalize_mount_path(at)
+
+          mounted_app = app_class.new
+          mounted_app.freeze!
+
+          @_mounted_apps[normalized_path] = mounted_app
+        end
+
+        private
+
+        def normalize_mount_path(path)
+          path.chomp('/')
+        end
+      end
+
+      module InstanceMethods
+        def call(env)
+          path_info = env[Rack::PATH_INFO]
+
+          self.class.instance_variable_get(:@_mounted_apps)&.each do |mount_path, app|
+            next unless path_info.start_with?("#{mount_path}/") || path_info == mount_path
+
+            env[Rack::PATH_INFO]   = path_info[mount_path.length..]
+            env[Rack::PATH_INFO]   = '/' if env[Rack::PATH_INFO].empty?
+            env[Rack::SCRIPT_NAME] = "#{env[Rack::SCRIPT_NAME]}#{mount_path}"
+
+            return app.call(env)
+          end
+
+          super
+        rescue StandardError => e
+          handle_error(e)
+        end
+
+        private
+
+        def handle_error(error)
+          case error
+          when ArgumentError
+            [400, { 'content-type' => 'text/plain' }, ["Bad Request: #{error.message}"]]
+          else
+            [500, { 'content-type' => 'text/plain' }, ['Internal Server Error']]
+          end
+        end
+      end
+    end
+    Lennarb::Plugin.register(:mount, Mount)
+  end
+end

data/lib/lennarb/request.rb

@@ -4,41 +4,80 @@
 # Copyright, 2023-2024, by Aristóteles Coutinho.
 
 class Lennarb
-	class Request < Rack::Request
-		# Initialize the request object
-		#
-		# @parameter [Hash] env
-		# @parameter [Hash] route_params
-		#
-		# @returns [Request]
-		#
-		def initialize(env, route_params = {})
-			super(env)
-			@route_params = route_params
-		end
-
-		# Get the request body
-		#
-		# @returns [String]
-    #
-		def params
-			@params ||= super.merge(@route_params)
-		end
-
-		# Read the body of the request
-		#
-		# @returns [String]
-		#
-		def body = @body ||= super.read
-
-		private
-
-		# Get the query string parameters
-		#
-		# @returns [String]
-		#
-		def query_params
-			@query_params ||= Rack::Utils.parse_nested_query(query_string)
-		end
-	end
+  class Request < Rack::Request
+    # The environment variables of the request
+    #
+    # @returns [Hash]
+    #
+    attr_reader :env
+
+    # Initialize the request object
+    #
+    # @parameter [Hash] env
+    # @parameter [Hash] route_params
+    #
+    # @returns [Request]
+    #
+    def initialize(env, route_params = {})
+      super(env)
+      @route_params = route_params
+    end
+
+    # Get the request body
+    #
+    # @returns [String]
+    #
+    def params = @params ||= super.merge(@route_params)&.transform_keys(&:to_sym)
+
+    # Get the request path
+    #
+    # @returns [String]
+    #
+    def path = @path ||= super.split('?').first
+
+    # Read the body of the request
+    #
+    # @returns [String]
+    #
+    def body = @body ||= super.read
+
+    # Get the query parameters
+    #
+    # @returns [Hash]
+    #
+    def query_params
+      @query_params ||= Rack::Utils.parse_nested_query(query_string).transform_keys(&:to_sym)
+    end
+
+    # Get the headers of the request
+    #
+    def headers
+      @headers ||= env.select { |key, _| key.start_with?('HTTP_') }
+    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?
+
+    def []=(key, value)
+      env[key] = value
+    end
+
+    def [](key)
+      env[key]
+    end
+
+    private
+
+    def ip_address
+      forwarded_for = headers['HTTP_X_FORWARDED_FOR']
+      forwarded_for ? forwarded_for.split(',').first.strip : env['REMOTE_ADDR']
+    end
+  end
 end