easy_talk 2.0.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e6244697afea285526b5b9cd3b58d036f3dd00e99ba25703777076a2c21a8f49
-  data.tar.gz: 6cc2cc8f918d064d0907f56f234bc8e4cfa30497292559d9690bfc0dd8377522
+  metadata.gz: ce558538c73afc10d98c0c6b5e38e68ce033a79d1c212bb91fede27f10fb3523
+  data.tar.gz: e46a7a67b6c1a3209108a800cefca8659381236c23ce14986e971babd874908d
 SHA512:
-  metadata.gz: 25e6c5f5eee7497bb4cddc0eb7f13beceafb551b0b7e5a2322467ec41e18ac66524ec4162307c881db65c6dc39a8e465fea8ddfcfcb6373ba07b4daf4ed68358
-  data.tar.gz: 6d1b2f9635436aa41b8eb83c3eb40d9af9ce8f984e76d3ad36bf9f4025e26e3c774e286ca6886ad48e5fa48f38142fcf3208a9b2b2b201e936fde07d8e91283a
+  metadata.gz: b523e6cd50edc0594d98fffdb8a9de0616e5f58a2af435a23e5f4a81ac54b25692cd0bccba71c93eca812022efd298b2a9d654b34e3b8f37301ea8e7b16a4de3
+  data.tar.gz: 7f287df819b0e09ddf5fce9506f045860dea876b0653cf7ede7dfb58e7a1d78e545933946921f0dfb4f1f02709357629f0b071c53e7c4ff945cdcf1908f5c2b6

data/CHANGELOG.md

@@ -1,3 +1,29 @@
+## [3.0.0] - 2025-01-03
+
+### BREAKING CHANGES
+- **Removed ActiveRecord Support**: Completely removed ActiveRecord integration including:
+  - Deleted `ActiveRecordSchemaBuilder` class and database schema introspection
+  - Removed `enhance_schema` method for ActiveRecord models
+  - Removed ActiveRecord-specific configuration options (`excluded_columns`, `exclude_foreign_keys`, 
+    `exclude_primary_key`, `exclude_timestamps`, `exclude_associations`)
+  - Deleted all ActiveRecord integration tests
+
+### Changed  
+- **Simplified Architecture**: EasyTalk now focuses exclusively on Plain Ruby classes with ActiveModel integration
+- **Unified Integration Path**: All models now follow the same integration pattern using `ActiveModel::API` and `ActiveModel::Validations`
+- **Streamlined Configuration**: Removed ActiveRecord-specific configuration options, keeping only core options
+- **Updated Documentation**: Removed ActiveRecord examples and configuration references from README
+
+### Fixed
+- **Code Quality**: Fixed ValidationBuilder class length violation by consolidating format validation methods
+- **Documentation**: Updated all examples to use `define_schema` pattern instead of removed `enhance_schema`
+
+### Migration Guide
+If you were using EasyTalk with ActiveRecord models:
+- Replace `enhance_schema` calls with `define_schema` blocks
+- Manually define properties instead of relying on database schema introspection  
+- Remove ActiveRecord-specific configuration options from your EasyTalk.configure blocks
+
 ## [2.0.0] - 2025-06-05
 
   ### Added

data/README.md

@@ -11,7 +11,7 @@ EasyTalk is a Ruby library that simplifies defining and generating JSON Schema.
 ### Key Features
 * **Intuitive Schema Definition**: Use Ruby classes and methods to define JSON Schema documents easily.
 * **Automatic ActiveModel Validations**: Schema constraints automatically generate corresponding ActiveModel validations (configurable).
-* **Works for plain Ruby classes and ActiveRecord models**: Integrate with existing code or build from scratch.
+* **Works for plain Ruby classes and ActiveModel classes**: Integrate with existing code or build from scratch.
 * **LLM Function Support**: Ideal for integrating with Large Language Models (LLMs) such as OpenAI's GPT series. EasyTalk enables you to effortlessly create JSON Schema documents describing the inputs and outputs of LLM function calls.
 * **Schema Composition**: Define EasyTalk models and reference them in other EasyTalk models to create complex schemas.
 * **Enhanced Model Integration**: Automatic instantiation of nested EasyTalk models from hash attributes.
@@ -518,119 +518,6 @@ user.address.class # => Address (automatically instantiated)
 user.address.street # => "123 Main St"
 ```
 
-## ActiveRecord Integration
-
-### Automatic Schema Generation
-For ActiveRecord models, EasyTalk automatically generates a schema based on the database columns:
-
-```ruby
-class Product < ActiveRecord::Base
-  include EasyTalk::Model
-end
-```
-
-This will create a schema with properties for each column in the `products` table.
-
-### Enhancing Generated Schemas
-You can enhance the auto-generated schema with the `enhance_schema` method:
-
-```ruby
-class Product < ActiveRecord::Base
-  include EasyTalk::Model
-  
-  enhance_schema({
-    title: "Retail Product",
-    description: "A product available for purchase",
-    properties: {
-      name: {
-        description: "Product display name",
-        title: "Product Name"
-      },
-      price: {
-        description: "Retail price in USD"
-      }
-    }
-  })
-end
-```
-
-### Column Exclusion Options
-EasyTalk provides several ways to exclude columns from your JSON schema:
-
-#### 1. Global Configuration
-
-```ruby
-EasyTalk.configure do |config|
-  # Exclude specific columns by name from all models
-  config.excluded_columns = [:created_at, :updated_at, :deleted_at]
-  
-  # Exclude all foreign key columns (columns ending with '_id')
-  config.exclude_foreign_keys = true   # Default: false
-  
-  # Exclude all primary key columns ('id')
-  config.exclude_primary_key = true    # Default: true
-  
-  # Exclude timestamp columns ('created_at', 'updated_at')
-  config.exclude_timestamps = true     # Default: true
-  
-  # Exclude all association properties
-  config.exclude_associations = true   # Default: false
-end
-```
-
-#### 2. Model-Specific Column Ignoring
-
-```ruby
-class Product < ActiveRecord::Base
-  include EasyTalk::Model
-  
-  enhance_schema({
-    ignore: [:internal_ref_id, :legacy_code]  # Model-specific exclusions
-  })
-end
-```
-
-### Virtual Properties
-You can add properties that don't exist as database columns:
-
-```ruby
-class Product < ActiveRecord::Base
-  include EasyTalk::Model
-  
-  enhance_schema({
-    properties: {
-      full_details: {
-        virtual: true,
-        type: :string,
-        description: "Complete product information"
-      }
-    }
-  })
-end
-```
-
-### Associations and Foreign Keys
-By default, EasyTalk includes your model's associations in the schema:
-
-```ruby
-class Product < ActiveRecord::Base
-  include EasyTalk::Model
-  belongs_to :category
-  has_many :reviews
-end
-```
-
-This will include `category` (as an object) and `reviews` (as an array) in the schema.
-
-You can control this behavior with configuration:
-
-```ruby
-EasyTalk.configure do |config|
-  config.exclude_associations = true    # Don't include associations  
-  config.exclude_foreign_keys = true    # Don't include foreign key columns
-end
-```
-
 ## Advanced Features
 
 ### LLM Function Generation
@@ -698,19 +585,10 @@ You can configure EasyTalk globally:
 
 ```ruby
 EasyTalk.configure do |config|
-  # ActiveRecord integration options
-  config.excluded_columns = [:created_at, :updated_at, :deleted_at]
-  config.exclude_foreign_keys = true
-  config.exclude_primary_key = true
-  config.exclude_timestamps = true
-  config.exclude_associations = false
-  
   # Schema behavior options
-  config.default_additional_properties = false
-  config.nilable_is_optional = false  # Makes T.nilable properties also optional
-  
-  # NEW in v2.0.0: Automatic validation generation
-  config.auto_validations = true      # Automatically generate ActiveModel validations
+  config.default_additional_properties = false  # Control additional properties on all models
+  config.nilable_is_optional = false           # Makes T.nilable properties also optional
+  config.auto_validations = true               # Automatically generate ActiveModel validations
 end
 ```
 
@@ -738,45 +616,18 @@ end
 ```
 
 ### Per-Model Configuration
-Some settings can be configured per model:
-
-```ruby
-class Product < ActiveRecord::Base
-  include EasyTalk::Model
-  
-  enhance_schema({
-    additionalProperties: true,
-    ignore: [:internal_ref_id, :legacy_code]
-  })
-end
-```
-
-### Exclusion Rules
-Columns are excluded based on the following rules (in order of precedence):
-
-1. Explicitly listed in `excluded_columns` global setting
-2. Listed in the model's `schema_enhancements[:ignore]` array
-3. Is a primary key when `exclude_primary_key` is true (default)
-4. Is a timestamp column when `exclude_timestamps` is true (default)
-5. Matches a foreign key pattern when `exclude_foreign_keys` is true
-
-### Customizing Output
-You can customize the JSON Schema output by enhancing the schema:
+You can configure additional properties for individual models:
 
 ```ruby
-class User < ActiveRecord::Base
+class User
   include EasyTalk::Model
   
-  enhance_schema({
-    title: "User Account",
-    description: "User account information",
-    properties: {
-      name: {
-        title: "Full Name",
-        description: "User's full name"
-      }
-    }
-  })
+  define_schema do
+    title "User"
+    additional_properties true  # Allow arbitrary additional properties on this model
+    property :name, String
+    property :email, String, format: "email"
+  end
 end
 ```
 
@@ -1277,7 +1128,7 @@ EasyTalk.configure do |config|
   
   # Existing options (unchanged)
   config.nilable_is_optional = false
-  config.exclude_foreign_keys = true
+  config.default_additional_properties = false
   # ... other existing config
 end
 ```
@@ -1287,7 +1138,7 @@ end
 - **Ruby Version**: Still requires Ruby 3.2+
 - **Dependencies**: Core dependencies remain the same
 - **JSON Schema Output**: No changes to generated schemas
-- **ActiveRecord Integration**: Fully backward compatible
+- **ActiveModel Integration**: Fully backward compatible
 
 ## Development and Contributing
 

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/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/configuration.rb

@@ -2,19 +2,12 @@
 
 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
+    attr_accessor :default_additional_properties, :nilable_is_optional, :auto_validations
 
     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
     end
   end
 

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
@@ -225,34 +220,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

@@ -189,7 +189,7 @@ 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
 

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.0.0'
 end

metadata

@@ -1,42 +1,68 @@
 --- !ruby/object:Gem::Specification
 name: easy_talk
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Sergio Bayona
 bindir: bin
 cert_chain: []
-date: 2025-06-05 00:00:00.000000000 Z
+date: 2025-09-03 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'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '7.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '7.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '7.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+- !ruby/object:Gem::Dependency
+  name: js_regex
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
   requirement: !ruby/object:Gem::Requirement
@@ -51,7 +77,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.5'
-description: Generate json-schema from plain Ruby classes.
+description: Generate json-schema from plain Ruby classes with ActiveModel integration
+  for validations and serialization.
 email:
 - bayona.sergio@gmail.com
 executables: []
@@ -73,7 +100,6 @@ files:
 - 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
 - lib/easy_talk/builders/boolean_builder.rb
 - lib/easy_talk/builders/collection_helpers.rb
@@ -123,5 +149,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.2
 specification_version: 4
-summary: Generate json-schema from Ruby classes.
+summary: Generate json-schema from Ruby classes with ActiveModel integration.
 test_files: []

data/lib/easy_talk/active_record_schema_builder.rb

@@ -1,299 +0,0 @@
-# frozen_string_literal: true
-
-module EasyTalk
-  # This class is responsible for building a SchemaDefinition from an ActiveRecord model
-  # It analyzes the database schema and creates a SchemaDefinition that can be
-  # passed to ObjectBuilder for final schema generation
-  class ActiveRecordSchemaBuilder
-    # Mapping of ActiveRecord column types to Ruby classes
-    COLUMN_TYPE_MAP = {
-      string: String,
-      text: String,
-      integer: Integer,
-      bigint: Integer,
-      float: Float,
-      decimal: Float,
-      boolean: T::Boolean,
-      date: Date,
-      datetime: DateTime,
-      timestamp: DateTime,
-      time: Time,
-      json: Hash,
-      jsonb: Hash
-    }.freeze
-
-    # Mapping for format constraints based on column type
-    FORMAT_MAP = {
-      date: 'date',
-      datetime: 'date-time',
-      timestamp: 'date-time',
-      time: 'time'
-    }.freeze
-
-    attr_reader :model
-
-    # Initialize the builder with an ActiveRecord model
-    #
-    # @param model [Class] An ActiveRecord model class
-    # @raise [ArgumentError] If the provided class is not an ActiveRecord model
-    def initialize(model)
-      raise ArgumentError, 'Class must be an ActiveRecord model' unless model.ancestors.include?(ActiveRecord::Base)
-
-      @model = model
-    end
-
-    # Build a SchemaDefinition object from the ActiveRecord model
-    #
-    # @return [EasyTalk::SchemaDefinition] A schema definition built from the database structure
-    def build_schema_definition
-      schema_def = SchemaDefinition.new(model.name)
-
-      # Apply basic schema metadata
-      apply_schema_metadata(schema_def)
-
-      # Add all database columns as properties
-      add_column_properties(schema_def)
-
-      # Add model associations as properties
-      add_association_properties(schema_def) unless EasyTalk.configuration.exclude_associations
-
-      # Add virtual properties defined in schema_enhancements
-      add_virtual_properties(schema_def)
-
-      schema_def
-    end
-
-    private
-
-    # Set top-level schema metadata like title, description, and additionalProperties
-    #
-    # @param schema_def [EasyTalk::SchemaDefinition] The schema definition to modify
-    def apply_schema_metadata(schema_def)
-      # Set title (from enhancements or derive from model name)
-      title = schema_enhancements['title'] || model.name.demodulize.humanize
-      schema_def.title(title)
-
-      # Set description if provided
-      if (description = schema_enhancements['description'])
-        schema_def.description(description)
-      end
-
-      # Set additionalProperties (from enhancements or configuration default)
-      additional_props = if schema_enhancements.key?('additionalProperties')
-                           schema_enhancements['additionalProperties']
-                         else
-                           EasyTalk.configuration.default_additional_properties
-                         end
-      schema_def.additional_properties(additional_props)
-    end
-
-    # Add properties based on database columns
-    #
-    # @param schema_def [EasyTalk::SchemaDefinition] The schema definition to modify
-    def add_column_properties(schema_def)
-      filtered_columns.each do |column|
-        # Get column enhancement info if it exists
-        column_enhancements = schema_enhancements.dig('properties', column.name.to_s) || {}
-
-        # Map the database type to Ruby type
-        ruby_type = COLUMN_TYPE_MAP.fetch(column.type, String)
-
-        # If the column is nullable, wrap the type in a Union with NilClass
-        ruby_type = T::Types::Union.new([ruby_type, NilClass]) if column.null
-
-        # Build constraints hash for this column
-        constraints = build_column_constraints(column, column_enhancements)
-
-        # Add the property to schema definition
-        schema_def.property(column.name.to_sym, ruby_type, constraints)
-      end
-    end
-
-    # Build constraints hash for a database column
-    #
-    # @param column [ActiveRecord::ConnectionAdapters::Column] The database column
-    # @param enhancements [Hash] Any schema enhancements for this column
-    # @return [Hash] The constraints hash
-    def build_column_constraints(column, enhancements)
-      constraints = {
-        optional: enhancements['optional'],
-        description: enhancements['description'],
-        title: enhancements['title']
-      }
-
-      # Add format constraint for date/time columns
-      if (format = FORMAT_MAP[column.type])
-        constraints[:format] = format
-      end
-
-      # Add max_length for string columns with limits
-      constraints[:max_length] = column.limit if column.type == :string && column.limit
-
-      # Add precision/scale for numeric columns
-      if column.type == :decimal && column.precision
-        constraints[:precision] = column.precision
-        constraints[:scale] = column.scale if column.scale
-      end
-
-      # Add default value if present and not a proc
-      if column.default && !column.default.is_a?(Proc) && column.type == :boolean
-        constraints[:default] = ActiveModel::Type::Boolean.new.cast(column.default)
-      elsif column.default && !column.default.is_a?(Proc)
-        constraints[:default] = column.default
-      end
-
-      # Remove nil values
-      constraints.compact
-    end
-
-    # Add properties based on ActiveRecord associations
-    #
-    # @param schema_def [EasyTalk::SchemaDefinition] The schema definition to modify
-    def add_association_properties(schema_def)
-      model.reflect_on_all_associations.each do |association|
-        # Skip if we can't determine the class or it's in the association exclusion list
-        next if association_excluded?(association)
-
-        # Get association enhancement info if it exists
-        assoc_enhancements = schema_enhancements.dig('properties', association.name.to_s) || {}
-
-        case association.macro
-        when :belongs_to, :has_one
-          schema_def.property(
-            association.name,
-            association.klass,
-            { optional: assoc_enhancements['optional'], description: assoc_enhancements['description'] }.compact
-          )
-        when :has_many, :has_and_belongs_to_many
-          schema_def.property(
-            association.name,
-            T::Array[association.klass],
-            { optional: assoc_enhancements['optional'], description: assoc_enhancements['description'] }.compact
-          )
-        end
-      end
-    end
-
-    # Add virtual properties defined in schema_enhancements
-    #
-    # @param schema_def [EasyTalk::SchemaDefinition] The schema definition to modify
-    def add_virtual_properties(schema_def)
-      return unless schema_enhancements['properties']
-
-      schema_enhancements['properties'].each do |name, options|
-        next unless options['virtual']
-
-        # Map string type name to Ruby class
-        ruby_type = map_type_string_to_ruby_class(options['type'] || 'string')
-
-        # Build constraints for virtual property
-        constraints = {
-          description: options['description'],
-          title: options['title'],
-          optional: options['optional'],
-          format: options['format'],
-          default: options['default'],
-          min_length: options['minLength'],
-          max_length: options['maxLength'],
-          enum: options['enum']
-        }.compact
-
-        # Add the virtual property
-        schema_def.property(name.to_sym, ruby_type, constraints)
-      end
-    end
-
-    # Map a type string to a Ruby class
-    #
-    # @param type_str [String] The type string (e.g., 'string', 'integer')
-    # @return [Class] The corresponding Ruby class
-    def map_type_string_to_ruby_class(type_str)
-      case type_str.to_s.downcase
-      when 'string' then String
-      when 'integer' then Integer
-      when 'number' then Float
-      when 'boolean' then T::Boolean
-      when 'object' then Hash
-      when 'array' then Array
-      when 'date' then Date
-      when 'datetime' then DateTime
-      when 'time' then Time
-      else String # Default fallback
-      end
-    end
-
-    # Get all columns that should be included in the schema
-    #
-    # @return [Array<ActiveRecord::ConnectionAdapters::Column>] Filtered columns
-    def filtered_columns
-      model.columns.reject do |column|
-        config = EasyTalk.configuration
-        excluded_columns.include?(column.name.to_sym) ||
-          (config.exclude_primary_key && column.name == model.primary_key) ||
-          (config.exclude_timestamps && timestamp_column?(column.name)) ||
-          (config.exclude_foreign_keys && foreign_key_column?(column.name))
-      end
-    end
-
-    # Check if a column is a timestamp column
-    #
-    # @param column_name [String] The column name
-    # @return [Boolean] True if the column is a timestamp column
-    def timestamp_column?(column_name)
-      %w[created_at updated_at].include?(column_name)
-    end
-
-    # Check if a column is a foreign key column
-    #
-    # @param column_name [String] The column name
-    # @return [Boolean] True if the column is a foreign key column
-    def foreign_key_column?(column_name)
-      column_name.end_with?('_id')
-    end
-
-    # Check if an association should be excluded
-    #
-    # @param association [ActiveRecord::Reflection::AssociationReflection] The association
-    # @return [Boolean] True if the association should be excluded
-    def association_excluded?(association)
-      !association.klass ||
-        excluded_associations.include?(association.name.to_sym) ||
-        association.options[:polymorphic] # Skip polymorphic associations (complex to model)
-    end
-
-    # Get schema enhancements
-    #
-    # @return [Hash] Schema enhancements
-    def schema_enhancements
-      @schema_enhancements ||= if model.respond_to?(:schema_enhancements)
-                                 model.schema_enhancements.deep_transform_keys(&:to_s)
-                               else
-                                 {}
-                               end
-    end
-
-    # Get all excluded columns
-    #
-    # @return [Array<Symbol>] Excluded column names
-    def excluded_columns
-      @excluded_columns ||= begin
-        config = EasyTalk.configuration
-        global_exclusions = config.excluded_columns || []
-        model_exclusions = schema_enhancements['ignore'] || []
-
-        # Combine and convert to symbols for consistent comparison
-        (global_exclusions + model_exclusions).map(&:to_sym)
-      end
-    end
-
-    # Get all excluded associations
-    #
-    # @return [Array<Symbol>] Excluded association names
-    def excluded_associations
-      @excluded_associations ||= begin
-        model_exclusions = schema_enhancements['ignore_associations'] || []
-        model_exclusions.map(&:to_sym)
-      end
-    end
-  end
-end