parametric 0.2.23 → 0.2.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e4c6ddb5aba085ae7a2c3d0adf46164ecaf9bf3d3e7d6a0ec6891d48a0af0b77
-  data.tar.gz: 3612f9a678802ed4353d964734932951fb5a09fdceaf52eca76090907210a225
+  metadata.gz: ef2f5f7c8f444e02045209688a8fecdc8157a4e7ac6c6e5ca64614bef263f568
+  data.tar.gz: bd843a7998284ab0caf9c989fa0dedd17a2830d3f7a6fe5ad1f306d5417137a0
 SHA512:
-  metadata.gz: 7181f7d9cd318fb362ab77a6bc9da5b9bf6bc41373b6de6d8e3e41ddb92d23b9a2a46c073d88570692edf644ab748c9f7fdb70e565372e710ece850978ed3cf0
-  data.tar.gz: 7998b13d22814989ebcd0cda3fab50b05a522dc853157dde131a0e0bb4b53f06aabb25c84c120136f2204ba289cc274a05793beb039edc466c172835bf3ceca5
+  metadata.gz: 6ff1524559a0caa82acf4ad8ed896387d151096a3cc0e2caf9035a61ebf4151d02f0249d7cb2506e3f8be30f983c836861cdc1024869f8e98b1b75f228728ef5
+  data.tar.gz: 3f0e20759b4a52412ad8b620098065dd6ff6dc6ceb1680a0e2e718b99216ac85c5b7ed9a65d4a4f0003916542cf63ae59a78a2c5afbed6a002764b241486b8b1

data/README.md

@@ -243,7 +243,30 @@ instance.data # => #<MyStruct::Data2:...> (User struct)
 instance.data.name # => 'Joe'
 ```
 
-## Built-in policies
+## `wrap`
+
+This helper turns a custom object into a policy. The object must respond to `.coerce(value)` and return something that responds to `#errors() Hash`.
+
+```ruby
+UserType = Data.define(:name) do
+  def self.coerce(value)
+    return value if value.is_a?(self)
+    new(value)
+  end
+
+  def errors
+    return { name: ['cannot be blank'] } if name.nil? || name.strip.empty?
+    {}
+  end
+end
+
+schema = Parametric::Schema.new do
+  field(:user).wrap(UserType).present
+end
+
+```
+
+## Built-in policies                                             
 
 Type coercions (the `type` method) and validations (the `validate` method) are all _policies_.
 

data/lib/parametric/field.rb

@@ -5,6 +5,7 @@ require 'parametric/field_dsl'
 require 'parametric/policy_adapter'
 require 'parametric/one_of'
 require 'parametric/tagged_one_of'
+require 'parametric/wrapper'
 
 module Parametric
   class ConfigurationError < StandardError; end
@@ -89,6 +90,56 @@ module Parametric
       policy OneOf.new(schemas)
     end
 
+    # Wraps a field with a custom type that handles both coercion and validation.
+    #
+    # The wrapper object must implement two methods:
+    # - `coerce(value)`: Converts the input value to the desired type
+    # - `errors`: Returns a hash of validation errors (empty hash if valid)
+    #
+    # This is useful for integrating domain objects, value objects, or custom types
+    # that have their own validation logic into Parametric schemas.
+    #
+    # @param wrapper [Object] An object that responds to `coerce(value)` and has an `errors` method
+    # @return [Field] Returns self for method chaining
+    #
+    # @example Using with a Data class
+    #   UserType = Data.define(:name) do
+    #     def self.coerce(value)
+    #       return value if value.is_a?(self)
+    #       new(value)
+    #     end
+    #
+    #     def errors
+    #       return { name: ['cannot be blank'] } if name.nil? || name.strip.empty?
+    #       {}
+    #     end
+    #   end
+    #
+    #   schema = Parametric::Schema.new do
+    #     field(:user).wrap(UserType).present
+    #   end
+    #
+    # @example Using with a custom class
+    #   class EmailAddress
+    #     def self.coerce(value)
+    #       new(value.to_s)
+    #     end
+    #
+    #     def initialize(email)
+    #       @email = email.strip.downcase
+    #     end
+    #
+    #     def errors
+    #       return { email: ['invalid format'] } unless @email.match?(/\A[^@\s]+@[^@\s]+\z/)
+    #       {}
+    #     end
+    #   end
+    #
+    #   field(:email).wrap(EmailAddress)
+    def wrap(wrapper)
+      policy Wrapper.new(wrapper)
+    end
+
     def schema(sc = nil, &block)
       sc = (sc ? sc : Schema.new(&block))
       meta schema: sc

data/lib/parametric/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Parametric
-  VERSION = '0.2.23'
+  VERSION = '0.2.24'
 end

data/lib/parametric/wrapper.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Parametric
+  # A policy wrapper that delegates type coercion and validation to external objects.
+  #
+  # This allows integration of custom types, domain objects, or value objects that
+  # implement their own coercion and validation logic into Parametric schemas.
+  #
+  # The wrapped object must implement:
+  # - `coerce(value)`: Method to convert input values to the desired type
+  # - The returned object must have an `errors` method that returns validation errors
+  #
+  # @example Basic usage
+  #   Money = Data.define(:amount, :currency) do
+  #     def self.coerce(value)
+  #       case value
+  #       when Hash
+  #         new(value[:amount], value[:currency])
+  #       when String
+  #         parts = value.split(' ')
+  #         new(parts[0].to_f, parts[1])
+  #       else
+  #         new(value, 'USD')
+  #       end
+  #     end
+  #
+  #     def errors
+  #       errors = {}
+  #       errors[:amount] = ['must be positive'] if amount <= 0
+  #       errors[:currency] = ['invalid'] unless %w[USD EUR GBP].include?(currency)
+  #       errors
+  #     end
+  #   end
+  #
+  #   field(:price).wrap(Money)
+  #
+  # @see Field#wrap
+  class Wrapper
+    # Initialize the wrapper with a caster object.
+    #
+    # @param caster [Object] Object that responds to `coerce(value)` method
+    def initialize(caster)
+      @caster = caster
+    end
+
+    # Build a policy runner for this wrapper.
+    #
+    # @param key [Symbol] The field key being processed
+    # @param value [Object] The input value to be coerced and validated
+    # @param payload [Hash] The complete input payload (unused)
+    # @param context [Context] The validation context (unused)
+    # @return [Runner] A runner instance that handles the coercion and validation
+    def build(key, value, payload:, context:)
+      Runner.new(@caster, key, value)
+    end
+
+    # Return metadata about this policy.
+    #
+    # @return [Hash] Metadata hash containing the wrapper type
+    def meta_data
+      { type: @caster }
+    end
+
+    # Policy runner that executes the wrapper's coercion and validation logic.
+    #
+    # This class implements the policy runner interface required by Parametric's
+    # policy system. It delegates coercion to the wrapper object and collects
+    # validation errors from the coerced value.
+    class Runner
+      attr_reader :key, :value
+
+      # Initialize the runner with coercion logic.
+      #
+      # @param caster [Object] Object that responds to `coerce(value)`
+      # @param key [Symbol] The field key being processed
+      # @param value [Object] The input value to be coerced and validated
+      def initialize(caster, key, value)
+        @caster = caster
+        @key = key
+        @value = caster.coerce(value)
+        @errors = @value.errors
+      end
+
+      # Check if this policy should run.
+      #
+      # @return [Boolean] Always returns true for wrapper policies
+      def eligible?
+        true
+      end
+
+      # Check if the coerced value is valid.
+      #
+      # @return [Boolean] True if no validation errors, false otherwise
+      def valid? = @errors.empty?
+
+      # Generate a human-readable error message from validation errors.
+      #
+      # @return [String] Formatted error message combining all validation errors
+      def message = @errors.map { |k, v| "#{k} #{v.join(', ')}" }.join('. ')
+    end
+  end
+end

data/spec/schema_spec.rb

@@ -274,6 +274,48 @@ describe Parametric::Schema do
     end
   end
 
+  describe '#wrap' do
+    let(:schema) do
+      described_class.new do |sc, _|
+        sc.field(:user).wrap(user_type).present
+      end
+    end
+
+    let(:user_type) do
+      Data.define(:name) do
+        def self.coerce(value)
+          return value if value.is_a?(self)
+
+          new(value)
+        end
+
+        def errors
+          return { name: ['cannot be blank'] } if name.nil? || name.strip.empty?
+
+          {}
+        end
+      end
+    end
+
+    it 'delegates to .coerce, #errors interface' do
+      result = schema.resolve(user: 'Joe')
+      expect(result.valid?).to be true
+      expect(result.output[:user]).to eq(user_type.new('Joe'))
+
+      result = schema.resolve(user: '')
+      expect(result.valid?).to be false
+      expect(result.errors['$.user']).to eq ['name cannot be blank']
+
+      result = schema.resolve(user: user_type.new('Joe'))
+      expect(result.valid?).to be true
+      expect(result.output[:user]).to eq(user_type.new('Joe'))
+    end
+
+    it 'does not break #walk' do
+      expect(schema.walk(:default).output).to be_a(Hash)
+    end
+  end
+
   describe '#one_of' do
     let(:kwh_schema) do
       described_class.new do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parametric
 version: !ruby/object:Gem::Version
-  version: 0.2.23
+  version: 0.2.24
 platform: ruby
 authors:
 - Ismael Celis
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-09-22 00:00:00.000000000 Z
+date: 2025-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -86,6 +86,7 @@ files:
 - lib/parametric/struct.rb
 - lib/parametric/tagged_one_of.rb
 - lib/parametric/version.rb
+- lib/parametric/wrapper.rb
 - parametric.gemspec
 - spec/custom_block_validator_spec.rb
 - spec/dsl_spec.rb