easy_talk 2.0.0 → 3.1.0

data/easy_talk.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.authors = ['Sergio Bayona']
   spec.email = ['bayona.sergio@gmail.com']
 
-  spec.summary = 'Generate json-schema from Ruby classes.'
-  spec.description = 'Generate json-schema from plain Ruby classes.'
+  spec.summary = 'Generate json-schema from Ruby classes with ActiveModel integration.'
+  spec.description = 'Generate json-schema from plain Ruby classes with ActiveModel integration for validations and serialization.'
   spec.homepage = 'https://github.com/sergiobayona/easy_talk'
   spec.license = 'MIT'
   spec.required_ruby_version = '>= 3.2'
@@ -30,8 +30,9 @@ Gem::Specification.new do |spec|
 
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'activemodel', '~> 7.0'
-  spec.add_dependency 'activesupport', '~> 7.0'
+  spec.add_dependency 'activemodel', ['>= 7.0', '< 9.0']
+  spec.add_dependency 'activesupport', ['>= 7.0', '< 9.0']
+  spec.add_dependency 'js_regex', '~> 3.0'
   spec.add_dependency 'sorbet-runtime', '~> 0.5'
 
   spec.metadata['rubygems_mfa_required'] = 'true'

data/lib/easy_talk/builders/integer_builder.rb

@@ -7,6 +7,7 @@ module EasyTalk
     # Builder class for integer properties.
     class IntegerBuilder < BaseBuilder
       extend T::Sig
+
       VALID_OPTIONS = {
         minimum: { type: Integer, key: :minimum },
         maximum: { type: Integer, key: :maximum },

data/lib/easy_talk/builders/object_builder.rb

@@ -39,6 +39,9 @@ module EasyTalk
         # We'll collect required property names in this Set
         @required_properties = Set.new
 
+        # Collect models that are referenced via $ref for $defs generation
+        @ref_models = Set.new
+
         # Usually the name is a string (class name). Fallback to :klass if nil.
         name_for_builder = schema_definition.name ? schema_definition.name.to_sym : :klass
 
@@ -60,12 +63,20 @@ module EasyTalk
         # Start with a copy of the raw schema
         merged = @original_schema.dup
 
+        # Remove schema_version and schema_id as they're handled separately in json_schema output
+        merged.delete(:schema_version)
+        merged.delete(:schema_id)
+
         # Extract and build sub-schemas first (handles allOf/anyOf/oneOf references, etc.)
         process_subschemas(merged)
 
         # Build :properties into a final form (and find "required" props)
+        # This also collects models that use $ref into @ref_models
         merged[:properties] = build_properties(merged.delete(:properties))
 
+        # Add $defs for any models that are referenced via $ref
+        add_ref_model_defs(merged) if @ref_models.any?
+
         # Populate the final "required" array from @required_properties
         merged[:required] = @required_properties.to_a if @required_properties.any?
 
@@ -127,6 +138,7 @@ module EasyTalk
       ##
       # Builds a single property. Could be a nested schema if it has sub-properties,
       # or a standard scalar property (String, Integer, etc.).
+      # Also tracks EasyTalk models that should be added to $defs when using $ref.
       #
       def build_property(prop_name, prop_options)
         @property_cache ||= {}
@@ -135,9 +147,91 @@ module EasyTalk
         @property_cache[prop_name] ||= begin
           # Remove optional constraints from the property
           constraints = prop_options[:constraints].except(:optional)
+          prop_type = prop_options[:type]
+
+          # Track models that will use $ref for later $defs generation
+          collect_ref_models(prop_type, constraints)
+
           # Normal property: e.g. { type: String, constraints: {...} }
-          Property.new(prop_name, prop_options[:type], constraints)
+          Property.new(prop_name, prop_type, constraints)
+        end
+      end
+
+      ##
+      # Collects EasyTalk models that will be referenced via $ref.
+      # These models need to be added to $defs in the final schema.
+      #
+      def collect_ref_models(prop_type, constraints)
+        # Check if this type should use $ref
+        if should_collect_ref?(prop_type, constraints)
+          @ref_models.add(prop_type)
+        # Handle typed arrays with EasyTalk model items
+        elsif typed_array_with_model?(prop_type)
+          inner_type = prop_type.type.raw_type
+          @ref_models.add(inner_type) if should_collect_ref?(inner_type, constraints)
+        # Handle nilable types
+        elsif nilable_with_model?(prop_type)
+          actual_type = T::Utils::Nilable.get_underlying_type(prop_type)
+          @ref_models.add(actual_type) if should_collect_ref?(actual_type, constraints)
+        end
+      end
+
+      ##
+      # Determines if a type should be collected for $ref based on config and constraints.
+      #
+      def should_collect_ref?(check_type, constraints)
+        return false unless easytalk_model?(check_type)
+
+        # Per-property constraint takes precedence
+        return constraints[:ref] if constraints.key?(:ref)
+
+        # Fall back to global configuration
+        EasyTalk.configuration.use_refs
+      end
+
+      ##
+      # Checks if a type is an EasyTalk model.
+      #
+      def easytalk_model?(check_type)
+        check_type.is_a?(Class) &&
+          check_type.respond_to?(:schema) &&
+          check_type.respond_to?(:ref_template) &&
+          defined?(EasyTalk::Model) &&
+          check_type.include?(EasyTalk::Model)
+      end
+
+      ##
+      # Checks if type is a typed array containing an EasyTalk model.
+      #
+      def typed_array_with_model?(prop_type)
+        return false unless prop_type.is_a?(T::Types::TypedArray)
+
+        inner_type = prop_type.type.raw_type
+        easytalk_model?(inner_type)
+      end
+
+      ##
+      # Checks if type is nilable and contains an EasyTalk model.
+      #
+      def nilable_with_model?(prop_type)
+        return false unless prop_type.respond_to?(:types)
+        return false unless prop_type.types.all? { |t| t.respond_to?(:raw_type) }
+        return false unless prop_type.types.any? { |t| t.raw_type == NilClass }
+
+        actual_type = T::Utils::Nilable.get_underlying_type(prop_type)
+        easytalk_model?(actual_type)
+      end
+
+      ##
+      # Adds $defs entries for all collected ref models.
+      #
+      def add_ref_model_defs(schema_hash)
+        definitions = @ref_models.each_with_object({}) do |model, acc|
+          acc[model.name] = model.schema
         end
+
+        existing_defs = schema_hash[:defs] || {}
+        schema_hash[:defs] = existing_defs.merge(definitions)
       end
 
       ##

data/lib/easy_talk/builders/string_builder.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'base_builder'
+require 'js_regex' # Compile the ruby regex to JS regex
 require 'sorbet-runtime' # Add the import statement for the T module
 
 module EasyTalk
@@ -8,6 +9,7 @@ module EasyTalk
     # Builder class for string properties.
     class StringBuilder < BaseBuilder
       extend T::Sig
+
       VALID_OPTIONS = {
         format: { type: String, key: :format },
         pattern: { type: String, key: :pattern },
@@ -22,6 +24,13 @@ module EasyTalk
       def initialize(name, constraints = {})
         super(name, { type: 'string' }, constraints, VALID_OPTIONS)
       end
+
+      def build
+        super.tap do |schema|
+          pattern = schema[:pattern]
+          schema[:pattern] = JsRegex.new(pattern).source if pattern.is_a?(String)
+        end
+      end
     end
   end
 end

data/lib/easy_talk/builders/typed_array_builder.rb

@@ -14,7 +14,8 @@ module EasyTalk
         max_items: { type: Integer, key: :maxItems },
         unique_items: { type: T::Boolean, key: :uniqueItems },
         enum: { type: T::Array[T.untyped], key: :enum },
-        const: { type: T::Array[T.untyped], key: :const }
+        const: { type: T::Array[T.untyped], key: :const },
+        ref: { type: T::Boolean, key: :ref }
       }.freeze
 
       attr_reader :type
@@ -35,7 +36,9 @@ module EasyTalk
       sig { returns(T::Hash[Symbol, T.untyped]) }
       def schema
         super.tap do |schema|
-          schema[:items] = Property.new(@name, inner_type, {}).build
+          # Pass ref constraint to items if present (for nested model references)
+          item_constraints = @options&.slice(:ref) || {}
+          schema[:items] = Property.new(@name, inner_type, item_constraints).build
         end
       end
 

data/lib/easy_talk/configuration.rb

@@ -2,19 +2,32 @@
 
 module EasyTalk
   class Configuration
-    attr_accessor :exclude_foreign_keys, :exclude_associations, :excluded_columns,
-                  :exclude_primary_key, :exclude_timestamps, :default_additional_properties,
-                  :nilable_is_optional, :auto_validations
+    # JSON Schema draft version URIs
+    SCHEMA_VERSIONS = {
+      draft202012: 'https://json-schema.org/draft/2020-12/schema',
+      draft201909: 'https://json-schema.org/draft/2019-09/schema',
+      draft7: 'http://json-schema.org/draft-07/schema#',
+      draft6: 'http://json-schema.org/draft-06/schema#',
+      draft4: 'http://json-schema.org/draft-04/schema#'
+    }.freeze
+
+    attr_accessor :default_additional_properties, :nilable_is_optional, :auto_validations, :schema_version, :schema_id,
+                  :use_refs
 
     def initialize
-      @exclude_foreign_keys = true
-      @exclude_associations = true
-      @excluded_columns = []
-      @exclude_primary_key = true
-      @exclude_timestamps = true
       @default_additional_properties = false
       @nilable_is_optional = false
-      @auto_validations = true # New option: enable validations by default
+      @auto_validations = true
+      @schema_version = :none
+      @schema_id = nil
+      @use_refs = false
+    end
+
+    # Returns the URI for the configured schema version, or nil if :none
+    def schema_uri
+      return nil if @schema_version == :none
+
+      SCHEMA_VERSIONS[@schema_version] || @schema_version.to_s
     end
   end
 

data/lib/easy_talk/keywords.rb

@@ -2,6 +2,8 @@
 
 module EasyTalk
   KEYWORDS = %i[
+    schema_id
+    schema_version
     description
     type
     title

data/lib/easy_talk/model.rb

@@ -9,7 +9,6 @@ require 'active_support/json'
 require 'active_model'
 require_relative 'builders/object_builder'
 require_relative 'schema_definition'
-require_relative 'active_record_schema_builder'
 require_relative 'validation_builder'
 
 module EasyTalk
@@ -36,16 +35,12 @@ module EasyTalk
   # @see SchemaDefinition
   module Model
     def self.included(base)
-      base.include ActiveModel::API # Include ActiveModel::API in the class including EasyTalk::Model
+      base.extend(ClassMethods)
+
+      base.include ActiveModel::API
       base.include ActiveModel::Validations
       base.extend ActiveModel::Callbacks
-      base.extend(ClassMethods)
       base.include(InstanceMethods)
-
-      # Apply ActiveRecord-specific functionality if appropriate
-      return unless defined?(ActiveRecord) && base.ancestors.include?(ActiveRecord::Base)
-
-      base.extend(ActiveRecordClassMethods)
     end
 
     # Instance methods mixed into models that include EasyTalk::Model
@@ -55,12 +50,7 @@ module EasyTalk
         super # Perform initial mass assignment
 
         # After initial assignment, instantiate nested EasyTalk::Model objects
-        # Get the appropriate schema definition based on model type
-        schema_def = if self.class.respond_to?(:active_record_schema_definition)
-                       self.class.active_record_schema_definition
-                     else
-                       self.class.schema_definition
-                     end
+        schema_def = self.class.schema_definition
 
         # Only proceed if we have a valid schema definition
         return unless schema_def.respond_to?(:schema) && schema_def.schema.is_a?(Hash)
@@ -69,6 +59,11 @@ module EasyTalk
           # Get the defined type and the currently assigned value
           defined_type = prop_definition[:type]
           current_value = public_send(prop_name)
+          nilable_type = defined_type.respond_to?(:nilable?) && defined_type.nilable?
+
+          next if nilable_type && current_value.nil?
+
+          defined_type = T::Utils::Nilable.get_underlying_type(defined_type) if nilable_type
 
           # Check if the type is another EasyTalk::Model and the value is a Hash
           next unless defined_type.is_a?(Class) && defined_type.include?(EasyTalk::Model) && current_value.is_a?(Hash)
@@ -116,6 +111,11 @@ module EasyTalk
         to_hash.merge(@additional_properties)
       end
 
+      # to_h includes both defined and additional properties
+      def to_h
+        to_hash.merge(@additional_properties)
+      end
+
       # Allow comparison with hashes
       def ==(other)
         case other
@@ -141,13 +141,8 @@ module EasyTalk
       # @return [Schema] The schema for the model.
       def schema
         @schema ||= if defined?(@schema_definition) && @schema_definition
-                      # Schema defined explicitly via define_schema
                       build_schema(@schema_definition)
-                    elsif respond_to?(:active_record_schema_definition)
-                      # ActiveRecord model without explicit schema definition
-                      build_schema(active_record_schema_definition)
                     else
-                      # Default case - empty schema
                       {}
                     end
       end
@@ -160,12 +155,63 @@ module EasyTalk
       end
 
       # Returns the JSON schema for the model.
+      # This is the final output that includes the $schema keyword if configured.
       #
       # @return [Hash] The JSON schema for the model.
       def json_schema
-        @json_schema ||= schema.as_json
+        @json_schema ||= build_json_schema
       end
 
+      private
+
+      # Builds the final JSON schema with optional $schema and $id keywords.
+      def build_json_schema
+        result = schema.as_json
+        schema_uri = resolve_schema_uri
+        id_uri = resolve_schema_id
+
+        # Build prefix hash with $schema and $id (in that order per JSON Schema convention)
+        prefix = {}
+        prefix['$schema'] = schema_uri if schema_uri
+        prefix['$id'] = id_uri if id_uri
+
+        return result if prefix.empty?
+
+        prefix.merge(result)
+      end
+
+      # Resolves the schema URI from per-model setting or global config.
+      def resolve_schema_uri
+        model_version = @schema_definition&.schema&.dig(:schema_version)
+
+        if model_version
+          # Per-model override - :none means explicitly no $schema
+          return nil if model_version == :none
+
+          Configuration::SCHEMA_VERSIONS[model_version] || model_version.to_s
+        else
+          # Fall back to global configuration
+          EasyTalk.configuration.schema_uri
+        end
+      end
+
+      # Resolves the schema ID from per-model setting or global config.
+      def resolve_schema_id
+        model_id = @schema_definition&.schema&.dig(:schema_id)
+
+        if model_id
+          # Per-model override - :none means explicitly no $id
+          return nil if model_id == :none
+
+          model_id.to_s
+        else
+          # Fall back to global configuration
+          EasyTalk.configuration.schema_id
+        end
+      end
+
+      public
+
       # Define the schema for the model using the provided block.
       #
       # @yield The block to define the schema.
@@ -225,34 +271,5 @@ module EasyTalk
         Builders::ObjectBuilder.new(schema_definition).build
       end
     end
-
-    # Module containing ActiveRecord-specific methods for schema generation
-    module ActiveRecordClassMethods
-      # Gets a SchemaDefinition that's built from the ActiveRecord database schema
-      #
-      # @return [SchemaDefinition] A schema definition built from the database
-      def active_record_schema_definition
-        @active_record_schema_definition ||= ActiveRecordSchemaBuilder.new(self).build_schema_definition
-      end
-
-      # Store enhancements to be applied to the schema
-      #
-      # @return [Hash] The schema enhancements
-      def schema_enhancements
-        @schema_enhancements ||= {}
-      end
-
-      # Enhance the generated schema with additional information
-      #
-      # @param enhancements [Hash] The schema enhancements
-      # @return [void]
-      def enhance_schema(enhancements)
-        @schema_enhancements = enhancements
-        # Clear cached values to force regeneration
-        @active_record_schema_definition = nil
-        @schema = nil
-        @json_schema = nil
-      end
-    end
   end
 end

data/lib/easy_talk/property.rb

@@ -101,22 +101,31 @@ module EasyTalk
     # This method handles different types of properties:
     # - Nilable types (can be null)
     # - Types with dedicated builders
-    # - Types that implement their own schema method
+    # - Types that implement their own schema method (EasyTalk models)
     # - Default fallback to 'object' type
     #
+    # When use_refs is enabled (globally or per-property), EasyTalk models
+    # are referenced via $ref instead of being inlined.
+    #
     # @return [Hash] The complete JSON Schema property definition
     #
     # @example Simple string property
     #   property = Property.new(:name, 'String')
     #   property.build  # => {"type"=>"string"}
     #
-    # @example Complex nested schema
+    # @example Complex nested schema (inlined)
     #   address = Address.new  # A class with a .schema method
     #   property = Property.new(:shipping_address, address, description: "Shipping address")
     #   property.build  # => Address schema merged with the description constraint
+    #
+    # @example Nested schema with $ref
+    #   property = Property.new(:shipping_address, Address, ref: true)
+    #   property.build  # => {"$ref"=>"#/$defs/Address", ...constraints}
     def build
       if nilable_type?
         build_nilable_schema
+      elsif should_use_ref?
+        build_ref_schema
       elsif builder
         args = builder.collection_type? ? [name, type, constraints] : [name, constraints]
         builder.new(*args).build
@@ -189,10 +198,18 @@ module EasyTalk
     #   {"type"=>["string", "null"]}
     def build_nilable_schema
       # Extract the non-nil type from the Union
-      actual_type = type.types.find { |t| t.raw_type != NilClass }
+      actual_type = T::Utils::Nilable.get_underlying_type(type)
 
       return { type: 'null' } unless actual_type
 
+      # Check if the underlying type is an EasyTalk model that should use $ref
+      if easytalk_model?(actual_type) && should_use_ref_for_type?(actual_type)
+        # Use anyOf with $ref and null type
+        ref_constraints = constraints.except(:ref, :optional)
+        schema = { anyOf: [{ '$ref': actual_type.ref_template }, { type: 'null' }] }
+        return ref_constraints.empty? ? schema : schema.merge(ref_constraints)
+      end
+
       # Create a property with the actual type
       non_nil_schema = Property.new(name, actual_type, constraints).build
 
@@ -201,5 +218,54 @@ module EasyTalk
         type: [non_nil_schema[:type], 'null'].compact
       )
     end
+
+    # Determines if $ref should be used for the current type.
+    #
+    # @return [Boolean] true if $ref should be used, false otherwise
+    # @api private
+    def should_use_ref?
+      return false unless easytalk_model?(type)
+
+      should_use_ref_for_type?(type)
+    end
+
+    # Determines if $ref should be used for a given type based on constraints and config.
+    #
+    # @param check_type [Class] The type to check
+    # @return [Boolean] true if $ref should be used, false otherwise
+    # @api private
+    def should_use_ref_for_type?(check_type)
+      return false unless easytalk_model?(check_type)
+
+      # Per-property constraint takes precedence
+      return constraints[:ref] if constraints.key?(:ref)
+
+      # Fall back to global configuration
+      EasyTalk.configuration.use_refs
+    end
+
+    # Checks if a type is an EasyTalk model.
+    #
+    # @param check_type [Object] The type to check
+    # @return [Boolean] true if the type is an EasyTalk model
+    # @api private
+    def easytalk_model?(check_type)
+      check_type.is_a?(Class) &&
+        check_type.respond_to?(:schema) &&
+        check_type.respond_to?(:ref_template) &&
+        defined?(EasyTalk::Model) &&
+        check_type.include?(EasyTalk::Model)
+    end
+
+    # Builds a $ref schema for an EasyTalk model.
+    #
+    # @return [Hash] A schema with $ref pointing to the model's definition
+    # @api private
+    def build_ref_schema
+      # Remove ref and optional from constraints as they're not JSON Schema keywords
+      ref_constraints = constraints.except(:ref, :optional)
+      schema = { '$ref': type.ref_template }
+      ref_constraints.empty? ? schema : schema.merge(ref_constraints)
+    end
   end
 end

data/lib/easy_talk/validation_builder.rb

@@ -65,8 +65,8 @@ module EasyTalk
     end
 
     # Check if the type is nilable (e.g., T.nilable(String))
-    def nilable_type?
-      @type.respond_to?(:nilable?) && @type.nilable?
+    def nilable_type?(type = @type)
+      type.respond_to?(:nilable?) && type.nilable?
     end
 
     # Extract the inner type from a complex type like T.nilable(String)
@@ -118,6 +118,8 @@ module EasyTalk
         end
       elsif type.to_s.include?('T::Boolean')
         [TrueClass, FalseClass] # Return both boolean classes
+      elsif nilable_type?(type)
+        extract_inner_type(type)
       else
         String # Default fallback
       end
@@ -137,48 +139,30 @@ module EasyTalk
       @klass.validates @property_name, format: { with: Regexp.new(@constraints[:pattern]) } if @constraints[:pattern]
 
       # Handle length constraints
-      length_options = {}
-      length_options[:minimum] = @constraints[:min_length] if @constraints[:min_length]
-      length_options[:maximum] = @constraints[:max_length] if @constraints[:max_length]
-      @klass.validates @property_name, length: length_options if length_options.any?
+      begin
+        length_options = {}
+        length_options[:minimum] = @constraints[:min_length] if @constraints[:min_length].is_a?(Numeric) && @constraints[:min_length] >= 0
+        length_options[:maximum] = @constraints[:max_length] if @constraints[:max_length].is_a?(Numeric) && @constraints[:max_length] >= 0
+        @klass.validates @property_name, length: length_options if length_options.any?
+      rescue ArgumentError
+        # Silently ignore invalid length constraints
+      end
     end
 
     # Apply format-specific validations (email, url, etc.)
     def apply_format_validation(format)
-      case format.to_s
-      when 'email'
-        @klass.validates @property_name, format: {
-          with: URI::MailTo::EMAIL_REGEXP,
-          message: 'must be a valid email address'
-        }
-      when 'uri', 'url'
-        @klass.validates @property_name, format: {
-          with: URI::DEFAULT_PARSER.make_regexp,
-          message: 'must be a valid URL'
-        }
-      when 'uuid'
-        uuid_regex = /\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i
-        @klass.validates @property_name, format: {
-          with: uuid_regex,
-          message: 'must be a valid UUID'
-        }
-      when 'date'
-        @klass.validates @property_name, format: {
-          with: /\A\d{4}-\d{2}-\d{2}\z/,
-          message: 'must be a valid date in YYYY-MM-DD format'
-        }
-      when 'date-time'
-        # ISO 8601 date-time format
-        @klass.validates @property_name, format: {
-          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'
-        }
-      when 'time'
-        @klass.validates @property_name, format: {
-          with: /\A\d{2}:\d{2}:\d{2}(?:\.\d+)?\z/,
-          message: 'must be a valid time in HH:MM:SS format'
-        }
-      end
+      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' }
+      }
+
+      config = format_configs[format.to_s]
+      @klass.validates @property_name, format: config if config
     end
 
     # Validate integer-specific constraints
@@ -193,15 +177,19 @@ module EasyTalk
 
     # Apply numeric validations for integers and floats
     def apply_numeric_validations(only_integer: false)
-      options = { only_integer: only_integer }
-
-      # Add range constraints
-      options[:greater_than_or_equal_to] = @constraints[:minimum] if @constraints[:minimum]
-      options[:less_than_or_equal_to] = @constraints[:maximum] if @constraints[:maximum]
-      options[:greater_than] = @constraints[:exclusive_minimum] if @constraints[:exclusive_minimum]
-      options[:less_than] = @constraints[:exclusive_maximum] if @constraints[:exclusive_maximum]
-
-      @klass.validates @property_name, numericality: options
+      begin
+        options = { only_integer: only_integer }
+
+        # Add range constraints - only if they are numeric
+        options[:greater_than_or_equal_to] = @constraints[:minimum] if @constraints[:minimum].is_a?(Numeric)
+        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)
+
+        @klass.validates @property_name, numericality: options
+      rescue ArgumentError
+        # Silently ignore invalid numeric constraints
+      end
 
       # Add multiple_of validation
       return unless @constraints[:multiple_of]

data/lib/easy_talk/version.rb

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