lite-validation 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0c5842168d5b978d852741d1d8b644af018155532b0fd82ff1b001f8e385a953
-  data.tar.gz: cab9dc80df653dce79ebbe0c78785bea1e2a7faa13f58f9025a040f5a04b5b69
+  metadata.gz: 72bde3b3c35381247baebe84b4b4d4394bf33769c4b5187e4d7a1124ca64464a
+  data.tar.gz: 4e97554d20e8bb5986a2d79b35483ad2b22ffa4c52ec874902108d1d37c77d0b
 SHA512:
-  metadata.gz: af912dd40521360adfe2da60cb920700f7d1d898ab9efd6062c1a822da6e33ee96ff0211481d00d3513448fbf781bb92d990e28c11d16ff8dc10b09183f318f3
-  data.tar.gz: 387a65a01ea8db1ea2786edb153ea492a52740a3bfe6fac882d2ffa4c777b197a47862b18ebc9c1e2c5d3e01d9200ed39f3ea7c52aa0da5a317bd400ceaf26ce
+  metadata.gz: 5f80e113ea3e07a76dd9b23a61c5e85a6302054f00c105d8efabbab4acf2077dbdd622f61988d78748374fa8d31d24a0ebdd158092b9dde824f4af359d634ee0
+  data.tar.gz: 332a9722829258a3631d84b12b432599b5d1722884273f81c33c40d8fb146d69e95adfabf10d468bfd29e53b3adda211270bfad49e29d4cc2886f08e34f2beea

data/.rubocop.yml

@@ -90,5 +90,8 @@ Style/MethodCallWithoutArgsParentheses:
 Style/SingleArgumentDig:
   Enabled: false
 
+Style/SymbolProc:
+  Enabled: false
+
 Style/TrailingUnderscoreVariable:
   Enabled: false

data/README.md

@@ -5,20 +5,20 @@ transform input into new shape through an immutable, composable interface
 that treats validation as a general-purpose computational tool.
 
 - Extensible wrapper system supports custom collections (like `ActiveRecord::Relation`)
-- Pluggable predicate engines — ships with `Dry::Logic` adapter for declarative validation
+- Pluggable predicate engines – ships with `Dry::Logic` adapter for declarative validation
 - Configurable result types and error formats
 - Transform data while validating through integrated commit/transformation mechanics
 
 Engineered for consistent performance regardless of validation outcome.
 This makes it ideal for high-throughput scenarios where validation serves
-as filtering, decision-making, or data processing logic — not just input sanitization.
+as filtering, decision-making, or data processing logic – not just input sanitization.
 Whether validating inputs that mostly pass or mostly fail, performance remains predictable.
 Perfect for applications that need validation throughout the system:
 API endpoints, background jobs, data pipelines, and anywhere you need reliable
 validation with transformation capabilities.
 
 ## Getting started
-Before validating data, you'll need to create a **coordinator** —
+Before validating data, you'll need to create a **coordinator** –
 a configuration object that defines how the validator integrates
 with your application. The coordinator specifies what types
 to use for results, options, and errors, making the library adaptable
@@ -79,18 +79,18 @@ expect(result.failure).to match({ errors: [have_attributes(code: :excessive)] })
 
 The core of validation is the `validate` method and its counterpart `validate?`.
 These methods expose the current value and context to your validation block,
-expecting a ruling in return — a decision about the value's validity.
+expecting a ruling in return – a decision about the value's validity.
 There are four types of ruling available in validate blocks:
-- `Pass()` — Indicates the value is valid. Rarely used since returning
+- `Pass()` – Indicates the value is valid. Rarely used since returning
   `nil` has the same effect.
-- `Dispute(code, message: nil, data: nil)` — Marks the value as invalid but allows validation
+- `Dispute(code, message: nil, data: nil)` – Marks the value as invalid but allows validation
   to continue on this node. All ancestor nodes also become disputed. You can also pass
   a structured error object: `Dispute(structured_error)`
-- `Refute(code, message: nil, data: nil)` — Marks the value as invalid with a fatal error
+- `Refute(code, message: nil, data: nil)` – Marks the value as invalid with a fatal error
   that stops further validation on this node. Parent nodes become disputed unless this
   occurs in a [critical section](#critical-section). Also accepts structured errors: `Refute(structured_error)`.
-- `Commit(value)` — Transforms the input data into a new structure. This enables validation
-  with simultaneous data transformation — we'll cover this [later](#transforming-the-validated-object).
+- `Commit(value)` – Transforms the input data into a new structure. This enables validation
+  with simultaneous data transformation – we'll cover this [later](#transforming-the-validated-object).
   Commited node can't be reopened for validation again, such attempt will trigger runtime error.
 
 The distinction between `Dispute` and `Refute` gives you some control over validation flow:
@@ -99,7 +99,7 @@ enough to halt processing.
 
 ### Validating structured data
 The library's capabilities become more apparent with hierarchical data.
-Pass a path as the first argument to `validate` — validator
+Pass a path as the first argument to `validate` – validator
 will navigate to that value and yield it to the validation block:
 
 ```ruby rspec validation_hash_aligned
@@ -125,7 +125,7 @@ expect(result.failure).to match({ children: { bar: { errors: [have_attributes(co
 
 This separation enables two powerful patterns:
 
-**1. Meaningful error keys** — Store errors under descriptive names rather than raw data keys:
+**1. Meaningful error keys** – Store errors under descriptive names rather than raw data keys:
 
 ```ruby rspec validation_hash_tuple_unaligned
 result = Validator
@@ -137,10 +137,10 @@ result = Validator
 expect(result.failure).to match({ children: { total: { errors: [have_attributes(code: :excessive)] } } })
 ```
 
-Note how the `from` parameter accepts an array of paths — this creates a tuple from multiple values,
+Note how the `from` parameter accepts an array of paths – this creates a tuple from multiple values,
 perfect for cross-field validations.
 
-**2. Data transformation** — Remap input data into new structures using `Commit` rulings.
+**2. Data transformation** – Remap input data into new structures using `Commit` rulings.
 The `from` parameter lets you source data from one location while building transformed
 output at another. We'll explore this pattern
 in detail [later](#transforming-the-validated-object).
@@ -148,7 +148,7 @@ in detail [later](#transforming-the-validated-object).
 ### Alternative syntax
 You can also apply rulings directly to validator nodes rather
 of returning them from validation blocks. This permits
-more concise phrasing in certain cases — for example when passing validator
+more concise phrasing in certain cases – for example when passing validator
 into functions:
 
 ```ruby rspec node_disputed
@@ -163,7 +163,7 @@ expect(disputed.to_result.failure)
   .to match({ children: { total: { errors: [have_attributes(code: :excessive)] } } })
 ```
 
-Remember that validators are immutable — methods like `dispute`, `refute`, and `commit`
+Remember that validators are immutable – methods like `dispute`, `refute`, and `commit`
 return new validator instance with updated state.
 
 ### Handling missing values
@@ -171,18 +171,18 @@ The `validate?` method provides flexible handling of missing values.
 While `validate` immediately refutes nodes when values aren't found,
 `validate?` offers more nuanced options:
 
-**Default behavior:** Skip validation entirely if the value is missing — the validator state
+**Default behavior:** Skip validation entirely if the value is missing – the validator state
 remains unchanged.
 
 **With missing value strategies:** Call `validate?` without a block, then chain `.some_or_nil` or `.option`
 to control how missing values are handled:
 
-- **`some_or_nil`** — Passes `nil` for missing values. In tuples, only missing fields become `nil`,
+- **`some_or_nil`** – Passes `nil` for missing values. In tuples, only missing fields become `nil`,
   not the entire tuple.
-- **`option`** — Passes an option type (like `Dry::Result::Failure(Unit)` when using the Dry interface).
+- **`option`** – Passes an option type (like `Dry::Result::Failure(Unit)` when using the Dry interface).
   Again, in tuples only missing fields become *none* values.
 
-The `option` strategy enables validations where fields have disjunctive relationships —
+The `option` strategy enables validations where fields have disjunctive relationships –
 like "either `:foo` or `:bar` must be set, but not both":
 
 ```ruby rspec validation_option
@@ -222,7 +222,7 @@ expect(result.failure)
   .to match({ children: { foo: { errors: [have_attributes(code: :invalid_access)] } } })
 ```
 
-This means you can validate any object without worrying about method availability — missing methods
+This means you can validate any object without worrying about method availability – missing methods
 become validation errors rather than runtime exceptions.
 
 ## Predicates
@@ -249,11 +249,11 @@ end
 ```
 
 **Key concepts:**
-- **`Ruling::Invalidate`** — A suspended ruling that doesn't specify severity (`dispute` vs `refute`).
+- **`Ruling::Invalidate`** – A suspended ruling that doesn't specify severity (`dispute` vs `refute`).
   The caller determines severity when using the predicate via `satisfy`.
-- **`validate_value`** — Handles definite values (the common case)
-- **`validate_option`** — Handles optional values from `satisfy?` with the option strategy.
-This is not required — omit if your predicate doesn't need to handle missing values.
+- **`validate_value`** – Handles definite values (the common case)
+- **`validate_option`** – Handles optional values from `satisfy?` with the option strategy.
+This is not required – omit if your predicate doesn't need to handle missing values.
 
 This separation lets predicates work with both definite and optional values
 while leaving severity decisions to the validation context where they're used.
@@ -316,7 +316,7 @@ expect(result.failure)
 disputes or refutations, giving you control over validation flow.
 
 **Missing values:** Like `validate?`, the `satisfy?` method handles missing values
-gracefully — skipping validation by default, or using `some_or_nil`/`option` strategies
+gracefully – skipping validation by default, or using `some_or_nil`/`option` strategies
 when chained.
 
 ## Navigation
@@ -443,10 +443,10 @@ variants (`at?`, `each_at?`) that handle missing values gracefully. Note that
 make sense for collection elements.
 
 **Supported collections:** Currently `each_at` works with `Array` and `Hash`. You can add support
-for other collection types (like `Set` or `ActiveRecord::Relation`) using [custom wrappers](#custom-wrappers).
+for other collection types (like `Set` or `ActiveRecord::Relation`) using [custom wrappers](#implementing-custom-wrappers).
 
 ## Flow control
-Basic flow control comes from the `Dispute`/`Refute` distinction—`Refute` rulings skip
+Basic flow control comes from the `Dispute`/`Refute` distinction – `Refute` rulings skip
 all subsequent validations on that node.
 
 For more sophisticated control, use `with_valid` to conditionally execute validation
@@ -542,12 +542,37 @@ letting you reshape data while validating it.
 You can commit values through several mechanisms:
 - Return `Commit(value)` from a `validate` block
 - Call the `commit(value)` method on a validator node
+- Use `transform` / `transform?` - extract and commit values with optional transformation
 - Pass `commit: true` to the `validate` or `satisfy` method (commits the original value if validation passes)
 - Pass `commit: <collection_type>` to the `each_at` - gathers values of all committed nodes
-into the specified collection — either `array` or `hash` and commits them to the node 
+into the specified collection – either `array` or `hash` and commits them to the node 
 after the iteration.
 
-Individual value commits aren't enough — you must also commit the containing structure. 
+The `transform`/`transform?` methods mirror the semantics of the `validate`/`validate?` pair,
+only they don't expect a ruling to be returned from the block, just the bare value. 
+The `transform?` variant supports suspended execution with `.option` and `.some_or_nil` strategies.
+
+
+```ruby rspec transformation_hash
+result = Validator.instance({ bar: 'bar' }, coordinator)
+                  .transform(from: [:bar]) { _1.upcase }
+                  .to_result
+                  .value!
+
+expect(result).to eq('BAR')
+
+result = Validator.instance({}, coordinator)
+                  .transform?(from: [:bar])
+                  .option { _1.value_or { 'default' } }
+                  .to_result
+                  .value!
+
+expect(result).to eq('default')
+```
+
+### Structural commitment
+
+Individual value commits aren't enough – you must also commit the containing structure. 
 The validator can't automatically determine the desired output format, 
 so you need to explicitly commit each level.
 
@@ -558,12 +583,14 @@ def self.item(item)
   item
     .satisfy(:name, commit: true) { :presence }
     .satisfy(:unit_price, from: [:price], commit: true ) { :presence }
+    .transform(:note, from: [:meta, :note]) { _1 }
     .auto_commit(as: :hash)
 end
 
+
 original_data = { 
   customer: { name: 'John Doe' }, 
-  items: [{ price: 100, name: 'Item 1' }], 
+  items: [{ price: 100, name: 'Item 1', meta: { note: 'A note' } }], 
   price: 100 
 }
 
@@ -577,7 +604,7 @@ result = Validator
 
 transformed_data = { 
   customer_name: 'John Doe', 
-  line_items: [{ name: 'Item 1', unit_price: 100 }], 
+  line_items: [{ name: 'Item 1', unit_price: 100, note: 'A note' }], 
   total: 100 
 }
 
@@ -585,13 +612,19 @@ expect(result.success).to eq(transformed_data)
 ```
 
 This example demonstrates the full transformation pipeline:
-1. Extract and validate data from nested sources (`customer.name`)
+1. Extract and validate data from nested sources (`customer.name`, `items.meta.note`)
 2. Commit individual values under new keys (`customer_name`, `total`, `line_items`, `unit_price`)
 3. Build the final transformed structure with `auto_commit`
 
 The result is a validated and transformed structure entirely different
 from the original data.
 
+**Performance consideration:** This library is built primarily for validation workflows 
+with transformation capabilities as a convenience feature. 
+It is not a dedicated transformation tool. For transformation-heavy workflows, traditional explicit 
+Ruby transformations or specialized tools will provide significantly better performance. Use the 
+validator's transformation features when validation is the primary goal and transformation is incidental.
+
 ## Implementing custom wrappers
 The validator supports `Hash` and `Array` out of the box, 
 but you can extend it to work with specialized collection types 
@@ -658,7 +691,7 @@ handling patterns and result types, whether you're using a proprietary solution,
 
 ### Validation errors
 Validation errors must include the `StructuredError` marker module. This module
-defines abstract methods as suggestions rather than requirements — the library
+defines abstract methods as suggestions rather than requirements – the library
 works with any type that includes the module.
 
 For simple cases, use the built-in `StructuredError::Record` class, which accepts:
@@ -694,7 +727,7 @@ method determines how the tree gets transformed into the final error
 structure returned by `to_result`. Different applications need different final formats.
 
 **Hierarchical Strategy** (`Coordinator::Errors::Hierarchical`)
-Preserves the tree structure as nested hashes — most natural for debugging:
+Preserves the tree structure as nested hashes – most natural for debugging:
 
 ```ruby rspec with_hierarchical_adapter
 expected_failure = {
@@ -711,7 +744,7 @@ expect(result.to_result.failure).to eq(expected_failure)
 ```
 
 **Flat Strategy** (`Coordinator::Errors::Flat`)
-Flattens errors into path-value tuples — useful for processing or storage:
+Flattens errors into path-value tuples – useful for processing or storage:
 
 ```ruby rspec with_flat_adapter
 expected_failure = [

data/bench/comparative/transformation.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'benchmark'
+require 'active_model'
+require 'dry/validation'
+require 'byebug'
+
+require_relative '../../lib/lite/validation/validator'
+require_relative '../../spec/validation/validator/support/functional/coordinators/dry'
+
+module Lite
+  module Validation
+    module Validator
+      module Benchmark
+        module Comparative
+          module Transformation
+            INPUT = {
+              customer: { name: 'John Doe' },
+              items: [
+                { price: '100', name: 'Item 1' },
+                { price: '200', name: 'Item 2' }
+              ],
+              charges: [
+                { price: '50', name: 'Charge 1' }
+              ],
+              item_total: '300',
+              charge_total: '50'
+            }.freeze
+
+            module HashBench
+              def self.call(input)
+                {
+                  customer_name: input.dig(:customer, :name),
+                  line_items: line_items(input[:items]),
+                  charges: charges(input[:charges]),
+                  total: input[:item_total].to_i + input[:charge_total].to_i
+                }
+              end
+
+              def self.line_items(items)
+                items.map { { unit_price: _1[:price].to_i, name: _1[:name] } }
+              end
+
+              def self.charges(charges)
+                charges.map { { amount: _1[:price].to_i, name: _1[:name] } }
+              end
+            end
+
+            module LiteBench
+              def self.call(input)
+                Validator
+                  .instance(input, Support::Functional::Coordinators::Dry::Flat)
+                  .transform(:customer_name, from: %i[customer name]) { _1 }
+                  .each_at(:line_items, from: [:items], commit: :array) { line_item(_1) }
+                  .each_at(:charges, commit: :array) { charge(_1) }
+                  .transform(:total, from: [%i[item_total charge_total]]) { _1.map(&:to_i).sum }
+                  .auto_commit(as: :hash)
+              end
+
+              def self.line_item(item)
+                item
+                  .transform(:unit_price, from: %i[price]) { _1.to_i }
+                  .transform(:name) { _1 }
+                  .auto_commit(as: :hash)
+              end
+
+              def self.charge(charge)
+                charge
+                  .transform(:amount, from: %i[price]) { _1.to_i }
+                  .transform(:name) { _1 }
+                  .auto_commit(as: :hash)
+              end
+            end
+
+            def self.run(n) # rubocop:disable Naming/MethodParameterName
+              runs = {}
+
+              runs[:Hash] = proc do
+                HashBench.call(INPUT)
+              end
+
+              runs[:Lite] = proc do
+                LiteBench.call(INPUT).to_result.success
+              end
+
+              runs.to_a.shuffle.each do |key, proc|
+                result = ::Benchmark.measure { n.times { proc.call } }
+                puts "#{key}: #{result}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Lite::Validation::Validator::Benchmark::Comparative::Transformation.run(10_000)

data/bench/comparative/validation.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require 'benchmark'
+require 'active_model'
+require 'dry/validation'
+require 'byebug'
+
+require_relative '../../spec/validation/validator/support/functional/contracts/hash'
+require_relative '../../spec/validation/validator/support/functional/coordinators/dry'
+require_relative '../../spec/validation/validator/support/shared/predicates/dry'
+
+module Lite
+  module Validation
+    module Validator
+      module Benchmark
+        module Comparative
+          module Validation
+            class DryBench < Dry::Validation::Contract
+              option(:limit)
+
+              json do
+                required(:id).filled(:string)
+                required(:price).value(:integer, gteq?: 0)
+                required(:dates).schema do
+                  required(:issued).value(:date_time)
+                  required(:due).value(:date_time)
+                end
+                required(:payments).array do
+                  schema do
+                    required(:amount).value(:integer, gteq?: 0)
+                    required(:type).value(:string, included_in?: %w[card cash])
+                  end
+                end
+                required(:items).array do
+                  schema do
+                    required(:id).filled(:string)
+                    required(:name).filled(:string)
+                    required(:price).value(:integer, gteq?: 0)
+                    required(:qty).value(:integer, gteq?: 0)
+                  end
+                end
+              end
+
+              rule(dates: %i[issued due]) do
+                next if value[0] <= value[1]
+
+                key.failure('first must be less than or equal to the second')
+              end
+
+              rule(:price) do
+                next if value <= limit
+
+                key.failure('is excessive')
+              end
+            end
+
+            module ActiveModelBench
+              def self.call(data, limit:)
+                model ||= BenchModel.instance(data, limit: limit)
+                model.valid? ? nil : model.errors
+              end
+
+              class BenchModel
+                def self.instance(data, limit:)
+                  dates = Dates.new(**data[:dates])
+                  items = data[:items].map { Item.new(**data.slice(:id, :name, :price, :qty)) }
+                  payments = data[:payments].map { Payment.new(**data.slice(:amount, :type)) }
+
+                  BenchModel.new(
+                    dates: dates,
+                    items: items,
+                    payments: payments,
+                    limit: limit,
+                    **data.slice(:id, :price)
+                  )
+                end
+
+                class Dates
+                  include ActiveModel::Model
+                  include ActiveModel::Attributes
+                  include ActiveModel::Validations
+
+                  attribute :issued, :datetime
+                  attribute :due, :datetime
+
+                  validates :issued, presence: true
+                  validates :due, presence: true
+
+                  validate do
+                    next if issued < due
+
+                    errors.add('(issued,due)', 'first must be less than or equal to the second')
+                  end
+                end
+
+                class Payment
+                  include ActiveModel::Model
+                  include ActiveModel::Attributes
+                  include ActiveModel::Validations
+
+                  attribute :amount, :integer
+                  attribute :type, :string
+
+                  validates :amount, presence: true, numericality: { greater_than: 0 }
+                  validates :type, presence: true, inclusion: %w[cash card]
+                end
+
+                class Item
+                  include ActiveModel::Model
+                  include ActiveModel::Attributes
+                  include ActiveModel::Validations
+
+                  attribute :id, :string
+                  attribute :name, :string
+                  attribute :price, :integer
+                  attribute :qty, :integer
+
+                  validates :price, presence: true, numericality: { greater_than: 0 }
+                  validates :qty, presence: true, numericality: { greater_than: 0 }
+                end
+
+                include ActiveModel::Model
+                include ActiveModel::Attributes
+                include ActiveModel::Validations
+
+                attribute :id, :string
+                attribute :price, :integer
+                attribute :limit, :integer
+                attribute :dates
+                attribute :items
+                attribute :payments
+
+                validates :id, presence: true
+                validates :price, presence: true
+
+                validate do
+                  next if dates.valid?
+
+                  dates.errors.messages.each { |attr, msg| errors.add("dates.#{attr}", msg) }
+                end
+
+                validate do
+                  items.each_with_index do |item, idx|
+                    next if item.valid?
+
+                    item.errors.messages.each { |attr, msg| errors.add("items.#{idx}.#{attr}", msg) }
+                  end
+                end
+
+                validate do
+                  payments.each_with_index do |payment, idx|
+                    next if payment.valid?
+
+                    payment.errors.messages.each { |attr, msg| errors.add("payments.#{idx}.#{attr}", msg) }
+                  end
+                end
+
+                validate do
+                  errors.add(:price, 'is excessive') if price > limit
+                end
+              end
+            end
+
+            LiteBench = Support::Functional::Contracts::Hash
+
+            VALID = LiteBench::VALID
+            INVALID = LiteBench::INVALID
+            CONTEXT = LiteBench::CONTEXT
+
+            def self.run(n) # rubocop:disable Naming/MethodParameterName, Metrics/AbcSize
+              runs = {}
+
+              runs[:ActiveModel] = proc do |idx|
+                ActiveModelBench.call(data(idx), **CONTEXT)
+              end
+
+              runs[:Dry] = proc do |idx|
+                DryBench.new(**CONTEXT).call(data(idx))
+              end
+
+              runs[:Lite] = proc do |idx|
+                LiteBench.call(
+                  data(idx),
+                  Support::Functional::Coordinators::Dry::Flat,
+                  CONTEXT
+                ).to_result
+              end
+
+              runs.to_a.shuffle.each do |key, proc|
+                result = ::Benchmark.measure { n.times { |idx| proc.call(idx) } }
+                puts "#{key}: #{result}"
+              end
+            end
+
+            def self.data(idx)
+              (idx % 5).zero? ? INVALID : VALID
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Lite::Validation::Validator::Benchmark::Comparative::Validation.run(1000)

data/lib/lite/validation/validator/node/abstract.rb

@@ -6,6 +6,7 @@ require_relative 'implementation/identity'
 require_relative 'implementation/iteration'
 require_relative 'implementation/predication'
 require_relative 'implementation/scoping'
+require_relative 'implementation/transformation'
 
 module Lite
   module Validation
@@ -18,6 +19,7 @@ module Lite
           include Implementation::Iteration
           include Implementation::Predication
           include Implementation::Scoping
+          include Implementation::Transformation
         end
       end
     end

data/lib/lite/validation/validator/node/implementation/apply_ruling.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../../ruling'
+require_relative '../../../error'
 require_relative 'helpers/with_result'
 
 module Lite
@@ -9,10 +9,24 @@ module Lite
       module Node
         module Implementation
           module ApplyRuling
-            include Ruling::Constructors
+            def self.apply_ruling(validator, path: nil)
+              updated, _meta = validator.result.navigate(*path) do |result|
+                applied = yield result
+                validator.merge_strategy.transform_result(applied, validator, path)
+              end
+              Helpers::WithResult.with_result(validator, updated)
+            end
+
+            def self.structured_error(coordinator, error, **opts)
+              case [error, opts]
+              in [StructuredError, {}] then error
+              in [Symbol, { ** }] then coordinator.structured_error(error, **opts)
+              else raise Error::Fatal, "Unexpected first argument: #{error.inspect}"
+              end
+            end
 
-            def commit(value)
-              ApplyRuling.apply_ruling(self, Commit(value))
+            def commit(value, at: nil)
+              ApplyRuling.apply_ruling(self, path: at) { _1.commit(value) }
             end
 
             def auto_commit(as:)
@@ -20,21 +34,15 @@ module Lite
             end
 
             def dispute(error, at: nil, **opts)
-              ApplyRuling.apply_ruling(self, Dispute(error, **opts), path: at)
+              ApplyRuling.apply_ruling(self, path: at) do |result|
+                result.dispute(ApplyRuling.structured_error(coordinator, error, **opts))
+              end
             end
 
             def refute(error, at: nil, **opts)
-              ApplyRuling.apply_ruling(self, Refute(error, **opts), path: at)
-            end
-
-            def self.apply_ruling(validator, ruling, path: nil)
-              return validator if ruling.is_a?(Ruling::Pass)
-
-              updated, _meta = validator.result.navigate(*path) do |result|
-                applied = Ruling.apply(ruling, result, validator.coordinator)
-                validator.merge_strategy.transform_result(applied, validator, path)
+              ApplyRuling.apply_ruling(self, path: at) do |result|
+                result.refute(ApplyRuling.structured_error(coordinator, error, **opts))
               end
-              Helpers::WithResult.with_result(validator, updated)
             end
           end
         end

data/lib/lite/validation/validator/node/implementation/helpers/yield_strategy.rb

@@ -24,8 +24,8 @@ module Lite
               end
 
               module Nullify
-                def self.child_parameters(_validator, option, _result, &block)
-                  block.call(option.some_or_nil)
+                def self.child_parameters(validator, option, _result, &block)
+                  block.call(option.some_or_nil, validator.send(:state).value_definite)
                 end
 
                 def self.block_parameters(_validator, option, _result, &block)

data/lib/lite/validation/validator/node/implementation/navigation.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 require_relative 'dig'
-require_relative 'helpers/yield_validator'
 require_relative '../suspended'
+require_relative 'helpers/yield_validator'
 require_relative 'helpers/yield_strategy'
 
 module Lite

data/lib/lite/validation/validator/node/implementation/transformation.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative '../../ruling'
+require_relative '../suspended'
+require_relative 'dig'
+require_relative 'helpers/call_foreign'
+require_relative 'helpers/yield_strategy'
+
+module Lite
+  module Validation
+    module Validator
+      module Node
+        module Implementation
+          module Transformation
+            include Ruling::Constructors
+            include Dig
+
+            def transform?(*path, from: nil, &block)
+              return Suspended.new(:transform!, self, path, from) if block.nil?
+
+              transform!(path, from, :skip, block)
+            end
+
+            def transform(*path, from: nil, &block)
+              transform!(path, from, :refute, block)
+            end
+
+            private
+
+            def transform!(path, from, strategy, block)
+              return self unless result.success?
+
+              dig(*path, from: from) do |option, result|
+                strategy = Helpers::YieldStrategy.to_yield(strategy)
+                strategy.block_parameters(self, option, result) do |to_yield|
+                  Helpers::CallForeign.call_foreign(result, coordinator) do
+                    value = block.call(to_yield, context)
+                    committed = result.commit(value)
+                    merge_strategy.transform_result(committed, self, path)
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/node/implementation/validation.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative 'dig'
 require_relative '../suspended'
+require_relative 'dig'
 require_relative 'helpers/call_foreign'
 require_relative 'helpers/yield_strategy'
 

data/lib/lite/validation/version.rb

@@ -3,7 +3,7 @@
 module Lite
   module Validation
     module Version
-      VERSION = '0.0.1'
+      VERSION = '0.0.3'
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lite-validation
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors:
 - Tomas Milsimer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-09-06 00:00:00.000000000 Z
+date: 2025-12-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lite-data
@@ -37,7 +37,8 @@ files:
 - Gemfile
 - README.md
 - bench/calibrational.rb
-- bench/comparative.rb
+- bench/comparative/transformation.rb
+- bench/comparative/validation.rb
 - bench/functional.rb
 - bench/profile.rb
 - lib/lite/validation.rb
@@ -86,6 +87,7 @@ files:
 - lib/lite/validation/validator/node/implementation/predication.rb
 - lib/lite/validation/validator/node/implementation/scoping.rb
 - lib/lite/validation/validator/node/implementation/scoping/evaluator.rb
+- lib/lite/validation/validator/node/implementation/transformation.rb
 - lib/lite/validation/validator/node/implementation/validation.rb
 - lib/lite/validation/validator/node/implementation/wrap.rb
 - lib/lite/validation/validator/node/root.rb

data/bench/comparative.rb

@@ -1,197 +0,0 @@
-# frozen_string_literal: true
-
-require 'benchmark'
-require 'active_model'
-require 'dry/validation'
-require 'byebug'
-
-require_relative '../spec/validation/validator/support/functional/contracts/hash'
-require_relative '../spec/validation/validator/support/functional/coordinators/dry'
-require_relative '../spec/validation/validator/support/shared/predicates/dry'
-
-module Lite
-  module Validation
-    module Validator
-      module Benchmark
-        module Comparative
-          class DryBench < Dry::Validation::Contract
-            option(:limit)
-
-            json do
-              required(:id).filled(:string)
-              required(:price).value(:integer, gteq?: 0)
-              required(:dates).schema do
-                required(:issued).value(:date_time)
-                required(:due).value(:date_time)
-              end
-              required(:payments).array do
-                schema do
-                  required(:amount).value(:integer, gteq?: 0)
-                  required(:type).value(:string, included_in?: %w[card cash])
-                end
-              end
-              required(:items).array do
-                schema do
-                  required(:id).filled(:string)
-                  required(:name).filled(:string)
-                  required(:price).value(:integer, gteq?: 0)
-                  required(:qty).value(:integer, gteq?: 0)
-                end
-              end
-            end
-
-            rule(dates: %i[issued due]) do
-              next if value[0] <= value[1]
-
-              key.failure('first must be less than or equal to the second')
-            end
-
-            rule(:price) do
-              next if value <= limit
-
-              key.failure('is excessive')
-            end
-          end
-
-          class ActiveModelBench < Dry::Validation::Contract
-            def self.call(data, limit:)
-              model ||= BenchModel.instance(data, limit: limit)
-              model.valid? ? nil : model.errors
-            end
-
-            class BenchModel
-              def self.instance(data, limit:)
-                dates = Dates.new(**data[:dates])
-                items = data[:items].map { Item.new(**data.slice(:id, :name, :price, :qty)) }
-                payments = data[:payments].map { Payment.new(**data.slice(:amount, :type)) }
-
-                BenchModel.new(dates: dates, items: items, payments: payments, limit: limit, **data.slice(:id, :price))
-              end
-
-              class Dates
-                include ActiveModel::Model
-                include ActiveModel::Attributes
-                include ActiveModel::Validations
-
-                attribute :issued, :datetime
-                attribute :due, :datetime
-
-                validates :issued, presence: true
-                validates :due, presence: true
-
-                validate do
-                  next if issued < due
-
-                  errors.add('(issued,due)', 'first must be less than or equal to the second')
-                end
-              end
-
-              class Payment
-                include ActiveModel::Model
-                include ActiveModel::Attributes
-                include ActiveModel::Validations
-
-                attribute :amount, :integer
-                attribute :type, :string
-
-                validates :amount, presence: true, numericality: { greater_than: 0 }
-                validates :type, presence: true, inclusion: %w[cash card]
-              end
-
-              class Item
-                include ActiveModel::Model
-                include ActiveModel::Attributes
-                include ActiveModel::Validations
-
-                attribute :id, :string
-                attribute :name, :string
-                attribute :price, :integer
-                attribute :qty, :integer
-
-                validates :price, presence: true, numericality: { greater_than: 0 }
-                validates :qty, presence: true, numericality: { greater_than: 0 }
-              end
-
-              include ActiveModel::Model
-              include ActiveModel::Attributes
-              include ActiveModel::Validations
-
-              attribute :id, :string
-              attribute :price, :integer
-              attribute :limit, :integer
-              attribute :dates
-              attribute :items
-              attribute :payments
-
-              validates :id, presence: true
-              validates :price, presence: true
-
-              validate do
-                next if dates.valid?
-
-                dates.errors.messages.each { |attr, msg| errors.add("dates.#{attr}", msg) }
-              end
-
-              validate do
-                items.each_with_index do |item, idx|
-                  next if item.valid?
-
-                  item.errors.messages.each { |attr, msg| errors.add("items.#{idx}.#{attr}", msg) }
-                end
-              end
-
-              validate do
-                payments.each_with_index do |payment, idx|
-                  next if payment.valid?
-
-                  payment.errors.messages.each { |attr, msg| errors.add("payments.#{idx}.#{attr}", msg) }
-                end
-              end
-
-              validate do
-                errors.add(:price, 'is excessive') if price > limit
-              end
-            end
-          end
-
-          LiteBench = Support::Functional::Contracts::Hash
-
-          VALID = LiteBench::VALID
-          INVALID = LiteBench::INVALID
-          CONTEXT = LiteBench::CONTEXT
-
-          def self.run(n) # rubocop:disable Naming/MethodParameterName, Metrics/AbcSize
-            runs = {}
-
-            runs[:ActiveModel] = proc do |idx|
-              ActiveModelBench.call(data(idx), **CONTEXT)
-            end
-
-            runs[:Dry] = proc do |idx|
-              DryBench.new(**CONTEXT).call(data(idx))
-            end
-
-            runs[:Lite] = proc do |idx|
-              LiteBench.call(
-                data(idx),
-                Support::Functional::Coordinators::Dry::Flat,
-                CONTEXT
-              ).to_result
-            end
-
-            runs.to_a.shuffle.each do |key, proc|
-              result = ::Benchmark.measure { n.times { |idx| proc.call(idx) } }
-              puts "#{key}: #{result}"
-            end
-          end
-
-          def self.data(idx)
-            (idx % 5).zero? ? INVALID : VALID
-          end
-        end
-      end
-    end
-  end
-end
-
-Lite::Validation::Validator::Benchmark::Comparative.run(1000)