easy_talk 3.3.0 → 3.3.2

data/lib/easy_talk/schema_definition.rb

@@ -121,7 +121,7 @@ module EasyTalk
       if args.size >= 1 && args.first.is_a?(Class)
         type = args.first
         # Merge all hash arguments as constraints
-        constraints = args[1..].select { |arg| arg.is_a?(Hash) }.reduce({}, :merge)
+        constraints = args[1..].grep(Hash).reduce({}, :merge)
         return { type:, **constraints }
       end
 

data/lib/easy_talk/type_introspection.rb

@@ -183,6 +183,11 @@ module EasyTalk
         return Array if type.is_a?(T::Types::TypedArray) || type.is_a?(EasyTalk::Types::Tuple)
         return [TrueClass, FalseClass] if boolean_type?(type)
 
+        if type.is_a?(Symbol) || type.is_a?(String)
+          klass = type.to_s.classify.safe_constantize
+          return klass if klass
+        end
+
         if nilable_type?(type)
           inner = extract_inner_type(type)
           return get_type_class(inner) if inner && inner != type
@@ -208,6 +213,10 @@ module EasyTalk
         end
 
         if type.respond_to?(:types)
+          # Prefer TypedArray if present in the union (for T.nilable(T::Array[...]) via .types path)
+          typed_arr = type.types.find { |t| t.is_a?(T::Types::TypedArray) }
+          return typed_arr if typed_arr
+
           non_nil = type.types.find do |t|
             raw = t.respond_to?(:raw_type) ? t.raw_type : t
             raw != NilClass

data/lib/easy_talk/validation_adapters/active_model_adapter.rb

@@ -128,6 +128,12 @@ module EasyTalk
 
       private
 
+      # Returns true if nil should be allowed by ActiveModel validators.
+      # This is the case when the property is optional or declared T.nilable.
+      def allow_nil?
+        optional? || nilable_type?
+      end
+
       # Apply validations based on the type of the property
       def apply_type_validations(context)
         if context.tuple_type?
@@ -185,7 +191,7 @@ module EasyTalk
         length_options[:maximum] = @constraints[:max_length] if valid_length_constraint?(:max_length)
         return unless length_options.any?
 
-        length_options[:allow_nil] = optional? || nilable_type?
+        length_options[:allow_nil] = allow_nil?
         @klass.validates @property_name, length: length_options
       rescue ArgumentError
         # Silently ignore invalid length constraints
@@ -297,6 +303,7 @@ module EasyTalk
         options[:less_than_or_equal_to] = @constraints[:maximum] if @constraints[:maximum].is_a?(Numeric)
         options[:greater_than] = @constraints[:exclusive_minimum] if @constraints[:exclusive_minimum].is_a?(Numeric)
         options[:less_than] = @constraints[:exclusive_maximum] if @constraints[:exclusive_maximum].is_a?(Numeric)
+        options[:allow_nil] = true if allow_nil?
 
         @klass.validates @property_name, numericality: options
 
@@ -407,16 +414,23 @@ module EasyTalk
         # Get inner type from T::Types::TypedArray (uses .type, which returns T::Types::Simple)
         inner_type_wrapper = type.type
         inner_type = inner_type_wrapper.respond_to?(:raw_type) ? inner_type_wrapper.raw_type : inner_type_wrapper
+        is_boolean = TypeIntrospection.boolean_type?(inner_type)
         prop_name = @property_name
-        is_easy_talk_model = inner_type.is_a?(Class) && inner_type.include?(EasyTalk::Model)
+        is_easy_talk_model = !is_boolean && inner_type.is_a?(Class) && inner_type.include?(EasyTalk::Model)
 
         @klass.validate do |record|
           value = record.public_send(prop_name)
           next unless value.is_a?(Array)
 
           value.each_with_index do |item, index|
-            unless item.is_a?(inner_type)
-              record.errors.add(prop_name, "item at index #{index} must be a #{inner_type}")
+            type_match = if is_boolean
+                           [true, false].include?(item)
+                         else
+                           item.is_a?(inner_type)
+                         end
+            unless type_match
+              type_label = is_boolean ? 'Boolean' : inner_type.to_s
+              record.errors.add(prop_name, "item at index #{index} must be a #{type_label}")
               next
             end
 
@@ -433,15 +447,11 @@ module EasyTalk
 
       # Validate boolean-specific constraints
       def apply_boolean_validations
-        # For boolean values, validate inclusion in [true, false]
-        # If not optional, don't allow nil (equivalent to presence validation for booleans)
-        if optional?
-          @klass.validates @property_name, inclusion: { in: [true, false] }, allow_nil: true
-        else
-          @klass.validates @property_name, inclusion: { in: [true, false] }
-          # Add custom validation for nil values that provides the "can't be blank" message
-          apply_boolean_presence_validation
-        end
+        # allow_nil? covers both optional and T.nilable — nil is explicitly permitted in both cases.
+        @klass.validates @property_name, inclusion: { in: [true, false] }, allow_nil: allow_nil?
+
+        # For required non-nilable booleans, add a custom nil check with the "can't be blank" message.
+        apply_boolean_presence_validation unless allow_nil?
 
         # Add type validation to ensure the value is actually a boolean
         apply_boolean_type_validation
@@ -482,33 +492,22 @@ module EasyTalk
         @klass.validate do |record|
           nested_object = record.public_send(prop_name)
 
-          # Only validate if the nested object is present
+          # Nil is handled by the outer presence validation — nothing to do here.
           next unless nested_object
 
-          # Check if the object is of the expected type (e.g., an actual Email instance)
           if nested_object.is_a?(expected_type)
-            # Check if this object appears to be empty (created from an empty hash)
-            # by checking if all defined properties are nil/blank
-            properties = expected_type.schema_definition.schema[:properties] || {}
-            all_properties_blank = properties.keys.all? do |property|
-              value = nested_object.public_send(property)
-              value.nil? || (value.respond_to?(:empty?) && value.empty?)
-            end
-
-            if all_properties_blank
-              # Treat as blank and add a presence error to the parent field
-              record.errors.add(prop_name, "can't be blank")
-            elsif !nested_object.valid?
-              # If it's the correct type and not empty, validate it
-              # Merge errors from the nested object into the parent
-              nested_object.errors.each do |error|
-                # Prefix the attribute name (e.g., 'email.address')
-                nested_key = "#{prop_name}.#{error.attribute}"
-                record.errors.add(nested_key.to_sym, error.message)
-              end
+            # Delegate entirely to the nested model's own validity.
+            # The outer presence validation already handles the nil case, so there
+            # is no need for a secondary "blank" heuristic here.
+            next if nested_object.valid?
+
+            # Propagate nested errors into the parent with a dotted-path prefix.
+            nested_object.errors.each do |error|
+              nested_key = "#{prop_name}.#{error.attribute}"
+              record.errors.add(nested_key.to_sym, error.message)
             end
           else
-            # If present but not the correct type, add a type error
+            # Value is present but is not the expected type.
             record.errors.add(prop_name, "must be a valid #{expected_type.name}")
           end
         end
@@ -519,7 +518,7 @@ module EasyTalk
         @klass.validates @property_name, inclusion: {
           in: @constraints[:enum],
           message: "must be one of: #{@constraints[:enum].join(', ')}",
-          allow_nil: optional?
+          allow_nil: allow_nil?
         }
       end
 
@@ -560,7 +559,7 @@ module EasyTalk
         end
 
         def array_requires_presence_validation?
-          @array_type && !@nilable
+          @array_type && !@nilable && !@optional
         end
 
         def tuple_type?
@@ -608,6 +607,7 @@ module EasyTalk
 
         return if length_options.empty?
 
+        length_options[:allow_nil] = true if allow_nil?
         @klass.validates @property_name, length: length_options
       end
 

data/lib/easy_talk/validation_adapters/base.rb

@@ -94,62 +94,30 @@ module EasyTalk
       end
 
       # Check if the type is nilable (e.g., T.nilable(String)).
+      # Delegates to TypeIntrospection.
       #
-      # @param t [Class, Object] The type to check (defaults to @type)
+      # @param type_to_check [Class, Object] The type to check (defaults to @type)
       # @return [Boolean] true if the type is nilable
       def nilable_type?(type_to_check = @type)
-        type_to_check.respond_to?(:nilable?) && type_to_check.nilable?
+        TypeIntrospection.nilable_type?(type_to_check)
       end
 
       # Extract the inner type from a complex type like T.nilable(String) or T.nilable(T::Array[Model]).
+      # Delegates to TypeIntrospection.
       #
       # @param type_to_unwrap [Class, Object] The type to unwrap (defaults to @type)
       # @return [Class, Object] The inner type, or the original type if not wrapped
       def extract_inner_type(type_to_unwrap = @type)
-        if type_to_unwrap.respond_to?(:unwrap_nilable)
-          unwrapped = type_to_unwrap.unwrap_nilable
-          # Return TypedArray directly (for T.nilable(T::Array[Model]))
-          return unwrapped if unwrapped.is_a?(T::Types::TypedArray)
-          # Return raw_type for simple types (for T.nilable(String))
-          return unwrapped.raw_type if unwrapped.respond_to?(:raw_type)
-        end
-
-        if type_to_unwrap.respond_to?(:types)
-          # For union types, find the non-nil type
-          # Prefer TypedArray if present, otherwise find type with raw_type
-          type_to_unwrap.types.find { |t| t.is_a?(T::Types::TypedArray) } ||
-            type_to_unwrap.types.find { |t| t.respond_to?(:raw_type) && t.raw_type != NilClass }
-        else
-          type_to_unwrap
-        end
+        TypeIntrospection.extract_inner_type(type_to_unwrap)
       end
 
       # Determine the actual class for a type, handling Sorbet types.
+      # Delegates to TypeIntrospection.
       #
       # @param type_to_resolve [Class, Object] The type to resolve
       # @return [Class, Array<Class>] The resolved class or classes
       def get_type_class(type_to_resolve)
-        if type_to_resolve.is_a?(Class)
-          type_to_resolve
-        elsif type_to_resolve.respond_to?(:raw_type)
-          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
-          rescue StandardError
-            String
-          end
-        elsif TypeIntrospection.boolean_type?(type_to_resolve)
-          [TrueClass, FalseClass]
-        elsif nilable_type?(type_to_resolve)
-          extract_inner_type(type_to_resolve)
-        else
-          String
-        end
+        TypeIntrospection.get_type_class(type_to_resolve)
       end
     end
   end

data/lib/easy_talk/version.rb

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

data/lib/easy_talk.rb

@@ -21,9 +21,10 @@ module EasyTalk
   # Builder registry for pluggable type support
   require 'easy_talk/builders/registry'
 
+  require 'easy_talk/property'
+  require 'easy_talk/schema_base'
   require 'easy_talk/model'
   require 'easy_talk/schema'
-  require 'easy_talk/property'
   require 'easy_talk/schema_definition'
   require 'easy_talk/validation_builder'
   require 'easy_talk/error_formatter'
@@ -57,6 +58,8 @@ module EasyTalk
   end
 
   def self.assert_valid_property_options(property_name, options, *valid_keys)
+    return if options.nil?
+
     valid_keys.flatten!
     options.each_key do |k|
       next if valid_keys.include?(k)
@@ -68,4 +71,23 @@ module EasyTalk
   def self.configure_nilable_behavior(nilable_is_optional = false)
     configuration.nilable_is_optional = nilable_is_optional
   end
+
+  # Deep duplicates a value, recursing into Hashes and Arrays.
+  # Class and Module objects are returned as-is since they represent types
+  # and cannot (and should not) be duplicated.
+  #
+  # @param obj [Object] The value to deep duplicate.
+  # @return [Object] A deep copy of obj.
+  def self.deep_dup(obj)
+    case obj
+    when Hash
+      obj.transform_values { |v| deep_dup(v) }
+    when Array
+      obj.map { |v| deep_dup(v) }
+    when Class, Module
+      obj
+    else
+      obj.duplicable? ? obj.dup : obj
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: easy_talk
 version: !ruby/object:Gem::Version
-  version: 3.3.0
+  version: 3.3.2
 platform: ruby
 authors:
 - Sergio Bayona
@@ -106,6 +106,10 @@ files:
 - docs/primitive-schema-rfc.md
 - docs/property-types.markdown
 - docs/schema-definition.markdown
+- easy_talk.gemspec
+- examples/ruby_llm/Gemfile
+- examples/ruby_llm/structured_output.rb
+- examples/ruby_llm/tools_integration.rb
 - lib/easy_talk.rb
 - lib/easy_talk/builders/base_builder.rb
 - lib/easy_talk/builders/boolean_builder.rb
@@ -132,6 +136,7 @@ files:
 - lib/easy_talk/error_formatter/rfc7807.rb
 - lib/easy_talk/errors.rb
 - lib/easy_talk/errors_helper.rb
+- lib/easy_talk/extensions/ruby_llm_compatibility.rb
 - lib/easy_talk/json_schema_equality.rb
 - lib/easy_talk/keywords.rb
 - lib/easy_talk/model.rb
@@ -140,6 +145,7 @@ files:
 - lib/easy_talk/property.rb
 - lib/easy_talk/ref_helper.rb
 - lib/easy_talk/schema.rb
+- lib/easy_talk/schema_base.rb
 - lib/easy_talk/schema_definition.rb
 - lib/easy_talk/schema_methods.rb
 - lib/easy_talk/sorbet_extension.rb