easy_talk 3.1.0 → 3.2.0

data/lib/easy_talk/validation_builder.rb

@@ -1,327 +1,46 @@
 # frozen_string_literal: true
 
-require 'uri'
-
 module EasyTalk
-  # The ValidationBuilder creates ActiveModel validations based on JSON Schema constraints
+  # @deprecated Use EasyTalk::ValidationAdapters::ActiveModelAdapter instead.
+  #
+  # The ValidationBuilder class is kept for backward compatibility.
+  # It delegates to the ActiveModelAdapter and shows a deprecation warning.
+  #
+  # This class will be removed in a future major version.
+  #
+  # @example Migration
+  #   # Before (deprecated)
+  #   EasyTalk::ValidationBuilder.build_validations(klass, :name, String, {})
+  #
+  #   # After (recommended)
+  #   EasyTalk::ValidationAdapters::ActiveModelAdapter.build_validations(klass, :name, String, {})
+  #
   class ValidationBuilder
-    # Build validations for a property and apply them to the model class
+    @deprecation_warned = false
+
+    # Build validations for a property and apply them to the model class.
     #
+    # @deprecated Use EasyTalk::ValidationAdapters::ActiveModelAdapter.build_validations instead.
     # @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 = @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
-      elsif nilable_type?(type)
-        extract_inner_type(type)
-      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
-      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)
-      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
-    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)
-      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
+      unless @deprecation_warned
+        warn "[DEPRECATION] EasyTalk::ValidationBuilder is deprecated and will be removed in a future version. " \
+             "Use EasyTalk::ValidationAdapters::ActiveModelAdapter instead."
+        @deprecation_warned = true
       end
 
-      # 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
+      ValidationAdapters::ActiveModelAdapter.build_validations(klass, property_name, type, constraints)
     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
+    # Reset the deprecation warning flag (useful for testing).
+    #
+    # @api private
+    def self.reset_deprecation_warning!
+      @deprecation_warned = false
     end
   end
 end

data/lib/easy_talk/version.rb

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

data/lib/easy_talk.rb

@@ -5,15 +5,56 @@ module EasyTalk
   require 'sorbet-runtime'
   require 'easy_talk/sorbet_extension'
   require 'easy_talk/errors'
+  require 'easy_talk/type_introspection'
   require 'easy_talk/errors_helper'
   require 'easy_talk/configuration'
+  require 'easy_talk/schema_methods'
   require 'easy_talk/types/composer'
+
+  # Validation adapters
+  require 'easy_talk/validation_adapters/base'
+  require 'easy_talk/validation_adapters/registry'
+  require 'easy_talk/validation_adapters/active_model_adapter'
+  require 'easy_talk/validation_adapters/none_adapter'
+
+  # Builder registry for pluggable type support
+  require 'easy_talk/builders/registry'
+
   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'
   require 'easy_talk/tools/function_builder'
   require 'easy_talk/version'
 
+  # Register default validation adapters
+  ValidationAdapters::Registry.register_default_adapters
+
+  # Register built-in type builders
+  Builders::Registry.register_built_in_types
+
+  # Register a custom type with its corresponding schema builder.
+  #
+  # This allows extending EasyTalk with domain-specific types without
+  # modifying the gem's source code.
+  #
+  # @param type_key [Class, String, Symbol] The type to register
+  # @param builder_class [Class] The builder class that generates JSON Schema
+  # @param collection [Boolean] Whether this is a collection type builder
+  #   Collection builders receive (name, type, constraints) instead of (name, constraints)
+  # @return [void]
+  #
+  # @example Register a custom Money type
+  #   EasyTalk.register_type(Money, MoneySchemaBuilder)
+  #
+  # @example Register a collection type
+  #   EasyTalk.register_type(CustomArray, CustomArrayBuilder, collection: true)
+  def self.register_type(type_key, builder_class, collection: false)
+    Builders::Registry.register(type_key, builder_class, collection: collection)
+  end
+
   def self.assert_valid_property_options(property_name, options, *valid_keys)
     valid_keys.flatten!
     options.each_key do |k|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: easy_talk
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 3.2.0
 platform: ruby
 authors:
 - Sergio Bayona
@@ -86,19 +86,22 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".rubocop.yml"
+- ".yardopts"
 - CHANGELOG.md
 - CONSTRAINTS.md
 - LICENSE.txt
 - README.md
 - Rakefile
 - docs/.gitignore
-- docs/404.html
 - docs/Gemfile
 - docs/_config.yml
-- docs/_posts/2024-05-07-welcome-to-jekyll.markdown
 - docs/about.markdown
+- docs/getting-started.markdown
 - docs/index.markdown
-- easy_talk.gemspec
+- docs/json_schema_compliance.md
+- docs/nested-models.markdown
+- docs/property-types.markdown
+- docs/schema-definition.markdown
 - lib/easy_talk.rb
 - lib/easy_talk/builders/base_builder.rb
 - lib/easy_talk/builders/boolean_builder.rb
@@ -108,21 +111,40 @@ files:
 - lib/easy_talk/builders/null_builder.rb
 - lib/easy_talk/builders/number_builder.rb
 - lib/easy_talk/builders/object_builder.rb
+- lib/easy_talk/builders/registry.rb
 - lib/easy_talk/builders/string_builder.rb
 - lib/easy_talk/builders/temporal_builder.rb
 - lib/easy_talk/builders/typed_array_builder.rb
 - lib/easy_talk/builders/union_builder.rb
 - lib/easy_talk/configuration.rb
+- lib/easy_talk/error_formatter.rb
+- lib/easy_talk/error_formatter/base.rb
+- lib/easy_talk/error_formatter/error_code_mapper.rb
+- lib/easy_talk/error_formatter/flat.rb
+- lib/easy_talk/error_formatter/json_pointer.rb
+- lib/easy_talk/error_formatter/jsonapi.rb
+- lib/easy_talk/error_formatter/path_converter.rb
+- lib/easy_talk/error_formatter/rfc7807.rb
 - lib/easy_talk/errors.rb
 - lib/easy_talk/errors_helper.rb
 - lib/easy_talk/keywords.rb
 - lib/easy_talk/model.rb
+- lib/easy_talk/model_helper.rb
+- lib/easy_talk/naming_strategies.rb
 - lib/easy_talk/property.rb
+- lib/easy_talk/ref_helper.rb
+- lib/easy_talk/schema.rb
 - lib/easy_talk/schema_definition.rb
+- lib/easy_talk/schema_methods.rb
 - lib/easy_talk/sorbet_extension.rb
 - lib/easy_talk/tools/function_builder.rb
+- lib/easy_talk/type_introspection.rb
 - lib/easy_talk/types/base_composer.rb
 - lib/easy_talk/types/composer.rb
+- lib/easy_talk/validation_adapters/active_model_adapter.rb
+- lib/easy_talk/validation_adapters/base.rb
+- lib/easy_talk/validation_adapters/none_adapter.rb
+- lib/easy_talk/validation_adapters/registry.rb
 - lib/easy_talk/validation_builder.rb
 - lib/easy_talk/version.rb
 homepage: https://github.com/sergiobayona/easy_talk

data/docs/404.html

@@ -1,25 +0,0 @@
----
-permalink: /404.html
-layout: default
----
-
-<style type="text/css" media="screen">
-  .container {
-    margin: 10px auto;
-    max-width: 600px;
-    text-align: center;
-  }
-  h1 {
-    margin: 30px 0;
-    font-size: 4em;
-    line-height: 1;
-    letter-spacing: -1px;
-  }
-</style>
-
-<div class="container">
-  <h1>404</h1>
-
-  <p><strong>Page not found :(</strong></p>
-  <p>The requested page could not be found.</p>
-</div>

data/docs/_posts/2024-05-07-welcome-to-jekyll.markdown

@@ -1,29 +0,0 @@
----
-layout: post
-title:  "Welcome to Jekyll!"
-date:   2024-05-07 18:39:19 -0500
-categories: jekyll update
----
-You’ll find this post in your `_posts` directory. Go ahead and edit it and re-build the site to see your changes. You can rebuild the site in many different ways, but the most common way is to run `jekyll serve`, which launches a web server and auto-regenerates your site when a file is updated.
-
-Jekyll requires blog post files to be named according to the following format:
-
-`YEAR-MONTH-DAY-title.MARKUP`
-
-Where `YEAR` is a four-digit number, `MONTH` and `DAY` are both two-digit numbers, and `MARKUP` is the file extension representing the format used in the file. After that, include the necessary front matter. Take a look at the source for this post to get an idea about how it works.
-
-Jekyll also offers powerful support for code snippets:
-
-{% highlight ruby %}
-def print_hi(name)
-  puts "Hi, #{name}"
-end
-print_hi('Tom')
-#=> prints 'Hi, Tom' to STDOUT.
-{% endhighlight %}
-
-Check out the [Jekyll docs][jekyll-docs] for more info on how to get the most out of Jekyll. File all bugs/feature requests at [Jekyll’s GitHub repo][jekyll-gh]. If you have questions, you can ask them on [Jekyll Talk][jekyll-talk].
-
-[jekyll-docs]: https://jekyllrb.com/docs/home
-[jekyll-gh]:   https://github.com/jekyll/jekyll
-[jekyll-talk]: https://talk.jekyllrb.com/

data/easy_talk.gemspec

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'lib/easy_talk/version'
-
-Gem::Specification.new do |spec|
-  spec.name = 'easy_talk'
-  spec.version = EasyTalk::VERSION
-  spec.authors = ['Sergio Bayona']
-  spec.email = ['bayona.sergio@gmail.com']
-
-  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'
-
-  spec.metadata['allowed_push_host'] = 'https://rubygems.org'
-
-  spec.metadata['homepage_uri'] = spec.homepage
-  spec.metadata['changelog_uri'] = 'https://github.com/sergiobayona/easy_talk/blob/main/CHANGELOG.md'
-
-  # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files = Dir.chdir(__dir__) do
-    `git ls-files -z`.split("\x0").reject do |f|
-      (File.expand_path(f) == __FILE__) ||
-        f.start_with?(*%w[bin/ spec/ .git .github Gemfile])
-    end
-  end
-
-  spec.require_paths = ['lib']
-
-  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'
-end