active-query 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 597183debb31f2b4490361200975eccbeeec9ef03e5d844abfe193e4114284d2
-  data.tar.gz: c82fd9b968a2dffcdd83914ea08bdc7b332453322008e41436d3f7ff7221e53e
+  metadata.gz: 5636b341a804f0c3b2fb42b02b57ac502655c70c1cdc37c7e955004012375181
+  data.tar.gz: 4e48fbc0f6877a05d963aca4aa04bac4cf2691111cc9857381428b3ff9998f22
 SHA512:
-  metadata.gz: c8abf99aad689c83d93223dfa5de1e5e7c2ece56b6235ca6594b50f2b5413a03a06e8fb44dbf815137c3217e5eebf18335f52204450b3aab7899e7064a969d65
-  data.tar.gz: 8c5165ccf7c2463198e39748fcf47f5c92bc916dd5ce6f6b448e5f682c18b88fdfe05d774e385a0f716cb6bc776f822357705834878f1fe96114b2eed74bdf4e
+  metadata.gz: b8c12b1ebe7b7317af9e2201d3cc6a6edc8cda475a2967e175f2e14605f273d87e1fe514045c3597396c7b5291ef83d6470212d41048af0c3a7ed7179b48df39
+  data.tar.gz: ed6ba6312dcf12f8f83594ce2d0557466d495a7c901e351eff1490a641a8afcb9dda96f6885ae935e722ffca3738285b03cf2339380fc1a0c5edf451c8330b51

data/Appraisals

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+appraise 'rails-7.0' do
+  gem 'activerecord', '~> 7.0.0'
+  gem 'activesupport', '~> 7.0.0'
+  gem 'sqlite3', '~> 1.4'
+end
+
+appraise 'rails-7.1' do
+  gem 'activerecord', '~> 7.1.0'
+  gem 'activesupport', '~> 7.1.0'
+  gem 'sqlite3', '~> 1.4'
+end
+
+appraise 'rails-8.0' do
+  gem 'activerecord', '~> 8.0.0'
+  gem 'activesupport', '~> 8.0.0'
+  gem 'sqlite3', '~> 2.1'
+end

data/CHANGELOG.md

@@ -7,6 +7,25 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.0] - 2026-03-11
+
+### Added
+- `ActiveQuery::TypeRegistry` for extensible type validation and coercion — register custom types via `TypeRegistry.register` with a `type_class:`, custom validator lambda, or coercer lambda
+- Built-in type classes (`Types::String`, `Types::Integer`, `Types::Float`, `Types::Boolean`) with default coercion support
+- Per-argument `coerce:` option in argument definitions, taking priority over registry-level coercion
+- `TypeRegistry.unregister` to disable built-in coercion and fall back to strict `is_a?` validation
+- Integer coercion restricted to base-10 strings to prevent unexpected hex/octal conversions
+
+### Fixed
+- Replace `instance_of?` with `is_a?` in type validation so subclass instances (e.g. `ActiveSupport::SafeBuffer`) pass `String` type checks
+
+## [0.1.3] - 2024-12-19
+
+### Added
+- Support for Rails 8.0
+- Compatibility with SQLite3 version 2.1+ required by Rails 8
+- Updated CI matrix to test against Rails 8.0
+
 ## [0.0.1] - 2024-12-19
 
 ### Added
@@ -31,5 +50,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Resolvers**: Support complex query logic with resolver classes
 - **Conditional Logic**: Apply scopes conditionally with `if`/`unless`
 
-[Unreleased]: https://github.com/matiasasis/active-query/compare/v0.0.1...HEAD
+[Unreleased]: https://github.com/matiasasis/active-query/compare/v0.2.0...HEAD
+[0.2.0]: https://github.com/matiasasis/active-query/compare/v0.1.3...v0.2.0
+[0.1.3]: https://github.com/matiasasis/active-query/compare/v0.0.1...v0.1.3
 [0.0.1]: https://github.com/matiasasis/active-query/releases/tag/v0.0.1

data/README.md

@@ -36,14 +36,14 @@ Create a query object by including `ActiveQuery::Base` and defining queries with
 ```ruby
 class UserQuery
   include ActiveQuery::Base
-  
+
   # The model is automatically inferred from the class name (User)
   # Or explicitly set it:
   model_name 'User'
-  
+
   # Simple query without arguments
   query :active, 'Returns all active users', -> { scope.where(active: true) }
-  
+
   # Query with arguments and type validation
   query :by_email, 'Find users by email address',
     { email: { type: String } },
@@ -69,13 +69,13 @@ ActiveQuery supports several argument types with automatic validation:
 ```ruby
 class ProductQuery
   include ActiveQuery::Base
-  
+
   query :filter_products, 'Filter products by various criteria',
     {
       name: { type: String },
       price: { type: Float },
       quantity: { type: Integer },
-      available: { type: ActiveQuery::Base::Boolean }
+      available: { type: Boolean }
     },
     -> (name:, price:, quantity:, available:) {
       scope.where(name: name)
@@ -97,22 +97,84 @@ ProductQuery.filter_products(
 ProductQuery.filter_products(name: 123, price: 'invalid', quantity: true, available: 'yes')
 ```
 
+### Custom Types & Coercion
+
+ActiveQuery includes built-in type coercion for `String`, `Integer`, `Float`, and `Boolean`. When a value doesn't match the expected type, ActiveQuery will attempt to coerce it before validation:
+
+```ruby
+# These all work — coercion converts the values automatically
+ProductQuery.filter_products(name: :widget, price: '19.99', quantity: '10', available: 'true')
+```
+
+**Built-in coercion behavior:**
+
+| Type | Coerces from | Example |
+|------|-------------|---------|
+| `String` | Any (via `.to_s`) | `42` → `"42"` |
+| `Integer` | Numeric strings | `"42"` → `42` |
+| `Float` | Numeric strings, integers | `"1.5"` → `1.5`, `42` → `42.0` |
+| `Boolean` | `"true"`, `"1"`, `1`, `"false"`, `"0"`, `0` | `"true"` → `true` |
+
+**Registering a custom type class:**
+
+Create a class that inherits from `ActiveQuery::Types::Base` and implements `.valid?` and `.coerce`:
+
+```ruby
+# config/initializers/active_query.rb
+class UuidType < ActiveQuery::Types::Base
+  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
+
+  def self.valid?(value)
+    value.is_a?(String) && value.match?(UUID_REGEX)
+  end
+
+  def self.coerce(value)
+    value.to_s.downcase.strip
+  end
+end
+
+ActiveQuery::TypeRegistry.register(UuidType, type_class: UuidType)
+```
+
+**Disabling built-in coercion:**
+
+If you prefer strict type validation without coercion, unregister the built-in type:
+
+```ruby
+# config/initializers/active_query.rb
+ActiveQuery::TypeRegistry.unregister(Integer)  # now "42" won't auto-convert to 42
+```
+
+After unregistering, the type falls back to `is_a?` validation with no coercion.
+
+**Per-argument coercion:**
+
+You can also define coercion on individual arguments using the `coerce:` option:
+
+```ruby
+query :by_number, 'Find by number',
+  { number: { type: Integer, coerce: ->(v) { v.to_i } } },
+  -> (number:) { scope.where(number: number) }
+```
+
+Per-argument `coerce:` takes priority over the global TypeRegistry coercion.
+
 ### Optional Arguments and Defaults
 
 ```ruby
 class OrderQuery
   include ActiveQuery::Base
-  
+
   query :search_orders, 'Search orders with optional filters',
     {
       status: { type: String },
-      paid: { type: ActiveQuery::Base::Boolean, default: true },
+      paid: { type: Boolean, default: true },
       customer_name: { type: String, optional: true }
     },
     -> (status:, paid:, customer_name:) {
       scope.where(status: status)
            .where(paid: paid)
-           .then { |s| customer_name ? s.where('customer_name LIKE ?', "%#{customer_name}%") : s }
+           .if(customer_name, -> { where('customer_name LIKE ?', "%#{customer_name}%") })
     }
 end
 
@@ -129,17 +191,17 @@ Use `if` and `unless` methods for conditional query building:
 ```ruby
 class UserQuery
   include ActiveQuery::Base
-  
+
   query :search_users, 'Search users with conditional filters',
     {
       name: { type: String, optional: true },
-      active: { type: ActiveQuery::Base::Boolean, optional: true }
+      active: { type: Boolean, optional: true }
     },
     -> (name:, active:) {
       scope.if(name.present?, -> { where('name LIKE ?', "%#{name}%") })
            .if(active == true, -> { where(active: true) })
     }
-  
+
   query :filter_unless_admin, 'Filter users unless they are admin',
     {
       role: { type: String, optional: true }
@@ -157,16 +219,16 @@ ActiveQuery provides additional query operations beyond standard ActiveRecord:
 ```ruby
 class ProductQuery
   include ActiveQuery::Base
-  
+
   # Comparison operations
   query :expensive_products, 'Products above price threshold', -> { scope.gt(:price, 100) }
   query :affordable_products, 'Products within budget', -> { scope.lteq(:price, 50) }
-  
-  # Text search operations  
+
+  # Text search operations
   query :search_by_name, 'Search products by name pattern', -> { scope.like(:name, 'Phone') }
   query :products_starting_with, 'Products starting with prefix', -> { scope.start_like(:name, 'iPhone') }
   query :products_ending_with, 'Products ending with suffix', -> { scope.end_like(:name, 'Pro') }
-  
+
   # Dynamic filtering
   query :by_price_range, 'Filter by price range',
     { min_price: { type: Float }, max_price: { type: Float } },
@@ -179,11 +241,11 @@ end
 
 **Available operations:**
 - `gt(column, value)` - greater than
-- `gteq(column, value)` - greater than or equal  
+- `gteq(column, value)` - greater than or equal
 - `lt(column, value)` - less than
 - `lteq(column, value)` - less than or equal
 - `like(column, value)` - contains pattern (wraps with %)
-- `start_like(column, value)` - starts with pattern  
+- `start_like(column, value)` - starts with pattern
 - `end_like(column, value)` - ends with pattern
 
 ### Custom Scopes
@@ -194,18 +256,18 @@ Define reusable scopes within your query objects:
 class UserQuery
   include ActiveQuery::Base
   include ActiveQuery::Scopes
-  
+
   # Define custom scopes
   module Scopes
     include ActiveQuery::Scopes
-    
+
     scope :recent, -> { where('created_at > ?', 1.month.ago) }
     scope :by_role, -> (role:) { where(role: role) }
   end
-  
+
   # Use scopes in queries
   query :recent_admins, 'Find recent admin users', -> { scope.recent.by_role(role: 'admin') }
-  
+
   query :count_recent, 'Count recent users', -> { scope.recent.count }
 end
 ```
@@ -228,11 +290,11 @@ end
 # Use resolver in query object
 class UserQuery
   include ActiveQuery::Base
-  
+
   # Resolver without arguments
-  query :high_value_users, 'Users with many orders', 
+  query :high_value_users, 'Users with many orders',
     resolver: UserStatsResolver
-  
+
   # Resolver with arguments
   query :users_with_orders, 'Users with minimum order count',
     { min_orders: { type: Integer } },
@@ -251,7 +313,7 @@ Query objects provide metadata about available queries:
 ```ruby
 class UserQuery
   include ActiveQuery::Base
-  
+
   query :active, 'Find active users', -> { scope.where(active: true) }
   query :by_name, 'Find by name', { name: { type: String } }, -> (name:) { scope.where(name: name) }
 end
@@ -296,7 +358,7 @@ ActiveQuery works seamlessly with Rails applications:
 # app/queries/user_query.rb
 class UserQuery
   include ActiveQuery::Base
-  
+
   query :active, 'Active users', -> { scope.where(active: true) }
   query :by_role, 'Users by role', { role: { type: String } }, -> (role:) { scope.where(role: role) }
 end
@@ -306,7 +368,7 @@ class UsersController < ApplicationController
   def index
     @users = UserQuery.active
   end
-  
+
   def admins
     @admins = UserQuery.by_role(role: 'admin')
   end
@@ -318,9 +380,23 @@ end
 
 ## Requirements
 
-- Ruby >= 2.6.0
-- ActiveRecord >= 6.1
-- ActiveSupport >= 6.1
+- Ruby >= 3.2.0
+- ActiveRecord >= 6.1, < 9.0
+- ActiveSupport >= 6.1, < 9.0
+
+### Rails 8 Support
+
+ActiveQuery fully supports Rails 8.0! Note that Rails 8 requires SQLite3 version 2.1 or higher:
+
+```ruby
+# For Rails 8 applications
+gem 'sqlite3', '~> 2.1'
+
+# For Rails 7 and below
+gem 'sqlite3', '~> 1.4'
+```
+
+See [RAILS_8_MIGRATION.md](RAILS_8_MIGRATION.md) for detailed migration instructions.
 
 ## Development
 
@@ -328,6 +404,51 @@ After checking out the repo, run `bin/setup` to install dependencies. Then, run
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`.
 
+### Testing Against Multiple Rails Versions
+
+This gem is tested against Rails 7.0, 7.1, and 8.0 to ensure compatibility across versions.
+
+#### Running Tests Locally
+
+To test against all supported Rails versions locally:
+
+```bash
+# Test against all Rails versions
+./bin/test_all_rails
+
+# Test against a specific Rails version
+BUNDLE_GEMFILE=gemfiles/rails_7_0.gemfile bundle exec rake spec
+BUNDLE_GEMFILE=gemfiles/rails_7_1.gemfile bundle exec rake spec
+BUNDLE_GEMFILE=gemfiles/rails_8_0.gemfile bundle exec rake spec
+```
+
+#### Using Appraisal (Alternative Method)
+
+If you prefer using the `appraisal` gem:
+
+```bash
+# Install appraisal gemfiles
+bundle exec appraisal install
+
+# Run tests against all Rails versions
+bundle exec appraisal rake spec
+
+# Run tests against specific Rails version
+bundle exec appraisal rails-7-0 rake spec
+bundle exec appraisal rails-7-1 rake spec
+bundle exec appraisal rails-8-0 rake spec
+```
+
+#### Continuous Integration
+
+The gem uses GitHub Actions to automatically test against multiple Ruby and Rails versions in a matrix configuration. Each push and pull request triggers tests across:
+
+- Ruby versions: 3.2, 3.3
+- Rails versions: 7.0, 7.1, 8.0
+- Appropriate SQLite3 versions for each Rails version (1.4 for Rails 7.x, 2.1+ for Rails 8.0)
+
+See `.github/workflows/main.yml` for the complete CI configuration.
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/matiasasis/active-query. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/matiasasis/active-query/blob/master/CODE_OF_CONDUCT.md).
@@ -338,4 +459,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the ActiveQuery project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/matiasasis/active-query/blob/master/CODE_OF_CONDUCT.md).
+Everyone interacting in the ActiveQuery project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/matiasasis/active-query/blob/master/CODE_OF_CONDUCT.md).

data/active-query.gemspec

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "lib/active_query/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "active-query"
+  spec.version = ActiveQuery::VERSION
+  spec.authors = ["Matias Asis"]
+  spec.email = ["matiasis.90@gmail.com"]
+
+  spec.summary = "ActiveQuery is a gem that helps you to create query objects in a simple way."
+  spec.description = "ActiveQuery is a gem that helps you to create query objects in a simple way. It provides a DSL to define queries and scopes for your query object."
+  spec.homepage = "https://github.com/matiasasis/active-query"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.2.0"
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/matiasasis/active-query"
+  spec.metadata["bug_tracker_uri"] = "https://github.com/matiasasis/active-query/issues"
+  spec.metadata["changelog_uri"] = "https://github.com/matiasasis/active-query/blob/master/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  spec.metadata['rubygems_mfa_required'] = 'true'
+  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/ test/ spec/ features/ .git .github appveyor Gemfile]) ||
+        f.match?(/\.gem\z/)
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  # Dependencies
+  spec.add_dependency 'activerecord', '>= 6.1', '< 9.0'
+  spec.add_dependency 'activesupport', '>= 6.1', '< 9.0'
+
+  # Dev dependencies
+  spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'rspec', '~> 3.9.0'
+  spec.add_development_dependency 'simplecov', '~> 0.17.1'
+  spec.add_development_dependency 'sqlite3', '>= 1.5.1', '< 3.0'
+  spec.add_development_dependency 'database_cleaner-active_record', '~> 2.2.0'
+  spec.add_development_dependency 'byebug', '~> 11.0'
+  spec.add_development_dependency 'appraisal', '~> 2.4'
+end

data/gemfiles/rails_7_0.gemfile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec path: ".."
+
+gem "activerecord", "~> 7.0.0"
+gem "activesupport", "~> 7.0.0"
+gem "sqlite3", "~> 1.4"

data/gemfiles/rails_7_1.gemfile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec path: ".."
+
+gem "activerecord", "~> 7.1.0"
+gem "activesupport", "~> 7.1.0"
+gem "sqlite3", "~> 1.4"

data/gemfiles/rails_8_0.gemfile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec path: ".."
+
+gem "activerecord", "~> 8.0.0"
+gem "activesupport", "~> 8.0.0"
+gem "sqlite3", "~> 2.1"

data/lib/active_query/type_registry.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative 'types/base'
+require_relative 'types/string'
+require_relative 'types/integer'
+require_relative 'types/float'
+require_relative 'types/boolean'
+
+module ActiveQuery
+  module TypeRegistry
+    @validators = {}
+    @coercers = {}
+    @type_classes = {}
+
+    def self.register(type, validator: nil, coerce: nil, type_class: nil)
+      @validators[type] = validator if validator
+      @coercers[type] = coerce if coerce
+      @type_classes[type] = type_class if type_class
+    end
+
+    def self.unregister(type)
+      @validators.delete(type)
+      @coercers.delete(type)
+      @type_classes.delete(type)
+    end
+
+    def self.valid?(type, value)
+      if @validators.key?(type)
+        @validators[type].call(value)
+      elsif @type_classes.key?(type)
+        @type_classes[type].valid?(value)
+      else
+        value.is_a?(type)
+      end
+    end
+
+    def self.coerce(type, value)
+      if @coercers.key?(type)
+        @coercers[type].call(value)
+      elsif @type_classes.key?(type)
+        @type_classes[type].coerce(value)
+      else
+        value
+      end
+    end
+
+    def self.coercer?(type)
+      @coercers.key?(type) || @type_classes.key?(type)
+    end
+
+    register(String, type_class: Types::String)
+    register(Integer, type_class: Types::Integer)
+    register(Float, type_class: Types::Float)
+    register(Types::Boolean, type_class: Types::Boolean)
+  end
+end

data/lib/active_query/types/base.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActiveQuery
+  module Types
+    class Base
+      def self.valid?(_value)
+        raise NotImplementedError, "#{name} must implement .valid?"
+      end
+
+      def self.coerce(value)
+        value
+      end
+    end
+  end
+end

data/lib/active_query/types/boolean.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ActiveQuery
+  module Types
+    class Boolean < Base
+      def self.to_s = 'Boolean'
+      def self.inspect = 'Boolean'
+
+      TRUTHY = [true, 'true', '1', 1].freeze
+      FALSY = [false, 'false', '0', 0].freeze
+
+      def self.valid?(value)
+        value == true || value == false
+      end
+
+      def self.coerce(value)
+        return true if TRUTHY.include?(value)
+        return false if FALSY.include?(value)
+
+        value
+      end
+    end
+  end
+end

data/lib/active_query/types/float.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActiveQuery
+  module Types
+    class Float < Base
+      def self.valid?(value)
+        value.is_a?(::Float)
+      end
+
+      def self.coerce(value)
+        ::Kernel.Float(value)
+      rescue ArgumentError, TypeError
+        value
+      end
+    end
+  end
+end

data/lib/active_query/types/integer.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActiveQuery
+  module Types
+    class Integer < Base
+      def self.valid?(value)
+        value.is_a?(::Integer)
+      end
+
+      def self.coerce(value)
+        ::Kernel.Integer(value, 10)
+      rescue ArgumentError, TypeError
+        value
+      end
+    end
+  end
+end

data/lib/active_query/types/string.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActiveQuery
+  module Types
+    class String < Base
+      def self.valid?(value)
+        value.is_a?(::String)
+      end
+
+      def self.coerce(value)
+        value.to_s
+      end
+    end
+  end
+end

data/lib/active_query/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveQuery
-  VERSION = '0.1.2'
+  VERSION = '0.2.0'
 end

data/lib/active_query.rb

@@ -5,13 +5,14 @@ require 'active_support'
 require 'active_support/concern'
 require_relative 'active_query/version'
 require_relative 'active_query/resolver'
+require_relative 'active_query/type_registry'
 require_relative 'active_record_relation_extensions'
 
 module ActiveQuery
   module Base
     extend ::ActiveSupport::Concern
 
-    class Boolean; end
+    Boolean = ActiveQuery::Types::Boolean
 
     included do
       infer_model
@@ -84,7 +85,7 @@ module ActiveQuery
       def query_with_arguments(name, description, args_def, lambda)
         register_query(name, description, args_def)
 
-        define_singleton_method(name) do |given_args|
+        define_singleton_method(name) do |given_args = {}|
           given_args = validate_args(name, given_args, args_def)
           lambda.call(**given_args)
         end
@@ -139,20 +140,20 @@ module ActiveQuery
         extra_params = given_args.keys - args_def.keys
         raise ArgumentError, "Unknown params: #{extra_params}" unless extra_params.empty?
 
-        given_args.each do |given_arg|
-          given_arg_config = args_def[given_arg.first]
+        given_args.each do |given_arg_name, given_arg_value|
+          given_arg_config = args_def[given_arg_name]
           given_arg_type = given_arg_config[:type]
-          given_arg_name = given_arg.first
-          given_arg_value = given_arg.second
 
-          if given_arg_type == ActiveQuery::Base::Boolean
-            unless given_arg_value == true || given_arg_value == false
-              raise ArgumentError, ":#{given_arg_name} must be of type Boolean"
-            end
-          else
-            unless given_arg_value.instance_of?(given_arg_type)
-              raise ArgumentError, ":#{given_arg_name} must be of type #{given_arg_type}"
-            end
+          if given_arg_config[:coerce]
+            given_args[given_arg_name] = given_arg_config[:coerce].call(given_arg_value)
+            given_arg_value = given_args[given_arg_name]
+          elsif ActiveQuery::TypeRegistry.coercer?(given_arg_type)
+            given_args[given_arg_name] = ActiveQuery::TypeRegistry.coerce(given_arg_type, given_arg_value)
+            given_arg_value = given_args[given_arg_name]
+          end
+
+          unless ActiveQuery::TypeRegistry.valid?(given_arg_type, given_arg_value)
+            raise ArgumentError, ":#{given_arg_name} must be of type #{given_arg_type}"
           end
         end
 

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: active-query
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Matias Asis
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-08-06 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -19,7 +18,7 @@ dependencies:
         version: '6.1'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '8.0'
+        version: '9.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -29,7 +28,7 @@ dependencies:
         version: '6.1'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '8.0'
+        version: '9.0'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -39,7 +38,7 @@ dependencies:
         version: '6.1'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '8.0'
+        version: '9.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -49,7 +48,7 @@ dependencies:
         version: '6.1'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '8.0'
+        version: '9.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -96,16 +95,22 @@ dependencies:
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.5.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.5.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: database_cleaner-active_record
   requirement: !ruby/object:Gem::Requirement
@@ -134,6 +139,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '11.0'
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
 description: ActiveQuery is a gem that helps you to create query objects in a simple
   way. It provides a DSL to define queries and scopes for your query object.
 email:
@@ -145,15 +164,26 @@ extra_rdoc_files: []
 files:
 - ".byebug_history"
 - ".rspec"
+- Appraisals
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - LICENSE.txt
 - README.md
 - Rakefile
+- active-query.gemspec
 - exe/active-query
+- gemfiles/rails_7_0.gemfile
+- gemfiles/rails_7_1.gemfile
+- gemfiles/rails_8_0.gemfile
 - lib/active-query.rb
 - lib/active_query.rb
 - lib/active_query/resolver.rb
+- lib/active_query/type_registry.rb
+- lib/active_query/types/base.rb
+- lib/active_query/types/boolean.rb
+- lib/active_query/types/float.rb
+- lib/active_query/types/integer.rb
+- lib/active_query/types/string.rb
 - lib/active_query/version.rb
 - lib/active_record_relation_extensions.rb
 homepage: https://github.com/matiasasis/active-query
@@ -165,7 +195,6 @@ metadata:
   bug_tracker_uri: https://github.com/matiasasis/active-query/issues
   changelog_uri: https://github.com/matiasasis/active-query/blob/master/CHANGELOG.md
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -173,15 +202,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.15
-signing_key:
+rubygems_version: 4.0.2
 specification_version: 4
 summary: ActiveQuery is a gem that helps you to create query objects in a simple way.
 test_files: []