spikard 0.3.6 → 0.5.0

data/vendor/crates/spikard-rb/build.rs

@@ -1,8 +1,199 @@
-use rb_sys_build::RbConfig;
+use std::env;
+use std::fs;
+use std::path::PathBuf;
 
-fn main() {
-    let mut rbconfig = RbConfig::current();
-    rbconfig.link_ruby(false);
-    rbconfig.print_cargo_args();
+fn main() -> Result<(), Box<dyn std::error::Error>> {
     println!("cargo:rerun-if-changed=build.rs");
+
+    let manifest_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR")?);
+    let workspace_root = manifest_dir
+        .parent()
+        .and_then(|p| p.parent())
+        .ok_or("Failed to resolve workspace root from manifest dir")?;
+
+    let target = workspace_root.join("packages/ruby/lib/spikard/response.rb");
+    if let Some(parent) = target.parent() {
+        fs::create_dir_all(parent)?;
+    }
+
+    fs::write(&target, generated_response_file())?;
+    Ok(())
+}
+
+fn generated_response_file() -> String {
+    r##"# frozen_string_literal: true
+
+# ⚠️ GENERATED BY crates/spikard-rb/build.rs — DO NOT EDIT BY HAND
+module Spikard
+  class Response # :nodoc: Native-backed HTTP response facade generated from Rust metadata.
+    attr_reader :content, :status_code, :headers, :native_response
+
+    def initialize(content: nil, body: nil, status_code: 200, headers: nil, content_type: nil)
+      @content = content.nil? ? body : content
+      @status_code = Integer(status_code || 200)
+      @headers = normalize_headers(headers)
+      set_header('content-type', content_type) if content_type
+      rebuild_native!
+    end
+
+    def status
+      @status_code
+    end
+
+    def status_code=(value)
+      @status_code = Integer(value)
+      rebuild_native!
+    rescue ArgumentError, TypeError
+      raise ArgumentError, 'status_code must be an integer'
+    end
+
+    def headers=(value)
+      @headers = normalize_headers(value)
+      rebuild_native!
+    end
+
+    def content=(value)
+      @content = value
+      rebuild_native!
+    end
+
+    def set_header(name, value)
+      @headers[name.to_s] = value.to_s
+      rebuild_native!
+    end
+
+    def set_cookie(name, value, **options)
+      raise ArgumentError, 'cookie name required' if name.nil? || name.empty?
+
+      header_value = ["#{name}=#{value}", *cookie_parts(options)].join('; ')
+      set_header('set-cookie', header_value)
+    end
+
+    def to_native_response
+      @native_response
+    end
+
+    private
+
+    def rebuild_native!
+      ensure_native!
+      @native_response = Spikard::Native.build_response(@content, @status_code, @headers)
+      return unless @native_response
+
+      @status_code = @native_response.status_code
+      @headers = @native_response.headers
+    end
+
+    def ensure_native!
+      return if defined?(Spikard::Native) && Spikard::Native.respond_to?(:build_response)
+
+      raise 'Spikard native extension is not loaded'
+    end
+
+    def cookie_parts(options)
+      [
+        options[:max_age] && "Max-Age=#{Integer(options[:max_age])}",
+        options[:domain] && "Domain=#{options[:domain]}",
+        "Path=#{options.fetch(:path, '/') || '/'}",
+        options[:secure] ? 'Secure' : nil,
+        options[:httponly] ? 'HttpOnly' : nil,
+        options[:samesite] && "SameSite=#{options[:samesite]}"
+      ].compact
+    end
+
+    def normalize_headers(value)
+      case value
+      when nil
+        {}
+      when Hash
+        value.each_with_object({}) do |(key, val), acc|
+          acc[key.to_s.downcase] = val.to_s
+        end
+      else
+        raise ArgumentError, 'headers must be a Hash'
+      end
+    end
+  end
+
+  class StreamingResponse # :nodoc: Streaming response wrapper backed by the native Rust builder.
+    attr_reader :stream, :status_code, :headers, :native_response
+
+    def initialize(stream, status_code: 200, headers: nil)
+      unless stream.respond_to?(:next) || stream.respond_to?(:each)
+        raise ArgumentError, 'StreamingResponse requires an object responding to #next or #each'
+      end
+
+      @stream = stream.respond_to?(:to_enum) ? stream.to_enum : stream
+      @status_code = Integer(status_code || 200)
+      header_hash = headers || {}
+      @headers = header_hash.each_with_object({}) do |(key, value), memo|
+        memo[String(key)] = String(value)
+      end
+
+      rebuild_native!
+    end
+
+    def to_native_response
+      @native_response
+    end
+
+    private
+
+    def rebuild_native!
+      ensure_native!
+      @native_response = Spikard::Native.build_streaming_response(@stream, @status_code, @headers)
+      return unless @native_response
+
+      @status_code = @native_response.status_code
+      @headers = @native_response.headers
+    end
+
+    def ensure_native!
+      return if defined?(Spikard::Native) && Spikard::Native.respond_to?(:build_streaming_response)
+
+      raise 'Spikard native extension is not loaded'
+    end
+  end
+
+  module Testing
+    class Response # :nodoc: Lightweight response wrapper used by the test client.
+      attr_reader :status_code, :headers, :body
+
+      def initialize(payload)
+        @status_code = payload[:status_code]
+        @headers = payload[:headers] || {}
+        @body = payload[:body]
+        @body_text = payload[:body_text]
+      end
+
+      def status
+        @status_code
+      end
+
+      def body_bytes
+        @body || ''.b
+      end
+
+      def body_text
+        @body_text || @body&.dup&.force_encoding(Encoding::UTF_8)
+      end
+
+      def text
+        body_text
+      end
+
+      def json
+        return nil if @body.nil? || @body.empty?
+
+        JSON.parse(@body)
+      end
+
+      def bytes
+        body_bytes.bytes
+      end
+    end
+  end
+end
+"##
+    .to_string()
 }

data/vendor/crates/spikard-rb/src/config/mod.rs

@@ -0,0 +1,5 @@
+//! Server configuration extraction from Ruby objects.
+
+pub mod server_config;
+
+pub use server_config::extract_server_config;

data/vendor/crates/spikard-rb/src/{config.rs → config/server_config.rs}

@@ -1,25 +1,18 @@
-//! ServerConfig extraction from Ruby configuration objects.
+//! ServerConfig extraction from Ruby objects.
 //!
-//! This module handles conversion of Ruby ServerConfig objects
-//! into Rust ServerConfig structs for Spikard HTTP server setup.
-
-#![allow(dead_code)]
+//! This module handles converting Ruby ServerConfig objects to the Rust
+//! spikard_http::ServerConfig type.
 
 use magnus::prelude::*;
 use magnus::{Error, RArray, RHash, Ruby, TryConvert, Value};
 use spikard_http::{
-    ApiKeyConfig, CompressionConfig, ContactInfo, JwtConfig, LicenseInfo, OpenApiConfig, RateLimitConfig, ServerConfig,
-    ServerInfo, StaticFilesConfig,
+    ApiKeyConfig, CompressionConfig, ContactInfo, JwtConfig, LicenseInfo, OpenApiConfig, RateLimitConfig, ServerInfo,
+    StaticFilesConfig,
 };
 use std::collections::HashMap;
 
-use crate::conversion::{get_optional_string_from_hash, get_required_string_from_hash};
-
-/// Extract a ServerConfig from a Ruby configuration object.
-///
-/// Handles all ServerConfig properties including middleware configs,
-/// authentication, static files, and OpenAPI documentation settings.
-pub fn extract_server_config(ruby: &Ruby, config_value: Value) -> Result<ServerConfig, Error> {
+/// Extract ServerConfig from Ruby ServerConfig object
+pub fn extract_server_config(ruby: &Ruby, config_value: Value) -> Result<spikard_http::ServerConfig, Error> {
     let host: String = config_value.funcall("host", ())?;
 
     let port: u32 = config_value.funcall("port", ())?;
@@ -46,7 +39,6 @@ pub fn extract_server_config(ruby: &Ruby, config_value: Value) -> Result<ServerC
 
     let shutdown_timeout: u64 = config_value.funcall("shutdown_timeout", ())?;
 
-    // Compression config
     let compression_value: Value = config_value.funcall("compression", ())?;
     let compression = if compression_value.is_nil() {
         None
@@ -63,7 +55,6 @@ pub fn extract_server_config(ruby: &Ruby, config_value: Value) -> Result<ServerC
         })
     };
 
-    // Rate limit config
     let rate_limit_value: Value = config_value.funcall("rate_limit", ())?;
     let rate_limit = if rate_limit_value.is_nil() {
         None
@@ -78,7 +69,6 @@ pub fn extract_server_config(ruby: &Ruby, config_value: Value) -> Result<ServerC
         })
     };
 
-    // JWT auth config
     let jwt_auth_value: Value = config_value.funcall("jwt_auth", ())?;
     let jwt_auth = if jwt_auth_value.is_nil() {
         None
@@ -107,7 +97,6 @@ pub fn extract_server_config(ruby: &Ruby, config_value: Value) -> Result<ServerC
         })
     };
 
-    // API key auth config
     let api_key_auth_value: Value = config_value.funcall("api_key_auth", ())?;
     let api_key_auth = if api_key_auth_value.is_nil() {
         None
@@ -117,7 +106,6 @@ pub fn extract_server_config(ruby: &Ruby, config_value: Value) -> Result<ServerC
         Some(ApiKeyConfig { keys, header_name })
     };
 
-    // Static files config
     let static_files_value: Value = config_value.funcall("static_files", ())?;
     let static_files_array = RArray::from_value(static_files_value)
         .ok_or_else(|| Error::new(ruby.exception_type_error(), "static_files must be an Array"))?;
@@ -142,7 +130,6 @@ pub fn extract_server_config(ruby: &Ruby, config_value: Value) -> Result<ServerC
         });
     }
 
-    // OpenAPI config
     let openapi_value: Value = config_value.funcall("openapi", ())?;
     let openapi = if openapi_value.is_nil() {
         None
@@ -160,9 +147,80 @@ pub fn extract_server_config(ruby: &Ruby, config_value: Value) -> Result<ServerC
         let redoc_path: String = openapi_value.funcall("redoc_path", ())?;
         let openapi_json_path: String = openapi_value.funcall("openapi_json_path", ())?;
 
-        let contact = extract_contact_info(ruby, &openapi_value)?;
-        let license = extract_license_info(ruby, &openapi_value)?;
-        let servers = extract_servers(ruby, &openapi_value)?;
+        let contact_value: Value = openapi_value.funcall("contact", ())?;
+        let contact = if contact_value.is_nil() {
+            None
+        } else if let Some(contact_hash) = RHash::from_value(contact_value) {
+            let name = get_optional_string_from_hash(contact_hash, "name")?;
+            let email = get_optional_string_from_hash(contact_hash, "email")?;
+            let url = get_optional_string_from_hash(contact_hash, "url")?;
+            Some(ContactInfo { name, email, url })
+        } else {
+            let name_value: Value = contact_value.funcall("name", ())?;
+            let email_value: Value = contact_value.funcall("email", ())?;
+            let url_value: Value = contact_value.funcall("url", ())?;
+            Some(ContactInfo {
+                name: if name_value.is_nil() {
+                    None
+                } else {
+                    Some(String::try_convert(name_value)?)
+                },
+                email: if email_value.is_nil() {
+                    None
+                } else {
+                    Some(String::try_convert(email_value)?)
+                },
+                url: if url_value.is_nil() {
+                    None
+                } else {
+                    Some(String::try_convert(url_value)?)
+                },
+            })
+        };
+
+        let license_value: Value = openapi_value.funcall("license", ())?;
+        let license = if license_value.is_nil() {
+            None
+        } else if let Some(license_hash) = RHash::from_value(license_value) {
+            let name = get_required_string_from_hash(license_hash, "name", ruby)?;
+            let url = get_optional_string_from_hash(license_hash, "url")?;
+            Some(LicenseInfo { name, url })
+        } else {
+            let name: String = license_value.funcall("name", ())?;
+            let url_value: Value = license_value.funcall("url", ())?;
+            let url = if url_value.is_nil() {
+                None
+            } else {
+                Some(String::try_convert(url_value)?)
+            };
+            Some(LicenseInfo { name, url })
+        };
+
+        let servers_value: Value = openapi_value.funcall("servers", ())?;
+        let servers_array = RArray::from_value(servers_value)
+            .ok_or_else(|| Error::new(ruby.exception_type_error(), "servers must be an Array"))?;
+
+        let mut servers = Vec::new();
+        for i in 0..servers_array.len() {
+            let server_value = servers_array.entry::<Value>(i as isize)?;
+
+            let (url, description) = if let Some(server_hash) = RHash::from_value(server_value) {
+                let url = get_required_string_from_hash(server_hash, "url", ruby)?;
+                let description = get_optional_string_from_hash(server_hash, "description")?;
+                (url, description)
+            } else {
+                let url: String = server_value.funcall("url", ())?;
+                let description_value: Value = server_value.funcall("description", ())?;
+                let description = if description_value.is_nil() {
+                    None
+                } else {
+                    Some(String::try_convert(description_value)?)
+                };
+                (url, description)
+            };
+
+            servers.push(ServerInfo { url, description });
+        }
 
         let security_schemes = HashMap::new();
 
@@ -181,7 +239,7 @@ pub fn extract_server_config(ruby: &Ruby, config_value: Value) -> Result<ServerC
         })
     };
 
-    Ok(ServerConfig {
+    Ok(spikard_http::ServerConfig {
         host,
         port: port as u16,
         workers,
@@ -196,99 +254,32 @@ pub fn extract_server_config(ruby: &Ruby, config_value: Value) -> Result<ServerC
         graceful_shutdown,
         shutdown_timeout,
         background_tasks: spikard_http::BackgroundTaskConfig::default(),
+        enable_http_trace: false,
         openapi,
+        jsonrpc: None,
         lifecycle_hooks: None,
-        #[cfg(feature = "di")]
         di_container: None,
     })
 }
 
-/// Extract contact information from OpenAPI config.
-fn extract_contact_info(_ruby: &Ruby, openapi_value: &Value) -> Result<Option<ContactInfo>, Error> {
-    let contact_value: Value = openapi_value.funcall("contact", ())?;
-    if contact_value.is_nil() {
-        return Ok(None);
+/// Helper to extract an optional string from a Ruby Hash
+pub fn get_optional_string_from_hash(hash: RHash, key: &str) -> Result<Option<String>, Error> {
+    match hash.get(String::from(key)) {
+        Some(v) if !v.is_nil() => Ok(Some(String::try_convert(v)?)),
+        _ => Ok(None),
     }
-
-    if let Some(contact_hash) = RHash::from_value(contact_value) {
-        let name = get_optional_string_from_hash(contact_hash, "name")?;
-        let email = get_optional_string_from_hash(contact_hash, "email")?;
-        let url = get_optional_string_from_hash(contact_hash, "url")?;
-        return Ok(Some(ContactInfo { name, email, url }));
-    }
-
-    let name_value: Value = contact_value.funcall("name", ())?;
-    let email_value: Value = contact_value.funcall("email", ())?;
-    let url_value: Value = contact_value.funcall("url", ())?;
-    Ok(Some(ContactInfo {
-        name: if name_value.is_nil() {
-            None
-        } else {
-            Some(String::try_convert(name_value)?)
-        },
-        email: if email_value.is_nil() {
-            None
-        } else {
-            Some(String::try_convert(email_value)?)
-        },
-        url: if url_value.is_nil() {
-            None
-        } else {
-            Some(String::try_convert(url_value)?)
-        },
-    }))
-}
-
-/// Extract license information from OpenAPI config.
-fn extract_license_info(ruby: &Ruby, openapi_value: &Value) -> Result<Option<LicenseInfo>, Error> {
-    let license_value: Value = openapi_value.funcall("license", ())?;
-    if license_value.is_nil() {
-        return Ok(None);
-    }
-
-    if let Some(license_hash) = RHash::from_value(license_value) {
-        let name = get_required_string_from_hash(license_hash, "name", ruby)?;
-        let url = get_optional_string_from_hash(license_hash, "url")?;
-        return Ok(Some(LicenseInfo { name, url }));
-    }
-
-    let name: String = license_value.funcall("name", ())?;
-    let url_value: Value = license_value.funcall("url", ())?;
-    let url = if url_value.is_nil() {
-        None
-    } else {
-        Some(String::try_convert(url_value)?)
-    };
-    Ok(Some(LicenseInfo { name, url }))
 }
 
-/// Extract server information from OpenAPI config.
-fn extract_servers(ruby: &Ruby, openapi_value: &Value) -> Result<Vec<ServerInfo>, Error> {
-    let servers_value: Value = openapi_value.funcall("servers", ())?;
-    let servers_array = RArray::from_value(servers_value)
-        .ok_or_else(|| Error::new(ruby.exception_type_error(), "servers must be an Array"))?;
-
-    let mut servers = Vec::new();
-    for i in 0..servers_array.len() {
-        let server_value = servers_array.entry::<Value>(i as isize)?;
-
-        let (url, description) = if let Some(server_hash) = RHash::from_value(server_value) {
-            let url = get_required_string_from_hash(server_hash, "url", ruby)?;
-            let description = get_optional_string_from_hash(server_hash, "description")?;
-            (url, description)
-        } else {
-            let url: String = server_value.funcall("url", ())?;
-            let description_value: Value = server_value.funcall("description", ())?;
-            let description = if description_value.is_nil() {
-                None
-            } else {
-                Some(String::try_convert(description_value)?)
-            };
-            (url, description)
-        };
-
-        servers.push(ServerInfo { url, description });
+/// Helper to extract a required string from a Ruby Hash
+pub fn get_required_string_from_hash(hash: RHash, key: &str, ruby: &Ruby) -> Result<String, Error> {
+    let value = hash
+        .get(String::from(key))
+        .ok_or_else(|| Error::new(ruby.exception_arg_error(), format!("missing required key '{}'", key)))?;
+    if value.is_nil() {
+        return Err(Error::new(
+            ruby.exception_arg_error(),
+            format!("key '{}' cannot be nil", key),
+        ));
     }
-
-    Ok(servers)
+    String::try_convert(value)
 }