active-query 0.1.3 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 426f4c764e93fcdacda7b354b9f4597ced451648ac4a0e56052f9cfc239f6d3f
-  data.tar.gz: b8e7db1ca8f99f4851a469feb412539c93a41e66f2d9d676ff619197dacf53a9
+  metadata.gz: bafd618669b6562ca622703d0b758b27fdc2ea64d031569a44757db21230cb71
+  data.tar.gz: 35328a7159020c14d201d2735d8f364073418383819efcaad260be8e6911a83f
 SHA512:
-  metadata.gz: 5437dc8c0c0e0ca61883a52799bc927c5bc710d708192be2fb1bd661c2f638e188d842be6098f3692d9fbd515a5659cdf881d684d49425ec9212e8d0b0d119b6
-  data.tar.gz: 7352b91b01bfa4fe0e96a9d6ad026f6a8ad6e1182d372e879c4eb0fdf453f2f410cd3f0016426b4a22ff9e42dd1f5cd6a45d21269340d20d89c87173142889f7
+  metadata.gz: f97020cced56e3f51ebb51c5c2844dafd408498d4a52b53722b542c9dfc5ae09e5838dede66601a01e0d6ccf1b8f764f1e6af791b416fd0d436103c0c494ff4a
+  data.tar.gz: 74ab0d6a7c1bb23475827832d87178112ff221f02dca5eb74b5a67703c4ec461f21e2499ed2deae15c09d609b63df7586ce6d8f5a124c8efb0e42c4bf63d0333

data/CHANGELOG.md

@@ -7,6 +7,27 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.1] - 2026-03-19
+
+### Added
+- `ActiveQuery::Base.registry` — a global registry tracking all classes that include `ActiveQuery::Base`, enabling programmatic discovery of query objects in an application
+
+### Fixed
+- Registry support for intermediary concern pattern (e.g. classes that include `ActiveQuery::Base` through an intermediate concern like `HireartQuery::Base`)
+- Guard `infer_model` against anonymous classes with nil name
+
+## [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
@@ -38,6 +59,8 @@ 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.1.3...HEAD
+[Unreleased]: https://github.com/matiasasis/active-query/compare/v0.2.1...HEAD
+[0.2.1]: https://github.com/matiasasis/active-query/compare/v0.2.0...v0.2.1
+[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

@@ -11,6 +11,7 @@ ActiveQuery is a Ruby gem that helps you create clean, reusable query objects wi
 - **Conditional Logic**: Apply scopes conditionally with `if` and `unless`
 - **Resolver Pattern**: Support for complex query logic in separate classes
 - **Custom Scopes**: Define reusable scopes within query objects
+- **Global Registry**: Discover all query objects in your application at runtime
 - **ActiveRecord Integration**: Works seamlessly with ActiveRecord models
 
 ## Installation
@@ -97,6 +98,68 @@ 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
@@ -264,6 +327,44 @@ UserQuery.queries
 # ]
 ```
 
+### Global Query Registry
+
+`ActiveQuery::Base` maintains a global registry of all classes that include it, enabling programmatic discovery of every query object in your application:
+
+```ruby
+# All query objects are automatically registered
+class UserQuery
+  include ActiveQuery::Base
+  # ...
+end
+
+class ProductQuery
+  include ActiveQuery::Base
+  # ...
+end
+
+# Discover all registered query objects
+ActiveQuery::Base.registry
+# => [UserQuery, ProductQuery]
+```
+
+This also works when including `ActiveQuery::Base` through an intermediary concern:
+
+```ruby
+module ApplicationQuery
+  extend ActiveSupport::Concern
+  include ActiveQuery::Base
+end
+
+class OrderQuery
+  include ApplicationQuery
+  # ...
+end
+
+ActiveQuery::Base.registry
+# => [..., OrderQuery]
+```
+
 ### Error Handling
 
 ActiveQuery provides clear error messages for common mistakes:

data/active-query.gemspec

@@ -7,7 +7,6 @@ Gem::Specification.new do |spec|
   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"

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.3'
+  VERSION = '0.2.1'
 end

data/lib/active_query.rb

@@ -5,15 +5,23 @@ 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
+
+    @registry = []
+
+    def self.registry
+      @registry
+    end
 
     included do
+      ActiveQuery::Base.registry << self unless ActiveQuery::Base.registry.include?(self)
       infer_model
       @__queries = []
     end
@@ -72,6 +80,8 @@ module ActiveQuery
       end
 
       def infer_model
+        return unless self.name
+
         model_class_name = self.name.sub(/::Query$/, '').classify
         return unless const_defined?(model_class_name)
 
@@ -139,20 +149,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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active-query
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.1
 platform: ruby
 authors:
 - Matias Asis
@@ -178,6 +178,12 @@ files:
 - 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