spikard 0.4.0-x64-mingw-ucrt

data/lib/spikard/provide.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+module Spikard
+  # Wrapper class for dependency providers
+  #
+  # This class wraps factory functions and configuration for dependency injection.
+  # It provides a consistent API across Python, Node.js, and Ruby bindings.
+  #
+  # @example Factory with caching
+  #   app.provide("db", Spikard::Provide.new(method("create_db"), cacheable: true))
+  #
+  # @example Factory with dependencies
+  #   app.provide("auth", Spikard::Provide.new(
+  #     method("create_auth_service"),
+  #     depends_on: ["db", "cache"],
+  #     singleton: true
+  #   ))
+  class Provide
+    attr_reader :factory, :depends_on, :singleton, :cacheable
+
+    # Create a new dependency provider
+    #
+    # @param factory [Proc, Method] The factory function that creates the dependency value
+    # @param depends_on [Array<String, Symbol>] List of dependency keys this factory depends on
+    # @param singleton [Boolean] Whether to cache the value globally (default: false)
+    # @param cacheable [Boolean] Whether to cache the value per-request (default: true)
+    def initialize(factory, depends_on: [], singleton: false, cacheable: true)
+      @factory = factory
+      @depends_on = Array(depends_on).map(&:to_s)
+      @singleton = singleton
+      @cacheable = cacheable
+    end
+
+    # Check if the factory is async (based on method arity or other heuristics)
+    #
+    # @return [Boolean] True if the factory appears to be async
+    def async?
+      # Ruby doesn't have explicit async/await like Python/JS
+      # We could check if it returns a Thread or uses Fiber
+      false
+    end
+
+    # Check if the factory is an async generator
+    #
+    # @return [Boolean] True if the factory is an async generator
+    def async_generator?
+      false
+    end
+  end
+
+  # Dependency Injection support for Spikard applications
+  #
+  # Provides methods for registering and managing dependencies that can be
+  # automatically injected into route handlers.
+  #
+  # @example Registering a value dependency
+  #   app.provide("database_url", "postgresql://localhost/mydb")
+  #
+  # @example Registering a factory dependency
+  #   app.provide("db_pool", depends_on: ["database_url"]) do |database_url:|
+  #     ConnectionPool.new(database_url)
+  #   end
+  #
+  # @example Singleton dependency (shared across all requests)
+  #   app.provide("config", singleton: true) do
+  #     Config.load_from_file("config.yml")
+  #   end
+  #
+  # @example Using Provide wrapper
+  #   app.provide("db", Spikard::Provide.new(method("create_db"), cacheable: true))
+  module ProvideSupport
+    # Register a dependency in the DI container
+    #
+    # This method supports three patterns:
+    # 1. **Value dependency**: Pass a value directly (e.g., string, number, object)
+    # 2. **Factory dependency**: Pass a block that computes the value
+    # 3. **Provide wrapper**: Pass a Spikard::Provide instance
+    #
+    # @param key [String, Symbol] Unique identifier for the dependency
+    # @param value [Object, Provide, nil] Static value, Provide instance, or nil
+    # @param depends_on [Array<String, Symbol>] List of dependency keys this factory depends on
+    # @param singleton [Boolean] Whether to cache the value globally (default: false)
+    # @param cacheable [Boolean] Whether to cache the value per-request (default: true)
+    # @yield Optional factory block that receives dependencies as keyword arguments
+    # @yieldparam **deps [Hash] Resolved dependencies as keyword arguments
+    # @yieldreturn [Object] The computed dependency value
+    # @return [self] Returns self for method chaining
+    #
+    # @example Value dependency
+    #   app.provide("app_name", "MyApp")
+    #   app.provide("port", 8080)
+    #
+    # @example Factory with dependencies
+    #   app.provide("database", depends_on: ["config"]) do |config:|
+    #     Database.connect(config["db_url"])
+    #   end
+    #
+    # @example Singleton factory
+    #   app.provide("thread_pool", singleton: true) do
+    #     ThreadPool.new(size: 10)
+    #   end
+    #
+    # @example Non-cacheable factory (resolves every time)
+    #   app.provide("request_id", cacheable: false) do
+    #     SecureRandom.uuid
+    #   end
+    #
+    # @example Using Provide wrapper
+    #   app.provide("db", Spikard::Provide.new(method("create_db"), cacheable: true))
+    def provide(key, value = nil, depends_on: [], singleton: false, cacheable: true, &block)
+      key_str = key.to_s
+      registry = ensure_native_dependencies!
+
+      # Handle Provide wrapper instances
+      if value.is_a?(Provide)
+        registry.register_factory(key_str, value.factory, value.depends_on, value.singleton, value.cacheable)
+      elsif block
+        registry.register_factory(key_str, block, Array(depends_on).map(&:to_s), singleton, cacheable)
+      else
+        raise ArgumentError, 'Either provide a value or a block, not both' if value.nil?
+
+        registry.register_value(key_str, value)
+      end
+
+      self
+    end
+
+    # Get all registered dependencies
+    #
+    # @return [Hash] Dictionary mapping dependency keys to their definitions
+    # @api private
+    def dependencies
+      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
+
+  # Dependency injection handler wrapper
+  #
+  # Wraps a route handler to inject dependencies based on parameter names.
+  # Dependencies are resolved from the DI container and passed as keyword arguments.
+  #
+  # @api private
+  module DIHandlerWrapper
+    # Wrap a handler to inject dependencies
+    #
+    # @param handler [Proc] The original route handler
+    # @param dependencies [Hash] Available dependencies from the app
+    # @return [Proc] Wrapped handler with DI support
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    def self.wrap_handler(handler, dependencies)
+      # Extract parameter names from the handler
+      params = handler.parameters.map { |_type, name| name.to_s }
+
+      # Find which parameters match registered dependencies
+      injectable_params = params & dependencies.keys
+
+      if injectable_params.empty?
+        # No DI needed, return original handler
+        return handler
+      end
+
+      # Create wrapped handler that injects dependencies
+      lambda do |request|
+        # Build kwargs with injected dependencies
+        kwargs = {}
+
+        injectable_params.each do |param_name|
+          dep_def = dependencies[param_name]
+          kwargs[param_name.to_sym] = resolve_dependency(dep_def, request)
+        end
+
+        # Call original handler with injected dependencies
+        if handler.arity.zero?
+          # Handler takes no arguments (dependencies injected via closure or instance vars)
+          handler.call
+        elsif injectable_params.length == params.length
+          # All parameters are dependencies
+          handler.call(**kwargs)
+        else
+          # Mix of request data and dependencies
+          handler.call(request, **kwargs)
+        end
+      end
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+    # Resolve a dependency definition
+    #
+    # @param dep_def [Hash] Dependency definition
+    # @param request [Hash] Request context (unused for now, future: per-request deps)
+    # @return [Object] Resolved dependency value
+    # @api private
+    def self.resolve_dependency(dep_def, _request)
+      case dep_def[:type]
+      when :value
+        dep_def[:value]
+      when :factory
+        factory = dep_def[:factory]
+        dep_def[:depends_on]
+        # TODO: Implement nested dependency resolution when dependencies are provided
+        factory.call
+      end
+    end
+  end
+end

data/lib/spikard/response.rb

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

data/lib/spikard/schema.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/ModuleLength
+module Spikard
+  # Schema extraction helpers for Ruby type systems
+  #
+  # Supports:
+  # - Plain JSON Schema (Hash)
+  # - Dry::Schema with :json_schema extension
+  # - Dry::Struct (Dry-Types)
+  #
+  # @example With Dry::Schema
+  #   require 'dry-schema'
+  #   Dry::Schema.load_extensions(:json_schema)
+  #
+  #   UserSchema = Dry::Schema.JSON do
+  #     required(:email).filled(:str?)
+  #     required(:age).filled(:int?)
+  #   end
+  #
+  #   schema = Spikard::Schema.extract_json_schema(UserSchema)
+  #
+  # @example With Dry::Struct
+  #   require 'dry-struct'
+  #
+  #   class User < Dry::Struct
+  #     attribute :email, Types::String
+  #     attribute :age, Types::Integer
+  #   end
+  #
+  #   schema = Spikard::Schema.extract_json_schema(User)
+  #
+  # @example With plain JSON Schema
+  #   schema_hash = {
+  #     "type" => "object",
+  #     "properties" => {
+  #       "email" => { "type" => "string" },
+  #       "age" => { "type" => "integer" }
+  #     },
+  #     "required" => ["email", "age"]
+  #   }
+  #
+  #   schema = Spikard::Schema.extract_json_schema(schema_hash)
+  module Schema
+    # rubocop:disable Metrics/ClassLength
+    class << self
+      # Extract JSON Schema from various Ruby schema sources
+      #
+      # @param schema_source [Object] The schema source (Hash, Dry::Schema, Dry::Struct class)
+      # @return [Hash, nil] JSON Schema hash or nil if extraction fails
+      def extract_json_schema(schema_source)
+        return nil if schema_source.nil?
+
+        # 1. Check if plain JSON Schema hash
+        return schema_source if schema_source.is_a?(Hash) && json_schema_hash?(schema_source)
+
+        # 2. Check for Dry::Schema with json_schema extension
+        return extract_from_dry_schema(schema_source) if dry_schema?(schema_source)
+
+        # 3. Check for Dry::Struct (Dry-Types)
+        return extract_from_dry_struct(schema_source) if dry_struct_class?(schema_source)
+
+        # 4. Unknown type
+        warn "Spikard: Unable to extract JSON Schema from #{schema_source.class}. " \
+             'Supported types: Hash, Dry::Schema, Dry::Struct'
+        nil
+      end
+
+      private
+
+      # Check if object is a plain JSON Schema hash
+      def json_schema_hash?(obj)
+        return false unless obj.is_a?(Hash)
+
+        # Must have 'type' key or '$schema' key
+        obj.key?('type') || obj.key?('$schema') || obj.key?(:type) || obj.key?(:$schema)
+      end
+
+      # Check if object is a Dry::Schema
+      def dry_schema?(obj)
+        defined?(Dry::Schema::Processor) && obj.is_a?(Dry::Schema::Processor)
+      end
+
+      # Check if object is a Dry::Struct class
+      def dry_struct_class?(obj)
+        return false unless obj.is_a?(Class)
+
+        defined?(Dry::Struct) && obj < Dry::Struct
+      end
+
+      # Extract JSON Schema from Dry::Schema
+      def extract_from_dry_schema(schema)
+        unless schema.respond_to?(:json_schema)
+          warn 'Spikard: Dry::Schema instance does not have json_schema method. ' \
+               'Did you load the :json_schema extension? ' \
+               'Add: Dry::Schema.load_extensions(:json_schema)'
+          return nil
+        end
+
+        begin
+          schema.json_schema
+        rescue StandardError => e
+          warn "Spikard: Failed to extract JSON Schema from Dry::Schema: #{e.message}"
+          nil
+        end
+      end
+
+      # Extract JSON Schema from Dry::Struct class
+      # rubocop:disable Metrics/MethodLength
+      def extract_from_dry_struct(struct_class)
+        # Dry::Struct doesn't have built-in JSON Schema export
+        # We need to manually build it from the attribute schema
+
+        properties = {}
+        required = []
+
+        struct_class.schema.each do |key, type_definition|
+          # Extract attribute name
+          attr_name = key.to_s
+
+          # Determine if required (non-optional)
+          is_required = !type_definition.optional?
+          required << attr_name if is_required
+
+          # Convert Dry::Types to JSON Schema type
+          json_type = dry_type_to_json_schema(type_definition)
+          properties[attr_name] = json_type if json_type
+        end
+
+        {
+          'type' => 'object',
+          'properties' => properties,
+          'required' => required
+        }
+      rescue StandardError => e
+        warn "Spikard: Failed to extract JSON Schema from Dry::Struct: #{e.message}"
+        nil
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      # Convert Dry::Types type to JSON Schema type
+      def dry_type_to_json_schema(type_def)
+        schema = base_schema_for(type_def)
+        apply_metadata_constraints(schema, type_def)
+      rescue StandardError
+        { 'type' => 'object' }
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def base_schema_for(type_def)
+        type_class = type_def.primitive.to_s
+        case type_class
+        when 'String' then { 'type' => 'string' }
+        when 'Integer' then { 'type' => 'integer' }
+        when 'Float', 'BigDecimal' then { 'type' => 'number' }
+        when 'TrueClass', 'FalseClass' then { 'type' => 'boolean' }
+        when 'Array'
+          {
+            'type' => 'array',
+            'items' => infer_array_items_schema(type_def)
+          }
+        when 'Hash'
+          { 'type' => 'object', 'additionalProperties' => true }
+        when 'NilClass' then { 'type' => 'null' }
+        else
+          { 'type' => 'object' }
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def infer_array_items_schema(type_def)
+        if type_def.respond_to?(:member) && type_def.member
+          dry_type_to_json_schema(type_def.member)
+        else
+          {}
+        end
+      rescue StandardError
+        {}
+      end
+
+      def apply_metadata_constraints(schema, type_def)
+        metadata = extract_metadata(type_def)
+        return schema if metadata.empty?
+
+        schema = apply_enum_and_format(schema, metadata)
+        apply_numeric_constraints(schema, metadata)
+      end
+
+      def apply_enum_and_format(schema, metadata)
+        enum_values = metadata[:enum] || metadata['enum']
+        schema['enum'] = Array(enum_values) if enum_values
+
+        format_value = metadata[:format] || metadata['format']
+        schema['format'] = format_value.to_s if format_value
+
+        description = metadata[:description] || metadata['description']
+        schema['description'] = description.to_s if description
+        schema
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def apply_numeric_constraints(schema, metadata)
+        mapping = {
+          min_size: 'minLength',
+          max_size: 'maxLength',
+          min_items: 'minItems',
+          max_items: 'maxItems',
+          min: 'minimum',
+          max: 'maximum',
+          gte: 'minimum',
+          lte: 'maximum',
+          gt: 'exclusiveMinimum',
+          lt: 'exclusiveMaximum'
+        }
+
+        mapping.each do |meta_key, json_key|
+          value = metadata[meta_key] || metadata[meta_key.to_s]
+          next unless value
+
+          schema[json_key] = value
+        end
+        schema
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def extract_metadata(type_def)
+        return {} unless type_def.respond_to?(:meta) || type_def.respond_to?(:options)
+
+        if type_def.respond_to?(:meta) && type_def.meta
+          type_def.meta
+        elsif type_def.respond_to?(:options) && type_def.options.is_a?(Hash)
+          type_def.options
+        else
+          {}
+        end
+      rescue StandardError
+        {}
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end
+# rubocop:enable Metrics/ModuleLength