lennarb 1.4.0 → 1.5.0

data/lib/lennarb/middleware/request_logger.rb

@@ -0,0 +1,117 @@
+module Lennarb
+  module Middleware
+    # Request logger for the Lennarb framework
+    # Logs HTTP request details with color formatting
+    #
+    # @example Output:
+    #   GET /users/123 (30ms)
+    #   Status: 200 OK
+    #   Params: {"id"=>"123", "password"=>"[FILTERED]"}
+    #
+    class RequestLogger
+      def initialize(app)
+        @app = app
+      end
+
+      # Get logger from application configuration
+      def logger = Lennarb::App.app.config.logger
+
+      # Process the request and log information
+      #
+      # @param [Hash] env Rack environment
+      # @return [Array] Rack response [status, headers, body]
+      def call(env)
+        request = Lennarb::Request.new(env)
+        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+        status, headers, body = @app.call(env)
+
+        duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
+
+        log_request(request, status, headers, duration)
+
+        [status, headers, body]
+      end
+
+      private
+
+      # Format duration in a human-readable way
+      #
+      # @param [Float] seconds Duration in seconds
+      # @return [String] Formatted duration
+      def format_duration(seconds)
+        if seconds < 1
+          "#{(seconds * 1000).round}ms"
+        elsif seconds < 60
+          format("%.2fs", seconds)
+        else
+          minutes = (seconds / 60).to_i
+          seconds = (seconds % 60).round
+          "#{minutes}m #{seconds}s"
+        end
+      end
+
+      # Log the complete request
+      def log_request(request, status, headers, duration)
+        logger.info { request_line(request, duration, status) }
+
+        logger.info { status_line(status) }
+
+        if request.params.any?
+          logger.info { params_line(request.params) }
+        end
+
+        if headers["Location"]
+          logger.info { redirect_line(headers["Location"]) }
+        end
+      end
+
+      # Format the request line
+      def request_line(request, duration, status)
+        method = request.request_method
+        path = filter_path(request.path)
+        duration_text = "(#{format_duration(duration)})"
+
+        "#{method} #{path} #{duration_text}".colorize(status_to_color(status)).bold
+      end
+
+      # Format the status line
+      def status_line(status)
+        status_text = "#{status} #{Rack::Utils::HTTP_STATUS_CODES[status]}"
+        "Status: #{status_text}".colorize(status_to_color(status)).bold
+      end
+
+      # Format the parameters line
+      def params_line(params)
+        filtered = filter_params(params)
+        "Params: #{filtered.inspect}"
+      end
+
+      # Format the redirect line
+      def redirect_line(location)
+        "Redirect: #{location}".colorize(:yellow)
+      end
+
+      # Filter the request path
+      def filter_path(path)
+        path
+      end
+
+      # Filter request parameters
+      def filter_params(params)
+        ParameterFilter.new.filter(params)
+      end
+
+      # Determine color based on HTTP status
+      def status_to_color(status)
+        case status
+        when 200..299 then :green
+        when 300..399 then :yellow
+        when 400..499 then :magenta
+        when 500..599 then :red
+        else :white
+        end
+      end
+    end
+  end
+end

data/lib/lennarb/middleware_stack.rb

@@ -0,0 +1,56 @@
+module Lennarb
+  # Basic middleware stack implementation.
+  #
+  class MiddlewareStack
+    attr_reader :app
+
+    # The app's middleware stack.
+    #
+    # @param [Rack::Builder] app
+    #
+    def initialize(app = nil)
+      @app = app
+      @store = []
+    end
+
+    # Insert a middleware in the stack.
+    #
+    # @param [Class] middleware
+    # @param [Array] args
+    # @param [Proc] block
+    #
+    # @retrn [void]
+    #
+    def use(middleware, *args, &block)
+      @store << [middleware, args, block]
+    end
+
+    # Add a middleware to the beginning of the stack.
+    #
+    # @param [Class] middleware
+    # @param [Array] args
+    # @param [Proc] block
+    #
+    # @retrn [void]
+    #
+    def unshift(middleware, *args, &block)
+      @store.unshift([middleware, args, block])
+    end
+
+    # Clear the middleware stack.
+    #
+    # @retrn [void]
+    #
+    def clear
+      @store.clear
+    end
+
+    # Convert the middleware stack to an array.
+    #
+    # @retrn [Array]
+    #
+    def to_a
+      @store
+    end
+  end
+end

data/lib/lennarb/parameter_filter.rb

@@ -0,0 +1,76 @@
+module Lennarb
+  # Filtra parâmetros sensíveis de logs e exceções.
+  # Útil para evitar o vazamento de informações confidenciais.
+  #
+  # Por padrão, as seguintes chaves de parâmetros são filtradas:
+  #
+  # - `passw`
+  # - `email`
+  # - `secret`
+  # - `token`
+  # - `_key`
+  # - `crypt`
+  # - `salt`
+  # - `certificate`
+  # - `otp`
+  # - `ssn`
+  # - `cvv`
+  # - `cvc`
+  # - `signature`
+  #
+  # @example
+  #   filter = Lennarb::ParameterFilter.new
+  #   filter.filter({ password: "secret", user: { email: "test@example.com" } })
+  #   # => { password: "[filtered]", user: { email: "[filtered]" } }
+  #
+  class ParameterFilter
+    # @api private
+    DEFAULT_MASK = "[FILTERED]"
+
+    # @api private
+    DEFAULT_FILTERS = %w[
+      passw email secret token _key crypt salt certificate otp ssn cvv cvc
+      signature
+    ].freeze
+
+    # Inicializa um novo filtro de parâmetros
+    #
+    # @param [Array<String, Regexp>] filters Lista de padrões para filtrar
+    def initialize(filters = DEFAULT_FILTERS)
+      @filter = Regexp.union(filters.map(&:to_s))
+    end
+
+    # Filtra os parâmetros conforme o filtro configurado
+    #
+    # @param [Hash, Array] params Parâmetros a serem filtrados
+    # @param [String] mask Valor que substituirá os parâmetros filtrados
+    # @return [Hash, Array] Parâmetros filtrados
+    def filter(params, mask: DEFAULT_MASK)
+      filter_object(params.dup, mask)
+    end
+
+    private
+
+    # Filtra recursivamente um objeto (hash ou array)
+    #
+    # @param [Object] object Objeto a ser filtrado
+    # @param [String] mask Valor que substituirá os parâmetros filtrados
+    # @return [Object] Objeto filtrado
+    def filter_object(object, mask)
+      case object
+      when Hash
+        object.each do |key, value|
+          object[key] = if key.to_s.match?(@filter)
+            mask
+          else
+            filter_object(value, mask)
+          end
+        end
+      when Array
+        object = object.map { filter_object(it, mask) }
+      end
+
+      object
+    end
+  end
+end

data/lib/lennarb/request.rb

@@ -1,86 +1,264 @@
-class Lennarb
+module Lennarb
+  # Request object
+  #
   class Request < Rack::Request
     # The environment variables of the request
     #
-    # @returns [Hash]
-    #
+    # @return [Hash]
     attr_reader :env
 
     # Initialize the request object
     #
-    # @parameter [Hash] env
-    # @parameter [Hash] route_params
+    # @param [Hash] env
+    # @param [Hash] route_params
     #
-    # @returns [Request]
+    # @return [Request]
     #
     def initialize(env, route_params = {})
       super(env)
-      @route_params = route_params
+      @route_params = route_params || {}
     end
 
-    # Get the request body
+    # Get the request parameters merged with route parameters
     #
-    # @returns [String]
+    # @return [Hash]
     #
-    def params = @params ||= super.merge(@route_params)&.transform_keys(&:to_sym)
+    def params
+      @params ||= super.merge(@route_params)&.transform_keys(&:to_sym)
+    end
 
-    # Get the request path
+    # Get the request path without query string
     #
-    # @returns [String]
+    # @return [String]
     #
-    def path = @path ||= super.split("?").first
+    def path
+      @path ||= super.split("?").first
+    end
 
     # Read the body of the request
     #
-    # @returns [String]
+    # @return [String]
     #
-    def body = @body ||= super.read
+    def body
+      @body ||= super.read
+    end
 
     # Get the query parameters
     #
-    # @returns [Hash]
+    # @return [Hash]
     #
     def query_params
-      @query_params ||= Rack::Utils.parse_nested_query(query_string).transform_keys(&:to_sym)
+      @query_params ||= Rack::Utils.parse_nested_query(query_string || "").transform_keys(&:to_sym)
+    end
+
+    # Set a value in the environment
+    #
+    # @param [String] key
+    # @param [Object] value
+    # @return [Object] the value
+    #
+    def []=(key, value)
+      env[key] = value
+    end
+
+    # Get a value from the environment
+    #
+    # @param [String] key
+    # @return [Object]
+    #
+    def [](key)
+      env[key]
     end
 
     # Get the headers of the request
     #
+    # @return [Hash]
+    #
     def headers
-      @headers ||= env.select { |key, _| key.start_with?("HTTP_") }
+      @headers ||= env.each_with_object({}) do |(key, value), result|
+        if key.start_with?("HTTP_")
+          header_name = key.sub("HTTP_", "").split("_").map(&:capitalize).join("-")
+          result[header_name] = value
+        end
+      end
     end
 
-    def ip = ip_address
+    # Get the client IP address
+    #
+    # @return [String]
+    #
+    def ip
+      ip_address
+    end
 
-    def secure? = scheme == "https"
+    # Check if the request is secure (HTTPS)
+    #
+    # @return [Boolean]
+    #
+    def secure?
+      scheme == "https"
+    end
 
-    def user_agent = headers["HTTP_USER_AGENT"]
+    # Shorthand methods for common headers
 
-    def accept = headers["HTTP_ACCEPT"]
+    # Get the user agent
+    #
+    # @return [String, nil]
+    #
+    def user_agent
+      env["HTTP_USER_AGENT"]
+    end
 
-    def referer = headers["HTTP_REFERER"]
+    # Get the accept header
+    #
+    # @return [String, nil]
+    #
+    def accept
+      env["HTTP_ACCEPT"]
+    end
 
-    def host = headers["HTTP_HOST"]
+    # Get the referer header
+    #
+    # @return [String, nil]
+    #
+    def referer
+      env["HTTP_REFERER"]
+    end
 
-    def content_length = headers["HTTP_CONTENT_LENGTH"]
+    # Get the host header
+    #
+    # @return [String, nil]
+    #
+    def host
+      env["HTTP_HOST"]
+    end
 
-    def content_type = headers["HTTP_CONTENT_TYPE"]
+    # Get the content length header
+    #
+    # @return [String, nil]
+    #
+    def content_length
+      env["HTTP_CONTENT_LENGTH"]
+    end
 
-    def xhr? = headers["HTTP_X_REQUESTED_WITH"]&.casecmp("XMLHttpRequest")&.zero?
+    # Get the content type header
+    #
+    # @return [String, nil]
+    #
+    def content_type
+      env["HTTP_CONTENT_TYPE"]
+    end
 
-    def []=(key, value)
-      env[key] = value
+    # Check if the request is an XHR request
+    #
+    # @return [Boolean]
+    #
+    def xhr?
+      env["HTTP_X_REQUESTED_WITH"]&.casecmp("XMLHttpRequest")&.zero? || false
     end
 
-    def [](key)
-      env[key]
+    # Check if the request is a JSON request
+    #
+    # @return [Boolean]
+    #
+    def json?
+      content_type&.include?("application/json")
+    end
+
+    # Parse JSON body if content type is application/json
+    #
+    # @return [Hash, nil]
+    #
+    def json_body
+      return nil unless json?
+      @json_body ||= begin
+        JSON.parse(body, symbolize_names: true)
+      rescue JSON::ParserError
+        nil
+      end
+    end
+
+    # Check if the request is an AJAX request (alias for xhr?)
+    #
+    # @return [Boolean]
+    #
+    def ajax?
+      xhr?
+    end
+
+    # Get the requested format (.html, .json, etc)
+    #
+    # @return [Symbol, nil]
+    #
+    def format
+      @format ||= begin
+        path_info = env["PATH_INFO"]
+        return nil unless path_info.include?(".")
+
+        extension = File.extname(path_info).delete(".")
+        extension.empty? ? nil : extension.to_sym
+      end
+    end
+
+    # Check if the request is a GET request
+    #
+    # @return [Boolean]
+    #
+    def get?
+      request_method == "GET"
+    end
+
+    # Check if the request is a POST request
+    #
+    # @return [Boolean]
+    #
+    def post?
+      request_method == "POST"
+    end
+
+    # Check if the request is a PUT request
+    #
+    # @return [Boolean]
+    #
+    def put?
+      request_method == "PUT"
+    end
+
+    # Check if the request is a DELETE request
+    #
+    # @return [Boolean]
+    #
+    def delete?
+      request_method == "DELETE"
+    end
+
+    # Check if the request is a HEAD request
+    #
+    # @return [Boolean]
+    #
+    def head?
+      request_method == "HEAD"
+    end
+
+    # Check if the request is a PATCH request
+    #
+    # @return [Boolean]
+    #
+    def patch?
+      request_method == "PATCH"
     end
 
     private
 
+    # Get the client IP address
+    #
+    # @return [String]
+    #
     def ip_address
-      forwarded_for = headers["HTTP_X_FORWARDED_FOR"]
-      forwarded_for ? forwarded_for.split(",").first.strip : env["REMOTE_ADDR"]
+      forwarded_for = env["HTTP_X_FORWARDED_FOR"]
+      return forwarded_for.split(",").map(&:strip).first if forwarded_for
+
+      env["REMOTE_ADDR"]
     end
   end
 end

data/lib/lennarb/request_handler.rb

@@ -0,0 +1,61 @@
+module Lennarb
+  # Handles requests and executes routes with helpers and hooks.
+  #
+  class RequestHandler
+    attr_reader :app
+
+    # Initialize the request handler
+    #
+    # @param [Lennarb::App] app The application instance
+    def initialize(app)
+      @app = app
+    end
+
+    # Handle a request according to Rack interface
+    #
+    # @param [Hash] env The Rack environment
+    # @return [Array] Rack response [status, headers, body]
+    def call(env)
+      http_method = env[Rack::REQUEST_METHOD].to_sym
+      parts = env[Rack::PATH_INFO].split("/").reject(&:empty?)
+      block, params = app.routes.match_route(parts, http_method)
+
+      return [404, {"content-type" => CONTENT_TYPE[:TEXT]}, ["Not Found"]] unless block
+
+      req = Request.new(env, params || {})
+      res = Response.new
+
+      catch(:halt) do
+        context = create_context
+
+        Hooks.execute(context, app.class, :before, req, res)
+
+        context.instance_exec(req, res, params, &block)
+
+        Hooks.execute(context, app.class, :after, req, res)
+
+        res.finish
+      rescue Lennarb::Error => e
+        app.class.config.logger.error("Error: #{e.message}")
+        app.class.config.logger.error(e.backtrace.first)
+        [500, {"content-type" => "text/plain"}, ["Internal Server Error"]]
+      end
+    end
+
+    private
+
+    # Create a context object with app's helper methods
+    #
+    # @return [Object] A context object with helper methods
+    def create_context
+      context = Object.new
+
+      context.define_singleton_method(:app) { app }
+
+      helpers_module = Helpers.for(app.class)
+      context.extend(helpers_module) if helpers_module
+
+      context
+    end
+  end
+end