spikard 0.12.0 → 0.15.2

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

@@ -1,200 +0,0 @@
-use std::env;
-use std::fs;
-use std::path::PathBuf;
-
-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(())
-}
-
-#[allow(clippy::too_many_lines)]
-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/background.rs

@@ -1,63 +0,0 @@
-use magnus::prelude::*;
-use magnus::value::{InnerValue, Opaque};
-use magnus::{Error, Ruby, Value};
-use once_cell::sync::Lazy;
-use spikard_http::{BackgroundHandle, BackgroundJobError, BackgroundJobMetadata};
-use std::sync::{Arc, RwLock};
-
-static BACKGROUND_HANDLE: Lazy<RwLock<Option<BackgroundHandle>>> = Lazy::new(|| RwLock::new(None));
-
-pub fn install_handle(handle: BackgroundHandle) {
-    match BACKGROUND_HANDLE.write() {
-        Ok(mut guard) => *guard = Some(handle),
-        Err(_) => eprintln!("warning: background handle lock poisoned, continuing"),
-    }
-}
-
-pub fn clear_handle() {
-    match BACKGROUND_HANDLE.write() {
-        Ok(mut guard) => *guard = None,
-        Err(_) => eprintln!("warning: background handle lock poisoned, continuing"),
-    }
-}
-
-pub fn background_run(ruby: &Ruby, block: Value) -> Result<(), Error> {
-    let call_sym = ruby.intern("call");
-    if !block.respond_to(call_sym, false)? {
-        return Err(Error::new(
-            ruby.exception_type_error(),
-            "background.run expects a callable block",
-        ));
-    }
-
-    let handle = BACKGROUND_HANDLE
-        .read()
-        .map_err(|_| Error::new(ruby.exception_runtime_error(), "background handle lock poisoned"))?
-        .clone()
-        .ok_or_else(|| Error::new(ruby.exception_runtime_error(), "background runtime not initialized"))?;
-
-    let proc_value = Arc::new(Opaque::from(block));
-
-    handle
-        .spawn_with_metadata(
-            async move {
-                let proc_clone = proc_value.clone();
-                tokio::task::spawn_blocking(move || -> Result<(), BackgroundJobError> {
-                    let ruby = Ruby::get().map_err(|e| BackgroundJobError::from(e.to_string()))?;
-                    let callable = proc_clone.get_inner_with(&ruby);
-                    callable
-                        .funcall::<_, _, Value>("call", ())
-                        .map(|_| ())
-                        .map_err(|err| BackgroundJobError::from(format_ruby_error(err)))
-                })
-                .await
-                .map_err(|e| BackgroundJobError::from(e.to_string()))?
-            },
-            BackgroundJobMetadata::default(),
-        )
-        .map_err(|err| Error::new(ruby.exception_runtime_error(), err.to_string()))
-}
-
-fn format_ruby_error(err: Error) -> String {
-    err.to_string()
-}

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

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

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

@@ -1,401 +0,0 @@
-//! ServerConfig extraction from Ruby objects.
-//!
-//! 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, r_hash::ForEach};
-use spikard_http::{
-    ApiKeyConfig, CompressionConfig, ContactInfo, JsonRpcConfig, JwtConfig, LicenseInfo, OpenApiConfig,
-    RateLimitConfig, ServerInfo, StaticFilesConfig,
-};
-use std::collections::HashMap;
-
-/// 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", ())?;
-
-    let workers: usize = config_value.funcall("workers", ())?;
-
-    let enable_request_id: bool = config_value.funcall("enable_request_id", ())?;
-
-    let max_body_size_value: Value = config_value.funcall("max_body_size", ())?;
-    let max_body_size = if max_body_size_value.is_nil() {
-        None
-    } else {
-        Some(u64::try_convert(max_body_size_value)? as usize)
-    };
-
-    let request_timeout_value: Value = config_value.funcall("request_timeout", ())?;
-    let request_timeout = if request_timeout_value.is_nil() {
-        None
-    } else {
-        Some(u64::try_convert(request_timeout_value)?)
-    };
-
-    let graceful_shutdown: bool = config_value.funcall("graceful_shutdown", ())?;
-
-    let shutdown_timeout: u64 = config_value.funcall("shutdown_timeout", ())?;
-
-    let compression_value: Value = config_value.funcall("compression", ())?;
-    let compression = if compression_value.is_nil() {
-        None
-    } else {
-        let gzip: bool = compression_value.funcall("gzip", ())?;
-        let brotli: bool = compression_value.funcall("brotli", ())?;
-        let min_size: usize = compression_value.funcall("min_size", ())?;
-        let quality: u32 = compression_value.funcall("quality", ())?;
-        Some(CompressionConfig {
-            gzip,
-            brotli,
-            min_size,
-            quality,
-        })
-    };
-
-    let rate_limit_value: Value = config_value.funcall("rate_limit", ())?;
-    let rate_limit = if rate_limit_value.is_nil() {
-        None
-    } else {
-        let per_second: u64 = rate_limit_value.funcall("per_second", ())?;
-        let burst: u32 = rate_limit_value.funcall("burst", ())?;
-        let ip_based: bool = rate_limit_value.funcall("ip_based", ())?;
-        Some(RateLimitConfig {
-            per_second,
-            burst,
-            ip_based,
-        })
-    };
-
-    let jwt_auth_value: Value = config_value.funcall("jwt_auth", ())?;
-    let jwt_auth = if jwt_auth_value.is_nil() {
-        None
-    } else {
-        let secret: String = jwt_auth_value.funcall("secret", ())?;
-        let algorithm: String = jwt_auth_value.funcall("algorithm", ())?;
-        let audience_value: Value = jwt_auth_value.funcall("audience", ())?;
-        let audience = if audience_value.is_nil() {
-            None
-        } else {
-            Some(Vec::<String>::try_convert(audience_value)?)
-        };
-        let issuer_value: Value = jwt_auth_value.funcall("issuer", ())?;
-        let issuer = if issuer_value.is_nil() {
-            None
-        } else {
-            Some(String::try_convert(issuer_value)?)
-        };
-        let leeway: u64 = jwt_auth_value.funcall("leeway", ())?;
-        Some(JwtConfig {
-            secret,
-            algorithm,
-            audience,
-            issuer,
-            leeway,
-        })
-    };
-
-    let api_key_auth_value: Value = config_value.funcall("api_key_auth", ())?;
-    let api_key_auth = if api_key_auth_value.is_nil() {
-        None
-    } else {
-        let keys: Vec<String> = api_key_auth_value.funcall("keys", ())?;
-        let header_name: String = api_key_auth_value.funcall("header_name", ())?;
-        Some(ApiKeyConfig { keys, header_name })
-    };
-
-    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"))?;
-
-    let mut static_files = Vec::new();
-    for i in 0..static_files_array.len() {
-        let sf_value = static_files_array.entry::<Value>(i as isize)?;
-        let directory: String = sf_value.funcall("directory", ())?;
-        let route_prefix: String = sf_value.funcall("route_prefix", ())?;
-        let index_file: bool = sf_value.funcall("index_file", ())?;
-        let cache_control_value: Value = sf_value.funcall("cache_control", ())?;
-        let cache_control = if cache_control_value.is_nil() {
-            None
-        } else {
-            Some(String::try_convert(cache_control_value)?)
-        };
-        static_files.push(StaticFilesConfig {
-            directory,
-            route_prefix,
-            index_file,
-            cache_control,
-        });
-    }
-
-    let openapi_value: Value = config_value.funcall("openapi", ())?;
-    let openapi = if openapi_value.is_nil() {
-        None
-    } else {
-        let enabled: bool = openapi_value.funcall("enabled", ())?;
-        let title: String = openapi_value.funcall("title", ())?;
-        let version: String = openapi_value.funcall("version", ())?;
-        let description_value: Value = openapi_value.funcall("description", ())?;
-        let description = if description_value.is_nil() {
-            None
-        } else {
-            Some(String::try_convert(description_value)?)
-        };
-        let swagger_ui_path: String = openapi_value.funcall("swagger_ui_path", ())?;
-        let redoc_path: String = openapi_value.funcall("redoc_path", ())?;
-        let openapi_json_path: String = openapi_value.funcall("openapi_json_path", ())?;
-
-        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_value: Value = openapi_value.funcall("security_schemes", ())?;
-        let mut security_schemes = HashMap::new();
-        if !security_schemes_value.is_nil() {
-            let schemes_hash = RHash::from_value(security_schemes_value).ok_or_else(|| {
-                Error::new(
-                    ruby.exception_type_error(),
-                    "security_schemes must be a Hash<String, SecuritySchemeInfo>",
-                )
-            })?;
-
-            schemes_hash.foreach(|key: Value, scheme_value: Value| -> Result<ForEach, Error> {
-                let key_str = if let Ok(sym) = magnus::Symbol::try_convert(key) {
-                    sym.name().map(|c| c.to_string()).unwrap_or_default()
-                } else {
-                    String::try_convert(key)?
-                };
-
-                let scheme_info = parse_security_scheme_from_value(ruby, scheme_value)?;
-                security_schemes.insert(key_str, scheme_info);
-                Ok(ForEach::Continue)
-            })?;
-        }
-
-        Some(OpenApiConfig {
-            enabled,
-            title,
-            version,
-            description,
-            swagger_ui_path,
-            redoc_path,
-            openapi_json_path,
-            contact,
-            license,
-            servers,
-            security_schemes,
-        })
-    };
-
-    let jsonrpc_value: Value = config_value.funcall("jsonrpc", ())?;
-    let jsonrpc = if jsonrpc_value.is_nil() {
-        None
-    } else {
-        let enabled: bool = jsonrpc_value.funcall("enabled", ())?;
-        let endpoint_path: String = jsonrpc_value.funcall("endpoint_path", ())?;
-        let enable_batch: bool = jsonrpc_value.funcall("enable_batch", ())?;
-        let max_batch_size: usize = jsonrpc_value.funcall("max_batch_size", ())?;
-
-        Some(JsonRpcConfig {
-            enabled,
-            endpoint_path,
-            enable_batch,
-            max_batch_size,
-        })
-    };
-
-    Ok(spikard_http::ServerConfig {
-        host,
-        port: port as u16,
-        workers,
-        enable_request_id,
-        max_body_size,
-        request_timeout,
-        compression,
-        rate_limit,
-        jwt_auth,
-        api_key_auth,
-        static_files,
-        graceful_shutdown,
-        shutdown_timeout,
-        background_tasks: spikard_http::BackgroundTaskConfig::default(),
-        enable_http_trace: false,
-        openapi,
-        jsonrpc,
-        grpc: None,
-        lifecycle_hooks: None,
-        di_container: None,
-    })
-}
-
-fn parse_security_scheme_from_value(
-    ruby: &Ruby,
-    scheme_value: Value,
-) -> Result<spikard_http::SecuritySchemeInfo, Error> {
-    let (scheme_type, scheme, bearer_format, location, name) =
-        if let Some(scheme_hash) = RHash::from_value(scheme_value) {
-            (
-                get_required_string_from_hash(scheme_hash, "type", ruby)?,
-                get_optional_string_from_hash(scheme_hash, "scheme")?,
-                get_optional_string_from_hash(scheme_hash, "bearer_format")?,
-                get_optional_string_from_hash(scheme_hash, "location")?,
-                get_optional_string_from_hash(scheme_hash, "name")?,
-            )
-        } else {
-            let scheme_obj = scheme_value;
-            let scheme_type: String = scheme_obj.funcall("type", ())?;
-            let scheme_value: Value = scheme_obj.funcall("scheme", ())?;
-            let bearer_format_value: Value = scheme_obj.funcall("bearer_format", ())?;
-            let location_value: Value = scheme_obj.funcall("location", ())?;
-            let name_value: Value = scheme_obj.funcall("name", ())?;
-            (
-                scheme_type,
-                if scheme_value.is_nil() {
-                    None
-                } else {
-                    Some(String::try_convert(scheme_value)?)
-                },
-                if bearer_format_value.is_nil() {
-                    None
-                } else {
-                    Some(String::try_convert(bearer_format_value)?)
-                },
-                if location_value.is_nil() {
-                    None
-                } else {
-                    Some(String::try_convert(location_value)?)
-                },
-                if name_value.is_nil() {
-                    None
-                } else {
-                    Some(String::try_convert(name_value)?)
-                },
-            )
-        };
-
-    match scheme_type.as_str() {
-        "http" => {
-            let scheme = scheme.ok_or_else(|| {
-                Error::new(
-                    ruby.exception_arg_error(),
-                    "HTTP security scheme requires 'scheme' field",
-                )
-            })?;
-            Ok(spikard_http::SecuritySchemeInfo::Http { scheme, bearer_format })
-        }
-        "apiKey" => {
-            let location = location.ok_or_else(|| {
-                Error::new(
-                    ruby.exception_arg_error(),
-                    "API key security scheme requires 'location' field",
-                )
-            })?;
-            let name = name.ok_or_else(|| {
-                Error::new(
-                    ruby.exception_arg_error(),
-                    "API key security scheme requires 'name' field",
-                )
-            })?;
-            Ok(spikard_http::SecuritySchemeInfo::ApiKey { location, name })
-        }
-        _ => Err(Error::new(
-            ruby.exception_arg_error(),
-            format!("Unsupported security scheme type '{}'", scheme_type),
-        )),
-    }
-}
-
-/// 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),
-    }
-}
-
-/// 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),
-        ));
-    }
-    String::try_convert(value)
-}