lite-validation 0.0.1

data/lib/lite/validation/validator/predicate/native/optional.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'instance'
+require_relative '../../ruling'
+
+module Lite
+  module Validation
+    module Validator
+      module Predicate
+        module Native
+          class Optional < Instance
+            Lite::Data.define(self, kwargs: [:definite])
+
+            def optional
+              self
+            end
+
+            def dispute
+              with(severity: :dispute, definite: definite&.dispute)
+            end
+
+            def refute
+              with(severity: :refute, definite: definite&.refute)
+            end
+
+            def validate_value(value)
+              definite.call(value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/predicate/registry.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative '../../error'
+require_relative 'abstract/variants'
+
+module Lite
+  module Validation
+    module Validator
+      module Predicate
+        module Registry
+          def self.register_predicate(key, predicate)
+            raise Error, "Not a predicate: #{predicate}" unless predicate.is_a?(Predicate::Abstract::Variants)
+            raise Error, "Key already taken: #{key}" if predicates.key?(key)
+
+            predicates[key] = predicate
+          end
+
+          def self.predicate(key)
+            raise Error, "Predicate not registered: #{key}" unless predicates.key?(key)
+
+            predicates[key]
+          end
+
+          def self.predicates
+            @predicates ||= {}
+          end
+
+          def self.register_adapter(key, engine)
+            raise Error, "Key already taken: #{key}" if engines.key?(key)
+
+            engines[key] = engine
+          end
+
+          def self.engine(key)
+            raise Error, "Engine not registered: #{key}" unless engines.key?(key)
+
+            engines[key]
+          end
+
+          def self.engines
+            @engines ||= {}
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'predicate/registry'
+require_relative 'predicate/native/builder'
+
+module Lite
+  module Validation
+    module Validator
+      module Predicate
+        def self.define(name, &block)
+          predicate = Native::Builder.define(&block)
+          Registry.register_predicate(name, predicate)
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/result/abstract/failure.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative '../abstract'
+
+module Lite
+  module Validation
+    module Validator
+      module Result
+        module Abstract
+          module Failure
+            include Validation::Result::Abstract::Failure
+
+            def to_failure(coordinator)
+              coordinator.build_final_error(self)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/result/abstract/instance.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative '../abstract'
+require 'lite/data'
+
+module Lite
+  module Validation
+    module Validator
+      module Result
+        module Abstract
+          class Instance
+            include Abstract
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/result/abstract/success.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative '../abstract'
+
+module Lite
+  module Validation
+    module Validator
+      module Result
+        module Abstract
+          module Success
+            include Validation::Result::Abstract::Success
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative '../../result/abstract'
+require_relative '../../result/abstract/disputable'
+require_relative '../../result/abstract/refutable'
+require_relative '../../error'
+
+module Lite
+  module Validation
+    module Validator
+      module Result
+        module Abstract
+          include Validation::Result::Abstract
+          include Validation::Result::Abstract::Disputable
+          include Validation::Result::Abstract::Refutable
+
+          EMPTY = {}.freeze
+
+          private
+
+          def signature(name, data)
+            full_name = "Result::#{name}"
+            "#<#{[full_name, data].compact.join(' ')}>"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/result/committed.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative 'abstract/instance'
+require_relative 'abstract/success'
+require_relative '../option'
+
+module Lite
+  module Validation
+    module Validator
+      module Result
+        class Committed < Abstract::Instance
+          include Abstract::Success
+
+          Lite::Data.define(self, args: %i[value])
+
+          def self.instance(value, *args)
+            new(value, *args)
+          end
+
+          private_class_method :new
+
+          def success_at?(*_path)
+            true
+          end
+
+          def committed?
+            true
+          end
+
+          def refuted?
+            false
+          end
+
+          def commit(*)
+            prevent_reopening!
+          end
+
+          def auto_commit(as:)
+            prevent_reopening!
+          end
+
+          def dispute(_error)
+            prevent_reopening!
+          end
+
+          def refute(_error)
+            prevent_reopening!
+          end
+
+          def navigate(*_path, &_block)
+            prevent_reopening!
+          end
+
+          def success
+            Option.some(value)
+          end
+
+          def inspect
+            signature('Committed', "value=#{value}")
+          end
+
+          private
+
+          def recurse(*_path, &_block)
+            prevent_reopening!
+          end
+
+          def prevent_reopening!
+            raise Error::Fatal, "Can't reopen committed result"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/result/disputable/hash.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Lite
+  module Validation
+    module Validator
+      module Result
+        module Disputable
+          module Hash
+            def child(key)
+              children[key] || Result.valid
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/result/disputable/instance.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative '../abstract/instance'
+require_relative '../refuted'
+
+module Lite
+  module Validation
+    module Validator
+      module Result
+        module Disputable
+          class Instance < Abstract::Instance
+            Lite::Data.define(self, args: %i[children])
+
+            private_class_method :new
+
+            def committed?
+              false
+            end
+
+            def refuted?
+              false
+            end
+
+            def refute(error, fall_through: false)
+              Refuted.instance(error, fall_through: fall_through)
+            end
+
+            private
+
+            def enter(key, *rest, &block)
+              child = child(key)
+              result, meta = child.navigate(*rest, &block)
+              return [self, meta] if child.equal?(result)
+              return [result, meta] if result.refuted? && result.fall_through
+
+              [merge(result, key), meta]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/result/disputable/iterable/array.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative '../iterable'
+
+module Lite
+  module Validation
+    module Validator
+      module Result
+        module Disputable
+          module Iterable
+            module Array
+              include Iterable
+
+              def child(_key)
+                Result.valid
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/result/disputable/iterable.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Lite
+  module Validation
+    module Validator
+      module Result
+        module Disputable
+          module Iterable
+            def navigate(key, &block)
+              enter(key, &block)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/result/disputable/navigable.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'hash'
+
+module Lite
+  module Validation
+    module Validator
+      module Result
+        module Disputable
+          module Navigable
+            include Hash
+
+            def success_at?(*path)
+              if path.empty?
+                success?
+              else
+                key, *rest = path
+                child(key).success_at?(*rest)
+              end
+            end
+
+            def navigate(*path, &block)
+              if path.empty?
+                block.call(self)
+              else
+                key, *rest = path
+                enter(key, *rest, &block)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/result/disputable.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative 'abstract/instance'
+
+module Lite
+  module Validation
+    module Validator
+      module Result
+        module Disputable
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/result/disputed/abstract/hash.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'instance'
+require_relative '../../disputable/hash'
+
+module Lite
+  module Validation
+    module Validator
+      module Result
+        module Disputed
+          module Abstract
+            class Hash < Abstract::Instance
+              include Disputable::Hash
+
+              Lite::Data.define(self, args: %i[errors_root])
+
+              def append(result, key)
+                raise Error::Fatal, "Key already taken #{key}" if children.key? key
+
+                super
+              end
+
+              def signature(class_name)
+                super(class_name, " with #{errors_root.count} root errors, #{children.count} children")
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/result/disputed/abstract/instance.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative '../../abstract/failure'
+require_relative '../../disputable/instance'
+
+module Lite
+  module Validation
+    module Validator
+      module Result
+        module Disputed
+          module Abstract
+            class Instance < Disputable::Instance
+              include Result::Abstract::Failure
+
+              def append(result, key)
+                raise Error::Fatal, "Can't append successful result: #{result.inspect}" if result.success?
+
+                merge(result, key)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/result/disputed/iterable/array.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative '../abstract/instance'
+require_relative '../../disputable/iterable/array'
+
+module Lite
+  module Validation
+    module Validator
+      module Result
+        module Disputed
+          module Iterable
+            class Array < Abstract::Instance
+              include Disputable::Iterable::Array
+
+              def self.instance(*args)
+                new([], *args)
+              end
+
+              def inspect
+                signature('Disputed::Iterable::Array')
+              end
+
+              def navigable
+                Disputed.navigable([], children.to_h)
+              end
+
+              def signature(class_name)
+                super(class_name, " with #{children.count} children")
+              end
+
+              def merge(result, key)
+                children << [key, result] unless result.success?
+
+                self
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/result/disputed/iterable/hash.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative '../abstract/hash'
+require_relative '../../disputable/iterable'
+
+module Lite
+  module Validation
+    module Validator
+      module Result
+        module Disputed
+          module Iterable
+            class Hash < Abstract::Hash
+              include Disputable::Iterable
+
+              def self.instance(errors, children)
+                new(errors.dup, children.dup)
+              end
+
+              def inspect
+                signature('Disputed::Iterable::Hash')
+              end
+
+              def navigable
+                Disputed.navigable(errors_root, children)
+              end
+
+              def merge(result, key)
+                children.merge!(key => result) unless result.success?
+
+                self
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/result/disputed/iterable.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'iterable/array'
+require_relative 'iterable/hash'
+
+module Lite
+  module Validation
+    module Validator
+      module Result
+        module Disputed
+          module Iterable
+            def self.initial
+              Array.instance
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/result/disputed/navigable.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative 'iterable'
+require_relative '../disputable/navigable'
+
+module Lite
+  module Validation
+    module Validator
+      module Result
+        module Disputed
+          class Navigable < Abstract::Hash
+            include Disputable::Navigable
+
+            def self.instance(*args, error: nil)
+              instance = new([], EMPTY, *args)
+              error ? instance.dispute(error) : instance
+            end
+
+            def initialize(errors, children, *args)
+              super(errors.freeze, children.freeze, *args)
+            end
+
+            def commit(_value)
+              self
+            end
+
+            def auto_commit(as:)
+              self
+            end
+
+            def dispute(error)
+              raise Error::Fatal, "Structured error expected, got: #{error.inspect}" unless error.is_a?(StructuredError)
+
+              self.class.send :new, [*errors_root, error], children
+            end
+
+            def inspect
+              signature('Disputed::Navigable')
+            end
+
+            def iterable(commit:)
+              Iterable::Hash.instance(errors_root, children)
+            end
+
+            def merge(result, key)
+              return self if result.success?
+
+              self.class.send(
+                :new,
+                errors_root,
+                children.merge(key => result)
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/result/disputed.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'disputed/navigable'
+
+module Lite
+  module Validation
+    module Validator
+      module Result
+        module Disputed
+          def self.navigable(errors, children)
+            Disputed::Navigable.send(:new, errors, children)
+          end
+        end
+      end
+    end
+  end
+end