rapitapir 0.1.0

data/lib/rapitapir/types/float.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module RapiTapir
+  module Types
+    # Float type for validating floating-point numbers with range constraints
+    # Supports minimum, maximum, and multiple validation rules
+    class Float < Base
+      protected
+
+      def validate_type(value)
+        return [] if value.is_a?(::Float) || value.is_a?(::Integer)
+
+        ["Expected number (float or integer), got #{value.class}"]
+      end
+
+      def validate_constraints(value)
+        errors = []
+        float_value = value.to_f
+
+        errors.concat(validate_range_constraints(float_value))
+        errors.concat(validate_multiple_constraint(float_value))
+
+        errors
+      end
+
+      private
+
+      def validate_range_constraints(float_value)
+        errors = []
+
+        errors.concat(validate_minimum_constraints(float_value))
+        errors.concat(validate_maximum_constraints(float_value))
+
+        errors
+      end
+
+      def validate_minimum_constraints(float_value)
+        errors = []
+
+        if constraints[:minimum] && float_value < constraints[:minimum]
+          errors << "Value #{float_value} is below minimum #{constraints[:minimum]}"
+        end
+
+        if constraints[:exclusive_minimum] && float_value <= constraints[:exclusive_minimum]
+          errors << "Value #{float_value} must be greater than #{constraints[:exclusive_minimum]}"
+        end
+
+        errors
+      end
+
+      def validate_maximum_constraints(float_value)
+        errors = []
+
+        if constraints[:maximum] && float_value > constraints[:maximum]
+          errors << "Value #{float_value} exceeds maximum #{constraints[:maximum]}"
+        end
+
+        if constraints[:exclusive_maximum] && float_value >= constraints[:exclusive_maximum]
+          errors << "Value #{float_value} must be less than #{constraints[:exclusive_maximum]}"
+        end
+
+        errors
+      end
+
+      def validate_multiple_constraint(float_value)
+        errors = []
+
+        if constraints[:multiple_of] && (float_value % constraints[:multiple_of]) != 0
+          errors << "Value #{float_value} is not a multiple of #{constraints[:multiple_of]}"
+        end
+
+        errors
+      end
+
+      def coerce_value(value)
+        case value
+        when ::Float then value
+        when ::Integer then value.to_f
+        when ::String then coerce_string_to_float(value)
+        when true, false then coerce_boolean_to_float(value)
+        else
+          coerce_other_to_float(value)
+        end
+      rescue ArgumentError => e
+        raise CoercionError.new(value, 'Float', e.message)
+      end
+
+      def coerce_string_to_float(value)
+        Kernel.Float(value.strip)
+      end
+
+      def coerce_boolean_to_float(value)
+        value ? 1.0 : 0.0
+      end
+
+      def coerce_other_to_float(value)
+        raise CoercionError.new(value, 'Float', 'Value cannot be converted to float') unless value.respond_to?(:to_f)
+
+        value.to_f
+      end
+
+      def json_type
+        'number'
+      end
+
+      def apply_constraints_to_schema(schema)
+        super
+        apply_range_constraints_to_schema(schema)
+        apply_multiple_constraint_to_schema(schema)
+      end
+
+      def apply_range_constraints_to_schema(schema)
+        apply_minimum_constraints_to_schema(schema)
+        apply_maximum_constraints_to_schema(schema)
+      end
+
+      def apply_minimum_constraints_to_schema(schema)
+        schema[:minimum] = constraints[:minimum] if constraints[:minimum]
+        schema[:exclusiveMinimum] = constraints[:exclusive_minimum] if constraints[:exclusive_minimum]
+      end
+
+      def apply_maximum_constraints_to_schema(schema)
+        schema[:maximum] = constraints[:maximum] if constraints[:maximum]
+        schema[:exclusiveMaximum] = constraints[:exclusive_maximum] if constraints[:exclusive_maximum]
+      end
+
+      def apply_multiple_constraint_to_schema(schema)
+        schema[:multipleOf] = constraints[:multiple_of] if constraints[:multiple_of]
+      end
+    end
+  end
+end

data/lib/rapitapir/types/hash.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module RapiTapir
+  module Types
+    # Hash type for validating hash/object structures with schema definitions
+    # Validates hash keys and values according to defined schemas
+    class Hash < Base
+      attr_reader :field_types
+
+      def initialize(field_types = {}, additional_properties: true, **options)
+        @field_types = field_types.freeze
+        super(
+          additional_properties: additional_properties,
+          **options
+        )
+      end
+
+      protected
+
+      def validate_type(value)
+        return ["Expected hash/object, got #{value.class}"] unless value.is_a?(::Hash)
+
+        []
+      end
+
+      def validate_constraints(value)
+        errors = []
+
+        errors.concat(validate_defined_fields(value))
+        errors.concat(validate_additional_properties(value))
+
+        errors
+      end
+
+      def validate_defined_fields(value)
+        errors = []
+
+        field_types.each do |field_name, field_type|
+          field_value = extract_field_value(value, field_name)
+          field_result = field_type.validate(field_value)
+          next if field_result[:valid]
+
+          field_result[:errors].each do |error|
+            errors << "Field '#{field_name}': #{error}"
+          end
+        end
+
+        errors
+      end
+
+      def validate_additional_properties(value)
+        return [] if constraints[:additional_properties]
+
+        expected_keys = field_types.keys.map { |k| [k, k.to_s, k.to_sym] }.flatten.uniq
+        unexpected_keys = value.keys - expected_keys
+        return [] if unexpected_keys.empty?
+
+        ["Unexpected fields: #{unexpected_keys.join(', ')}"]
+      end
+
+      def extract_field_value(value, field_name)
+        value[field_name] || value[field_name.to_s] || value[field_name.to_sym]
+      end
+
+      def coerce_value(value)
+        case value
+        when ::Hash
+          coerce_hash_value(value)
+        when ::String
+          coerce_json_string_value(value)
+        else
+          raise CoercionError.new(value, 'Hash', 'Value cannot be converted to hash')
+        end
+      rescue JSON::ParserError => e
+        raise CoercionError.new(value, 'Hash', "Invalid JSON: #{e.message}")
+      end
+
+      private
+
+      def coerce_hash_value(value)
+        coerced = {}
+
+        # Coerce defined fields
+        coerce_defined_fields(value, coerced)
+
+        # Include additional properties if allowed
+        coerce_additional_properties(value, coerced) if constraints[:additional_properties]
+
+        coerced
+      end
+
+      def coerce_defined_fields(value, coerced)
+        field_types.each do |field_name, field_type|
+          field_value = find_field_value(value, field_name)
+          coerced[field_name] = field_type.coerce(field_value) if field_value || !field_type.optional?
+        end
+      end
+
+      def find_field_value(value, field_name)
+        value[field_name] || value[field_name.to_s] || value[field_name.to_sym]
+      end
+
+      def coerce_additional_properties(value, coerced)
+        additional_keys = value.keys - field_types.keys.map { |k| [k, k.to_s, k.to_sym] }.flatten
+        additional_keys.each do |key|
+          coerced[key] = value[key]
+        end
+      end
+
+      def coerce_json_string_value(value)
+        # Try to parse as JSON
+        require 'json'
+        parsed = JSON.parse(value)
+        raise CoercionError.new(value, 'Hash', 'JSON string did not parse to hash') unless parsed.is_a?(::Hash)
+
+        coerce_value(parsed)
+      end
+
+      def json_type
+        'object'
+      end
+
+      def apply_constraints_to_schema(schema)
+        super
+        apply_field_types_to_schema(schema)
+        apply_additional_properties_constraint(schema)
+      end
+
+      def apply_field_types_to_schema(schema)
+        return unless field_types.any?
+
+        schema[:properties] = build_properties_schema
+        required_fields = collect_required_fields
+        schema[:required] = required_fields unless required_fields.empty?
+      end
+
+      def build_properties_schema
+        field_types.transform_values(&:to_json_schema)
+      end
+
+      def collect_required_fields
+        field_types.reject { |_, field_type| field_type.optional? }.keys
+      end
+
+      def apply_additional_properties_constraint(schema)
+        schema[:additionalProperties] = constraints[:additional_properties]
+      end
+
+      def to_s
+        if field_types.empty?
+          'Hash'
+        else
+          field_strs = field_types.map { |k, v| "#{k}: #{v}" }
+          "Hash{#{field_strs.join(', ')}}"
+        end
+      end
+    end
+  end
+end

data/lib/rapitapir/types/integer.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module RapiTapir
+  module Types
+    # Integer type with numeric constraints
+    #
+    # Validates integer values with optional constraints for minimum/maximum values,
+    # exclusive bounds, and multiple-of validation.
+    #
+    # @example Basic integer
+    #   RapiTapir::Types.integer
+    #
+    # @example Integer with constraints
+    #   RapiTapir::Types.integer(minimum: 0, maximum: 100, multiple_of: 5)
+    class Integer < Base
+      protected
+
+      def validate_type(value)
+        return ["Expected integer, got #{value.class}"] unless value.is_a?(::Integer)
+
+        []
+      end
+
+      def validate_constraints(value)
+        errors = []
+
+        errors.concat(validate_range_constraints(value))
+        errors.concat(validate_multiple_constraint(value))
+
+        errors
+      end
+
+      private
+
+      def validate_range_constraints(value)
+        errors = []
+
+        errors.concat(validate_minimum_constraints(value))
+        errors.concat(validate_maximum_constraints(value))
+
+        errors
+      end
+
+      def validate_minimum_constraints(value)
+        errors = []
+
+        if constraints[:minimum] && value < constraints[:minimum]
+          errors << "Value #{value} is below minimum #{constraints[:minimum]}"
+        end
+
+        if constraints[:exclusive_minimum] && value <= constraints[:exclusive_minimum]
+          errors << "Value #{value} must be greater than #{constraints[:exclusive_minimum]}"
+        end
+
+        errors
+      end
+
+      def validate_maximum_constraints(value)
+        errors = []
+
+        if constraints[:maximum] && value > constraints[:maximum]
+          errors << "Value #{value} exceeds maximum #{constraints[:maximum]}"
+        end
+
+        if constraints[:exclusive_maximum] && value >= constraints[:exclusive_maximum]
+          errors << "Value #{value} must be less than #{constraints[:exclusive_maximum]}"
+        end
+
+        errors
+      end
+
+      def validate_multiple_constraint(value)
+        errors = []
+
+        if constraints[:multiple_of] && (value % constraints[:multiple_of]) != 0
+          errors << "Value #{value} is not a multiple of #{constraints[:multiple_of]}"
+        end
+
+        errors
+      end
+
+      def coerce_value(value)
+        case value
+        when ::Integer then value
+        when ::Float then value.to_i
+        when ::String then coerce_string_to_integer(value)
+        when true, false then coerce_boolean_to_integer(value)
+        else
+          coerce_other_to_integer(value)
+        end
+      rescue ArgumentError => e
+        raise CoercionError.new(value, 'Integer', e.message)
+      end
+
+      def coerce_string_to_integer(value)
+        Kernel.Integer(value.strip)
+      end
+
+      def coerce_boolean_to_integer(value)
+        value ? 1 : 0
+      end
+
+      def coerce_other_to_integer(value)
+        unless value.respond_to?(:to_i)
+          raise CoercionError.new(value, 'Integer', 'Value cannot be converted to integer')
+        end
+
+        value.to_i
+      end
+
+      def json_type
+        'integer'
+      end
+
+      def apply_constraints_to_schema(schema)
+        super
+        apply_range_constraints_to_schema(schema)
+        apply_multiple_constraint_to_schema(schema)
+      end
+
+      def apply_range_constraints_to_schema(schema)
+        apply_minimum_constraints(schema)
+        apply_maximum_constraints(schema)
+      end
+
+      def apply_minimum_constraints(schema)
+        schema[:minimum] = constraints[:minimum] if constraints[:minimum]
+        schema[:exclusiveMinimum] = constraints[:exclusive_minimum] if constraints[:exclusive_minimum]
+      end
+
+      def apply_maximum_constraints(schema)
+        schema[:maximum] = constraints[:maximum] if constraints[:maximum]
+        schema[:exclusiveMaximum] = constraints[:exclusive_maximum] if constraints[:exclusive_maximum]
+      end
+
+      def apply_multiple_constraint_to_schema(schema)
+        schema[:multipleOf] = constraints[:multiple_of] if constraints[:multiple_of]
+      end
+    end
+  end
+end

data/lib/rapitapir/types/object.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module RapiTapir
+  module Types
+    # Object type for validating complex object structures with typed properties
+    # Defines objects with named properties and their respective types
+    class Object < Base
+      attr_reader :fields
+
+      def initialize(**options, &block)
+        @fields = {}
+        super(**options)
+
+        return unless block_given?
+
+        builder = ObjectBuilder.new(self)
+        builder.instance_eval(&block)
+      end
+
+      def field(name, type, required: true, **options)
+        field_type = required ? type : ::RapiTapir::Types::Optional.new(type)
+        field_type = field_type.with_metadata(**options) if options.any?
+        @fields[name.to_sym] = field_type
+        self
+      end
+
+      def required_field(name, type, **options)
+        field(name, type, required: true, **options)
+      end
+
+      def optional_field(name, type, **options)
+        field(name, type, required: false, **options)
+      end
+
+      protected
+
+      def validate_type(value)
+        return ["Expected hash/object, got #{value.class}"] unless value.is_a?(::Hash)
+
+        []
+      end
+
+      def validate_constraints(value)
+        errors = []
+
+        # Validate each defined field
+        fields.each do |field_name, field_type|
+          field_value = extract_field_value(value, field_name)
+
+          field_result = field_type.validate(field_value)
+          next if field_result[:valid]
+
+          field_result[:errors].each do |error|
+            errors << "Field '#{field_name}': #{error}"
+          end
+        end
+
+        errors
+      end
+
+      def coerce_value(value)
+        case value
+        when ::Hash
+          coerce_hash_to_object(value)
+        when ::String
+          coerce_json_string_to_object(value)
+        else
+          raise CoercionError.new(value, 'Object', 'Value cannot be converted to object')
+        end
+      rescue JSON::ParserError => e
+        raise CoercionError.new(value, 'Object', "Invalid JSON: #{e.message}")
+      end
+
+      private
+
+      def coerce_hash_to_object(value)
+        coerced = {}
+
+        # Coerce each defined field
+        fields.each do |field_name, field_type|
+          field_value = extract_field_value(value, field_name)
+          coerced[field_name] = field_type.coerce(field_value) if field_value || !field_type.optional?
+        end
+
+        coerced
+      end
+
+      def coerce_json_string_to_object(value)
+        # Try to parse as JSON
+        require 'json'
+        parsed = JSON.parse(value)
+        raise CoercionError.new(value, 'Object', 'JSON string did not parse to object') unless parsed.is_a?(::Hash)
+
+        coerce_value(parsed)
+      end
+
+      def json_type
+        'object'
+      end
+
+      def apply_constraints_to_schema(schema)
+        super
+
+        if fields.any?
+          schema[:properties] = {}
+          required_fields = []
+
+          fields.each do |field_name, field_type|
+            schema[:properties][field_name] = field_type.to_json_schema
+            required_fields << field_name unless field_type.optional?
+          end
+
+          schema[:required] = required_fields unless required_fields.empty?
+        end
+
+        schema[:additionalProperties] = false # Objects are strict by default
+      end
+
+      def to_s
+        if fields.empty?
+          'Object'
+        else
+          field_strs = fields.map { |name, type| "#{name}: #{type}" }
+          "Object{#{field_strs.join(', ')}}"
+        end
+      end
+
+      def extract_field_value(hash, field_name)
+        # Try different key formats: symbol, string, and string version of symbol
+        hash[field_name] || hash[field_name.to_s] || hash[field_name.to_sym]
+      end
+
+      # Builder for constructing Object type definitions
+      # Provides a fluent interface for defining object properties
+      class ObjectBuilder
+        def initialize(object_type)
+          @object_type = object_type
+        end
+
+        def field(name, type, required: true, **options)
+          @object_type.field(name, type, required: required, **options)
+        end
+
+        def required_field(name, type, **options)
+          @object_type.required_field(name, type, **options)
+        end
+
+        def optional_field(name, type, **options)
+          @object_type.optional_field(name, type, **options)
+        end
+      end
+    end
+  end
+end

data/lib/rapitapir/types/optional.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module RapiTapir
+  module Types
+    # Optional type wrapper for nullable values
+    # Wraps other types to allow nil values in addition to the wrapped type
+    class Optional < Base
+      attr_reader :wrapped_type
+
+      def initialize(wrapped_type)
+        @wrapped_type = wrapped_type
+        super(optional: true)
+      end
+
+      def validate(value)
+        # Optional types allow nil
+        return validation_result(true, []) if value.nil?
+
+        # Delegate to wrapped type
+        wrapped_type.validate(value)
+      end
+
+      def coerce(value)
+        return nil if value.nil?
+
+        wrapped_type.coerce(value)
+      end
+
+      def required?
+        false
+      end
+
+      def optional?
+        true
+      end
+
+      def to_json_schema
+        wrapped_type.to_json_schema
+        # Optional types are handled by not including them in the required array
+        # at the parent level, so we don't need to modify the schema here
+      end
+
+      def to_s
+        "Optional[#{wrapped_type}]"
+      end
+
+      def with_metadata(**meta)
+        # Delegate metadata to wrapped type but maintain Optional wrapper
+        Optional.new(wrapped_type.with_metadata(**meta))
+      end
+
+      private
+
+      def validation_result(valid, errors)
+        {
+          valid: valid,
+          errors: errors,
+          value_errors: errors.empty? ? [] : [ValidationError.new(nil, self, errors)]
+        }
+      end
+    end
+  end
+end