easy_talk 1.0.4 → 2.0.0

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.4'
+  VERSION = '2.0.0'
 end

metadata

@@ -1,196 +1,56 @@
 --- !ruby/object:Gem::Specification
 name: easy_talk
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 2.0.0
 platform: ruby
 authors:
 - Sergio Bayona
 bindir: bin
 cert_chain: []
-date: 2025-03-12 00:00:00.000000000 Z
+date: 2025-06-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '7.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '7.0'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '7.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '7.0'
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.5'
-- !ruby/object:Gem::Dependency
-  name: activerecord
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '7.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '7.0'
-- !ruby/object:Gem::Dependency
-  name: pry-byebug
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '3.10'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '3.10'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '13.1'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '13.1'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: rspec-json_expectations
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.0'
-- !ruby/object:Gem::Dependency
-  name: rspec-mocks
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '3.13'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '3.13'
-- !ruby/object:Gem::Dependency
-  name: rubocop
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.21'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.21'
-- !ruby/object:Gem::Dependency
-  name: rubocop-rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0.6'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0.6'
-- !ruby/object:Gem::Dependency
-  name: rubocop-rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.29'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.29'
-- !ruby/object:Gem::Dependency
-  name: sqlite3
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2'
 description: Generate json-schema from plain Ruby classes.
 email:
 - bayona.sergio@gmail.com
@@ -211,6 +71,7 @@ files:
 - docs/_posts/2024-05-07-welcome-to-jekyll.markdown
 - docs/about.markdown
 - docs/index.markdown
+- easy_talk.gemspec
 - lib/easy_talk.rb
 - lib/easy_talk/active_record_schema_builder.rb
 - lib/easy_talk/builders/base_builder.rb
@@ -236,6 +97,7 @@ files:
 - lib/easy_talk/tools/function_builder.rb
 - lib/easy_talk/types/base_composer.rb
 - lib/easy_talk/types/composer.rb
+- lib/easy_talk/validation_builder.rb
 - lib/easy_talk/version.rb
 homepage: https://github.com/sergiobayona/easy_talk
 licenses:
@@ -243,8 +105,8 @@ licenses:
 metadata:
   allowed_push_host: https://rubygems.org
   homepage_uri: https://github.com/sergiobayona/easy_talk
-  source_code_uri: https://github.com/sergiobayona/easy_talk
   changelog_uri: https://github.com/sergiobayona/easy_talk/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib