spikard 0.3.6 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f5fecf669ec67e8c861f1109e55d813f3daf43cb09596cee0f9ac0ee56514c5a
-  data.tar.gz: a3ffe8c8013a24dbaa4ba89310ec1ea0a0aec97eb2b7d95d2bfa392eb86e65fc
+  metadata.gz: ab9d6a7c6017e06cb3fcc9eb7396ae3771e8e4176907d0d3a5b5af0597823310
+  data.tar.gz: e37b6cb0b218622a2abbfdb58f2a20c1bfa50cea53af005e5802573bdfe51f52
 SHA512:
-  metadata.gz: b3d38a4d2da68aaa53953927f6c7c450abea613e8a24d68a866d9f8dcbd4a15ad28141cb5852728aea75fa5b8f50ca729529d399868924f1f33a3357cf7545a3
-  data.tar.gz: 327c499797f33123a98b4f096a8847dd63f99ff7c4d729ddb0afd6b1d2ea617b3f431dff899b61aa54cb4eb833c512bebf5535f214df23e06da2ab4c6c09189a
+  metadata.gz: 5af5495f8b41a896fbc792914b319902f61ec1807db95e648bd41afa141f6a0021ca899311bf4d4d8fd17217911ed05f77e3238e756a4a332814382d259fa944
+  data.tar.gz: 9664886689994eee085ef08e03a345e598d8529de7a6df27b96dd8626923c6f5bbff442b14730747e9ca11d4bdf9a525b77a83a762b8d004ba60ae18425b259d

data/README.md

@@ -4,12 +4,8 @@
 [![Gem Version](https://img.shields.io/gem/v/spikard.svg)](https://rubygems.org/gems/spikard)
 [![Gem Downloads](https://img.shields.io/gem/dt/spikard.svg)](https://rubygems.org/gems/spikard)
 [![Ruby Version](https://img.shields.io/badge/ruby-%3E%3D%203.2-red.svg)](https://www.ruby-lang.org/)
-[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 [![codecov](https://codecov.io/gh/Goldziher/spikard/graph/badge.svg?token=H4ZXDZ4A69)](https://codecov.io/gh/Goldziher/spikard)
-[![PyPI](https://img.shields.io/pypi/v/spikard.svg)](https://pypi.org/project/spikard/)
-[![npm](https://img.shields.io/npm/v/spikard.svg)](https://www.npmjs.com/package/spikard)
-[![Crates.io](https://img.shields.io/crates/v/spikard.svg)](https://crates.io/crates/spikard)
-[![Packagist](https://img.shields.io/packagist/v/spikard/spikard.svg)](https://packagist.org/packages/spikard/spikard)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 
 High-performance Ruby web framework with a Rust core. Build REST APIs with Sinatra-style routing and zero-overhead async handlers backed by Axum and Tower-HTTP.
 
@@ -245,7 +241,7 @@ app.provide("db_pool", depends_on: ["config"], singleton: true) do |config:|
   { url: config["db_url"], driver: "pool" }
 end
 
-app.get "/stats" do |_params, _query, _body, config:, db_pool:|
+app.get "/stats" do |request, config:, db_pool:|
   { db: db_pool[:url], env: config["db_url"] }
 end
 ```
@@ -617,6 +613,25 @@ Ruby bindings use:
 - Idiomatic Ruby blocks and procs
 - GC-safe handler storage
 
+### CI Benchmarks (2025-12-20)
+
+Run: `snapshots/benchmarks/20397054933` (commit `25e4fdf`, oha, 50 concurrency, 10s, Linux x86_64).
+
+| Metric | Value |
+| --- | --- |
+| Avg RPS (all workloads) | 8,271 |
+| Avg latency (ms) | 6.50 |
+
+Category breakdown:
+
+| Category | Avg RPS | Avg latency (ms) |
+| --- | --- | --- |
+| path-params | 9,591 | 5.22 |
+| json-bodies | 8,648 | 5.78 |
+| forms | 7,989 | 6.27 |
+| query-params | 7,984 | 6.33 |
+| multipart | 5,604 | 10.36 |
+
 ## Examples
 
 The [examples directory](../../examples/) contains comprehensive demonstrations:

data/ext/spikard_rb/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "spikard-rb-ext"
-version = "0.3.6"
+version = "0.5.0"
 edition = "2024"
 license = "MIT"
 authors = ["Na'aman Hirschfeld <nhirschfeld@gmail.com>"]
@@ -12,6 +12,6 @@ crate-type = ["cdylib"]
 [workspace]
 
 [dependencies]
-magnus = { git = "https://github.com/matsadler/magnus", rev = "f6db11769efb517427bf7f121f9c32e18b059b38", features = ["rb-sys"] }
+magnus = { version = "0.8.2", features = ["rb-sys"] }
 # Use vendored crates for packaged gem distribution
 spikard_rb_core = { package = "spikard-rb", path = "../../vendor/crates/spikard-rb" }

data/lib/spikard/app.rb

@@ -119,7 +119,7 @@ module Spikard
 
     HTTP_METHODS = %w[GET POST PUT PATCH DELETE OPTIONS HEAD TRACE].freeze
     SUPPORTED_OPTIONS = %i[request_schema response_schema parameter_schema file_params is_async cors
-                           body_param_name].freeze
+                           body_param_name jsonrpc_method].freeze
 
     attr_reader :routes
 
@@ -138,19 +138,38 @@ module Spikard
       handler_name = handler_name&.to_s
       validate_route_arguments!(block, options)
       metadata = if defined?(Spikard::Native) && Spikard::Native.respond_to?(:build_route_metadata)
-                   Spikard::Native.build_route_metadata(
-                     method,
-                     path,
-                     handler_name,
-                     options[:request_schema],
-                     options[:response_schema],
-                     options[:parameter_schema],
-                     options[:file_params],
-                     options.fetch(:is_async, false),
-                     options[:cors],
-                     options[:body_param_name]&.to_s,
-                     block
-                   )
+                   begin
+                     Spikard::Native.build_route_metadata(
+                       method,
+                       path,
+                       handler_name,
+                       options[:request_schema],
+                       options[:response_schema],
+                       options[:parameter_schema],
+                       options[:file_params],
+                       options.fetch(:is_async, false),
+                       options[:cors],
+                       options[:body_param_name]&.to_s,
+                       options[:jsonrpc_method],
+                       block
+                     )
+                   rescue ArgumentError => e
+                     raise unless e.message.include?('wrong number of arguments')
+
+                     Spikard::Native.build_route_metadata(
+                       method,
+                       path,
+                       handler_name,
+                       options[:request_schema],
+                       options[:response_schema],
+                       options[:parameter_schema],
+                       options[:file_params],
+                       options.fetch(:is_async, false),
+                       options[:cors],
+                       options[:body_param_name]&.to_s,
+                       block
+                     )
+                   end
                  else
                    handler_name ||= default_handler_name(method, path)
 

data/lib/spikard/testing.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'json'
+require 'timeout'
 
 module Spikard
   # Testing helpers that wrap the native Ruby extension.
@@ -8,25 +9,37 @@ module Spikard
     module_function
 
     def create_test_client(app, config: nil)
-      unless defined?(Spikard::Native::TestClient)
-        raise LoadError, 'Spikard native test client is not available. Build the native extension before running tests.'
-      end
+      trace('create_test_client:start')
+      ensure_native_test_client!
+      config = resolve_test_config(app, config)
+      native = build_native_test_client(app, config)
+      trace('create_test_client:done')
+      TestClient.new(native)
+    end
 
-      # Allow generated apps to stash a test config
-      if config.nil? && app.instance_variable_defined?(:@__spikard_test_config)
-        config = app.instance_variable_get(:@__spikard_test_config)
+    def ensure_native_test_client!
+      return if defined?(Spikard::Native::TestClient)
+
+      raise LoadError, 'Spikard native test client is not available. Build the native extension before running tests.'
+    end
+
+    def resolve_test_config(app, config)
+      return config if config
+
+      if app.instance_variable_defined?(:@__spikard_test_config)
+        return app.instance_variable_get(:@__spikard_test_config)
       end
 
-      # Use default config if none provided
-      config ||= Spikard::ServerConfig.new
+      Spikard::ServerConfig.new
+    end
 
+    def build_native_test_client(app, config)
       routes_json = app.normalized_routes_json
       handlers = app.handler_map.transform_keys(&:to_sym)
       ws_handlers = app.websocket_handlers || {}
       sse_producers = app.sse_producers || {}
       dependencies = app.dependencies || {}
-      native = Spikard::Native::TestClient.new(routes_json, handlers, config, ws_handlers, sse_producers, dependencies)
-      TestClient.new(native)
+      Spikard::Native::TestClient.new(routes_json, handlers, config, ws_handlers, sse_producers, dependencies)
     end
 
     # High level wrapper around the native test client.
@@ -50,7 +63,9 @@ module Spikard
       end
 
       def websocket(path)
+        Testing.trace("websocket:start #{path}")
         native_ws = @native.websocket(path)
+        Testing.trace("websocket:connected #{path}")
         WebSocketTestConnection.new(native_ws)
       end
 
@@ -77,22 +92,26 @@ module Spikard
       end
 
       def send_text(text)
+        Testing.trace('websocket:send_text')
         @native_ws.send_text(JSON.generate(text))
       end
 
       def send_json(obj)
+        Testing.trace('websocket:send_json')
         @native_ws.send_json(obj)
       end
 
       def receive_text
-        raw = @native_ws.receive_text
+        Testing.trace('websocket:receive_text')
+        raw = with_timeout { @native_ws.receive_text }
         JSON.parse(raw)
       rescue JSON::ParserError
         raw
       end
 
       def receive_json
-        @native_ws.receive_json
+        Testing.trace('websocket:receive_json')
+        with_timeout { @native_ws.receive_json }
       end
 
       def receive_bytes
@@ -105,8 +124,18 @@ module Spikard
       end
 
       def close
+        Testing.trace('websocket:close')
         @native_ws.close
       end
+
+      private
+
+      def with_timeout(&)
+        timeout_ms = ENV.fetch('SPIKARD_RB_TEST_TIMEOUT_MS', nil)
+        return yield unless timeout_ms
+
+        Timeout.timeout(timeout_ms.to_f / 1000.0, &)
+      end
     end
 
     # WebSocket message wrapper
@@ -217,5 +246,11 @@ module Spikard
         JSON.parse(@data)
       end
     end
+
+    def trace(message)
+      return unless ENV['SPIKARD_RB_TEST_TRACE'] == '1'
+
+      warn("[spikard-rb-test] #{message}")
+    end
   end
 end

data/lib/spikard/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Spikard
-  VERSION = '0.3.6'
+  VERSION = '0.5.0'
 end

data/vendor/crates/spikard-bindings-shared/Cargo.toml

@@ -0,0 +1,63 @@
+[package]
+name = "spikard-bindings-shared"
+version = "0.5.0"
+edition = "2024"
+authors = ["Na'aman Hirschfeld <nhirschfeld@gmail.com>"]
+license = "MIT"
+repository = "https://github.com/Goldziher/spikard"
+homepage = "https://github.com/Goldziher/spikard"
+
+[dependencies]
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+axum = { version = "0.8", features = ["multipart", "ws"] }
+tokio = { version = "1", features = ["full"] }
+thiserror = "2.0"
+spikard-core = { path = "../spikard-core", features = ["di"] }
+spikard-http = { path = "../spikard-http", features = ["di"] }
+tracing = "0.1"
+http = "1.4"
+http-body-util = "0.1"
+
+[features]
+default = []
+python-support = ["pyo3", "pyo3-async-runtimes"]
+node-support = ["napi", "napi-derive"]
+ruby-support = ["magnus"]
+php-support = ["ext-php-rs"]
+wasm-support = ["wasm-bindgen"]
+
+[dependencies.pyo3]
+version = "0.27"
+optional = true
+features = ["abi3-py310"]
+
+[dependencies.pyo3-async-runtimes]
+version = "0.27"
+optional = true
+features = ["tokio-runtime"]
+
+[dependencies.napi]
+version = "3"
+optional = true
+default-features = false
+features = ["napi9", "async"]
+
+[dependencies.napi-derive]
+version = "3"
+optional = true
+
+[dependencies.magnus]
+version = "0.8.2"
+optional = true
+
+[dependencies.ext-php-rs]
+version = "0.15"
+optional = true
+
+[dependencies.wasm-bindgen]
+version = "0.2"
+optional = true
+
+[dev-dependencies]
+pretty_assertions = "1.4"

data/vendor/crates/spikard-bindings-shared/examples/config_extraction.rs

@@ -0,0 +1,132 @@
+//! Example of implementing ConfigSource for a language binding
+//!
+//! This example demonstrates how a language binding (e.g., Python, Node.js, Ruby, PHP)
+//! would implement the `ConfigSource` trait to extract ServerConfig from language-specific objects.
+
+use spikard_bindings_shared::{ConfigExtractor, ConfigSource};
+use std::collections::HashMap;
+
+/// Example: PyO3 Python dict wrapper
+struct PyDictWrapper {
+    data: HashMap<String, String>,
+}
+
+impl PyDictWrapper {
+    fn new() -> Self {
+        Self { data: HashMap::new() }
+    }
+
+    fn insert(&mut self, key: &str, value: &str) {
+        self.data.insert(key.to_string(), value.to_string());
+    }
+}
+
+impl ConfigSource for PyDictWrapper {
+    fn get_bool(&self, key: &str) -> Option<bool> {
+        self.data.get(key).and_then(|v| match v.as_str() {
+            "true" | "True" => Some(true),
+            "false" | "False" => Some(false),
+            _ => v.parse().ok(),
+        })
+    }
+
+    fn get_u64(&self, key: &str) -> Option<u64> {
+        self.data.get(key).and_then(|v| v.parse().ok())
+    }
+
+    fn get_u16(&self, key: &str) -> Option<u16> {
+        self.data.get(key).and_then(|v| v.parse().ok())
+    }
+
+    fn get_string(&self, key: &str) -> Option<String> {
+        self.data.get(key).cloned()
+    }
+
+    fn get_vec_string(&self, key: &str) -> Option<Vec<String>> {
+        self.data
+            .get(key)
+            .map(|s| s.split(',').map(|item| item.trim().to_string()).collect())
+    }
+
+    fn get_nested(&self, _key: &str) -> Option<Box<dyn ConfigSource + '_>> {
+        None
+    }
+
+    fn has_key(&self, key: &str) -> bool {
+        self.data.contains_key(key)
+    }
+}
+
+fn main() {
+    println!("=== ConfigExtractor Example ===\n");
+
+    println!("1. Extracting compression configuration:");
+    let mut compression_config = PyDictWrapper::new();
+    compression_config.insert("gzip", "true");
+    compression_config.insert("brotli", "true");
+    compression_config.insert("min_size", "2048");
+    compression_config.insert("quality", "9");
+
+    match ConfigExtractor::extract_compression_config(&compression_config) {
+        Ok(config) => {
+            println!("   gzip: {}", config.gzip);
+            println!("   brotli: {}", config.brotli);
+            println!("   min_size: {}", config.min_size);
+            println!("   quality: {}\n", config.quality);
+        }
+        Err(e) => println!("   Error: {}\n", e),
+    }
+
+    println!("2. Extracting JWT authentication configuration:");
+    let mut jwt_config = PyDictWrapper::new();
+    jwt_config.insert("secret", "my-secret-key");
+    jwt_config.insert("algorithm", "HS256");
+    jwt_config.insert("leeway", "60");
+
+    match ConfigExtractor::extract_jwt_config(&jwt_config) {
+        Ok(config) => {
+            println!("   secret: [REDACTED]");
+            println!("   algorithm: {}", config.algorithm);
+            println!("   leeway: {}\n", config.leeway);
+        }
+        Err(e) => println!("   Error: {}\n", e),
+    }
+
+    println!("3. Extracting API Key authentication configuration:");
+    let mut api_key_config = PyDictWrapper::new();
+    api_key_config.insert("keys", "key1,key2,key3");
+    api_key_config.insert("header_name", "X-API-Key");
+
+    match ConfigExtractor::extract_api_key_config(&api_key_config) {
+        Ok(config) => {
+            println!("   keys: {:?}", config.keys);
+            println!("   header_name: {}\n", config.header_name);
+        }
+        Err(e) => println!("   Error: {}\n", e),
+    }
+
+    println!("4. Extracting rate limit configuration:");
+    let mut rate_limit_config = PyDictWrapper::new();
+    rate_limit_config.insert("per_second", "100");
+    rate_limit_config.insert("burst", "20");
+    rate_limit_config.insert("ip_based", "true");
+
+    match ConfigExtractor::extract_rate_limit_config(&rate_limit_config) {
+        Ok(config) => {
+            println!("   per_second: {}", config.per_second);
+            println!("   burst: {}", config.burst);
+            println!("   ip_based: {}\n", config.ip_based);
+        }
+        Err(e) => println!("   Error: {}\n", e),
+    }
+
+    println!("5. Testing error handling (missing 'burst' field):");
+    let rate_limit_config = PyDictWrapper::new();
+
+    match ConfigExtractor::extract_rate_limit_config(&rate_limit_config) {
+        Ok(_config) => println!("   Success (unexpected!)"),
+        Err(e) => println!("   Expected error: {}\n", e),
+    }
+
+    println!("=== Example Complete ===");
+}