active-query 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 426f4c764e93fcdacda7b354b9f4597ced451648ac4a0e56052f9cfc239f6d3f
-  data.tar.gz: b8e7db1ca8f99f4851a469feb412539c93a41e66f2d9d676ff619197dacf53a9
+  metadata.gz: 5636b341a804f0c3b2fb42b02b57ac502655c70c1cdc37c7e955004012375181
+  data.tar.gz: 4e48fbc0f6877a05d963aca4aa04bac4cf2691111cc9857381428b3ff9998f22
 SHA512:
-  metadata.gz: 5437dc8c0c0e0ca61883a52799bc927c5bc710d708192be2fb1bd661c2f638e188d842be6098f3692d9fbd515a5659cdf881d684d49425ec9212e8d0b0d119b6
-  data.tar.gz: 7352b91b01bfa4fe0e96a9d6ad026f6a8ad6e1182d372e879c4eb0fdf453f2f410cd3f0016426b4a22ff9e42dd1f5cd6a45d21269340d20d89c87173142889f7
+  metadata.gz: b8c12b1ebe7b7317af9e2201d3cc6a6edc8cda475a2967e175f2e14605f273d87e1fe514045c3597396c7b5291ef83d6470212d41048af0c3a7ed7179b48df39
+  data.tar.gz: ed6ba6312dcf12f8f83594ce2d0557466d495a7c901e351eff1490a641a8afcb9dda96f6885ae935e722ffca3738285b03cf2339380fc1a0c5edf451c8330b51

data/CHANGELOG.md

@@ -7,6 +7,18 @@ 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
@@ -38,6 +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.1.3...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

@@ -97,6 +97,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

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.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
@@ -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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active-query
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 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