tarsier 0.1.0

data/lib/tarsier/request.rb

@@ -0,0 +1,274 @@
+# frozen_string_literal: true
+
+require "uri"
+require "json"
+
+module Tarsier
+  # Immutable request object with lazy parsing
+  # Provides efficient access to request data without unnecessary allocations
+  class Request
+    attr_reader :env, :route_params
+
+    # Standard HTTP methods
+    HTTP_METHODS = %w[GET POST PUT PATCH DELETE HEAD OPTIONS TRACE CONNECT].freeze
+
+    # @param env [Hash] Rack environment hash
+    # @param route_params [Hash] parameters extracted from route matching
+    def initialize(env, route_params = {})
+      @env = env.freeze
+      @route_params = route_params.transform_keys(&:to_sym).freeze
+      @parsed_body = nil
+      @query_params = nil
+      @headers = nil
+      @cookies = nil
+    end
+
+    # HTTP method
+    # @return [Symbol]
+    def method
+      @method ||= @env["REQUEST_METHOD"].to_sym
+    end
+
+    # Request path
+    # @return [String]
+    def path
+      @path ||= @env["PATH_INFO"] || "/"
+    end
+
+    # Full URL
+    # @return [String]
+    def url
+      @url ||= "#{scheme}://#{host}#{path}#{query_string.empty? ? '' : "?#{query_string}"}"
+    end
+
+    # URL scheme (http/https)
+    # @return [String]
+    def scheme
+      @scheme ||= @env["rack.url_scheme"] || (@env["HTTPS"] == "on" ? "https" : "http")
+    end
+
+    # Host name
+    # @return [String]
+    def host
+      @host ||= @env["HTTP_HOST"] || @env["SERVER_NAME"]
+    end
+
+    # Server port
+    # @return [Integer]
+    def port
+      @port ||= (@env["SERVER_PORT"] || 80).to_i
+    end
+
+    # Query string
+    # @return [String]
+    def query_string
+      @query_string ||= @env["QUERY_STRING"] || ""
+    end
+
+    # Query parameters (lazy parsed)
+    # @return [Hash]
+    def query_params
+      @query_params ||= parse_query_string.freeze
+    end
+
+    # Combined parameters (route + query + body)
+    # @return [Params]
+    def params
+      @params ||= Params.new(route_params.merge(query_params).merge(body_params))
+    end
+
+    # Request body (raw)
+    # @return [String]
+    def body
+      @body ||= begin
+        input = @env["rack.input"]
+        return "" unless input
+        input.rewind if input.respond_to?(:rewind)
+        input.read.to_s
+      end
+    end
+
+    # Parsed body parameters (JSON, form data, etc.)
+    # @return [Hash]
+    def body_params
+      @body_params ||= parse_body.freeze
+    end
+
+    # Request headers (lazy loaded)
+    # @return [Hash]
+    def headers
+      @headers ||= extract_headers.freeze
+    end
+
+    # Get a specific header
+    # @param name [String] header name (case-insensitive)
+    # @return [String, nil]
+    def header(name)
+      headers[normalize_header_name(name)]
+    end
+
+    # Content type
+    # @return [String, nil]
+    def content_type
+      @content_type ||= @env["CONTENT_TYPE"]
+    end
+
+    # Content length
+    # @return [Integer, nil]
+    def content_length
+      @content_length ||= @env["CONTENT_LENGTH"]&.to_i
+    end
+
+    # Accept header
+    # @return [String, nil]
+    def accept
+      @accept ||= @env["HTTP_ACCEPT"]
+    end
+
+    # Accepted content types (parsed)
+    # @return [Array<String>]
+    def accepted_types
+      @accepted_types ||= parse_accept_header
+    end
+
+    # Check if request accepts a content type
+    # @param type [String] content type to check
+    # @return [Boolean]
+    def accepts?(type)
+      accepted_types.any? { |t| t == "*/*" || t == type || t.start_with?(type.split("/").first + "/*") }
+    end
+
+    # Cookies (lazy parsed)
+    # @return [Hash]
+    def cookies
+      @cookies ||= parse_cookies.freeze
+    end
+
+    # User agent
+    # @return [String, nil]
+    def user_agent
+      @user_agent ||= @env["HTTP_USER_AGENT"]
+    end
+
+    # Client IP address
+    # @return [String]
+    def ip
+      @ip ||= @env["HTTP_X_FORWARDED_FOR"]&.split(",")&.first&.strip ||
+              @env["HTTP_X_REAL_IP"] ||
+              @env["REMOTE_ADDR"] ||
+              "127.0.0.1"
+    end
+
+    # Check if request is secure (HTTPS)
+    # @return [Boolean]
+    def secure?
+      scheme == "https"
+    end
+
+    # Check if request is XHR/AJAX
+    # @return [Boolean]
+    def xhr?
+      @env["HTTP_X_REQUESTED_WITH"]&.downcase == "xmlhttprequest"
+    end
+
+    # Check if request is JSON
+    # @return [Boolean]
+    def json?
+      content_type&.include?("application/json")
+    end
+
+    # Check if request is form data
+    # @return [Boolean]
+    def form?
+      content_type&.include?("application/x-www-form-urlencoded") ||
+        content_type&.include?("multipart/form-data")
+    end
+
+    # HTTP method helpers
+    HTTP_METHODS.each do |m|
+      define_method("#{m.downcase}?") { method == m.to_sym }
+    end
+
+    # Check if request is safe (GET, HEAD, OPTIONS)
+    # @return [Boolean]
+    def safe?
+      %i[GET HEAD OPTIONS].include?(method)
+    end
+
+    # Check if request is idempotent
+    # @return [Boolean]
+    def idempotent?
+      %i[GET HEAD PUT DELETE OPTIONS].include?(method)
+    end
+
+    private
+
+    def parse_query_string
+      return {} if query_string.empty?
+
+      query_string.split("&").each_with_object({}) do |pair, hash|
+        key, value = pair.split("=", 2).map { |s| URI.decode_www_form_component(s.to_s) }
+        hash[key.to_sym] = value
+      end
+    end
+
+    def parse_body
+      return {} if body.empty?
+
+      case content_type
+      when /json/i
+        JSON.parse(body, symbolize_names: true)
+      when /x-www-form-urlencoded/i
+        parse_form_data(body)
+      else
+        {}
+      end
+    rescue JSON::ParserError
+      {}
+    end
+
+    def parse_form_data(data)
+      data.split("&").each_with_object({}) do |pair, hash|
+        key, value = pair.split("=", 2).map { |s| URI.decode_www_form_component(s.to_s) }
+        hash[key.to_sym] = value
+      end
+    end
+
+    def extract_headers
+      @env.each_with_object({}) do |(key, value), headers|
+        next unless key.start_with?("HTTP_")
+        header_name = key[5..].split("_").map(&:capitalize).join("-")
+        headers[header_name] = value
+      end
+    end
+
+    def normalize_header_name(name)
+      name.to_s.split(/[-_]/).map(&:capitalize).join("-")
+    end
+
+    def parse_accept_header
+      return ["*/*"] unless accept
+
+      accept.split(",").map do |type|
+        type.split(";").first.strip
+      end.sort_by do |type|
+        # Sort by specificity
+        case type
+        when "*/*" then 2
+        when %r{.+/\*} then 1
+        else 0
+        end
+      end
+    end
+
+    def parse_cookies
+      cookie_header = @env["HTTP_COOKIE"]
+      return {} unless cookie_header
+
+      cookie_header.split(";").each_with_object({}) do |cookie, hash|
+        key, value = cookie.strip.split("=", 2)
+        hash[key.to_sym] = value
+      end
+    end
+  end
+end

data/lib/tarsier/response.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+require "json"
+require "time"
+
+module Tarsier
+  # Response object supporting streaming and async rendering
+  # Rack-compatible but optimized for direct use
+  class Response
+    attr_reader :status, :headers
+    attr_accessor :body
+
+    # Common HTTP status codes
+    STATUS_CODES = {
+      100 => "Continue",
+      200 => "OK",
+      201 => "Created",
+      204 => "No Content",
+      301 => "Moved Permanently",
+      302 => "Found",
+      304 => "Not Modified",
+      400 => "Bad Request",
+      401 => "Unauthorized",
+      403 => "Forbidden",
+      404 => "Not Found",
+      405 => "Method Not Allowed",
+      422 => "Unprocessable Entity",
+      429 => "Too Many Requests",
+      500 => "Internal Server Error",
+      502 => "Bad Gateway",
+      503 => "Service Unavailable"
+    }.freeze
+
+    # @param status [Integer] HTTP status code
+    # @param headers [Hash] response headers
+    # @param body [String, Array, nil] response body
+    def initialize(status: 200, headers: {}, body: nil)
+      @status = status
+      @headers = default_headers.merge(headers)
+      @body = body
+      @streaming = false
+      @sent = false
+    end
+
+    # Set response status
+    # @param code [Integer] HTTP status code
+    # @return [self]
+    def status=(code)
+      raise ResponseAlreadySentError if @sent
+      @status = code
+    end
+
+    # Set a header
+    # @param name [String] header name
+    # @param value [String] header value
+    # @return [self]
+    def set_header(name, value)
+      raise ResponseAlreadySentError if @sent
+      @headers[name] = value
+      self
+    end
+
+    alias []= set_header
+
+    # Get a header
+    # @param name [String] header name
+    # @return [String, nil]
+    def get_header(name)
+      @headers[name]
+    end
+
+    alias [] get_header
+
+    # Delete a header
+    # @param name [String] header name
+    # @return [String, nil]
+    def delete_header(name)
+      raise ResponseAlreadySentError if @sent
+      @headers.delete(name)
+    end
+
+    # Set content type
+    # @param type [String] content type
+    # @param charset [String] character set
+    # @return [self]
+    def content_type=(type, charset: "utf-8")
+      set_header("Content-Type", charset ? "#{type}; charset=#{charset}" : type)
+    end
+
+    # Set content length
+    # @param length [Integer] content length
+    # @return [self]
+    def content_length=(length)
+      set_header("Content-Length", length.to_s)
+    end
+
+    # Write to response body
+    # @param data [String] data to write
+    # @return [self]
+    def write(data)
+      raise ResponseAlreadySentError if @sent && !@streaming
+
+      @body ||= +""
+      @body << data.to_s
+      self
+    end
+
+    alias << write
+
+    # Render JSON response
+    # @param data [Object] data to serialize
+    # @param status [Integer] HTTP status code
+    # @return [self]
+    def json(data, status: 200)
+      @status = status
+      self.content_type = "application/json"
+      @body = JSON.generate(data)
+      self
+    end
+
+    # Render HTML response
+    # @param content [String] HTML content
+    # @param status [Integer] HTTP status code
+    # @return [self]
+    def html(content, status: 200)
+      @status = status
+      self.content_type = "text/html"
+      @body = content
+      self
+    end
+
+    # Render plain text response
+    # @param content [String] text content
+    # @param status [Integer] HTTP status code
+    # @return [self]
+    def text(content, status: 200)
+      @status = status
+      self.content_type = "text/plain"
+      @body = content
+      self
+    end
+
+    # Redirect to another URL
+    # @param url [String] redirect URL
+    # @param status [Integer] HTTP status code (301 or 302)
+    # @return [self]
+    def redirect(url, status: 302)
+      @status = status
+      set_header("Location", url)
+      @body = ""
+      self
+    end
+
+    # Set a cookie
+    # @param name [String] cookie name
+    # @param value [String] cookie value
+    # @param options [Hash] cookie options
+    # @return [self]
+    def set_cookie(name, value, **options)
+      cookie = "#{name}=#{value}"
+      cookie << "; Path=#{options[:path]}" if options[:path]
+      cookie << "; Domain=#{options[:domain]}" if options[:domain]
+      cookie << "; Expires=#{options[:expires].httpdate}" if options[:expires]
+      cookie << "; Max-Age=#{options[:max_age]}" if options[:max_age]
+      cookie << "; Secure" if options[:secure]
+      cookie << "; HttpOnly" if options[:http_only]
+      cookie << "; SameSite=#{options[:same_site]}" if options[:same_site]
+
+      existing = @headers["Set-Cookie"]
+      if existing
+        @headers["Set-Cookie"] = [existing, cookie].flatten
+      else
+        @headers["Set-Cookie"] = cookie
+      end
+      self
+    end
+
+    # Delete a cookie
+    # @param name [String] cookie name
+    # @param options [Hash] cookie options
+    # @return [self]
+    def delete_cookie(name, **options)
+      set_cookie(name, "", **options.merge(max_age: 0, expires: Time.at(0)))
+    end
+
+    # Stream response body
+    # @yield [StreamWriter] stream writer for chunked output
+    # @return [self]
+    def stream(&block)
+      raise ResponseAlreadySentError if @sent
+
+      @streaming = true
+      set_header("Transfer-Encoding", "chunked")
+      delete_header("Content-Length")
+
+      @body = StreamBody.new(&block)
+      self
+    end
+
+    # Check if response is streaming
+    # @return [Boolean]
+    def streaming?
+      @streaming
+    end
+
+    # Check if response has been sent
+    # @return [Boolean]
+    def sent?
+      @sent
+    end
+
+    # Mark response as sent
+    def mark_sent!
+      @sent = true
+    end
+
+    # Convert to Rack response format
+    # @return [Array] Rack response tuple [status, headers, body]
+    def to_rack
+      body_content = normalize_body
+      @headers["Content-Length"] ||= calculate_content_length(body_content) unless @streaming
+
+      [@status, @headers, body_content]
+    end
+
+    # Finish and return Rack response
+    # @return [Array]
+    def finish
+      mark_sent!
+      to_rack
+    end
+
+    private
+
+    def default_headers
+      {
+        "Content-Type" => "text/html; charset=utf-8",
+        "X-Content-Type-Options" => "nosniff",
+        "X-Frame-Options" => "SAMEORIGIN"
+      }
+    end
+
+    def normalize_body
+      case @body
+      when nil then []
+      when String then [@body]
+      when Array then @body
+      else @body
+      end
+    end
+
+    def calculate_content_length(body_content)
+      return nil unless body_content.respond_to?(:sum)
+      body_content.sum { |chunk| chunk.bytesize }.to_s
+    end
+  end
+
+  # Streaming body wrapper for chunked responses
+  class StreamBody
+    def initialize(&block)
+      @block = block
+    end
+
+    def each(&output_block)
+      writer = StreamWriter.new(&output_block)
+      @block.call(writer)
+    end
+  end
+
+  # Writer for streaming responses
+  class StreamWriter
+    def initialize(&block)
+      @output = block
+    end
+
+    def write(data)
+      @output.call(data.to_s)
+    end
+
+    alias << write
+  end
+end