spikard 0.2.5 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 21d1d862d3d5601a97e14de7cd38ea5b8ae58e424e0ab0996c318e0d09347f40
-  data.tar.gz: 44393a37df38446867e34d079e732e4269b88e4b8b2f4fd71deb681a0994c97b
+  metadata.gz: c70da2d00ebf8c9d79e3ef9f0a76743f39c9a0ac5d13cf723f7f87920bf5d199
+  data.tar.gz: 1fdc0938e1974995cfb46d960c1d2e6d2266c64c81077a6c2d6a046e8d045f21
 SHA512:
-  metadata.gz: e053bd46853a7dfd4950b4273491435700d9308f04b412707e6f404d6c4ef3c9cb79a64a1686ffa313ce3cd65a7bcd6aebba78afb2c2cc193f3fb13bcfdd00f9
-  data.tar.gz: 2f80c651e36c0d6412e017525b074fc6f7d139fc84fb68691ab2e785803cb9d6ccbb3a5ca50cc85798b13bbd3da091520a3c28113ff20af1d0cc6c68ef34d965
+  metadata.gz: 05d3e4e7859dbab147d66c246ffae6e412df42ebc532b1a55c60ed25fa952d25a092e53458759e2b8f046539c08ffd17d7159d3b0ef72e1b79ae48d2cf3a0f45
+  data.tar.gz: bc6c6d79bdf8f709443a08642b27939534f15cb4faf842f7a3380acf1f85ae4b449dc653b233234cdad0ad83b7fe6a5e3b120d39d0d7a341035a18618707fb73

data/README.md

@@ -5,7 +5,7 @@
 [![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)
-[![CI Status](https://img.shields.io/github/actions/workflow/status/Goldziher/spikard/ci.yml?branch=main)](https://github.com/Goldziher/spikard/actions)
+[![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)
@@ -47,6 +47,39 @@ bundle exec rake ext:build
 - Bundler
 - Rust toolchain (for building from source)
 
+## Windows Development
+
+On Windows, Spikard uses the GNU toolchain (not MSVC) to match Ruby's official RubyInstaller distribution.
+
+### Prerequisites
+
+1. **Install RubyInstaller with DevKit:**
+   - Download from [RubyInstaller.org](https://rubyinstaller.org/downloads/)
+   - Choose Ruby+Devkit 3.2.x (x64)
+   - During installation, select "MSYS2 development toolchain"
+
+2. **Install Rust with GNU target:**
+   ```powershell
+   rustup toolchain install stable-x86_64-pc-windows-gnu
+   rustup default stable-x86_64-pc-windows-gnu
+   ```
+
+3. **Verify setup:**
+   ```powershell
+   ruby --version  # Should show 3.2.x
+   rustup show     # Should show *-pc-windows-gnu
+   ```
+
+### Building on Windows
+
+```bash
+cd packages/ruby
+bundle install
+bundle exec rake compile
+```
+
+The build uses the GNU toolchain automatically via RubyInstaller's MSYS2 DevKit. No MSVC configuration needed.
+
 ## Quick Start
 
 ```ruby

data/ext/spikard_rb/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "spikard-rb-ext"
-version = "0.2.5"
+version = "0.3.0"
 edition = "2024"
 license = "MIT"
 authors = ["Na'aman Hirschfeld <nhirschfeld@gmail.com>"]
@@ -13,5 +13,5 @@ crate-type = ["cdylib"]
 
 [dependencies]
 magnus = { git = "https://github.com/matsadler/magnus", rev = "f6db11769efb517427bf7f121f9c32e18b059b38", features = ["rb-sys"] }
-# Vendored workspace crates - created by rake vendor:sync before gem build
-spikard_rb_core = { package = "spikard-rb", path = "../../vendor/crates/spikard-rb" }
+# Use workspace crate directly (no vendoring for local builds/tests)
+spikard_rb_core = { package = "spikard-rb", path = "../../../../crates/spikard-rb" }

data/lib/spikard/app.rb

@@ -20,7 +20,7 @@ module Spikard
     #     request
     #   end
     def on_request(&hook)
-      @lifecycle_hooks[:on_request] << hook
+      native_hooks.add_on_request(hook)
       hook
     end
 
@@ -42,7 +42,7 @@ module Spikard
     #     end
     #   end
     def pre_validation(&hook)
-      @lifecycle_hooks[:pre_validation] << hook
+      native_hooks.add_pre_validation(hook)
       hook
     end
 
@@ -64,7 +64,7 @@ module Spikard
     #     end
     #   end
     def pre_handler(&hook)
-      @lifecycle_hooks[:pre_handler] << hook
+      native_hooks.add_pre_handler(hook)
       hook
     end
 
@@ -81,7 +81,7 @@ module Spikard
     #     response
     #   end
     def on_response(&hook)
-      @lifecycle_hooks[:on_response] << hook
+      native_hooks.add_on_response(hook)
       hook
     end
 
@@ -98,21 +98,16 @@ module Spikard
     #     response
     #   end
     def on_error(&hook)
-      @lifecycle_hooks[:on_error] << hook
+      native_hooks.add_on_error(hook)
       hook
     end
 
-    # Get all registered lifecycle hooks
-    #
-    # @return [Hash] Dictionary of hook arrays by type
-    def lifecycle_hooks
-      {
-        on_request: @lifecycle_hooks[:on_request].dup,
-        pre_validation: @lifecycle_hooks[:pre_validation].dup,
-        pre_handler: @lifecycle_hooks[:pre_handler].dup,
-        on_response: @lifecycle_hooks[:on_response].dup,
-        on_error: @lifecycle_hooks[:on_error].dup
-      }
+    private
+
+    def native_hooks
+      raise 'Spikard native lifecycle registry unavailable' unless defined?(@native_hooks) && @native_hooks
+
+      @native_hooks
     end
   end
 
@@ -123,7 +118,8 @@ module Spikard
     include ProvideSupport
 
     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].freeze
+    SUPPORTED_OPTIONS = %i[request_schema response_schema parameter_schema file_params is_async cors
+                           body_param_name].freeze
 
     attr_reader :routes
 
@@ -131,28 +127,43 @@ module Spikard
       @routes = []
       @websocket_handlers = {}
       @sse_producers = {}
-      @dependencies = {}
-      @lifecycle_hooks = {
-        on_request: [],
-        pre_validation: [],
-        pre_handler: [],
-        on_response: [],
-        on_error: []
-      }
+      @native_hooks = Spikard::Native::LifecycleRegistry.new
+      @native_dependencies = Spikard::Native::DependencyRegistry.new
     end
 
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
     def register_route(method, path, handler_name: nil, **options, &block)
+      method = method.to_s
+      path = path.to_s
+      handler_name = handler_name&.to_s
       validate_route_arguments!(block, options)
-      handler_name ||= default_handler_name(method, path)
-
-      # Extract handler dependencies from block parameters
-      handler_dependencies = extract_handler_dependencies(block)
-
-      metadata = build_metadata(method, path, handler_name, options, handler_dependencies)
+      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
+                   )
+                 else
+                   handler_name ||= default_handler_name(method, path)
+
+                   # Extract handler dependencies from block parameters
+                   handler_dependencies = extract_handler_dependencies(block)
+
+                   build_metadata(method, path, handler_name, options, handler_dependencies)
+                 end
 
       @routes << RouteEntry.new(metadata, block)
       block
     end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
     HTTP_METHODS.each do |verb|
       define_method(verb.downcase) do |path, handler_name: nil, **options, &block|
@@ -161,17 +172,7 @@ module Spikard
     end
 
     def route_metadata
-      # Extract handler dependencies when metadata is requested
-      # This allows dependencies to be registered after routes
-      @routes.map do |entry|
-        metadata = entry.metadata.dup
-
-        # Re-extract dependencies in case they were registered after the route
-        handler_dependencies = extract_handler_dependencies(entry.handler)
-        metadata[:handler_dependencies] = handler_dependencies unless handler_dependencies.empty?
-
-        metadata
-      end
+      @routes.map(&:metadata)
     end
 
     def handler_map
@@ -184,8 +185,20 @@ module Spikard
       map
     end
 
+    def normalized_routes_json
+      json = JSON.generate(route_metadata)
+      if defined?(Spikard::Native) && Spikard::Native.respond_to?(:normalize_route_metadata)
+        Spikard::Native.normalize_route_metadata(json)
+      else
+        json
+      end
+    end
+
     def default_handler_name(method, path)
-      normalized_path = path.gsub(/[^a-zA-Z0-9]+/, '_').gsub(/__+/, '_').sub(/^_+|_+$/, '')
+      normalized_path = path.gsub(/[^a-zA-Z0-9]+/, '_').gsub(/__+/, '_')
+      # ReDoS mitigation: use bounded quantifier {1,100} instead of + to prevent
+      # polynomial time complexity with excessive trailing underscores
+      normalized_path = normalized_path.sub(/^_{1,100}/, '').sub(/_{1,100}$/, '')
       normalized_path = 'root' if normalized_path.empty?
       "#{method.to_s.downcase}_#{normalized_path}"
     end
@@ -258,7 +271,7 @@ module Spikard
     #
     # @example Backward compatible (deprecated)
     #   app.run(host: '0.0.0.0', port: 8000)
-    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    # rubocop:disable Metrics/MethodLength
     def run(config: nil, host: nil, port: nil)
       require 'json'
 
@@ -274,21 +287,20 @@ module Spikard
         config = ServerConfig.new(**config)
       end
 
-      # Convert route metadata to JSON
-      routes_json = JSON.generate(route_metadata)
+      routes_json = normalized_routes_json
 
       # Get handler map
       handlers = handler_map
 
       # Get lifecycle hooks
-      hooks = lifecycle_hooks
+      hooks = @native_hooks
 
       # Get WebSocket handlers and SSE producers
       ws_handlers = websocket_handlers
       sse_prods = sse_producers
 
       # Get dependencies for DI
-      deps = dependencies
+      deps = @native_dependencies
 
       # Call the Rust extension's run_server function
       Spikard::Native.run_server(routes_json, handlers, config, hooks, ws_handlers, sse_prods, deps)
@@ -299,7 +311,7 @@ module Spikard
       raise 'Failed to load Spikard extension. ' \
             "Build it with: task build:ruby\n#{e.message}"
     end
-    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+    # rubocop:enable Metrics/MethodLength
 
     private
 

data/lib/spikard/converters.rb

@@ -1,85 +1,13 @@
 # frozen_string_literal: true
 
-require_relative 'upload_file'
-
 module Spikard
-  # Type conversion utilities for handler parameters
-  #
-  # This module handles converting validated JSON data from Rust into Ruby types,
-  # particularly for UploadFile instances.
+  # Conversion helpers between native Rust values and Ruby types.
   module Converters
     module_function
 
-    # Check if a value looks like file metadata from Rust
-    #
-    # @param value [Object] Value to check
-    # @return [Boolean]
-    def file_metadata?(value)
-      value.is_a?(Hash) && value.key?('filename') && value.key?('content')
-    end
-
-    # Convert file metadata hash to UploadFile instance
-    #
-    # @param file_data [Hash] File metadata from Rust (filename, content, size, content_type)
-    # @return [UploadFile] UploadFile instance
-    def convert_file_metadata_to_upload_file(file_data)
-      UploadFile.new(
-        file_data['filename'],
-        file_data['content'],
-        content_type: file_data['content_type'],
-        size: file_data['size'],
-        headers: file_data['headers'],
-        content_encoding: file_data['content_encoding']
-      )
-    end
-
-    # Process handler parameters, converting file metadata to UploadFile instances
-    #
-    # This method recursively processes the body parameter, looking for file metadata
-    # structures and converting them to UploadFile instances.
-    #
-    # @param value [Object] The value to process (can be Hash, Array, or primitive)
-    # @return [Object] Processed value with UploadFile instances
-    def process_upload_file_fields(value)
-      # Handle nil
-      return value if value.nil?
-
-      # Handle primitives (String, Numeric, Boolean)
-      return value unless value.is_a?(Hash) || value.is_a?(Array)
-
-      # Handle arrays - recursively process each element
-      if value.is_a?(Array)
-        return value.map do |item|
-          # Check if this array item is file metadata
-          if file_metadata?(item)
-            convert_file_metadata_to_upload_file(item)
-          else
-            # Recursively process nested arrays/hashes
-            process_upload_file_fields(item)
-          end
-        end
-      end
-
-      # Handle hashes - check if it's file metadata first
-      return convert_file_metadata_to_upload_file(value) if file_metadata?(value)
-
-      # Otherwise, recursively process hash values
-      value.transform_values { |v| process_upload_file_fields(v) }
-    end
-
-    # Process handler body parameter, handling UploadFile conversion
-    #
-    # This is the main entry point for converting Rust-provided request data
-    # into Ruby types. It handles:
-    # - Single UploadFile
-    # - Arrays of UploadFile
-    # - Hashes with UploadFile fields
-    # - Nested structures
-    #
-    # @param body [Object] The body parameter from Rust (already JSON-parsed)
-    # @return [Object] Processed body with UploadFile instances
+    # No-op conversion now that Rust materialises UploadFile.
     def convert_handler_body(body)
-      process_upload_file_fields(body)
+      body
     end
   end
 end

data/lib/spikard/handler_wrapper.rb

@@ -3,10 +3,10 @@
 require_relative 'converters'
 
 module Spikard
-  # Handler wrapper utilities for automatic file metadata conversion
+  # Handler wrapper utilities.
   #
-  # Provides ergonomic handler patterns that automatically convert
-  # file metadata to UploadFile instances, eliminating boilerplate.
+  # UploadFile conversion now happens in the Rust binding, so these wrappers
+  # simply forward the already-converted body/params.
   #
   # @example Basic usage with body only
   #   app.post('/upload', &wrap_body_handler do |body|
@@ -46,8 +46,7 @@ module Spikard
       # Return a proc that matches the signature expected by Spikard::App
       # The actual handler receives path params, query params, and body from Rust
       lambda do |_params, _query, body|
-        converted_body = Converters.convert_handler_body(body)
-        handler.call(converted_body)
+        handler.call(body)
       end
     end
 
@@ -74,8 +73,7 @@ module Spikard
       raise ArgumentError, 'block required for wrap_handler' unless handler
 
       lambda do |params, query, body|
-        converted_body = Converters.convert_handler_body(body)
-        handler.call(params, query, converted_body)
+        handler.call(params, query, body)
       end
     end
 
@@ -103,11 +101,10 @@ module Spikard
       raise ArgumentError, 'block required for wrap_handler_with_context' unless handler
 
       lambda do |params, query, body|
-        converted_body = Converters.convert_handler_body(body)
         context = {
           params: params,
           query: query,
-          body: converted_body
+          body: body
         }
         handler.call(context)
       end

data/lib/spikard/provide.rb

@@ -107,53 +107,39 @@ module Spikard
     #
     # @example Using Provide wrapper
     #   app.provide("db", Spikard::Provide.new(method("create_db"), cacheable: true))
-    # rubocop:disable Metrics/MethodLength
     def provide(key, value = nil, depends_on: [], singleton: false, cacheable: true, &block)
       key_str = key.to_s
-      @dependencies ||= {}
+      registry = ensure_native_dependencies!
 
       # Handle Provide wrapper instances
       if value.is_a?(Provide)
-        provider = value
-        @dependencies[key_str] = {
-          type: :factory,
-          factory: provider.factory,
-          depends_on: provider.depends_on,
-          singleton: provider.singleton,
-          cacheable: provider.cacheable
-        }
+        registry.register_factory(key_str, value.factory, value.depends_on, value.singleton, value.cacheable)
       elsif block
-        # Factory dependency (block form)
-        @dependencies[key_str] = {
-          type: :factory,
-          factory: block,
-          depends_on: Array(depends_on).map(&:to_s),
-          singleton: singleton,
-          cacheable: cacheable
-        }
+        registry.register_factory(key_str, block, Array(depends_on).map(&:to_s), singleton, cacheable)
       else
-        # Value dependency
         raise ArgumentError, 'Either provide a value or a block, not both' if value.nil?
 
-        @dependencies[key_str] = {
-          type: :value,
-          value: value,
-          singleton: true, # Values are always singleton
-          cacheable: true
-        }
+        registry.register_value(key_str, value)
       end
 
       self
     end
-    # rubocop:enable Metrics/MethodLength
 
     # Get all registered dependencies
     #
     # @return [Hash] Dictionary mapping dependency keys to their definitions
     # @api private
     def dependencies
-      @dependencies ||= {}
-      @dependencies.dup
+      ensure_native_dependencies!
+    end
+
+    private
+
+    def ensure_native_dependencies!
+      registry = (@native_dependencies if instance_variable_defined?(:@native_dependencies) && @native_dependencies)
+      raise 'Spikard native dependency registry unavailable' unless registry
+
+      registry
     end
   end
 

data/lib/spikard/response.rb

@@ -1,18 +1,16 @@
 # frozen_string_literal: true
 
+# ⚠️ GENERATED BY crates/spikard-rb/build.rs — DO NOT EDIT BY HAND
 module Spikard
-  # Response object returned from route handlers.
-  # Mirrors the Python/Node response helpers so the native layer
-  # can extract status, headers, and JSON-serialisable content.
-  class Response
-    attr_accessor :content
-    attr_reader :status_code, :headers
+  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
-      self.status_code = status_code
-      self.headers = headers
+      @status_code = Integer(status_code || 200)
+      @headers = normalize_headers(headers)
       set_header('content-type', content_type) if content_type
+      rebuild_native!
     end
 
     def status
@@ -21,16 +19,24 @@ module Spikard
 
     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)
@@ -40,8 +46,27 @@ module Spikard
       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])}",
@@ -59,7 +84,7 @@ module Spikard
         {}
       when Hash
         value.each_with_object({}) do |(key, val), acc|
-          acc[key.to_s] = val.to_s
+          acc[key.to_s.downcase] = val.to_s
         end
       else
         raise ArgumentError, 'headers must be a Hash'
@@ -67,9 +92,48 @@ module Spikard
     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
-    # Lightweight wrapper around native response hashes.
-    class Response
+    class Response # :nodoc: Lightweight response wrapper used by the test client.
       attr_reader :status_code, :headers, :body
 
       def initialize(payload)

data/lib/spikard/streaming_response.rb

@@ -3,7 +3,7 @@
 module Spikard
   # Represents a streaming HTTP response made of chunks produced lazily.
   class StreamingResponse
-    attr_reader :stream, :status_code, :headers
+    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)
@@ -16,6 +16,29 @@ module Spikard
       @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
 end

data/lib/spikard/testing.rb

@@ -20,7 +20,7 @@ module Spikard
       # Use default config if none provided
       config ||= Spikard::ServerConfig.new
 
-      routes_json = JSON.generate(app.route_metadata)
+      routes_json = app.normalized_routes_json
       handlers = app.handler_map.transform_keys(&:to_sym)
       ws_handlers = app.websocket_handlers || {}
       sse_producers = app.sse_producers || {}