easy_talk 3.2.0 → 3.3.0

data/lib/easy_talk/validation_adapters/active_model_adapter.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require 'uri'
+require_relative 'active_model_schema_validation'
+require 'easy_talk/json_schema_equality'
 
 module EasyTalk
   module ValidationAdapters
@@ -24,42 +26,116 @@ module EasyTalk
     #   user.errors[:email] # => ["must be a valid email address"]
     #
     class ActiveModelAdapter < Base
+      # Helper class methods for tuple validation (defined at class level for use in validate blocks)
+      # Resolve a Sorbet type to a Ruby class for type checking
+      def self.resolve_tuple_type_class(type)
+        # Handle T.untyped - any value is valid
+        return :untyped if type.is_a?(T::Types::Untyped) || type == T.untyped
+
+        # Handle union types (T.any, T.nilable)
+        return type.types.flat_map { |t| resolve_tuple_type_class(t) } if type.is_a?(T::Types::Union)
+
+        if type.respond_to?(:raw_type)
+          type.raw_type
+        elsif type == T::Boolean
+          [TrueClass, FalseClass]
+        elsif type.is_a?(Class)
+          type
+        else
+          type
+        end
+      end
+
+      # Check if a value matches a type class (supports arrays for union types like Boolean)
+      def self.type_matches?(value, type_class)
+        # :untyped means any value is valid (from empty schema {} in JSON Schema)
+        return true if type_class == :untyped
+
+        if type_class.is_a?(Array)
+          type_class.any? { |tc| value.is_a?(tc) }
+        else
+          value.is_a?(type_class)
+        end
+      end
+
+      # Generate a human-readable type name for error messages
+      def self.type_name_for_error(type_class)
+        return 'unknown' if type_class.nil?
+
+        if type_class.is_a?(Array)
+          type_class.map { |tc| tc.respond_to?(:name) ? tc.name : tc.to_s }.join(' or ')
+        elsif type_class.respond_to?(:name) && type_class.name
+          type_class.name
+        else
+          type_class.to_s
+        end
+      end
+
+      # Regex-based format validators
+      REGEX_FORMAT_CONFIGS = {
+        'email' => { with: /\A[^@\s]+@[^@\s]+\.[^@\s]+\z/, message: 'must be a valid email address' },
+        'uuid' => { with: /\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i,
+                    message: 'must be a valid UUID' }
+      }.freeze
+
+      # Formats that require parsing validation (not just regex)
+      PARSING_FORMATS = %w[date date-time time uri url].freeze
+
+      # Build schema-level validations for object-level constraints.
+      # Delegates to ActiveModelSchemaValidation module.
+      #
+      # @param klass [Class] The model class to apply validations to
+      # @param schema [Hash] The full schema hash containing schema-level constraints
+      # @return [void]
+      def self.build_schema_validations(klass, schema)
+        ActiveModelSchemaValidation.apply(klass, schema)
+      end
+
       # Apply validations based on property type and constraints.
       #
       # @return [void]
       def apply_validations
-        # Determine if the type is boolean
-        type_class = get_type_class(@type)
-        is_boolean = type_class == [TrueClass, FalseClass] ||
-                     type_class == TrueClass ||
-                     type_class == FalseClass ||
-                     TypeIntrospection.boolean_type?(@type)
-
-        # Determine if the type is an array (empty arrays should be valid)
-        is_array = type_class == Array || @type.is_a?(T::Types::TypedArray)
-
-        # Skip presence validation for booleans, nilable types, and arrays
-        # (empty arrays are valid - use min_items constraint if you need non-empty)
-        apply_presence_validation unless optional? || is_boolean || nilable_type? || is_array
-
-        if nilable_type?
-          # For nilable types, get the inner type and apply validations to it
-          inner_type = extract_inner_type(@type)
-          apply_type_validations(inner_type)
-        else
-          apply_type_validations(@type)
-        end
+        context = build_validation_context
+
+        apply_presence_validation unless context.skip_presence_validation?
+        apply_array_presence_validation if context.array_requires_presence_validation?
+
+        apply_type_validations(context)
 
-        # Common validations for most types
         apply_enum_validation if @constraints[:enum]
         apply_const_validation if @constraints[:const]
       end
 
+      # Build ValidationContext with pre-computed values from the adapter
+      def build_validation_context
+        is_optional = optional?
+        is_nilable = nilable_type?(@type)
+        validation_type = is_nilable ? extract_inner_type(@type) : @type
+        validation_type ||= @type
+        type_class = get_type_class(validation_type)
+
+        ValidationContext.new(
+          klass: @klass,
+          property_name: @property_name.to_sym,
+          constraints: @constraints || {},
+          validation_type: validation_type,
+          type_class: type_class,
+          optional: is_optional,
+          nilable: is_nilable
+        )
+      end
+      private :build_validation_context
+
       private
 
       # Apply validations based on the type of the property
-      def apply_type_validations(type)
-        type_class = get_type_class(type)
+      def apply_type_validations(context)
+        if context.tuple_type?
+          apply_tuple_type_validations(context.validation_type)
+          return
+        end
+
+        type_class = context.type_class
 
         if type_class == String
           apply_string_validations
@@ -68,13 +144,11 @@ module EasyTalk
         elsif [Float, BigDecimal].include?(type_class)
           apply_number_validations
         elsif type_class == Array
-          apply_array_validations(type)
-        elsif type_class == [TrueClass,
-                             FalseClass] || [TrueClass,
-                                             FalseClass].include?(type_class) || TypeIntrospection.boolean_type?(type)
+          apply_array_validations(context.validation_type)
+        elsif context.boolean?
           apply_boolean_validations
-        elsif type_class.is_a?(Object) && type_class.include?(EasyTalk::Model)
-          apply_object_validations
+        elsif context.model_class
+          apply_object_validations(context.model_class)
         end
       end
 
@@ -89,15 +163,21 @@ module EasyTalk
         apply_format_validation(@constraints[:format]) if @constraints[:format]
 
         # Handle pattern (regex) constraints
-        if @constraints[:pattern]
-          @klass.validates @property_name, format: { with: Regexp.new(@constraints[:pattern]) },
-                                           allow_nil: optional?
-        end
+        apply_pattern_validation if @constraints[:pattern]
 
         # Handle length constraints
         apply_length_validations
       end
 
+      # Apply pattern validation (only for string values per JSON Schema spec)
+      def apply_pattern_validation
+        property_name = @property_name
+
+        @klass.validates property_name,
+                         format: { with: Regexp.new(@constraints[:pattern]) },
+                         if: -> { public_send(property_name).is_a?(String) }
+      end
+
       # Apply length validations for strings
       def apply_length_validations
         length_options = {}
@@ -117,24 +197,85 @@ module EasyTalk
       end
 
       # Apply format-specific validations (email, url, etc.)
+      # Per JSON Schema spec, format validation only applies to string values
       def apply_format_validation(format)
-        format_configs = {
-          'email' => { with: URI::MailTo::EMAIL_REGEXP, message: 'must be a valid email address' },
-          'uri' => { with: URI::DEFAULT_PARSER.make_regexp, message: 'must be a valid URL' },
-          'url' => { with: URI::DEFAULT_PARSER.make_regexp, message: 'must be a valid URL' },
-          'uuid' => { with: /\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i,
-                      message: 'must be a valid UUID' },
-          'date' => { with: /\A\d{4}-\d{2}-\d{2}\z/, message: 'must be a valid date in YYYY-MM-DD format' },
-          'date-time' => { with: /\A\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})?\z/,
-                           message: 'must be a valid ISO 8601 date-time' },
-          'time' => { with: /\A\d{2}:\d{2}:\d{2}(?:\.\d+)?\z/, message: 'must be a valid time in HH:MM:SS format' }
-        }
+        format_str = format.to_s
 
-        config = format_configs[format.to_s]
+        # Handle parsing-based formats (date, date-time, time)
+        if PARSING_FORMATS.include?(format_str)
+          apply_parsing_format_validation(format_str)
+          return
+        end
+
+        # Handle regex-based formats
+        config = REGEX_FORMAT_CONFIGS[format_str]
         return unless config
 
-        config[:allow_nil] = optional? || nilable_type?
-        @klass.validates @property_name, format: config
+        property_name = @property_name
+        # Per JSON Schema spec, format validation only applies when value is a string
+        @klass.validates property_name, format: config, if: -> { public_send(property_name).is_a?(String) }
+      end
+
+      # Apply parsing-based format validations for date, date-time, and time
+      def apply_parsing_format_validation(format)
+        case format
+        when 'date' then apply_date_format_validation
+        when 'date-time' then apply_datetime_format_validation
+        when 'time' then apply_time_format_validation
+        when 'uri', 'url' then apply_uri_format_validation
+        end
+      end
+
+      def apply_uri_format_validation
+        prop_name = @property_name
+        @klass.validate do |record|
+          value = record.public_send(prop_name)
+          next unless value.is_a?(String)
+
+          begin
+            uri = URI.parse(value)
+            record.errors.add(prop_name, 'must be a valid URL') unless uri.absolute?
+          rescue URI::InvalidURIError, ArgumentError
+            record.errors.add(prop_name, 'must be a valid URL')
+          end
+        end
+      end
+
+      def apply_date_format_validation
+        prop_name = @property_name
+        @klass.validate do |record|
+          value = record.public_send(prop_name)
+          next if value.blank? || !value.is_a?(String)
+
+          Date.iso8601(value)
+        rescue Date::Error
+          record.errors.add(prop_name, 'must be a valid date in YYYY-MM-DD format')
+        end
+      end
+
+      def apply_datetime_format_validation
+        prop_name = @property_name
+        @klass.validate do |record|
+          value = record.public_send(prop_name)
+          next if value.blank? || !value.is_a?(String)
+
+          DateTime.iso8601(value)
+        rescue Date::Error
+          record.errors.add(prop_name, 'must be a valid ISO 8601 date-time')
+        end
+      end
+
+      def apply_time_format_validation
+        prop_name = @property_name
+        @klass.validate do |record|
+          value = record.public_send(prop_name)
+          next if value.blank? || !value.is_a?(String)
+
+          Time.parse(value)
+          record.errors.add(prop_name, 'must be a valid time in HH:MM:SS format') unless value.match?(/\A\d{2}:\d{2}:\d{2}/)
+        rescue ArgumentError
+          record.errors.add(prop_name, 'must be a valid time in HH:MM:SS format')
+        end
       end
 
       # Validate integer-specific constraints
@@ -177,28 +318,87 @@ module EasyTalk
 
       # Validate array-specific constraints
       def apply_array_validations(type)
-        # Validate array length
-        if @constraints[:min_items] || @constraints[:max_items]
-          length_options = {}
-          length_options[:minimum] = @constraints[:min_items] if @constraints[:min_items]
-          length_options[:maximum] = @constraints[:max_items] if @constraints[:max_items]
+        apply_array_length_validation
+
+        # Validate uniqueness within the array
+        apply_unique_items_validation if @constraints[:unique_items]
 
-          @klass.validates @property_name, length: length_options
+        # Check if this is a tuple (items constraint is an array of types)
+        if @constraints[:items].is_a?(::Array)
+          apply_tuple_validations(@constraints[:items], @constraints[:additional_items])
+        elsif type.is_a?(T::Types::TypedArray)
+          # Validate array item types if using T::Array[SomeType]
+          apply_array_item_type_validation(type)
         end
+      end
+
+      # Apply validations for T::Tuple[...] types
+      def apply_tuple_type_validations(tuple_type)
+        # Apply standard array constraints (min_items, max_items, unique_items)
+        apply_array_length_validation
 
-        # Validate uniqueness within the array
         apply_unique_items_validation if @constraints[:unique_items]
 
-        # Validate array item types if using T::Array[SomeType]
-        apply_array_item_type_validation(type) if type.is_a?(T::Types::TypedArray)
+        # Extract tuple types from the Tuple type
+        item_types = tuple_type.types
+
+        # Get additional_items from constraints
+        additional_items = @constraints[:additional_items]
+
+        apply_tuple_validations(item_types, additional_items)
+      end
+
+      # Apply tuple validation for arrays with positional type constraints
+      def apply_tuple_validations(item_types, additional_items)
+        prop_name = @property_name
+        # Pre-resolve type classes for use in validate block
+        resolved_item_types = item_types.map { |t| self.class.resolve_tuple_type_class(t) }
+        resolved_additional_type = additional_items && ![true, false].include?(additional_items) ? self.class.resolve_tuple_type_class(additional_items) : nil
+
+        @klass.validate do |record|
+          value = record.public_send(prop_name)
+          next unless value.is_a?(Array)
+
+          # Validate positional items
+          resolved_item_types.each_with_index do |type_class, index|
+            next if index >= value.length # Item not present (may be valid depending on minItems)
+
+            item = value[index]
+            next if ActiveModelAdapter.type_matches?(item, type_class)
+
+            type_name = ActiveModelAdapter.type_name_for_error(type_class)
+            record.errors.add(prop_name, "item at index #{index} must be a #{type_name}")
+          end
+
+          # Validate additional items constraint
+          next unless value.length > resolved_item_types.length
+
+          case additional_items
+          when false
+            record.errors.add(prop_name, "must have at most #{resolved_item_types.length} items")
+          when nil, true
+            # Any additional items allowed
+          else
+            # additional_items is a type - validate extra items against it
+            value[resolved_item_types.length..].each_with_index do |item, offset|
+              index = resolved_item_types.length + offset
+              next if ActiveModelAdapter.type_matches?(item, resolved_additional_type)
+
+              type_name = ActiveModelAdapter.type_name_for_error(resolved_additional_type)
+              record.errors.add(prop_name, "item at index #{index} must be a #{type_name}")
+            end
+          end
+        end
       end
 
-      # Apply unique items validation for arrays
+      # Apply unique items validation for arrays using JSON Schema equality semantics
       def apply_unique_items_validation
         prop_name = @property_name
         @klass.validate do |record|
           value = record.public_send(prop_name)
-          record.errors.add(prop_name, 'must contain unique items') if value && value.uniq.length != value.length
+          next unless value.is_a?(Array)
+
+          record.errors.add(prop_name, 'must contain unique items') if JsonSchemaEquality.duplicates?(value)
         end
       end
 
@@ -252,7 +452,16 @@ module EasyTalk
         prop_name = @property_name
         @klass.validate do |record|
           value = record.public_send(prop_name)
-          record.errors.add(prop_name, "can't be blank") if value.nil?
+          record.errors.add(prop_name, :blank) if value.nil?
+        end
+      end
+
+      # Apply presence validation for arrays (nil check, but allow empty arrays)
+      def apply_array_presence_validation
+        prop_name = @property_name
+        @klass.validate do |record|
+          value = record.public_send(prop_name)
+          record.errors.add(prop_name, :blank) if value.nil?
         end
       end
 
@@ -266,10 +475,9 @@ module EasyTalk
       end
 
       # Validate object/hash-specific constraints
-      def apply_object_validations
+      def apply_object_validations(expected_type)
         # Capture necessary variables outside the validation block's scope
         prop_name = @property_name
-        expected_type = get_type_class(@type) # Get the raw model class
 
         @klass.validate do |record|
           nested_object = record.public_send(prop_name)
@@ -324,6 +532,86 @@ module EasyTalk
           record.errors.add(prop_name, "must be equal to #{const_value}") if !value.nil? && value != const_value
         end
       end
+
+      # Plain data object holding pre-computed validation context.
+      # All values are computed by ActiveModelAdapter and passed in,
+      # avoiding tight coupling to adapter internals.
+      class ValidationContext
+        attr_reader :klass, :property_name, :constraints, :validation_type, :type_class, :model_class
+
+        def initialize(attrs)
+          @klass = attrs[:klass]
+          @property_name = attrs[:property_name]
+          @constraints = attrs[:constraints]
+          @validation_type = attrs[:validation_type]
+          @type_class = attrs[:type_class]
+          @optional = attrs[:optional]
+          @nilable = attrs[:nilable]
+
+          # Derive additional flags from the pre-computed values
+          @boolean_type = boolean_type_from_context?
+          @array_type = array_type_from_context?
+          @tuple_type = tuple_type_from_context?
+          @model_class = model_class_from_context
+        end
+
+        def skip_presence_validation?
+          @optional || @boolean_type || @nilable || @array_type
+        end
+
+        def array_requires_presence_validation?
+          @array_type && !@nilable
+        end
+
+        def tuple_type?
+          @tuple_type
+        end
+
+        def boolean?
+          @boolean_type
+        end
+
+        private
+
+        def boolean_type_from_context?
+          TypeIntrospection.boolean_type?(@validation_type) ||
+            @type_class == TrueClass ||
+            @type_class == FalseClass ||
+            TypeIntrospection.boolean_union_type?(@type_class)
+        end
+
+        def array_type_from_context?
+          return false if @validation_type.nil?
+
+          @validation_type == Array ||
+            TypeIntrospection.typed_array?(@validation_type) ||
+            tuple_type_from_context?
+        end
+
+        def tuple_type_from_context?
+          defined?(EasyTalk::Types::Tuple) && @validation_type.is_a?(EasyTalk::Types::Tuple)
+        end
+
+        def model_class_from_context
+          return unless @type_class.is_a?(Class)
+
+          @type_class.include?(EasyTalk::Model) ? @type_class : nil
+        end
+      end
+
+      # Shared min_items/max_items handling for array-like validations
+      def apply_array_length_validation
+        length_options = {
+          minimum: @constraints[:min_items],
+          maximum: @constraints[:max_items]
+        }.compact
+
+        return if length_options.empty?
+
+        @klass.validates @property_name, length: length_options
+      end
+
+      private_constant :ValidationContext
     end
   end
 end

data/lib/easy_talk/validation_adapters/active_model_schema_validation.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module EasyTalk
+  module ValidationAdapters
+    # ActiveModel-specific schema-level validations for object-level constraints.
+    #
+    # This module provides ActiveModel validations for JSON Schema keywords that apply
+    # to the object as a whole rather than individual properties:
+    # - minProperties: minimum number of properties that must be present
+    # - maxProperties: maximum number of properties that can be present
+    # - dependentRequired: conditional property requirements
+    #
+    # This module is tightly coupled with ActiveModel and is used exclusively by
+    # ActiveModelAdapter. Other validation adapters should implement their own
+    # schema-level validation logic.
+    #
+    module ActiveModelSchemaValidation
+      # Apply all applicable schema-level validations.
+      #
+      # @param klass [Class] The model class to apply validations to
+      # @param schema [Hash] The full schema hash containing schema-level constraints
+      # @return [void]
+      def self.apply(klass, schema)
+        apply_min_properties_validation(klass, schema[:min_properties]) if schema[:min_properties]
+        apply_max_properties_validation(klass, schema[:max_properties]) if schema[:max_properties]
+        apply_dependent_required_validation(klass, schema[:dependent_required]) if schema[:dependent_required]
+      end
+
+      # Apply minimum properties validation.
+      #
+      # @param klass [Class] The model class
+      # @param min_count [Integer] Minimum number of properties that must be present
+      def self.apply_min_properties_validation(klass, min_count)
+        define_count_method(klass)
+
+        klass.validate do |record|
+          present_count = record.send(:count_present_properties)
+          if present_count < min_count
+            record.errors.add(:base, "must have at least #{min_count} #{min_count == 1 ? 'property' : 'properties'} present")
+          end
+        end
+      end
+
+      # Apply maximum properties validation.
+      #
+      # @param klass [Class] The model class
+      # @param max_count [Integer] Maximum number of properties that can be present
+      def self.apply_max_properties_validation(klass, max_count)
+        define_count_method(klass)
+
+        klass.validate do |record|
+          present_count = record.send(:count_present_properties)
+          if present_count > max_count
+            record.errors.add(:base, "must have at most #{max_count} #{max_count == 1 ? 'property' : 'properties'} present")
+          end
+        end
+      end
+
+      # Apply dependent required validation.
+      # When a trigger property is present, all dependent properties must also be present.
+      #
+      # @param klass [Class] The model class
+      # @param dependencies [Hash<String, Array<String>>] Map of trigger properties to required properties
+      def self.apply_dependent_required_validation(klass, dependencies)
+        dependencies.each do |trigger_property, required_properties|
+          trigger_prop = trigger_property.to_sym
+          required_props = required_properties.map(&:to_sym)
+
+          klass.validate do |record|
+            trigger_value = record.public_send(trigger_prop)
+            trigger_present = trigger_value.present? || trigger_value == false
+
+            next unless trigger_present
+
+            required_props.each do |required_prop|
+              value = record.public_send(required_prop)
+              value_present = value.present? || value == false
+
+              record.errors.add(required_prop, "is required when #{trigger_prop} is present") unless value_present
+            end
+          end
+        end
+      end
+
+      # Define the count_present_properties private instance method on the class if not already defined.
+      # The method counts how many schema properties have non-nil/non-blank values.
+      #
+      # @param klass [Class] The model class
+      def self.define_count_method(klass)
+        # Check for private methods as well with the second argument
+        return if klass.method_defined?(:count_present_properties, true)
+
+        klass.send(:define_method, :count_present_properties) do
+          schema_props = self.class.schema_definition.schema[:properties] || {}
+          schema_props.keys.count do |prop|
+            value = public_send(prop)
+            value.present? || value == false # false is a valid present value
+          end
+        end
+        klass.send(:private, :count_present_properties)
+      end
+
+      private_class_method :define_count_method
+    end
+  end
+end

data/lib/easy_talk/validation_adapters/base.rb

@@ -44,6 +44,16 @@ module EasyTalk
         new(klass, property_name, type, constraints).apply_validations
       end
 
+      # Build schema-level validations (e.g., min_properties, max_properties, dependent_required).
+      # Subclasses can override this method to implement schema-level validations.
+      #
+      # @param klass [Class] The model class to apply validations to
+      # @param schema [Hash] The full schema hash containing schema-level constraints
+      # @return [void]
+      def self.build_schema_validations(klass, schema)
+        # Default implementation does nothing - subclasses can override
+      end
+
       # Initialize a new validation adapter instance.
       #
       # @param klass [Class] The model class to apply validations to
@@ -125,6 +135,8 @@ module EasyTalk
           type_to_resolve.raw_type
         elsif type_to_resolve.is_a?(T::Types::TypedArray)
           Array
+        elsif type_to_resolve.is_a?(EasyTalk::Types::Tuple)
+          Array
         elsif type_to_resolve.is_a?(Symbol) || type_to_resolve.is_a?(String)
           begin
             type_to_resolve.to_s.classify.constantize

data/lib/easy_talk/validation_adapters/none_adapter.rb

@@ -25,6 +25,15 @@ module EasyTalk
     #   end
     #
     class NoneAdapter < Base
+      # Build no schema-level validations (no-op).
+      #
+      # @param klass [Class] The model class (unused)
+      # @param schema [Hash] The schema hash (unused)
+      # @return [void]
+      def self.build_schema_validations(klass, schema)
+        # Intentionally empty - no validations applied
+      end
+
       # Apply no validations (no-op).
       #
       # @return [void]

data/lib/easy_talk/validation_builder.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 
 module EasyTalk
   # @deprecated Use EasyTalk::ValidationAdapters::ActiveModelAdapter instead.

data/lib/easy_talk/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EasyTalk
-  VERSION = '3.2.0'
+  VERSION = '3.3.0'
 end

data/lib/easy_talk.rb

@@ -10,6 +10,7 @@ module EasyTalk
   require 'easy_talk/configuration'
   require 'easy_talk/schema_methods'
   require 'easy_talk/types/composer'
+  require 'easy_talk/types/tuple'
 
   # Validation adapters
   require 'easy_talk/validation_adapters/base'