decision_agent 0.3.0 → 1.1.0

data/lib/decision_agent/web/rack_helpers.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+# Rack helpers for framework-agnostic web server
+# These helpers provide convenience methods for pure Rack applications
+
+require "rack"
+require "rack/file"
+require "uri"
+
+module DecisionAgent
+  module Web
+    module RackHelpers
+      # Simple router for Rack applications
+      class Router
+        def initialize
+          @routes = []
+          @before_filters = []
+        end
+
+        def get(path, &block)
+          add_route("GET", path, block)
+        end
+
+        def post(path, &block)
+          add_route("POST", path, block)
+        end
+
+        def put(path, &block)
+          add_route("PUT", path, block)
+        end
+
+        def delete(path, &block)
+          add_route("DELETE", path, block)
+        end
+
+        def options(path, &block)
+          add_route("OPTIONS", path, block)
+        end
+
+        def before(&block)
+          @before_filters << block if block
+        end
+
+        def match(env)
+          method = env["REQUEST_METHOD"]
+          path = env["PATH_INFO"] || "/"
+          script_name = env["SCRIPT_NAME"] || ""
+
+          # Remove script_name prefix if present
+          path = path[script_name.length..] || "/" if script_name && !script_name.empty? && path.start_with?(script_name)
+
+          route = find_route(method, path)
+          return nil unless route
+
+          {
+            handler: route[:handler],
+            params: route[:params],
+            before_filters: @before_filters
+          }
+        end
+
+        private
+
+        def add_route(method, path_pattern, handler)
+          # Convert path patterns to regex
+          # Example: "/api/versions/:id" -> /^\/api\/versions\/(?<id>[^\/]+)$/
+          # Handle wildcard "*" for catch-all routes
+          regex_pattern = if path_pattern == "*"
+                            ".*"
+                          else
+                            path_pattern
+                              .gsub(%r{:[^/]+}) { |match| "(?<#{match[1..]}>[^/]+)" }
+                              .gsub("*", ".*")
+                          end
+          regex = /^#{regex_pattern}$/
+
+          @routes << {
+            method: method,
+            pattern: regex,
+            handler: handler,
+            path_pattern: path_pattern
+          }
+        end
+
+        def find_route(method, path)
+          # Try exact match first, then try routes in order
+          # More specific routes should be registered first
+          @routes.each do |route|
+            next unless [method, "*"].include?(route[:method])
+
+            match = route[:pattern].match(path)
+            next unless match
+
+            params = match.named_captures || {}
+            params.transform_keys!(&:to_sym) if params.any?
+            return {
+              handler: route[:handler],
+              params: params
+            }
+          end
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/decision_agent/web/rack_request_helpers.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+# Request/Response helpers for Rack applications
+# Provides convenience methods for handling requests and responses
+
+require "rack"
+require "rack/utils"
+require "uri"
+
+module DecisionAgent
+  module Web
+    module RackRequestHelpers
+      # Context object that provides convenience methods in route handlers
+      class RequestContext
+        attr_reader :env, :request, :response_status, :response_headers, :response_body, :halted_response
+        attr_accessor :current_user, :current_session
+
+        def initialize(env, route_params = {})
+          @env = env
+          @request = Rack::Request.new(env)
+          @route_params = route_params
+          @response_status = 200
+          @response_headers = { "Content-Type" => "text/html" }
+          @response_body = []
+          @halted = false
+          @halted_response = nil
+          @params_hybrid = nil
+
+          # Merge route params, query params, and body params
+          # Convert all keys to symbols for consistency
+          route_params_sym = route_params.transform_keys(&:to_sym)
+          query_params_sym = query_params.transform_keys(&:to_sym)
+          body_params_sym = body_params.transform_keys(&:to_sym)
+          @params = route_params_sym.merge(query_params_sym).merge(body_params_sym)
+
+          # Handle multipart form data (file uploads)
+          content_type_header = @env["CONTENT_TYPE"] || ""
+          return unless content_type_header.include?("multipart/form-data")
+
+          # Rack::Request handles multipart automatically
+          multipart_params = @request.params
+          multipart_params_sym = multipart_params.transform_keys(&:to_sym)
+          @params.merge!(multipart_params_sym)
+        end
+
+        def params
+          # Return params with support for both symbol and string key access
+          @params ||= begin
+            hash = @params.dup
+            # Add string-key versions for all symbol keys
+            @params.each do |k, v|
+              hash[k.to_s] = v if k.is_a?(Symbol)
+            end
+            # Add symbol-key versions for all string keys
+            hash.to_a.each do |k, v|
+              hash[k.to_sym] = v if k.is_a?(String) && !hash.key?(k.to_sym)
+            end
+            # Create accessor that checks both
+            def hash.[](key)
+              super(key.to_sym) || super(key.to_s) || super
+            end
+            hash
+          end
+        end
+
+        def status(code)
+          @response_status = code
+          code
+        end
+
+        def content_type(type)
+          @response_headers["Content-Type"] = type
+        end
+
+        def headers
+          @response_headers
+        end
+
+        def body(str = nil)
+          if str
+            @response_body = [str.to_s]
+            str
+          else
+            @response_body
+          end
+        end
+
+        def json(obj)
+          content_type "application/json"
+          body(obj.to_json)
+        end
+
+        def halt(status_code, body = nil)
+          @halted = true
+          @response_status = status_code
+          if body
+            content_type "application/json" if @response_headers["Content-Type"] == "text/html"
+            @halted_response = [status_code, @response_headers.dup, [body.to_s]]
+          else
+            @halted_response = [status_code, @response_headers.dup, []]
+          end
+        end
+
+        def halted?
+          @halted
+        end
+
+        def send_file(filepath)
+          return unless File.exist?(filepath)
+
+          content = File.read(filepath)
+          ext = File.extname(filepath).downcase
+          mime_types = {
+            ".css" => "text/css",
+            ".js" => "application/javascript",
+            ".html" => "text/html",
+            ".json" => "application/json",
+            ".xml" => "application/xml",
+            ".svg" => "image/svg+xml"
+          }
+          content_type(mime_types[ext] || "application/octet-stream")
+          body(content)
+        end
+
+        def script_name
+          @request.script_name
+        end
+
+        def path_info
+          @request.path_info
+        end
+
+        def cookies
+          @request.cookies
+        end
+
+        def to_rack_response
+          if @halted && @halted_response
+            @halted_response
+          else
+            # Ensure body is an array
+            body_array = @response_body.is_a?(Array) ? @response_body : [@response_body.to_s]
+            body_array = [""] if body_array.empty?
+            [@response_status, @response_headers.dup, body_array]
+          end
+        end
+
+        private
+
+        def query_params
+          @request.params
+        end
+
+        def body_params
+          return {} unless @env["rack.input"]
+
+          # Read body if content type is JSON or form data
+          content_type_header = @env["CONTENT_TYPE"] || ""
+          body_input = @env["rack.input"].read
+          @env["rack.input"].rewind
+
+          return {} if body_input.nil? || body_input.empty?
+
+          if content_type_header.include?("application/json")
+            begin
+              parsed = JSON.parse(body_input)
+              # Convert string keys to symbol keys for consistency
+              parsed.is_a?(Hash) ? parsed.transform_keys(&:to_sym) : parsed
+            rescue JSON::ParserError
+              {}
+            end
+          elsif content_type_header.include?("application/x-www-form-urlencoded")
+            parsed = Rack::Utils.parse_nested_query(body_input)
+            parsed.is_a?(Hash) ? parsed.transform_keys(&:to_sym) : parsed
+          elsif content_type_header.include?("multipart/form-data")
+            # For multipart, use Rack::Request.params which handles it automatically
+            # This will be merged in initialize
+            {}
+          else
+            {}
+          end
+        end
+      end
+
+      # Helper to read request body as string
+      def self.read_body(env)
+        input = env["rack.input"]
+        return "" unless input
+
+        body = input.read
+        input.rewind
+        body.to_s
+      end
+    end
+  end
+end