lennarb 1.1.0 → 1.3.0

data/lib/lennarb/response.rb

@@ -4,137 +4,137 @@
 # Copyright, 2023-2024, by Aristóteles Coutinho.
 
 class Lennarb
-	class Response
-		# @!attribute [rw] status
-		#  @returns [Integer]
-		#
-		attr_accessor :status
-
-		# @!attribute [r] body
-		#  @returns [Array]
-		#
-		attr_reader :body
-
-		# @!attribute [r] headers
-		#  @returns [Hash]
-		#
-		attr_reader :headers
-
-		# @!attribute [r] length
-		#  @returns [Integer]
-		#
-		attr_reader :length
-
-		# Constants
-		#
-		LOCATION = 'location'
-		private_constant :LOCATION
-
-		CONTENT_TYPE = 'content-type'
-		private_constant :CONTENT_TYPE
-
-		CONTENT_LENGTH = 'content-length'
-		private_constant :CONTENT_LENGTH
-
-		ContentType = { HTML: 'text/html', TEXT: 'text/plain', JSON: 'application/json' }.freeze
-		private_constant :ContentType
-
-		# Initialize the response object
-		#
-		# @returns [Response]
-		#
-		def initialize
-			@status = 404
-			@headers = {}
-			@body    = []
-			@length  = 0
-		end
-
-		# Set the response header
-		#
-		# @parameter [String] key
-		#
-		# @returns [String] value
-		#
-		def [](key)
-			@headers[key]
-		end
-
-		# Get the response header
-		#
-		# @parameter [String] key
-		# @parameter [String] value
-		#
-		# @returns [String] value
-		#
-		def []=(key, value)
-			@headers[key] = value
-		end
-
-		# Write to the response body
-		#
-		# @parameter [String] str
-		#
-		# @returns [String] str
-		#
-		def write(str)
-			str = str.to_s
-			@length += str.bytesize
-			@headers[CONTENT_LENGTH] = @length.to_s
-			@body << str
-		end
-
-		# Set the response type to text
-		#
-		# @parameter [String] str
-		#
-		# @returns [String] str
-		#
-		def text(str)
-			@headers[CONTENT_TYPE] = ContentType[:TEXT]
-			write(str)
-		end
-
-		# Set the response type to html
-		#
-		# @parameter [String] str
-		#
-		# @returns [String] str
-		#
-		def html(str)
-			@headers[CONTENT_TYPE] = ContentType[:HTML]
-			write(str)
-		end
-
-		# Set the response type to json
-		#
-		# @parameter [String] str
-		#
-		# @returns [String] str
-		#
-		def json(str)
-			@headers[CONTENT_TYPE] = ContentType[:JSON]
-			write(str)
-		end
-
-		# Redirect the response
-		#
-		# @parameter [String] path
-		# @parameter [Integer] status, default: 302
-		#
-		def redirect(path, status = 302)
-			@headers[LOCATION] = path
-			@status = status
-
-			throw :halt, finish
-		end
-
-		# Finish the response
-		#
-		# @returns [Array] response
-		#
-		def finish
-			[@status, @headers, @body]
-		end
-	end
+  class Response
+    # @!attribute [rw] status
+    #  @returns [Integer]
+    #
+    attr_accessor :status
+
+    # @!attribute [r] body
+    #  @returns [Array]
+    #
+    attr_reader :body
+
+    # @!attribute [r] headers
+    #  @returns [Hash]
+    #
+    attr_reader :headers
+
+    # @!attribute [r] length
+    #  @returns [Integer]
+    #
+    attr_reader :length
+
+    # Constants
+    #
+    LOCATION = 'location'
+    private_constant :LOCATION
+
+    CONTENT_TYPE = 'content-type'
+    private_constant :CONTENT_TYPE
+
+    CONTENT_LENGTH = 'content-length'
+    private_constant :CONTENT_LENGTH
+
+    ContentType = { HTML: 'text/html', TEXT: 'text/plain', JSON: 'application/json' }.freeze
+    private_constant :ContentType
+
+    # Initialize the response object
+    #
+    # @returns [Response]
+    #
+    def initialize
+      @status  = 404
+      @headers = {}
+      @body    = []
+      @length  = 0
+    end
+
+    # Set the response header
+    #
+    # @parameter [String] key
+    #
+    # @returns [String] value
+    #
+    def [](key)
+      @headers[key]
+    end
+
+    # Get the response header
+    #
+    # @parameter [String] key
+    # @parameter [String] value
+    #
+    # @returns [String] value
+    #
+    def []=(key, value)
+      @headers[key] = value
+    end
+
+    # Write to the response body
+    #
+    # @parameter [String] str
+    #
+    # @returns [String] str
+    #
+    def write(str)
+      str = str.to_s
+      @length += str.bytesize
+      @headers[CONTENT_LENGTH] = @length.to_s
+      @body << str
+    end
+
+    # Set the response type to text
+    #
+    # @parameter [String] str
+    #
+    # @returns [String] str
+    #
+    def text(str)
+      @headers[CONTENT_TYPE] = ContentType[:TEXT]
+      write(str)
+    end
+
+    # Set the response type to html
+    #
+    # @parameter [String] str
+    #
+    # @returns [String] str
+    #
+    def html(str)
+      @headers[CONTENT_TYPE] = ContentType[:HTML]
+      write(str)
+    end
+
+    # Set the response type to json
+    #
+    # @parameter [String] str
+    #
+    # @returns [String] str
+    #
+    def json(str)
+      @headers[CONTENT_TYPE] = ContentType[:JSON]
+      write(str)
+    end
+
+    # Redirect the response
+    #
+    # @parameter [String] path
+    # @parameter [Integer] status, default: 302
+    #
+    def redirect(path, status = 302)
+      @headers[LOCATION] = path
+      @status = status
+
+      throw :halt, finish
+    end
+
+    # Finish the response
+    #
+    # @returns [Array] response
+    #
+    def finish
+      [@status, @headers, @body]
+    end
+  end
 end

data/lib/lennarb/route_node.rb

@@ -4,69 +4,63 @@
 # Copyright, 2023-2024, by Aristóteles Coutinho.
 
 class Lennarb
-	class RouteNode
-		attr_accessor :static_children, :dynamic_children, :blocks, :param_key
+  class RouteNode
+    attr_accessor :static_children, :dynamic_children, :blocks, :param_key
 
-		# Initializes the RouteNode class.
-		#
-		# @return [RouteNode]
-		#
-		def initialize
-			@blocks           = {}
-			@param_key        = nil
-			@static_children  = {}
-			@dynamic_children = {}
-		end
+    def initialize
+      @blocks           = {}
+      @param_key        = nil
+      @static_children  = {}
+      @dynamic_children = {}
+    end
 
-		# Add a route to the route node
-		#
-		# @parameter parts       [Array<String>] The parts of the route
-		# @parameter http_method [Symbol] The HTTP method of the route
-		# @parameter block       [Proc] The block to be executed when the route is matched
-		#
-		# @return [void]
-		#
-		def add_route(parts, http_method, block)
-			current_node = self
+    def add_route(parts, http_method, block)
+      current_node = self
 
-			parts.each do |part|
-				if part.start_with?(':')
-					param_sym = part[1..].to_sym
-					current_node.dynamic_children[param_sym] ||= RouteNode.new
-					dynamic_node = current_node.dynamic_children[param_sym]
-					dynamic_node.param_key = param_sym
-					current_node = dynamic_node
-				else
-					current_node.static_children[part] ||= RouteNode.new
-					current_node = current_node.static_children[part]
-				end
-			end
+      parts.each do |part|
+        if part.start_with?(':')
+          param_sym = part[1..].to_sym
+          current_node.dynamic_children[param_sym] ||= RouteNode.new
+          dynamic_node = current_node.dynamic_children[param_sym]
+          dynamic_node.param_key = param_sym
+          current_node = dynamic_node
+        else
+          current_node.static_children[part] ||= RouteNode.new
+          current_node = current_node.static_children[part]
+        end
+      end
 
-			current_node.blocks[http_method] = block
-		end
+      current_node.blocks[http_method] = block
+    end
 
-		def match_route(parts, http_method, params: {})
-			if parts.empty?
-				return [blocks[http_method], params] if blocks[http_method]
-			else
-				part = parts.first
-				rest = parts[1..]
+    def match_route(parts, http_method, params: {})
+      if parts.empty?
+        return [blocks[http_method], params] if blocks[http_method]
+      else
+        part = parts.first
+        rest = parts[1..]
 
-				if static_children.key?(part)
-					result_block, result_params = static_children[part].match_route(rest, http_method, params:)
-					return [result_block, result_params] if result_block
-				end
+        if static_children.key?(part)
+          result_block, result_params = static_children[part].match_route(rest, http_method, params:)
+          return [result_block, result_params] if result_block
+        end
 
-				dynamic_children.each_value do |dyn_node|
-					new_params = params.dup
-					new_params[dyn_node.param_key] = part
-					result_block, result_params = dyn_node.match_route(rest, http_method, params: new_params)
+        dynamic_children.each_value do |dyn_node|
+          new_params = params.dup
+          new_params[dyn_node.param_key] = part
+          result_block, result_params = dyn_node.match_route(rest, http_method, params: new_params)
 
-					return [result_block, result_params] if result_block
-				end
-			end
+          return [result_block, result_params] if result_block
+        end
+      end
 
-			[nil, nil]
-		end
-	end
+      [nil, nil]
+    end
+
+    def merge!(other)
+      static_children.merge!(other.static_children)
+      dynamic_children.merge!(other.dynamic_children)
+      blocks.merge!(other.blocks)
+    end
+  end
 end

data/lib/lennarb/version.rb

@@ -4,7 +4,7 @@
 # Copyright, 2023-2024, by Aristóteles Coutinho.
 
 class Lennarb
-	VERSION = '1.1.0'
+  VERSION = '1.3.0'
 
-	public_constant :VERSION
+  public_constant :VERSION
 end

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,115 +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
-
-	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
+  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
+
+  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