spikard 0.12.0 → 0.15.2

data/lib/spikard/schema.rb

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

data/lib/spikard/sse.rb

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-module Spikard
-  # Represents a Server-Sent Event.
-  #
-  # @!attribute [rw] data
-  #   @return [Hash] Event data (will be JSON serialized)
-  # @!attribute [rw] event_type
-  #   @return [String, nil] Optional event type
-  # @!attribute [rw] id
-  #   @return [String, nil] Optional event ID for client reconnection support
-  # @!attribute [rw] retry_ms
-  #   @return [Integer, nil] Optional retry timeout in milliseconds
-  class SseEvent
-    attr_accessor :data, :event_type, :id, :retry_ms
-
-    # Create a new SSE event.
-    #
-    # @param data [Hash] Event data (will be JSON serialized)
-    # @param event_type [String, nil] Optional event type
-    # @param id [String, nil] Optional event ID for client reconnection support
-    # @param retry_ms [Integer, nil] Optional retry timeout in milliseconds
-    def initialize(data:, event_type: nil, id: nil, retry_ms: nil)
-      @data = data
-      @event_type = event_type
-      @id = id
-      @retry_ms = retry_ms
-    end
-
-    # Convert to hash for JSON serialization.
-    #
-    # @return [Hash] Hash representation of the event
-    def to_h
-      {
-        data: @data,
-        event_type: @event_type,
-        id: @id,
-        retry: @retry_ms
-      }.compact
-    end
-  end
-
-  # Base class for SSE event producers.
-  #
-  # Implement this class to generate Server-Sent Events.
-  #
-  # @example
-  #   class NotificationProducer < Spikard::SseEventProducer
-  #     def initialize
-  #       @count = 0
-  #     end
-  #
-  #     def next_event
-  #       sleep 1  # Wait 1 second between events
-  #
-  #       return nil if @count >= 10  # End stream after 10 events
-  #
-  #       event = Spikard::SseEvent.new(
-  #         data: { message: "Notification #{@count}" },
-  #         event_type: 'notification',
-  #         id: @count.to_s
-  #       )
-  #       @count += 1
-  #       event
-  #     end
-  #
-  #     def on_connect
-  #       puts "Client connected to SSE stream"
-  #     end
-  #
-  #     def on_disconnect
-  #       puts "Client disconnected from SSE stream"
-  #     end
-  #   end
-  #
-  #   app = Spikard::App.new
-  #
-  #   app.sse('/notifications') do
-  #     NotificationProducer.new
-  #   end
-  #
-  #   app.run
-  class SseEventProducer
-    # Generate the next event.
-    #
-    # This method is called repeatedly to produce the event stream.
-    #
-    # @return [SseEvent, nil] SseEvent when an event is ready, or nil to end the stream.
-    def next_event
-      raise NotImplementedError, "#{self.class.name} must implement #next_event"
-    end
-
-    # Called when a client connects to the SSE endpoint.
-    #
-    # Override this method to perform initialization when a client connects.
-    #
-    # @return [void]
-    def on_connect
-      # Optional hook - default implementation does nothing
-    end
-
-    # Called when a client disconnects from the SSE endpoint.
-    #
-    # Override this method to perform cleanup when a client disconnects.
-    #
-    # @return [void]
-    def on_disconnect
-      # Optional hook - default implementation does nothing
-    end
-  end
-end

data/lib/spikard/streaming_response.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module Spikard
-  # Represents a streaming HTTP response made of chunks produced lazily.
-  class StreamingResponse
-    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
-end