lite-validation 0.0.1

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'implementation/apply_ruling'
+require_relative 'implementation/navigation'
+require_relative 'implementation/identity'
+require_relative 'implementation/iteration'
+require_relative 'implementation/predication'
+require_relative 'implementation/scoping'
+
+module Lite
+  module Validation
+    module Validator
+      module Node
+        module Abstract
+          include Implementation::Identity
+          include Implementation::ApplyRuling
+          include Implementation::Navigation
+          include Implementation::Iteration
+          include Implementation::Predication
+          include Implementation::Scoping
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative 'abstract/instance'
+require_relative 'abstract/leaf'
+require_relative 'abstract/branch'
+require_relative '../result'
+require_relative '../state'
+require_relative '../option'
+
+module Lite
+  module Validation
+    module Validator
+      module Node
+        module Child
+          module Parent
+            def child(path, result, option: self.option, state: self.state)
+              if path.nil? || path.empty?
+                self.class::Leaf.instance(parent, self.path, option, result, state)
+              else
+                Child::Leaf.instance(self, path, option, result, state)
+              end
+            end
+          end
+
+          include Parent
+
+          def inspect
+            "#<Child::#{super}"
+          end
+
+          class Leaf < Abstract::Instance
+            include Abstract::Leaf
+            include Child
+          end
+
+          class Branch < Abstract::Instance
+            include Abstract::Branch
+            include Child
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative '../../ruling'
+require_relative 'helpers/with_result'
+
+module Lite
+  module Validation
+    module Validator
+      module Node
+        module Implementation
+          module ApplyRuling
+            include Ruling::Constructors
+
+            def commit(value)
+              ApplyRuling.apply_ruling(self, Commit(value))
+            end
+
+            def auto_commit(as:)
+              Helpers::WithResult.with_result(self, result.auto_commit(as: as))
+            end
+
+            def dispute(error, at: nil, **opts)
+              ApplyRuling.apply_ruling(self, Dispute(error, **opts), path: at)
+            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)
+              end
+              Helpers::WithResult.with_result(validator, updated)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative '../../helpers/path'
+require_relative '../../option/some/complex/wrappers/abstract'
+require_relative 'helpers/with_result'
+
+module Lite
+  module Validation
+    module Validator
+      module Node
+        module Implementation
+          module Dig
+            protected
+
+            def dig(*path, from: nil, &block)
+              from = Validator::Helpers::Path.expand_path(from || path, [])
+              dig!(path, from, &block)
+            end
+
+            private
+
+            def dig!(path, from, &block)
+              updated, _meta = result.navigate(*path) do |local|
+                option = self.option.dig(from)
+
+                block.call(option, local)
+              rescue Option::Some::Complex::Wrappers::Abstract::InvalidAccess => e
+                local.refute(coordinator.internal_error(:invalid_access, message: e.message))
+              end
+
+              Helpers::WithResult.with_result(self, updated)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Lite
+  module Validation
+    module Validator
+      module Node
+        module Implementation
+          module Helpers
+            module CallForeign
+              def self.call_foreign(result, coordinator, &block)
+                block.call
+              rescue Error::Fatal
+                raise
+              rescue StandardError => e
+                rescue_execution_error(result, coordinator, e)
+              end
+
+              def self.rescue_execution_error(result, coordinator, error)
+                error = coordinator.internal_error(
+                  :execution_error,
+                  message: error.message, data: { error_class: error.class.name }
+                )
+                result.refute(error)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative '../../../ruling'
+
+module Lite
+  module Validation
+    module Validator
+      module Node
+        module Implementation
+          module Helpers
+            module WithResult
+              def self.with_result(validator, result)
+                return validator if result.equal?(validator.result)
+
+                validator.send(:with, result: result)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative '../../../../error'
+
+module Lite
+  module Validation
+    module Validator
+      module Node
+        module Implementation
+          module Helpers
+            module YieldStrategy
+              module Skip
+                def self.child_parameters(validator, option, result, &block)
+                  maybe_yield(nil, option, result) { block.call(option, validator.send(:state).value_definite) }
+                end
+
+                def self.block_parameters(_validator, option, result, &block)
+                  maybe_yield(nil, option, result) { block.call(option.unwrap) }
+                end
+
+                def self.maybe_yield(_, option, result, &block)
+                  option.some? ? block.call : result
+                end
+              end
+
+              module Nullify
+                def self.child_parameters(_validator, option, _result, &block)
+                  block.call(option.some_or_nil)
+                end
+
+                def self.block_parameters(_validator, option, _result, &block)
+                  block.call(option.some_or_nil.unwrap)
+                end
+              end
+
+              module Refute
+                def self.child_parameters(validator, option, result, &block)
+                  maybe_yield(validator, option, result) { block.call(option, validator.send(:state).value_definite) }
+                end
+
+                def self.block_parameters(validator, option, result, &block)
+                  maybe_yield(validator, option, result) { block.call(option.unwrap) }
+                end
+
+                def self.maybe_yield(validator, option, result, &block)
+                  option.some? ? block.call : result.refute(validator.coordinator.internal_error(:value_missing))
+                end
+              end
+
+              module YieldOption
+                def self.child_parameters(validator, option, _result, &block)
+                  block.call(option, validator.send(:state).value_optional)
+                end
+
+                def self.block_parameters(validator, option, _result, &block)
+                  block.call(option.to_option(validator.coordinator))
+                end
+              end
+
+              def self.to_yield(strategy)
+                case strategy
+                when :skip then Skip
+                when :nullify then Nullify
+                when :refute then Refute
+                when :yield_option then YieldOption
+                else raise Error::Fatal, "Unexpected missing yield strategy: #{strategy}"
+                end
+              end
+
+              def self.to_iterate(strategy)
+                case strategy
+                when :skip then Skip
+                when :refute then Refute
+                else raise Error::Fatal, "Unexpected missing iteration strategy: #{strategy}"
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative 'call_foreign'
+
+module Lite
+  module Validation
+    module Validator
+      module Node
+        module Implementation
+          module Helpers
+            module YieldValidator
+              def self.yield_child(parent, child, block)
+                updated, meta = yield_validator(child, block)
+                transformed = parent.merge_strategy.transform_result(updated, parent, child.path)
+                [transformed, meta]
+              end
+
+              def self.yield_validator(validator, block)
+                validator = ensure_valid_result!(validator, block.call(validator))
+
+                [validator.result, validator.context]
+              rescue Error::Fatal
+                raise
+              rescue StandardError => e
+                [
+                  CallForeign.rescue_execution_error(validator.result, validator.coordinator, e),
+                  validator.context
+                ]
+              end
+
+              def self.ensure_valid_result!(origin, result)
+                ensure_validator!(result)
+                Implementation::Identity.ensure_identical! origin, result
+
+                result
+              end
+
+              def self.ensure_validator!(candidate)
+                return if candidate.is_a?(Abstract::Instance)
+
+                raise Error::Fatal, "Validator expected, got: #{candidate.inspect}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Lite
+  module Validation
+    module Validator
+      module Node
+        module Implementation
+          module Identity
+            def self.intent_id
+              @count ||= 0
+              @count += 1
+            end
+
+            def self.ensure_identical!(origin, current)
+              return if origin.identical?(current)
+
+              raise_error!(origin, current, origin.send(:intent) == current.send(:intent) ? :origin : :intent)
+            end
+
+            def self.raise_error!(origin, current, key)
+              full = key == :intent
+              message = "Not the #{key}: #{origin.send(:display_path, full)} <> #{current.send(:display_path, full)}"
+              raise Error::Fatal, message
+            end
+
+            def self.display_path(full_path)
+              case full_path
+              when Array then "[#{full_path.map { |element| display_path_element(element) }.join(',')}]"
+              else full_path
+              end
+            end
+
+            def self.display_path_element(element)
+              case element
+              when Array then "(#{element.map { |path| display_path(path) }.join(',')})"
+              else element
+              end
+            end
+
+            def identical?(other)
+              return true if other.equal?(self)
+              return false unless other.path == path
+              return true if other.parent.equal?(parent)
+              return false if other.root? || root?
+
+              other.parent.identical?(parent)
+            end
+
+            def key
+              path.last
+            end
+
+            def full_path(full)
+              if root?
+                full ? path : []
+              else
+                parent.full_path(full) + path
+              end
+            end
+
+            def display_path(full)
+              Identity.display_path(full_path(full))
+            end
+
+            def path_to(ancestor)
+              trace(ancestor, trace: [])
+            end
+
+            def intent
+              root? ? path.first : parent.intent
+            end
+
+            def root?
+              parent.nil?
+            end
+
+            protected
+
+            def trace(ancestor, trace: [])
+              return trace if ancestor.identical?(self)
+              return if root?
+
+              parent.trace(ancestor, trace: path + trace)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require_relative '../helpers/yield_strategy'
+require_relative '../helpers/yield_validator'
+require_relative '../validation'
+
+module Lite
+  module Validation
+    module Validator
+      module Node
+        module Implementation
+          module Iteration
+            class Iterator
+              def self.iterate(node, path, from, strategy, commit, &block)
+                node.send(:dig!, path, from) do |option, result|
+                  Helpers::YieldStrategy
+                    .to_iterate(strategy)
+                    .maybe_yield(node, option, result) do
+                    complex = option.to_complex
+                    next result.refute(node.coordinator.internal_error(:not_iterable)) unless complex.iterable?
+
+                    iterable = node.child(path, result.iterable(commit: commit), option: complex)
+                    updated, meta = reduce(iterable, block)
+
+                    [node.merge_strategy.transform_result(updated.navigable, node, path), meta]
+                  end
+                end
+              end
+
+              def self.reduce(iterable, block)
+                iterable.send(:option).reduce([iterable.result, iterable.context]) do |(result, context), (value, key)|
+                  break [result, context] if result.refuted?
+
+                  result.navigate(key) do |key_result|
+                    block.call(iterable, key, value, key_result, context)
+                  end
+                end
+              end
+
+              def initialize(parent, path, from, strategy, commit)
+                @parent = parent
+                @path = path
+                @from = from
+                @strategy = strategy
+                @commit = commit
+                freeze
+              end
+
+              def validate(commit: false, &block)
+                self.class.iterate(
+                  parent,
+                  path,
+                  from,
+                  strategy,
+                  self.commit
+                ) do |iterable, _key, value, result, context|
+                  updated = Validation.validate(
+                    iterable.coordinator,
+                    value,
+                    result,
+                    context,
+                    commit,
+                    block
+                  )
+                  [updated, context]
+                end
+              end
+
+              def satisfy(using: nil, severity: :dispute, commit: false, &block)
+                predicate = Predication
+                            .resolve_predicate(using, from, parent.context, block)
+                            .definite
+                            .send(severity)
+
+                self.class.iterate(
+                  parent,
+                  path,
+                  from,
+                  strategy,
+                  self.commit
+                ) do |iterable, _key, value, result, context|
+                  Validation.validate(
+                    iterable.coordinator,
+                    value,
+                    result,
+                    context,
+                    commit,
+                    predicate
+                  )
+                end
+              end
+
+              private
+
+              attr_reader :parent, :path, :from, :strategy, :commit
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative 'dig'
+require_relative 'helpers/yield_validator'
+require_relative 'helpers/yield_strategy'
+require_relative 'iteration/iterator'
+
+module Lite
+  module Validation
+    module Validator
+      module Node
+        module Implementation
+          module Iteration
+            include Dig
+
+            def each_at?(*path, from: nil, commit: false, &block)
+              each_at!(path, from, :skip, commit, block)
+            end
+
+            def each_at(*path, from: nil, commit: false, &block)
+              each_at!(path, from, :refute, commit, block)
+            end
+
+            private
+
+            def each_at!(path, from, strategy, commit, block)
+              from = Validator::Helpers::Path.expand_path(from || path, [])
+              return Iterator.new(self, path, from, strategy, commit) if block.nil?
+
+              Iterator.iterate(self, path, from, strategy, commit) do |iterable, key, value, result, context|
+                child = iterable.child(
+                  [key],
+                  result,
+                  option: Option.some(value),
+                  state: iterable.send(:state).with(context: context).value_definite
+                )
+
+                Helpers::YieldValidator.yield_child(iterable, child, block)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative 'dig'
+require_relative 'helpers/yield_validator'
+require_relative '../suspended'
+require_relative 'helpers/yield_strategy'
+
+module Lite
+  module Validation
+    module Validator
+      module Node
+        module Implementation
+          module Navigation
+            include Dig
+
+            def at?(*path, from: nil, &block)
+              return Suspended.new(:at!, self, path, from) if block.nil?
+
+              at!(path, from, :skip, block)
+            end
+
+            def at(*path, from: nil, &block)
+              at!(path, from, :refute, block)
+            end
+
+            private
+
+            def at!(path, from, strategy, block)
+              dig(*path, from: from) do |option, result|
+                strategy = Helpers::YieldStrategy.to_yield(strategy)
+                strategy.child_parameters(self, option, result) do |to_yield, child_state|
+                  child = child(path, result, option: to_yield, state: child_state)
+
+                  Helpers::YieldValidator.yield_child(self, child, block)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative 'validation'
+require_relative '../../predicate/registry'
+
+module Lite
+  module Validation
+    module Validator
+      module Node
+        module Implementation
+          module Predication
+            include Validation
+
+            def self.resolve_predicate(using, path, context, block)
+              object = call_builder_block(using, path, context, block)
+              fetch_predicate(object)
+            end
+
+            def self.call_builder_block(using, path, context, block)
+              case using
+              when nil then block.call(context)
+              else
+                engine = Predicate::Registry.engine(using)
+                engine.build_contextual(path, context, &block)
+              end
+            end
+
+            def self.fetch_predicate(object)
+              case object
+              when Symbol then Predicate::Registry.predicate(object)
+              when Predicate::Abstract::Variants then object
+              else raise Error::Fatal, "Unexpected predicate object: #{object.inspect}"
+              end
+            end
+
+            def satisfy?(*path, from: nil, using: nil, severity: :dispute, commit: false, &block)
+              return Suspended.new(:satisfy!, self, path, from, using, severity, commit) if block.nil?
+
+              satisfy!(path, from, :skip, using, severity, commit, block)
+            end
+
+            def satisfy(*path, from: nil, using: nil, severity: :dispute, commit: false, &block)
+              satisfy!(path, from, :refute, using, severity, commit, block)
+            end
+
+            private
+
+            # rubocop:disable Metrics/ParameterLists
+            def satisfy!(path, from, strategy, using, severity, commit, block)
+              from = Validator::Helpers::Path.expand_path(from || path, [])
+              predicate = Predication.resolve_predicate(using, from, context, block)
+              variant = strategy == :yield_option ? predicate.optional : predicate.definite
+              validate!(path, from, strategy, commit, variant.send(severity))
+            end
+            # rubocop:enable Metrics/ParameterLists
+          end
+        end
+      end
+    end
+  end
+end