lennarb 0.1.5 → 0.1.7

data/lib/lenna/middleware/default/logging.rb

@@ -1,95 +1,93 @@
 # frozen_string_literal: true
 
+# Released under the MIT License.
+# Copyright, 2023, by Aristóteles Coutinho.
+
 require 'colorize'
 
 module Lenna
-  module Middleware
-    module Default
-      # The Logging module is responsible for logging the requests.
-      #
-      # @api private
-      #
-      # @example:
-      #   Logging.call(req, res, next_middleware)
-      #  # => [2021-01-01 00:00:00 +0000] "GET /" 200 0.00ms
-      module Logging
-        extend self
+	module Middleware
+		module Default
+			# The Logging module is responsible for logging the requests.
+			#
+			# @private
+			#
+			module Logging
+				extend self
 
-        # This method is used to log the request.
-        #
-        # @param req             [Rack::Request ] The request
-        # @param res             [Rack::Response] The response
-        # @param next_middleware [Proc]           The next middleware
-        def call(req, res, next_middleware)
-          start_time = ::Time.now
-          next_middleware.call
-          end_time = ::Time.now
+				# This method is used to log the request.
+				#
+				# @parameter req             [Rack::Request ] The request
+				# @parameter res             [Rack::Response] The response
+				# @parameter next_middleware [Proc]           The next middleware
+				#
+				def call(req, res, next_middleware)
+					start_time = ::Time.now
+					next_middleware.call
+					end_time = ::Time.now
 
-          http_method = colorize_http_method(req.request_method)
-          status_code = colorize_status_code(res.status.to_s)
-          duration    = calculate_duration(start_time, end_time)
+					http_method = colorize_http_method(req.request_method)
+					status_code = colorize_status_code(res.status.to_s)
+					duration = calculate_duration(start_time, end_time)
 
-          log_message = "[#{start_time}] \"#{http_method} #{req.path_info}\" " \
-                        "#{status_code} #{format('%.2f', duration)}ms"
+					log_message = "[#{start_time}] \"#{http_method} #{req.path_info}\" " \
+																			"#{status_code} #{format('%.2f', duration)}ms"
 
-          ::Kernel.puts(log_message)
-        end
+					::Kernel.puts(log_message)
+				end
 
-        private
+				private
 
-        # This method is used to colorize the request method.
-        #
-        # @param request_method [String] The request method
-        # @return               [String] The colorized request method
-        #
-        # @api private
-        #
-        # @example:
-        #   colorize_http_method('GET') # => 'GET'.green
-        def colorize_http_method(request_method)
-          case request_method
-          in 'GET'    then 'GET'.green
-          in 'POST'   then 'POST'.magenta
-          in 'PUT'    then 'PUT'.yellow
-          in 'DELETE' then 'DELETE'.red
-          else request_method.blue
-          end
-        end
+				# This method is used to colorize the request method.
+				#
+				# @parameter request_method [String] The request method
+				#
+				# @return                   [String] The colorized request method
+				#
+				# @private
+				#
+				def colorize_http_method(request_method)
+					case request_method
+					in 'GET' then 'GET'.green
+					in 'POST' then 'POST'.magenta
+					in 'PUT' then 'PUT'.yellow
+					in 'DELETE' then 'DELETE'.red
+					else request_method.blue
+					end
+				end
 
-        # This method is used to colorize the status code.
-        #
-        # @param status_code [String] The status code
-        # @return            [String] The colorized status code
-        #
-        # @api private
-        #
-        # @example:
-        #   colorize_status_code('200') # => '200'.green
-        def colorize_status_code(status_code)
-          case status_code[0]
-          in '2' then status_code.green
-          in '3' then status_code.blue
-          in '4' then status_code.yellow
-          in '5' then status_code.red
-          else status_code
-          end
-        end
+				# This method is used to colorize the status code.
+				#
+				# @param status_code [String] The status code
+				#
+				# @return            [String] The colorized status code
+				#
+				# @private
+				#
+				def colorize_status_code(status_code)
+					case status_code
+					in '2' then status_code.green
+					in '3' then status_code.blue
+					in '4' then status_code.yellow
+					in '5' then status_code.red
+					else status_code
+					end
+				end
 
-        # This method is used to calculate the duration.
-        #
-        # @param start_time [Time] The start time
-        # @param end_time   [Time] The end time
-        # @return           [Float] The duration
-        #
-        # @api private
-        #
-        # @example:
-        #   calculate_duration(Time.now, Time.now + 1) # => 1000
-        def calculate_duration(start_time, end_time)
-          millis_in_second = 1000.0
-          (end_time - start_time) * millis_in_second
-        end
-      end
-    end
-  end
+				# This method is used to calculate the duration.
+				#
+				# @param start_time [Time] The start time
+				#
+				# @param end_time   [Time] The end time
+				# @return           [Float] The duration
+				#
+				# @api private
+				#
+				def calculate_duration(start_time, end_time)
+					millis_in_second = 1000.0
+					(end_time - start_time) * millis_in_second
+				end
+			end
+		end
+	end
 end

data/lib/lenna/middleware/default/reload.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2023, by Aristóteles Coutinho.
+
+require 'console'
+
+# This middleware is used to reload files in development mode.
+#
+module Lenna
+	module Middleware
+		module Default
+			class Reload
+				attr_accessor :directories, :files_mtime
+
+				# Initializes a new instance of Middleware::Default::Reload.
+				#
+				# @parameter directories [Array] An array of directories to monitor.
+				#
+				# @return [Middleware::Default::Reload] A new instance of Middleware::Default::Reload.
+				def initialize(directories = [])
+					self.files_mtime = {}
+					self.directories = directories
+
+					monitor_directories(directories)
+				end
+
+				# Calls the middleware.
+				#
+				# @parameter req             [Rack::Request] The request.
+				# @parameter _res            [Rack::Response] The response.
+				# @parameter next_middleware [Proc] The next middleware.
+				#
+				# @return [void]
+				#
+				def call(_req, _res, next_middleware)
+					reload_if_needed
+
+					next_middleware.call
+				rescue ::StandardError => error
+					::Console.error(self, error)
+				end
+
+				private
+
+				# Reloads files if needed.
+				#
+				# @return [void]
+				#
+				def reload_if_needed
+					modified_files = check_for_modified_files
+
+					reload_files(modified_files) unless modified_files.empty?
+				end
+
+				# Monitors directories for changes.
+				#
+				# @parameter directories [Array] An array of directories to monitor.
+				#
+				# @return [void]
+				#
+				def monitor_directories(directories)
+					directories.each do |directory|
+						::Dir.glob(directory).each { |file| files_mtime[file] = ::File.mtime(file) }
+					end
+				end
+
+				# Checks for modified files.
+				#
+				# @return [Array] An array of modified files.
+				#
+				# @example
+				#   check_for_modified_files #=> ["/path/to/file.rb"]
+				#
+				def check_for_modified_files
+					@files_mtime.select do |file, last_mtime|
+						::File.mtime(file) > last_mtime
+					end.keys
+				end
+
+				# Reloads files.
+				#
+				# @parameter files [Array] An array of files(paths) to reload.
+				#
+				# @return [void]
+				#
+				def reload_files(files)
+					files.each do |file|
+						::Console.debug("Reloading #{file}")
+						::Kernel.load file
+						@files_mtime[file] = ::File.mtime(file)
+					end
+				end
+			end
+		end
+	end
+end

data/lib/lenna/router/builder.rb

@@ -1,99 +1,124 @@
 # frozen_string_literal: true
 
+# Released under the MIT License.
+# Copyright, 2023, by Aristóteles Coutinho.
+
 module Lenna
-  class Router
-    # The Route::Builder class is responsible for building the tree of routes.
-    #
-    # The tree of routes is built by adding routes to the tree. Each route is
-    # represented by a node in the tree and each node has a path and an
-    # endpoint. The path is the path of the route and the endpoint is then
-    # action to be executed when the route is matched.
-    #
-    # Those nodes are stored in a cache to avoid rebuilding the tree of routes
-    # for each request.
-    #
-    # The tree use `Trie` data structures to optimize the search for a route.
-    # The trie is a tree where each node is a character of the path.
-    # This way, the search for a route is O(n) where n is the length of the
-    # path.
-    #
-    class Builder
-      def initialize(root_node) = @root_node = root_node
+	class Router
+		# The Route::Builder class is responsible for building the tree of routes.
+		#
+		# The tree of routes is built by adding routes to the tree. Each route is
+		# represented by a node in the tree and each node has a path and an
+		# endpoint. The path is the path of the route and the endpoint is then
+		# action to be executed when the route is matched.
+		#
+		# Those nodes are stored in a cache to avoid rebuilding the tree of routes
+		# for each request.
+		#
+		# The tree use `Trie` data structures to optimize the search for a route.
+		# The trie is a tree where each node is a character of the path.
+		# This way, the search for a route is O(n) where n is the length of the
+		# path.
+		#
+		# @private
+		#
+		class Builder
+			def initialize(root_node) = @root_node = root_node
 
-      # @param method [String] the HTTP method
-      # @param path   [String] the path to be matched
-      # @param action [Proc]   the action to be executed
-      # @param cache  [Cache]  the cache to be used
-      # @return       [void]
-      def call(method, path, action, cache)
-        path_key = cache.cache_key(method, path)
+			# This method will add a route to the tree of routes.
+			#
+			# @parameter method  [String] the HTTP method
+			# @parameter path    [String] the path to be matched
+			# @parameter action  [Proc]   the action to be executed
+			# @parameter cache   [Cache]  the cache to be used
+			#
+			# @return            [void]
+			#
+			def call(method, path, action, cache)
+				path_key = cache.cache_key(method, path)
 
-        return if cache.exist?(path_key)
+				return if cache.exist?(path_key)
 
-        current_node = find_or_create_route_node(path)
-        setup_endpoint(current_node, method, action)
+				current_node = find_or_create_route_node(path)
+				setup_endpoint(current_node, method, action)
 
-        cache.add(path_key, current_node)
-      end
+				cache.add(path_key, current_node)
+			end
 
-      private
+			private
 
-      # This method will create routes that are missing.
-      # @param path [String] the path to be matched
-      # @return     [Node]   the node that matches the path
-      def find_or_create_route_node(path)
-        current_node = @root_node
-        split_path(path).each do |part|
-          current_node = find_or_create_node(current_node, part)
-        end
-        current_node
-      end
+			# This method will create routes that are missing.
+			# @parameter path [String] the path to be matched
+			#
+			# @return         [Node]   the node that matches the path
+			#
+			def find_or_create_route_node(path)
+				current_node = @root_node
+				split_path(path).each do |part|
+					current_node = find_or_create_node(current_node, part)
+				end
+				current_node
+			end
 
-      # @param current_node [Node]  the current node
-      # @param part         [String] the part of the path
-      # @return             [Node]  the node that matches the part of the path
-      # @note               This method will create the nodes that are missing.
-      #                     This way, the tree of routes is built.
-      # @example            Given the part ':id' and the tree bellow:
-      #                     root
-      #                     └── users
-      #                         └── :id
-      #                     The method will return the node :id.
-      #                     If the node :id does not exist, it will be created.
-      #                     The tree will be:
-      #                     root
-      #                     └── users
-      #                         └── :id
-      def find_or_create_node(current_node, part)
-        if part.start_with?(':')
-          # If it is a placeholder, then we just create or update
-          # the placeholder node with the placeholder name.
-          placeholder_name = part[1..].to_sym
-          current_node.children[:placeholder] ||= Node.new(
-            {},
-            nil,
-            placeholder_name
-          )
-        else
-          current_node.children[part] ||= Node.new
-        end
-        current_node.children[part.start_with?(':') ? :placeholder : part]
-      end
+			# This method will create the nodes that are missing.
+			#
+			# @parameter current_node [Node]  the current node
+			# @parameter part         [String] the part of the path
+			#
+			# @return                 [Node]  the node that matches the part of the path
+			#
+			#                     This way, the tree of routes is built.
+			# @example            Given the part ':id' and the tree bellow:
+			#                     root
+			#                     └── users
+			#                         └── :id
+			#                     The method will return the node :id.
+			#                     If the node :id does not exist, it will be created.
+			#                     The tree will be:
+			#                     root
+			#                     └── users
+			#                         └── :id
+			#
+			def find_or_create_node(current_node, part)
+				if part.start_with?(':')
+					# If it is a placeholder, then we just create or update
+					# the placeholder node with the placeholder name.
+					placeholder_name = part[1..].to_sym
+					current_node.children[:placeholder] ||= Node.new(
+						{},
+						nil,
+						placeholder_name
+					)
+				else
+					current_node.children[part] ||= Node.new
+				end
+				current_node.children[part.start_with?(':') ? :placeholder : part]
+			end
 
-      # @param current_node [Node]  the current node
-      # @param method       [String] the HTTP method
-      # @param action       [Proc]   the action to be executed
-      def setup_endpoint(current_node, method, action)
-        current_node.endpoint ||= {}
-        current_node.endpoint[method] = action
-      end
+			# This method will setup the endpoint of the current node.
+			#
+			# @parameter current_node [Node]  the current node
+			# @parameter method       [String] the HTTP method
+			# @parameter action       [Proc]   the action to be executed
+			#
+			# @return                 [void]
+			#
+			def setup_endpoint(current_node, method, action)
+				current_node.endpoint ||= {}
+				current_node.endpoint[method] = action
+			end
 
-      # @param path [String] the path to be split
-      # @return     [Array]  the splitted path
-      # @todo: Move this to a separate file and require it here.
-      # Maybe utils or something like that.
-      # Use Rack::Utils.split_path_info instead.
-      def split_path(path) = path.split('/').reject(&:empty?)
-    end
-  end
+			# This method will split the path into parts.
+			#
+			# @parameter path [String] the path to be split
+			#
+			# @return         [Array]  the splitted path
+			#
+			# TODO: Move this to a separate file and require it here.
+			# Maybe utils or something like that.
+			# Use Rack::Utils.split_path_info instead.
+			#
+			def split_path(path) = path.split('/').reject(&:empty?)
+		end
+	end
 end

data/lib/lenna/router/cache.rb

@@ -1,38 +1,52 @@
 # frozen_string_literal: true
 
+# Released under the MIT License.
+# Copyright, 2023, by Aristóteles Coutinho.
+
 module Lenna
-  class Router
-    # @api public
-    # @note This class is used to cache the routes.
-    class Cache
-      def initialize = @cache = {}
+	class Router
+		# This class is used to cache the routes.
+		#
+		# @private
+		#
+		class Cache
+			def initialize = @cache = {}
 
-      # @api public
-      # @param [String] method
-      # @param [String] path
-      # @return [String]
-      # @note This method is used to generate a key for the cache.
-      def cache_key(method, path) = "#{method} #{path}"
+			# This method is used to generate a key for the cache.
+			#
+			# @parameter [String] method
+			# @parameter [String] path
+			#
+			# @return [String]
+			#
+			def cache_key(method, path) = "#{method} #{path}"
 
-      # @api public
-      # @param route_key [String] The key for the route.
-      # @param node      [Lenna::Route::Node] The node for the route.
-      # @return          [Lenna::Route::Node]
-      # @note            This method is used to add a route to the cache.
-      def add(route_key, node) = @cache[route_key] = node
+			# This method is used to add a route to the cache.
+			#
+			# @parameter route_key [String] The key for the route.
+			# @parameter node      [Lenna::Route::Node] The node for the route.
+			#
+			# @return              [Lenna::Route::Node]
+			#
+			def add(route_key, node) = @cache[route_key] = node
 
-      # @api public
-      # @param route_key [String] The key for the route.
-      # @return          [Lenna::Route::Node]
-      # @note            This method is used to get a route from the cache.
-      def get(route_key) = @cache[route_key]
+			# This method is used to get a route from the cache.
+			#
+			# @parameter route_key [String] The key for the route.
+			#
+			# @return              [Lenna::Route::Node]
+			#
+			def get(route_key) = @cache[route_key]
 
-      # @api public
-      # @param route_key [String] The key for the route.
-      # @return          [Boolean]
-      # @note            This method is used to check if a route exists
-      #                  in the cache.
-      def exist?(route_key) = @cache.key?(route_key)
-    end
-  end
+			# This method is used to check if a route is in the cache.
+			#
+			# @api public
+			#
+			# @parameter route_key [String] The key for the route.
+			#
+			# @return              [Boolean]
+			#
+			def exist?(route_key) = @cache.key?(route_key)
+		end
+	end
 end