lite-validation 0.0.1

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

@@ -0,0 +1,40 @@
+# 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 Hash < Abstract::Iterable
+                include Singular
+
+                def fetch(key)
+                  return Option.none unless value.key? key
+
+                  Option.some(value[key])
+                end
+
+                def reduce(initial_state, &block)
+                  value.lazy
+                       .map { |key, value| [value, key] }
+                       .reduce(initial_state, &block)
+                end
+
+                def inspect
+                  "#<Option::Some::Hash length=#{value.length}>"
+                end
+
+                Registry.register(::Hash, self)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'abstract/non_iterable'
+require_relative '../../singular'
+
+module Lite
+  module Validation
+    module Validator
+      module Option
+        module Some
+          module Complex
+            module Wrappers
+              class Object < Abstract::NonIterable
+                include Singular
+
+                def fetch(key)
+                  Option.some(value.send(key))
+                rescue StandardError => e
+                  raise InvalidAccess, e.message
+                end
+
+                def inspect
+                  "#<Option::Some::Object class=#{value.class.name}>"
+                end
+
+                Registry.register(::Object, self)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative 'abstract/non_iterable'
+
+module Lite
+  module Validation
+    module Validator
+      module Option
+        module Some
+          module Complex
+            module Wrappers
+              class Tuple < Abstract::NonIterable
+                def some_or_nil
+                  return self if some?
+
+                  self.class.new(value.map(&:some_or_nil))
+                end
+
+                def to_option(coordinator)
+                  value.map { _1.to_option(coordinator) }
+                end
+
+                def unwrap
+                  transpose.unwrap
+                end
+
+                def transpose
+                  return Option.none unless some?
+
+                  Option.some(value.map(&:value))
+                end
+
+                def some?
+                  value.all?(&:some?)
+                end
+
+                def inspect
+                  "#<Option::Some::Tuple (#{value.map(&:inspect).join(', ')})>"
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative 'wrappers/array'
+require_relative 'wrappers/hash'
+require_relative 'wrappers/object'

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'complex/wrappers'
+
+module Lite
+  module Validation
+    module Validator
+      module Option
+        module Some
+          module Complex
+            def self.instance(object)
+              return object if object.is_a?(Complex)
+
+              wrapper = Registry.wrapper_for(object.class)
+              raise Error::Fatal, "No wrapper for: #{object.class}" unless wrapper
+
+              wrapper.new(object)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'complex/wrappers/tuple'
+
+module Lite
+  module Validation
+    module Validator
+      module Option
+        module Some
+          module Dig
+            def dig(paths)
+              if paths.length == 1
+                follow_path(paths.first)
+              else
+                tuple = paths.map { follow_path(_1) }
+                Complex::Wrappers::Tuple.new(tuple)
+              end
+            end
+
+            private
+
+            def follow_path(path)
+              path.reduce(self) do |option, key|
+                break option if option.none?
+
+                option.to_complex.fetch(key)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'abstract'
+require_relative 'complex'
+require_relative 'singular'
+
+module Lite
+  module Validation
+    module Validator
+      module Option
+        module Some
+          class Simple < Abstract
+            include Singular
+
+            def to_complex
+              Complex.instance(value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative 'dig'
+
+module Lite
+  module Validation
+    module Validator
+      module Option
+        module Some
+          module Singular
+            include Dig
+
+            def some_or_nil
+              self
+            end
+
+            def to_option(coordinator)
+              coordinator.some(value)
+            end
+
+            def unwrap
+              value
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'lite/data'
+
+require_relative 'some/simple'
+require_relative 'some/complex'
+
+module Lite
+  module Validation
+    module Validator
+      module Option
+        module Some
+          def self.instance(value)
+            Simple.new(value)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'option/some'
+require_relative 'option/none'
+
+module Lite
+  module Validation
+    module Validator
+      module Option
+        def self.some(value)
+          Some.instance(value)
+        end
+
+        def self.none
+          None
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative '../../../error'
+
+module Lite
+  module Validation
+    module Validator
+      module Predicate
+        module Abstract
+          module Variants
+            def definite
+              raise Error::Fatal, 'Definite variant not available'
+            end
+
+            def optional
+              raise Error::Fatal, 'Optional variant not available'
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/predicate/foreign/adapter/input/single.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Lite
+  module Validation
+    module Validator
+      module Predicate
+        module Foreign
+          module Adapter
+            module Input
+              module Single
+                def self.pass_in(value, block)
+                  block.call(value)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/predicate/foreign/adapter/input/tuple.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Lite
+  module Validation
+    module Validator
+      module Predicate
+        module Foreign
+          module Adapter
+            module Input
+              module Tuple
+                def self.pass_in(value, block)
+                  block.call(*value)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/predicate/foreign/adapter/input.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative '../../../../error'
+require_relative 'input/single'
+require_relative 'input/tuple'
+
+module Lite
+  module Validation
+    module Validator
+      module Predicate
+        module Foreign
+          module Adapter
+            module Input
+              def self.instance(arity)
+                raise Error::Fatal, "Arity must be positive integer, got: #{arity}" unless arity.positive?
+
+                case arity
+                when 1 then Single
+                else Tuple
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/predicate/foreign/adapter/ruling/instance.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'lite/data'
+
+module Lite
+  module Validation
+    module Validator
+      module Predicate
+        module Foreign
+          module Adapter
+            module Ruling
+              class Instance
+                Lite::Data.define(self, args: %i[severity ruling_class])
+
+                def dispute
+                  severity == :dispute ? self : Ruling.instance(:dispute)
+                end
+
+                def refute
+                  severity == :refute ? self : Ruling.instance(:refute)
+                end
+
+                def to_ruling(error)
+                  ruling_class.instance(error)
+                end
+
+                private_class_method :new
+
+                private :with
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/predicate/foreign/adapter/ruling.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative '../../../ruling'
+require_relative 'ruling/instance'
+
+module Lite
+  module Validation
+    module Validator
+      module Predicate
+        module Foreign
+          module Adapter
+            module Ruling
+              def self.instance(severity)
+                case severity
+                when :dispute then @dispute ||= Instance.send(:new, :dispute, Validator::Ruling::Dispute)
+                when :refute then @refute ||= Instance.send(:new, :refute, Validator::Ruling::Refute)
+                else raise Validation::Error::Fatal, 'Unexpected severity'
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'variants'
+require_relative '../registry'
+require_relative '../../ruling'
+
+module Lite
+  module Validation
+    module Validator
+      module Predicate
+        module Foreign
+          class Engine
+            Lite::Data.define(self, args: [:error_adapter])
+
+            def build(_keys, &_block)
+              raise NotImplementedError, "#{self.class.name}##{__method__} unimplemented"
+            end
+
+            def build_contextual(_keys, _context, &_block)
+              raise NotImplementedError, "#{self.class.name}##{__method__} unimplemented"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'lite/data'
+
+module Lite
+  module Validation
+    module Validator
+      module Predicate
+        module Foreign
+          class Variant
+            Lite::Data.define(self, args: %i[callable adapter])
+
+            def call(value, _context)
+              adapter.to_ruling(adapter.pass_in(value, callable), callable, value)
+            end
+
+            def severity
+              adapter.severity
+            end
+
+            def dispute
+              severity == :dispute ? self : with(adapter: adapter.dispute)
+            end
+
+            def refute
+              severity == :refute ? self : with(adapter: adapter.refute)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative '../abstract/variants'
+require_relative 'variant'
+
+module Lite
+  module Validation
+    module Validator
+      module Predicate
+        module Foreign
+          class Variants
+            include Abstract::Variants
+
+            Lite::Data.define(self, kwargs: %i[definite optional])
+
+            def initialize(definite: nil, optional: nil)
+              super
+            end
+
+            def definite
+              @definite || super
+            end
+
+            def optional
+              @optional || super
+            end
+
+            def dispute
+              with definite: definite&.dispute, optional: optional&.dispute
+            end
+
+            def refute
+              with definite: definite&.refute, optional: optional&.refute
+            end
+
+            def with(definite: self.definite, optional: self.optional)
+              return self if definite == self.definite && optional == self.optional
+
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative 'definite'
+require_relative 'optional'
+
+require_relative '../../coordinator/default'
+require_relative '../../node/root'
+require_relative '../../coordinator/errors/flat'
+
+module Lite
+  module Validation
+    module Validator
+      module Predicate
+        module Native
+          class Builder
+            include Ruling::Constructors
+
+            def initialize
+              @validate_value = nil
+              @validate_option = nil
+            end
+
+            def self.define(&block)
+              new.tap { _1.instance_eval(&block) }.build
+            end
+
+            def validate_value(&block)
+              if block
+                raise(Error, 'Test value already set') unless @validate_value.nil?
+
+                @validate_value = block
+
+              else
+                @validate_value
+              end
+            end
+
+            def validate_option(&block)
+              if block
+                raise(Error, 'Test option already set') unless @validate_option.nil?
+
+                @validate_option = block
+              else
+                @validate_option
+              end
+            end
+
+            def build
+              result = validate
+              raise Error, "Builder invalid: #{result.error.message}" unless result.success?
+
+              definite = validate_value ? Native::Definite.new(validate_value) : nil
+              return definite if validate_option.nil?
+
+              Native::Optional.new(validate_option, definite: definite)
+            end
+
+            def validate
+              coordinator = Coordinator::Default.instance(Coordinator::Errors::Flat)
+
+              Validator::Node::Root.initial(self, coordinator).at do |builder|
+                builder.validate(%i[validate_option validate_value]) do |tuple|
+                  Refute(coordinator.internal_error(:value_missing)) if tuple.all?(&:nil?)
+                end
+              end.to_result
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'instance'
+
+module Lite
+  module Validation
+    module Validator
+      module Predicate
+        module Native
+          class Definite < Instance
+            def definite
+              self
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'lite/data'
+
+require_relative '../abstract/variants'
+
+module Lite
+  module Validation
+    module Validator
+      module Predicate
+        module Native
+          class Instance
+            Lite::Data.define(self, args: [:proc], kwargs: [:severity])
+            include Ruling::Constructors
+            include Abstract::Variants
+
+            def initialize(proc, severity: nil)
+              super
+            end
+
+            def dispute
+              with(severity: :dispute)
+            end
+
+            def refute
+              with(severity: :refute)
+            end
+
+            def call(*args, **opts)
+              raise Error::Fatal, 'Level not set' unless severity
+
+              ruling = instance_exec(*args, **opts, &proc)
+              ruling = Pass() if ruling.nil?
+              ruling.invalid { |invalid| invalid.send(severity) }
+            end
+          end
+        end
+      end
+    end
+  end
+end