lite-validation 0.0.1

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative '../helpers/with_result'
+
+module Lite
+  module Validation
+    module Validator
+      module Node
+        module Implementation
+          module Scoping
+            class Evaluator
+              def self.instance(validator, path)
+                new(validator, [path].freeze)
+              end
+
+              private_class_method :new
+
+              def initialize(validator, paths)
+                @validator = validator
+                @paths = paths
+              end
+
+              def and(path, &block)
+                compound = self.class.send(:new, validator, [*paths, path])
+                return compound if block.nil?
+
+                compound.call(&block)
+              end
+
+              attr_reader :validator, :paths
+
+              def call(&block)
+                return validator unless paths.all? { validator.result.success_at?(*_1) }
+
+                Helpers::WithResult.with_result(validator, validator.send(:wrap, &block))
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative 'helpers/yield_validator'
+require_relative 'scoping/evaluator'
+require_relative 'dig'
+require_relative 'wrap'
+
+module Lite
+  module Validation
+    module Validator
+      module Node
+        module Implementation
+          module Scoping
+            include Dig
+            include Wrap
+
+            def critical(error_generator, &block)
+              dig do |_option, result|
+                child = child(nil, result, state: state.critical(self, error_generator))
+                updated, _meta = Helpers::YieldValidator.yield_validator(child, block)
+                updated.refuted? ? updated.with(fall_through: false) : updated
+              end
+            end
+
+            def with_context(context, &block)
+              if block
+                result, _meta = wrap(state: state.with(context: context), &block)
+                Helpers::WithResult.with_result(self, result)
+              else
+                with(state: state.with(context: context))
+              end
+            end
+
+            def with_valid(*path, &block)
+              with_valid = Evaluator.instance(self, path)
+              block.nil? ? with_valid : with_valid.call(&block)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative 'dig'
+require_relative '../suspended'
+require_relative 'helpers/call_foreign'
+require_relative 'helpers/yield_strategy'
+
+module Lite
+  module Validation
+    module Validator
+      module Node
+        module Implementation
+          module Validation
+            # rubocop:disable Metrics/ParameterLists
+            def self.validate(coordinator, to_yield, result, context, commit, block)
+              updated = Helpers::CallForeign.call_foreign(result, coordinator) do
+                ruling = block.call(to_yield, context)
+                Validator::Ruling.apply(ruling.nil? ? Validator::Ruling::Pass() : ruling, result, coordinator)
+              end
+
+              case commit
+              when false then updated
+              when true then updated.commit(to_yield)
+              else raise Error::Fatal, "Invalid commit argument. Expected boolean, got: #{commit.inspect}"
+              end
+            end
+            # rubocop:enable Metrics/ParameterLists
+
+            def validate?(*path, from: nil, commit: false, &block)
+              from = Validator::Helpers::Path.expand_path(from || path, [])
+              return Suspended.new(:validate!, self, path, from, commit) if block.nil?
+
+              validate!(path, from, :skip, commit, block)
+            end
+
+            def validate(*path, from: nil, commit: false, &block)
+              from = Validator::Helpers::Path.expand_path(from || path, [])
+              validate!(path, from, :refute, commit, block)
+            end
+
+            private
+
+            def validate!(path, from, strategy, commit, block)
+              strategy = Helpers::YieldStrategy.to_yield(strategy)
+              dig!(path, from) do |option, result|
+                updated = strategy.block_parameters(self, option, result) do |to_yield|
+                  Validation.validate(
+                    coordinator,
+                    to_yield,
+                    result,
+                    context,
+                    commit,
+                    block
+                  )
+                end
+                merge_strategy.transform_result(updated, self, path)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative 'helpers/call_foreign'
+require_relative 'helpers/yield_validator'
+
+module Lite
+  module Validation
+    module Validator
+      module Node
+        module Implementation
+          module Wrap
+            private
+
+            def wrap(**opts, &block)
+              Helpers::CallForeign.call_foreign(result, coordinator) do
+                proxy = opts.empty? ? self : child(nil, result, **opts)
+
+                Helpers::YieldValidator.ensure_valid_result!(proxy, block.call(proxy)).result
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative '../result'
+require_relative '../state'
+require_relative '../option'
+
+require_relative 'abstract/instance'
+require_relative 'abstract/leaf'
+require_relative 'abstract/branch'
+require_relative 'child'
+
+module Lite
+  module Validation
+    module Validator
+      module Node
+        module Root
+          include Child::Parent
+
+          def self.initial(bare_value, coordinator, context: nil)
+            Leaf.instance(
+              nil,
+              [Node::Implementation::Identity.intent_id],
+              Option.some(bare_value),
+              Result.valid,
+              State.initial(coordinator, context: context)
+            )
+          end
+
+          def to_result(coordinator: self.coordinator)
+            result.success? ? to_success(coordinator) : to_failure(coordinator)
+          end
+
+          def inspect
+            "#<Root::#{super}"
+          end
+
+          private
+
+          def to_success(coordinator)
+            coordinator.success(result.success.some? ? result.success.value : option.value)
+          end
+
+          def to_failure(coordinator)
+            coordinator.failure(result.to_failure(coordinator))
+          end
+
+          class Leaf < Abstract::Instance
+            include Abstract::Leaf
+            include Root
+          end
+
+          class Branch < Abstract::Instance
+            include Abstract::Branch
+            include Root
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Lite
+  module Validation
+    module Validator
+      module Node
+        class Suspended
+          def initialize(action, node, path, from, *args)
+            @action = action
+            @node = node
+            @path = path
+            @from = from
+            @args = args
+          end
+
+          attr_reader :action, :node, :path, :from, :args
+
+          def option(&block)
+            node.send(action, path, from, :yield_option, *args, block)
+          end
+
+          def some(&block)
+            node.send(action, path, from, :skip, *args, block)
+          end
+
+          def some_or_nil(&block)
+            node.send(action, path, from, :nullify, *args, block)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative 'node/root'
+
+module Lite
+  module Validation
+    module Validator
+      module Node
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/option/none.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Lite
+  module Validation
+    module Validator
+      module Option
+        module None
+          def self.some?
+            false
+          end
+
+          def self.none?
+            true
+          end
+
+          def self.dig(*_path)
+            self
+          end
+
+          def self.to_complex
+            self
+          end
+
+          def self.some_or_nil
+            Option.some(nil)
+          end
+
+          def self.to_option(coordinator)
+            coordinator.none
+          end
+
+          def self.iterable?
+            false
+          end
+
+          def self.inspect
+            '#<Option::None>'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/option/some/abstract.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'lite/data'
+
+module Lite
+  module Validation
+    module Validator
+      module Option
+        module Some
+          class Abstract
+            Lite::Data.define(self, args: %i[value])
+
+            def some?
+              true
+            end
+
+            def none?
+              false
+            end
+
+            def inspect
+              "#<Option::Some value of #{value.class.name}>"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/option/some/complex/registry/abstract.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'lite/data'
+
+module Lite
+  module Validation
+    module Validator
+      module Option
+        module Some
+          module Complex
+            module Registry
+              class Abstract
+                Lite::Data.define(self, args: [:children])
+
+                private_class_method :new
+
+                def self.insert(node, children)
+                  updated = insert_as_child(node, children)
+                  return updated if updated
+
+                  insert_as_parent(node, children)
+                end
+
+                def self.insert_as_child(node, children)
+                  parents, unrelated = children.partition { |child| child.key >= node.key }
+
+                  case parents.length
+                  when 0 then nil
+                  when 1
+                    [parents.first.insert(node), *unrelated]
+                  else
+                    raise Error, "Multiple parents found for #{node.key}: #{parents.map(&:key).join(', ')}"
+                  end
+                end
+
+                def self.insert_as_parent(node, children)
+                  descendants, unrelated = children.partition { |child| child.key < node.key }
+
+                  if descendants.empty?
+                    [*unrelated, node]
+                  else
+                    [node.with(children: descendants.freeze), *unrelated]
+                  end
+                end
+
+                def insert(node)
+                  with(children: self.class.insert(node, children).freeze)
+                end
+
+                def wrapper_for(key)
+                  provider = children.find { |candidate| candidate.key >= key }
+                  provider&.wrapper_for(key)
+                end
+
+                private
+
+                def describe_children(severity)
+                  children.flat_map { |child| child.describe(severity) }
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/option/some/complex/registry/node.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative 'abstract'
+
+module Lite
+  module Validation
+    module Validator
+      module Option
+        module Some
+          module Complex
+            module Registry
+              class Node < Abstract
+                Lite::Data.define(self, args: %i[key wrapper])
+
+                def self.instance(key, wrapper, children: [])
+                  raise Error, "Key must be a class, got: #{key.inpect}" unless key.is_a?(Class)
+
+                  new key, wrapper, children.freeze
+                end
+
+                private_class_method :new
+
+                def insert(node)
+                  if key > node.key
+                    super
+                  elsif key == node.key
+                    with(wrapper: node.wrapper)
+                  end
+                end
+
+                def wrapper_for(key)
+                  return if self.key < key
+
+                  super || wrapper
+                end
+
+                def describe(severity)
+                  ["#{'--' * severity}#{key}:#{wrapper.class.name}", *describe_children(severity + 1)]
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/option/some/complex/registry/root.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'abstract'
+
+module Lite
+  module Validation
+    module Validator
+      module Option
+        module Some
+          module Complex
+            module Registry
+              class Root < Abstract
+                def self.instance(children: [])
+                  new children.freeze
+                end
+
+                def insert(key, wrapper)
+                  super(Node.instance(key, wrapper))
+                end
+
+                def describe
+                  describe_children(0).join("\n")
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/option/some/complex/registry.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'registry/root'
+require_relative 'registry/node'
+
+module Lite
+  module Validation
+    module Validator
+      module Option
+        module Some
+          module Complex
+            module Registry
+              def self.register(key, wrapper)
+                @root = root.insert(key, wrapper)
+              end
+
+              def self.root
+                @root ||= Root.instance
+              end
+
+              def self.wrapper_for(key)
+                root.wrapper_for(key)
+              end
+
+              private_constant :Abstract, :Root, :Node
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/option/some/complex/wrappers/abstract/iterable.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative '../abstract'
+
+module Lite
+  module Validation
+    module Validator
+      module Option
+        module Some
+          module Complex
+            module Wrappers
+              module Abstract
+                class Iterable < Some::Abstract
+                  include Abstract
+
+                  def iterable?
+                    true
+                  end
+
+                  def reduce
+                    raise NotImplementedError, "#{self.class.name}##{__method__} unimplemented"
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/option/some/complex/wrappers/abstract/non_iterable.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative '../abstract'
+
+module Lite
+  module Validation
+    module Validator
+      module Option
+        module Some
+          module Complex
+            module Wrappers
+              module Abstract
+                class NonIterable < Some::Abstract
+                  include Abstract
+
+                  def iterable?
+                    false
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/option/some/complex/wrappers/abstract.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative '../../../../../error'
+require_relative '../../abstract'
+require_relative '../registry'
+
+module Lite
+  module Validation
+    module Validator
+      module Option
+        module Some
+          module Complex
+            module Wrappers
+              module Abstract
+                class InvalidAccess < Error::Fatal; end
+
+                def fetch(_key)
+                  raise NotImplementedError, "#{self.class.name}##{__method__} unimplemented"
+                end
+
+                def iterable?
+                  raise NotImplementedError, "#{self.class.name}##{__method__} unimplemented"
+                end
+
+                def to_complex
+                  self
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/option/some/complex/wrappers/array.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative 'abstract/iterable'
+require_relative '../../singular'
+
+module Lite
+  module Validation
+    module Validator
+      module Option
+        module Some
+          module Complex
+            module Wrappers
+              class Array < Abstract::Iterable
+                include Singular
+
+                def fetch(index)
+                  raise InvalidAccess, "Invalid index to array: #{index}" unless index.is_a?(Integer)
+                  return Option.none unless (0...value.length).include?(index)
+
+                  Option.some(value[index])
+                end
+
+                def reduce(initial_state, &block)
+                  value.lazy
+                       .each_with_index
+                       .reduce(initial_state, &block)
+                end
+
+                def inspect
+                  "#<Option::Some::Array length=#{value.length}>"
+                end
+
+                Registry.register(::Array, self)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end