easy_talk 1.0.3 → 2.0.0

data/lib/easy_talk/schema_definition.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require_relative 'keywords'
+require_relative 'types/composer'
+require_relative 'validation_builder'
 
 module EasyTalk
   #
@@ -15,11 +17,13 @@ module EasyTalk
     extend T::AllOf
 
     attr_reader :name, :schema
+    attr_accessor :klass # Add accessor for the model class
 
     def initialize(name, schema = {})
       @schema = schema
       @schema[:additional_properties] = false unless schema.key?(:additional_properties)
       @name = name
+      @klass = nil # Initialize klass to nil
     end
 
     EasyTalk::KEYWORDS.each do |keyword|
@@ -33,36 +37,44 @@ module EasyTalk
       @schema[:subschemas] += subschemas
     end
 
-    sig do
-      params(name: T.any(Symbol, String), type: T.untyped, constraints: T.untyped, blk: T.nilable(T.proc.void)).void
-    end
-    def property(name, type, constraints = {}, &blk)
+    def property(name, type, constraints = {}, &)
       validate_property_name(name)
       @schema[:properties] ||= {}
 
       if block_given?
-        property_schema = SchemaDefinition.new(name)
-        property_schema.instance_eval(&blk)
-
-        @schema[:properties][name] = {
-          type:,
-          constraints:,
-          properties: property_schema
-        }
-      else
-        @schema[:properties][name] = { type:, constraints: }
+        raise ArgumentError,
+              'Block-style sub-schemas are no longer supported. Use class references as types instead.'
       end
+
+      @schema[:properties][name] = { type:, constraints: }
     end
 
     def validate_property_name(name)
       return if name.to_s.match?(/^[A-Za-z_][A-Za-z0-9_]*$/)
 
-      raise InvalidPropertyNameError,
-            "Invalid property name '#{name}'. Must start with letter/underscore and contain only letters, numbers, underscores"
+      message = "Invalid property name '#{name}'. Must start with letter/underscore " \
+                'and contain only letters, numbers, underscores'
+      raise InvalidPropertyNameError, message
     end
 
     def optional?
       @schema[:optional]
     end
+
+    # Helper method for nullable and optional properties
+    def nullable_optional_property(name, type, constraints = {})
+      # Ensure type is nilable
+      nilable_type = if type.respond_to?(:nilable?) && type.nilable?
+                       type
+                     else
+                       T.nilable(type)
+                     end
+
+      # Ensure constraints include optional: true
+      constraints = constraints.merge(optional: true)
+
+      # Call standard property method
+      property(name, nilable_type, constraints)
+    end
   end
 end

data/lib/easy_talk/types/composer.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require_relative 'base_composer'
+
+module EasyTalk
+  module Types
+    # Base class for composition types
+    class Composer < BaseComposer
+      # Returns the name of the composition type.
+      def self.name
+        raise NotImplementedError, "#{self.class.name} must implement the name method"
+      end
+
+      # Returns the name of the composition type.
+      def name
+        self.class.name
+      end
+
+      # Represents a composition type that allows all of the specified types.
+      class AllOf < Composer
+        def self.name
+          :allOf
+        end
+
+        def name
+          :allOf
+        end
+      end
+
+      # Represents a composition type that allows any of the specified types.
+      class AnyOf < Composer
+        def self.name
+          :anyOf
+        end
+
+        def name
+          :anyOf
+        end
+      end
+
+      # Represents a composition type that allows one of the specified types.
+      class OneOf < Composer
+        def self.name
+          :oneOf
+        end
+
+        def name
+          :oneOf
+        end
+      end
+    end
+  end
+end
+
+# Shorthand module for accessing the AllOf composer
+module T
+  # Provides composition logic for combining multiple schemas with AllOf semantics
+  module AllOf
+    # Creates a new instance of `EasyTalk::Types::Composer::AllOf` with the given arguments.
+    #
+    # @param args [Array] the list of arguments to be passed to the constructor
+    # @return [EasyTalk::Types::Composer::AllOf] a new instance
+    def self.[](*)
+      EasyTalk::Types::Composer::AllOf.new(*)
+    end
+  end
+
+  # Shorthand module for accessing the AnyOf composer
+  module AnyOf
+    # Creates a new instance of `EasyTalk::Types::Composer::AnyOf` with the given arguments.
+    #
+    # @param args [Array] the list of arguments to be passed to the constructor
+    # @return [EasyTalk::Types::Composer::AnyOf] a new instance
+    def self.[](*)
+      EasyTalk::Types::Composer::AnyOf.new(*)
+    end
+  end
+
+  # Shorthand module for accessing the OneOf composer
+  module OneOf
+    # Creates a new instance of `EasyTalk::Types::Composer::OneOf` with the given arguments.
+    #
+    # @param args [Array] the list of arguments to be passed to the constructor
+    # @return [EasyTalk::Types::Composer::OneOf] a new instance
+    def self.[](*)
+      EasyTalk::Types::Composer::OneOf.new(*)
+    end
+  end
+end

data/lib/easy_talk/validation_builder.rb

@@ -0,0 +1,339 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module EasyTalk
+  # The ValidationBuilder creates ActiveModel validations based on JSON Schema constraints
+  class ValidationBuilder
+    # Build validations for a property and apply them to the model class
+    #
+    # @param klass [Class] The model class to apply validations to
+    # @param property_name [Symbol, String] The name of the property
+    # @param type [Class, Object] The type of the property
+    # @param constraints [Hash] The JSON Schema constraints for the property
+    # @return [void]
+    def self.build_validations(klass, property_name, type, constraints)
+      builder = new(klass, property_name, type, constraints)
+      builder.apply_validations
+    end
+
+    # Initialize a new ValidationBuilder
+    #
+    # @param klass [Class] The model class to apply validations to
+    # @param property_name [Symbol, String] The name of the property
+    # @param type [Class, Object] The type of the property
+    # @param constraints [Hash] The JSON Schema constraints for the property
+    attr_reader :klass, :property_name, :type, :constraints
+
+    def initialize(klass, property_name, type, constraints)
+      @klass = klass
+      @property_name = property_name.to_sym
+      @type = type
+      @constraints = constraints || {}
+    end
+
+    # Apply validations based on property type and constraints
+    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 ||
+                   @type.to_s.include?('T::Boolean')
+
+      # Skip presence validation for booleans and nilable types
+      apply_presence_validation unless optional? || is_boolean || nilable_type?
+      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
+
+      # Common validations for most types
+      apply_enum_validation if @constraints[:enum]
+      apply_const_validation if @constraints[:const]
+    end
+
+    private
+
+    # Determine if a property is optional based on constraints and configuration
+    def optional?
+      @constraints[:optional] == true ||
+        (@type.respond_to?(:nilable?) && @type.nilable? && EasyTalk.configuration.nilable_is_optional)
+    end
+
+    # Check if the type is nilable (e.g., T.nilable(String))
+    def nilable_type?
+      @type.respond_to?(:nilable?) && @type.nilable?
+    end
+
+    # Extract the inner type from a complex type like T.nilable(String)
+    def extract_inner_type(type)
+      if type.respond_to?(:unwrap_nilable) && type.unwrap_nilable.respond_to?(:raw_type)
+        type.unwrap_nilable.raw_type
+      elsif type.respond_to?(:types)
+        # For union types like T.nilable(String), extract the non-nil type
+        type.types.find { |t| t.respond_to?(:raw_type) && t.raw_type != NilClass }
+      else
+        type
+      end
+    end
+
+    # Apply validations based on the type of the property
+    def apply_type_validations(type)
+      type_class = get_type_class(type)
+
+      if type_class == String
+        apply_string_validations
+      elsif type_class == Integer
+        apply_integer_validations
+      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) || type.to_s.include?('T::Boolean')
+        apply_boolean_validations
+      elsif type_class.is_a?(Object) && type_class.include?(EasyTalk::Model)
+        apply_object_validations
+      end
+    end
+
+    # Determine the actual class for a type, handling Sorbet types
+    def get_type_class(type)
+      if type.is_a?(Class)
+        type
+      elsif type.respond_to?(:raw_type)
+        type.raw_type
+      elsif type.is_a?(T::Types::TypedArray)
+        Array
+      elsif type.is_a?(Symbol) || type.is_a?(String)
+        begin
+          type.to_s.classify.constantize
+        rescue StandardError
+          String
+        end
+      elsif type.to_s.include?('T::Boolean')
+        [TrueClass, FalseClass] # Return both boolean classes
+      else
+        String # Default fallback
+      end
+    end
+
+    # Add presence validation for the property
+    def apply_presence_validation
+      @klass.validates @property_name, presence: true
+    end
+
+    # Validate string-specific constraints
+    def apply_string_validations
+      # Handle format constraints
+      apply_format_validation(@constraints[:format]) if @constraints[:format]
+
+      # Handle pattern (regex) constraints
+      @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?
+    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
+    end
+
+    # Validate integer-specific constraints
+    def apply_integer_validations
+      apply_numeric_validations(only_integer: true)
+    end
+
+    # Validate number-specific constraints
+    def apply_number_validations
+      apply_numeric_validations(only_integer: false)
+    end
+
+    # 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
+
+      # Add multiple_of validation
+      return unless @constraints[:multiple_of]
+
+      prop_name = @property_name
+      multiple_of_value = @constraints[:multiple_of]
+      @klass.validate do |record|
+        value = record.public_send(prop_name)
+        record.errors.add(prop_name, "must be a multiple of #{multiple_of_value}") if value && (value % multiple_of_value != 0)
+      end
+    end
+
+    # 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]
+
+        @klass.validates @property_name, length: length_options
+      end
+
+      # Validate uniqueness within the array
+      if @constraints[:unique_items]
+        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
+        end
+      end
+
+      # Validate array item types if using T::Array[SomeType]
+      return unless type.respond_to?(:type_parameter)
+
+      inner_type = type.type_parameter
+      prop_name = @property_name
+      @klass.validate do |record|
+        value = record.public_send(prop_name)
+        if value.is_a?(Array)
+          value.each_with_index do |item, index|
+            record.errors.add(prop_name, "item at index #{index} must be a #{inner_type}") unless item.is_a?(inner_type)
+          end
+        end
+      end
+    end
+
+    # 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
+        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?
+        end
+      end
+
+      # Add type validation to ensure the value is actually a boolean
+      prop_name = @property_name
+      @klass.validate do |record|
+        value = record.public_send(prop_name)
+        record.errors.add(prop_name, 'must be a boolean') if value && ![true, false].include?(value)
+      end
+    end
+
+    # Validate object/hash-specific constraints
+    def apply_object_validations
+      # 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)
+
+        # Only validate if the nested object is present
+        if 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")
+            else
+              # If it's the correct type and not empty, validate it
+              unless nested_object.valid?
+                # 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
+              end
+            end
+          else
+            # If present but not the correct type, add a type error
+            record.errors.add(prop_name, "must be a valid #{expected_type.name}")
+          end
+        end
+        # NOTE: Presence validation (if nested_object is nil) is handled
+        # by apply_presence_validation based on the property definition.
+      end
+    end
+
+    # Apply enum validation for inclusion in a specific list
+    def apply_enum_validation
+      @klass.validates @property_name, inclusion: {
+        in: @constraints[:enum],
+        message: "must be one of: #{@constraints[:enum].join(', ')}"
+      }
+    end
+
+    # Apply const validation for equality with a specific value
+    def apply_const_validation
+      const_value = @constraints[:const]
+      prop_name = @property_name
+      @klass.validate do |record|
+        value = record.public_send(prop_name)
+        record.errors.add(prop_name, "must be equal to #{const_value}") if !value.nil? && value != const_value
+      end
+    end
+  end
+end

data/lib/easy_talk/version.rb

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

data/lib/easy_talk.rb

@@ -7,9 +7,7 @@ module EasyTalk
   require 'easy_talk/errors'
   require 'easy_talk/errors_helper'
   require 'easy_talk/configuration'
-  require 'easy_talk/types/any_of'
-  require 'easy_talk/types/all_of'
-  require 'easy_talk/types/one_of'
+  require 'easy_talk/types/composer'
   require 'easy_talk/model'
   require 'easy_talk/property'
   require 'easy_talk/schema_definition'
@@ -24,4 +22,8 @@ module EasyTalk
       ErrorHelper.raise_unknown_option_error(property_name: property_name, option: options, valid_options: valid_keys)
     end
   end
+
+  def self.configure_nilable_behavior(nilable_is_optional = false)
+    configuration.nilable_is_optional = nilable_is_optional
+  end
 end