spikard 0.4.0-x86_64-linux

data/vendor/crates/spikard-rb/Cargo.toml

@@ -0,0 +1,43 @@
+[package]
+name = "spikard-rb"
+version = "0.4.0"
+edition = "2024"
+authors = ["Na'aman Hirschfeld <nhirschfeld@gmail.com>"]
+license = "MIT"
+repository = "https://github.com/Goldziher/spikard"
+homepage = "https://github.com/Goldziher/spikard"
+description = "High-performance Ruby bindings for Spikard HTTP framework via Magnus"
+keywords = ["ruby", "bindings", "magnus", "http", "framework"]
+categories = ["api-bindings", "web-programming::http-server"]
+documentation = "https://docs.rs/spikard-rb"
+readme = "README.md"
+build = "build.rs"
+
+[lib]
+name = "spikard_rb_core"
+
+[dependencies]
+magnus = { version = "0.8.2", features = ["rb-sys"] }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+spikard-core = { path = "../spikard-core", features = ["di"] }
+spikard-http = { path = "../spikard-http", features = ["di"] }
+spikard-bindings-shared = { path = "../spikard-bindings-shared" }
+axum = { version = "0.8", features = ["multipart", "ws"] }
+axum-test = "18"
+bytes = "1.11"
+cookie = "0.18"
+tokio = { version = "1", features = ["full"] }
+tracing = "0.1"
+serde_qs = "0.15"
+urlencoding = "2.1"
+once_cell = "1.21"
+async-stream = "0.3"
+http = "1.4"
+
+[features]
+default = ["di"]
+di = ["spikard-core/di", "spikard-http/di"]
+
+[build-dependencies]
+rb-sys-build = "0.9"

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

@@ -0,0 +1,199 @@
+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(())
+}
+
+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

@@ -0,0 +1,63 @@
+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

@@ -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/server_config.rs

@@ -0,0 +1,283 @@
+//! 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};
+use spikard_http::{
+    ApiKeyConfig, CompressionConfig, ContactInfo, 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 = HashMap::new();
+
+        Some(OpenApiConfig {
+            enabled,
+            title,
+            version,
+            description,
+            swagger_ui_path,
+            redoc_path,
+            openapi_json_path,
+            contact,
+            license,
+            servers,
+            security_schemes,
+        })
+    };
+
+    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(),
+        openapi,
+        lifecycle_hooks: None,
+        di_container: 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),
+    }
+}
+
+/// 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)
+}