lennarb 1.2.0 → 1.3.0

data/lib/lennarb.rb

@@ -8,9 +8,6 @@
 require 'pathname'
 require 'rack'
 
-# Base class for Lennarb
-#
-require_relative 'lennarb/application/base'
 require_relative 'lennarb/plugin'
 require_relative 'lennarb/request'
 require_relative 'lennarb/response'
@@ -18,127 +15,144 @@ require_relative 'lennarb/route_node'
 require_relative 'lennarb/version'
 
 class Lennarb
-	# Error class
-	#
-	class LennarbError < StandardError; end
-
-	# @attribute [r] root
-	# @returns [RouteNode]
-	#
-	attr_reader :_root
-
-	# @attribute [r] applied_plugins
-	# @returns [Array]
-	#
-	attr_reader :_applied_plugins
-
-	# Initialize the application
-	#
-	# @yield { ... } The application
-	#
-	# @returns [Lennarb]
-	#
-	def initialize
-		@_root = RouteNode.new
-		@_applied_plugins = []
-		yield self if block_given?
-	end
-
-	# Split a path into parts
-	#
-	# @parameter [String] path
-	#
-	# @returns [Array] parts. Ex. ['users', ':id']
-	#
-	SplitPath = ->(path) { path.split('/').reject(&:empty?) }
-	private_constant :SplitPath
-
-	# Call the application
-	#
-	# @parameter [Hash] env
-	#
-	# @returns [Array] response
-	#
-	def call(env)
-		http_method = env[Rack::REQUEST_METHOD].to_sym
-		parts       = SplitPath[env[Rack::PATH_INFO]]
-
-		block, params = @_root.match_route(parts, http_method)
-		return [404, { 'content-type' => 'text/plain' }, ['Not Found']] unless block
-
-		@res = Response.new
-		req  = Request.new(env, params)
-
-		catch(:halt) do
-			instance_exec(req, @res, &block)
-			@res.finish
-		end
-	end
-
-	# Freeze the routes
-	#
-	# @returns [void]
-	#
-	def freeze! = @_root.freeze
-
-	# Add a routes
-	#
-	# @parameter [String] path
-	# @parameter [Proc] block
-	#
-	# @returns [void]
-	#
-	def get(path, &block)     = add_route(path, :GET, block)
-	def put(path, &block)     = add_route(path, :PUT, block)
-	def post(path, &block)    = add_route(path, :POST, block)
-	def head(path, &block)    = add_route(path, :HEAD, block)
-	def patch(path, &block)   = add_route(path, :PATCH, block)
-	def delete(path, &block)  = add_route(path, :DELETE, block)
-	def options(path, &block) = add_route(path, :OPTIONS, block)
-
-	# Add plugin to extend the router
-	#
-	# @parameter [String] plugin_name
-	# @parameter [args]  *args
-	# @parameter [Block] block
-	#
-	# @returns [void]
-	#
-	def plugin(plugin_name, *, &)
-		return if @_applied_plugins.include?(plugin_name)
-
-		plugin_module = Plugin.load(plugin_name)
-		extend plugin_module::InstanceMethods         if defined?(plugin_module::InstanceMethods)
-		self.class.extend plugin_module::ClassMethods if defined?(plugin_module::ClassMethods)
-		plugin_module.setup(self.class, *, &)         if plugin_module.respond_to?(:setup)
-
-		@_applied_plugins << plugin_name
-	end
-
-	# Merge the other RouteNode into the current one
-	#
-	# @parameter other [RouteNode] The other RouteNode to merge into the current one
-	#
-	# @return [void]
-	#
-	def merge!(other)
-		raise "Expected a Lennarb instance, got #{other.class}" unless other.is_a?(Lennarb)
-
-		@_root.merge!(other._root)
+  class LennarbError < StandardError; end
+
+  attr_reader :_root, :_plugins, :_loaded_plugins, :_middlewares, :_app
+
+  def self.use(middleware, *args, &block)
+    @_middlewares ||= []
+    @_middlewares << [middleware, args, block]
+  end
+
+  def self.get(path, &block)     = add_route(path, :GET, block)
+  def self.put(path, &block)     = add_route(path, :PUT, block)
+  def self.post(path, &block)    = add_route(path, :POST, block)
+  def self.head(path, &block)    = add_route(path, :HEAD, block)
+  def self.patch(path, &block)   = add_route(path, :PATCH, block)
+  def self.delete(path, &block)  = add_route(path, :DELETE, block)
+  def self.options(path, &block) = add_route(path, :OPTIONS, block)
+
+  def self.inherited(subclass)
+    super
+    subclass.instance_variable_set(:@_root, RouteNode.new)
+    subclass.instance_variable_set(:@_plugins, [])
+    subclass.instance_variable_set(:@_middlewares, @_middlewares&.dup || [])
+
+    Plugin.load_defaults! if Plugin.load_defaults?
+  end
+
+  def self.plugin(plugin_name, *, &)
+    @_loaded_plugins ||= {}
+    @_plugins        ||= []
+
+    return if @_loaded_plugins.key?(plugin_name)
+
+    plugin_module = Plugin.load(plugin_name)
+    plugin_module.configure(self, *, &) if plugin_module.respond_to?(:configure)
+
+    @_loaded_plugins[plugin_name] = plugin_module
+    @_plugins << plugin_name
+  end
+
+  def self.freeze!
+    app = new
+    app.freeze!
+    app
+  end
+
+  def self.add_route(path, http_method, block)
+    @_root ||= RouteNode.new
+    parts = path.split('/').reject(&:empty?)
+    @_root.add_route(parts, http_method, block)
+  end
+
+  private_class_method :add_route
+
+  def initialize
+    @_mutex = Mutex.new
+    @_root             = self.class.instance_variable_get(:@_root)&.dup           || RouteNode.new
+    @_plugins          = self.class.instance_variable_get(:@_plugins)&.dup        || []
+    @_loaded_plugins   = self.class.instance_variable_get(:@_loaded_plugins)&.dup || {}
+    @_middlewares      = self.class.instance_variable_get(:@_middlewares)&.dup    || []
+
+    build_app
+
+    yield self if block_given?
   end
 
-	private
-
-	# Add a route
-	#
-	# @parameter [String] path
-	# @parameter [String] http_method
-	# @parameter [Proc] block
-	#
-	# @returns [void]
-	#
-	def add_route(path, http_method, block)
-		parts = SplitPath[path]
-		@_root.add_route(parts, http_method, block)
-	end
+  def call(env) = @_mutex.synchronize { @_app.call(env) }
+
+  def freeze!
+    return self if @_mounted
+
+    @_root.freeze
+    @_plugins.freeze
+    @_loaded_plugins.freeze
+    @_middlewares.freeze
+    @_app.freeze if @_app.respond_to?(:freeze)
+    self
+  end
+
+  def get(path, &block)     = add_route(path, :GET, block)
+  def put(path, &block)     = add_route(path, :PUT, block)
+  def post(path, &block)    = add_route(path, :POST, block)
+  def head(path, &block)    = add_route(path, :HEAD, block)
+  def patch(path, &block)   = add_route(path, :PATCH, block)
+  def delete(path, &block)  = add_route(path, :DELETE, block)
+  def options(path, &block) = add_route(path, :OPTIONS, block)
+
+  def plugin(plugin_name, *, &)
+    return if @_loaded_plugins.key?(plugin_name)
+
+    plugin_module = Plugin.load(plugin_name)
+    self.class.extend plugin_module::ClassMethods     if plugin_module.const_defined?(:ClassMethods)
+    self.class.include plugin_module::InstanceMethods if plugin_module.const_defined?(:InstanceMethods)
+    plugin_module.configure(self, *, &)               if plugin_module.respond_to?(:configure)
+    @_loaded_plugins[plugin_name] = plugin_module
+    @_plugins << plugin_name
+  end
+
+  private
+
+  def build_app
+    @_app = method(:process_request)
+
+    @_middlewares.reverse_each do |middleware, args, block|
+      @_app = middleware.new(@_app, *args, &block)
+    end
+  end
+
+  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 not_found unless block
+
+    res = Response.new
+    req = Request.new(env, params)
+
+    catch(:halt) do
+      instance_exec(req, res, &block)
+      res.finish
+    end
+  rescue StandardError => e
+    handle_error(e)
+  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: #{error.message}"]]
+    end
+  end
+
+  def not_found = [404, { 'content-type' => 'text/plain' }, ['Not Found']]
+
+  def add_route(path, http_method, block)
+    parts = path.split('/').reject(&:empty?)
+    @_root.add_route(parts, http_method, block)
+  end
 end

data/license.md

@@ -1,7 +1,6 @@
 # MIT License
 
-Copyright, 2023-2024, by Aristóteles Coutinho.  
-Copyright, 2023, by aristotelesbr.  
+Copyright (c) 2023-2025 Aristótels Coutinho
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lennarb
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Aristóteles Coutinho
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-10-09 00:00:00.000000000 Z
+date: 2024-11-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize
@@ -180,8 +180,9 @@ files:
 - changelog.md
 - exe/lenna
 - lib/lennarb.rb
-- lib/lennarb/application/base.rb
 - lib/lennarb/plugin.rb
+- lib/lennarb/plugins/hooks.rb
+- lib/lennarb/plugins/mount.rb
 - lib/lennarb/request.rb
 - lib/lennarb/response.rb
 - lib/lennarb/route_node.rb
@@ -212,7 +213,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
+rubygems_version: 3.5.23
 signing_key:
 specification_version: 4
 summary: Lennarb provides a lightweight yet robust solution for web routing in Ruby,

data/lib/lennarb/application/base.rb

@@ -1,283 +0,0 @@
-# frozen_string_literal: true
-
-# Released under the MIT License.
-# Copyright, 2023-2024, by Aristóteles Coutinho.
-
-require 'colorize'
-
-class Lennarb
-	module Application
-		class Base
-			# @attribute [r] _route
-			# @returns [RouteNode]
-			#
-			# @attribute [r] _middlewares
-			# @returns [Array]
-			#
-			# @attribute [r] _global_after_hooks
-			# @returns [Array]
-			#
-			# @attribute [r] _global_before_hooks
-			# @returns [Array]
-			#
-			# @attribute [r] _after_hooks
-			# @returns [RouteNode]
-			#
-			# @attribute [r] _before_hooks
-			# @returns [RouteNode]
-			#
-			attr_accessor :_route, :_global_after_hooks, :_global_before_hooks, :_after_hooks, :_before_hooks
-
-			# Initialize the Application
-			#
-			# @returns [Base]
-			#
-			class << self
-				def inherited(subclass)
-          super
-          _applications << subclass
-					subclass.instance_variable_set(:@_route, Lennarb.new)
-					subclass.instance_variable_set(:@_middlewares, [])
-					subclass.instance_variable_set(:@_global_after_hooks, [])
-					subclass.instance_variable_set(:@_global_before_hooks, [])
-					subclass.instance_variable_set(:@_after_hooks, Lennarb::RouteNode.new)
-					subclass.instance_variable_set(:@_before_hooks, Lennarb::RouteNode.new)
-				end
-
-				def get(...)     = @_route.get(...)
-				def put(...)     = @_route.put(...)
-				def post(...)    = @_route.post(...)
-				def head(...)    = @_route.head(...)
-				def match(...)   = @_route.match(...)
-				def patch(...)   = @_route.patch(...)
-				def delete(...)  = @_route.delete(...)
-				def options(...) = @_route.options(...)
-          
-				# @returns [Array] middlewares
-				#
-				def _middlewares = @_middlewares ||= []
-
-				# @returns [Array] applications
-				#
-				def _applications = @_applications ||= []
-
-				# Mount a controller
-				#
-				# @parameter [Class] controller
-				#
-				def mount(controller_class)
-					_applications << controller_class
-					puts "Mounted controller: #{controller_class}"
-				end
-
-				# Use a middleware
-				#
-				# @parameter [Object] middleware
-				# @parameter [Array] args
-				# @parameter [Block] block
-				#
-				# @returns [Array] middlewares
-				#
-				def use(middleware, *args, &block)
-					@_middlewares << [middleware, args, block]
-				end
-
-				# Add a before hook
-				#
-				# @parameter [String] path
-				# @parameter [Block] block
-				#
-				def before(path = nil, &block)
-					if path
-						parts = path.split('/').reject(&:empty?)
-						@_before_hooks.add_route(parts, :before, block)
-					else
-						@_global_before_hooks << block
-					end
-				end
-
-				# Add a after hook
-				#
-				# @parameter [String] path
-				# @parameter [Block] block
-				#
-				def after(path = nil, &block)
-					if path
-						parts = path.split('/').reject(&:empty?)
-						@_after_hooks.add_route(parts, :after, block)
-					else
-						@_global_after_hooks << block
-					end
-				end
-
-				# Run the Application
-				#
-				# @returns [Base] self
-				#
-				# When you use this method, the application will be frozen. And you can't add more routes after that.
-				# This method is used to run the application in a Rack server so, you can use the `rackup` command
-				#     to run the application.
-				# Ex. rackup -p 3000
-				# This command will use the following middleware:
-				#  - Rack::ShowExceptions
-				#  - Rack::MethodOverride
-				#  - Rack::Head
-				#  - Rack::ContentLength
-				#
-				def run!
-					stack = Rack::Builder.new
-
-					use Rack::ShowExceptions if test? || development?
-					use Rack::MethodOverride
-					use Rack::Head
-					use Rack::ContentLength
-
-					_middlewares.each do |(middleware, args, block)|
-						stack.use(middleware, *args, &block)
-					end
-
-					_applications.each do |app|
-						app_route = app.instance_variable_get(:@_route)
-
-						app_after_hooks = app.instance_variable_get(:@_after_hooks) 
-						app_before_hooks = app.instance_variable_get(:@_before_hooks)
-						global_after_hooks = app.instance_variable_get(:@_global_after_hooks)
-						global_before_hooks = app.instance_variable_get(:@_global_before_hooks)
-
-						@_route.merge!(app_route)
-						@_before_hooks.merge!(app_before_hooks)
-						@_after_hooks.merge!(app_after_hooks)
-
-						@_global_before_hooks.concat(global_before_hooks)
-						@_global_after_hooks.concat(global_after_hooks)
-					end
-
-					stack.run ->(env) do
-						catch(:halt) do
-							execute_hooks(@_before_hooks, env, :before)
-							res = @_route.call(env)
-							execute_hooks(@_after_hooks, env, :after)
-							res
-						rescue StandardError => e
-							render_error if production?
-
-							puts e.message.red
-							puts e.backtrace
-							raise e
-						end
-					end
-
-					@_route.freeze!
-					stack.to_app
-				end
-
-				def test?        = ENV['RACK_ENV'] == 'test'        || ENV['LENNARB_ENV'] == 'test'
-				def production?  = ENV['RACK_ENV'] == 'production'  || ENV['LENNARB_ENV'] == 'production'
-				def development? = ENV['RACK_ENV'] == 'development' || ENV['LENNARB_ENV'] == 'development'
-
-				# Render a not found
-				#
-				# @returns [void]
-				#
-				def render_not_found(content = nil)
-					default = File.exist?('public/404.html')
-					body = content || default || 'Not Found'
-					throw :halt, [404, { 'content-type' => 'text/html' }, [body]]
-				end
-
-				# Render an error
-				#
-				# @returns [void]
-				#
-				def render_error(content = nil)
-					default = File.exist?('public/500.html')
-					body = content || default || 'Internal Server Error'
-					throw :halt, [500, { 'content-type' => 'text/html' }, [body]]
-				end
-
-				# Redirect to a path
-				#
-				# @parameter [String] path
-				# @parameter [Integer] status default is 302
-				#
-				def redirect(path, status = 302) = throw :halt, [status, { 'location' => path }, []]
-
-				# Include a plugin in the application
-				#
-				# @parameter [String] plugin_name
-				# @parameter [Array] args
-				# @parameter [Block] block
-				#
-				# @returns [void]
-				#
-				def plugin(plugin_name, *, &)
-					@_route.plugin(plugin_name, *, &)
-					plugin_module = @_route.class::Plugin.load(plugin_name)
-
-					include plugin_module::InstanceMethods if plugin_module.const_defined?(:InstanceMethods)
-					extend plugin_module::ClassMethods     if plugin_module.const_defined?(:ClassMethods)
-				end
-
-				private
-
-				# Execute the hooks
-				#
-				# @parameter [RouteNode] hook_route
-				# @parameter [Hash] env
-				# @parameter [Symbol] action
-				#
-				# @returns [void]
-				#
-				def execute_hooks(hook_route, env, action)
-					execute_global_hooks(env, action)
-
-					execute_route_hooks(hook_route, env, action)
-				end
-
-				# Execute the global hooks
-				#
-				# @parameter [Hash] env
-				# @parameter [Symbol] action
-				#
-				# @returns [void]
-				#
-				def execute_global_hooks(env, action)
-					global_hooks = action == :before ? @_global_before_hooks : @_global_after_hooks
-					global_hooks.each { |hook| hook.call(env) }
-				end
-
-				# Execute the route hooks
-				#
-				# @parameter [RouteNode] hook_route
-				# @parameter [Hash] env
-				# @parameter [Symbol] action
-				#
-				# @returns [void]
-				#
-				def execute_route_hooks(hook_route, env, action)
-					parts = parse_path(env)
-					return unless parts
-
-					block, = hook_route.match_route(parts, action)
-					block&.call(env)
-				end
-
-				# Parse the path
-				#
-				# @parameter [Hash] env
-				#
-				# @returns [Array] parts
-				#
-				def parse_path(env) = env[Rack::PATH_INFO]&.split('/')&.reject(&:empty?)
-
-				# Check if the request is a HTML request
-				#
-				# @parameter [Hash] env
-				#
-				# @returns [Boolean]
-				#
-				def html_request?(env) = env['HTTP_ACCEPT']&.include?('text/html')
-			end
-		end
-	end
-end