lite-validation 0.0.1

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative 'abstract/instance'
+require_relative 'abstract/failure'
+
+module Lite
+  module Validation
+    module Validator
+      module Result
+        class Refuted < Abstract::Instance
+          include Abstract::Failure
+
+          Lite::Data.define(self, args: %i[error], kwargs: [:fall_through])
+
+          def self.instance(error, *args, fall_through: false)
+            raise Error::Fatal, "Structured error expected, got: #{error.inspect}" unless error.is_a?(StructuredError)
+
+            new(error, *args, fall_through: fall_through)
+          end
+
+          private_class_method :new
+
+          def success_at?(*_path)
+            false
+          end
+
+          def committed?
+            false
+          end
+
+          def refuted?
+            true
+          end
+
+          def commit(_value)
+            self
+          end
+
+          def auto_commit(as:)
+            self
+          end
+
+          def dispute(error)
+            raise Error, "Structured error expected, got: #{error.inspect}" unless error.is_a?(StructuredError)
+
+            self
+          end
+
+          def refute(error)
+            raise Error::Fatal, "Structured error expected, got: #{error.inspect}" unless error.is_a?(StructuredError)
+
+            self
+          end
+
+          def navigable
+            self
+          end
+
+          def navigate(*_path, &_block)
+            self
+          end
+
+          def errors_root
+            [error]
+          end
+
+          def children
+            EMPTY
+          end
+
+          def inspect
+            signature('Refuted', "error=#{error.code}")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'commit'
+require_relative '../../../../error'
+
+module Lite
+  module Validation
+    module Validator
+      module Result
+        module Valid
+          module Abstract
+            module Collect
+              include Commit
+
+              private
+
+              def collect_committed(as:)
+                case as
+                when :array then collect_committed_as_array
+                when :hash then collect_committed_as_hash
+                else raise Error::Fatal, "Unexpected option: #{as}"
+                end
+              end
+
+              def collect_committed_as_hash
+                each_child({}) do |(key, child), acc|
+                  next unless child.committed?
+
+                  acc[key] = child.send :value
+                end
+              end
+
+              def each_child(initial_object, &block)
+                children.each_with_object(initial_object, &block)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative '../../committed'
+
+module Lite
+  module Validation
+    module Validator
+      module Result
+        module Valid
+          module Abstract
+            module Commit
+              def commit(value)
+                Committed.instance(value)
+              end
+
+              def unexpected_option!(option)
+                raise Error, "Unexpected option: #{option}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative '../../abstract/success'
+require_relative '../../disputable/instance'
+require_relative '../../committed'
+require_relative '../../disputed'
+require_relative '../../../option'
+
+module Lite
+  module Validation
+    module Validator
+      module Result
+        module Valid
+          module Abstract
+            class Instance < Disputable::Instance
+              include Result::Abstract::Success
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/result/valid/iterable/array/abstract.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative '../../abstract/instance'
+require_relative '../../../disputable/iterable/array'
+require_relative '../../abstract/commit'
+
+module Lite
+  module Validation
+    module Validator
+      module Result
+        module Valid
+          module Iterable
+            module Array
+              module Abstract
+                include Disputable::Iterable::Array
+                include Valid::Abstract::Commit
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/result/valid/iterable/array/tuples.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative 'abstract'
+
+module Lite
+  module Validation
+    module Validator
+      module Result
+        module Valid
+          module Iterable
+            module Array
+              class Tuples < Valid::Abstract::Instance
+                include Abstract
+
+                Lite::Data.define(self, args: %i[commit_as])
+
+                def self.instance(commit, *args)
+                  new(commit, [], *args)
+                end
+
+                def inspect
+                  signature('Valid::Iterable::Array::Tuples', nil)
+                end
+
+                def navigable
+                  case commit_as
+                  when false then Valid.navigable(children.to_h.freeze)
+                  when :hash then commit(children.to_h.freeze)
+                  else unexpected_option!(commit_as)
+                  end
+                end
+
+                def child(_key)
+                  Result.valid
+                end
+
+                def merge(result, key)
+                  if result.failure?
+                    Disputed::Iterable.initial.append(result, key)
+                  else
+                    merge_success(result, key)
+                    self
+                  end
+                end
+
+                private
+
+                def merge_success(result, key)
+                  case commit_as
+                  when false
+                    children << [key, result]
+                  when :hash
+                    children << [key, result.value] if result.committed?
+                  else unexpected_option!(commit_as)
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/result/valid/iterable/array/values.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'abstract'
+
+module Lite
+  module Validation
+    module Validator
+      module Result
+        module Valid
+          module Iterable
+            module Array
+              class Values < Valid::Abstract::Instance
+                include Abstract
+
+                def self.instance(*args)
+                  new([], *args)
+                end
+
+                def inspect
+                  signature('Valid::Iterable::Array::Values', nil)
+                end
+
+                def navigable
+                  commit(children.freeze)
+                end
+
+                def merge(result, key)
+                  if result.success?
+                    children << result.value if result.committed?
+                    self
+                  else
+                    Disputed::Iterable.initial.append(result, key)
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative '../abstract/instance'
+require_relative '../../disputable/hash'
+require_relative '../../disputable/iterable'
+
+module Lite
+  module Validation
+    module Validator
+      module Result
+        module Valid
+          module Iterable
+            class Hash < Valid::Abstract::Instance
+              include Disputable::Hash
+              include Disputable::Iterable
+
+              Lite::Data.define(self, args: %i[commit_as])
+
+              def self.instance(commit, children)
+                new(commit, children.dup)
+              end
+
+              def inspect
+                signature('Valid::Iterable::Hash', nil)
+              end
+
+              def navigable
+                navigable = Valid.navigable(children)
+                commit_as ? navigable.auto_commit(as: commit_as) : navigable
+              end
+
+              def merge(result, key)
+                if result.success?
+                  children.merge!(key => result) if commit_as == false || result.committed?
+                  self
+                else
+                  Disputed::Iterable.initial.append(result, key)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'iterable/array/tuples'
+require_relative 'iterable/array/values'
+require_relative 'iterable/hash'
+
+module Lite
+  module Validation
+    module Validator
+      module Result
+        module Valid
+          module Iterable
+            def self.instance(children, commit:)
+              if children.empty?
+                initial(commit: commit)
+              else
+                Hash.instance(commit, children)
+              end
+            end
+
+            def self.initial(commit:)
+              case commit
+              when :hash, false then Array::Tuples.instance(commit)
+              when :array then Array::Values.instance
+              else raise Error, "Unexpected option: #{commit}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative 'iterable'
+require_relative '../disputable/navigable'
+require_relative 'abstract/collect'
+
+module Lite
+  module Validation
+    module Validator
+      module Result
+        module Valid
+          class Navigable < Abstract::Instance
+            include Disputable::Navigable
+            include Abstract::Collect
+
+            def self.instance(*args)
+              new(EMPTY, *args)
+            end
+
+            def initialize(children, *args)
+              super(children.freeze, *args)
+            end
+
+            def auto_commit(as:)
+              commit(collect_committed(as: as))
+            end
+
+            def dispute(error)
+              Disputed::Navigable.instance(error: error)
+            end
+
+            def success
+              Option.none
+            end
+
+            def inspect
+              signature('Valid::Navigable', nil)
+            end
+
+            def iterable(commit:)
+              Iterable.instance(children, commit: commit)
+            end
+
+            def merge(result, key)
+              if result.success?
+                self.class.send(
+                  :new,
+                  children.merge(key => result)
+                )
+              else
+                Disputed::Navigable.instance.append(result, key)
+              end
+            end
+
+            private
+
+            def collect_committed_as_array
+              children.values
+                      .lazy
+                      .select(&:committed?)
+                      .map(&:value).force
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'abstract/success'
+require_relative 'valid/navigable'
+require_relative 'committed'
+require_relative 'disputed'
+require_relative '../option'
+
+module Lite
+  module Validation
+    module Validator
+      module Result
+        module Valid
+          def self.navigable(children)
+            Valid::Navigable.send(:new, children)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative 'result/valid'
+
+module Lite
+  module Validation
+    module Validator
+      module Result
+        def self.valid
+          @valid ||= Valid::Navigable.instance
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/ruling/abstract/invalid.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'lite/data'
+
+require_relative '../abstract'
+require_relative '../../../error'
+require_relative '../../../structured_error'
+
+module Lite
+  module Validation
+    module Validator
+      module Ruling
+        module Abstract
+          class Invalid
+            module Abstract
+              include Ruling::Abstract
+
+              def invalid(&block)
+                block.call(self)
+              end
+            end
+
+            class Raw
+              include Abstract
+
+              Lite::Data.define(self, args: %i[code message data])
+
+              def self.instance(code, message: nil, data: nil)
+                new code, message, data
+              end
+
+              def structured_error(coordinator)
+                coordinator.structured_error(code, message: message, data: data)
+              end
+            end
+
+            include Abstract
+
+            Lite::Data.define(self, args: [:error])
+
+            def self.instance(error, **opts)
+              case [error, opts]
+              in [StructuredError, {}] then new error
+              in [Symbol, { ** }] then self::Raw.instance(error, **opts)
+              else raise Error::Fatal, "Unexpected first argument: #{error.inspect}"
+              end
+            end
+
+            private_class_method :new
+
+            def structured_error(*)
+              error
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/ruling/abstract/valid.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'lite/data'
+
+require_relative '../abstract'
+require_relative '../../../error'
+require_relative '../../../structured_error'
+
+module Lite
+  module Validation
+    module Validator
+      module Ruling
+        module Abstract
+          module Valid
+            def invalid(&_block)
+              self
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Lite
+  module Validation
+    module Validator
+      module Ruling
+        module Abstract
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/ruling/commit.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'lite/data'
+require_relative 'abstract/valid'
+
+module Lite
+  module Validation
+    module Validator
+      module Ruling
+        class Commit
+          Lite::Data.define(self, args: [:value])
+          include Abstract::Valid
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/ruling/dispute.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'abstract/invalid'
+
+module Lite
+  module Validation
+    module Validator
+      module Ruling
+        class Dispute < Ruling::Abstract::Invalid
+          module Abstract; end
+
+          class Raw < Ruling::Abstract::Invalid::Raw
+            include Abstract
+          end
+
+          include Abstract
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/ruling/invalidate.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'lite/data'
+require_relative 'abstract/invalid'
+
+module Lite
+  module Validation
+    module Validator
+      module Ruling
+        class Invalidate < Abstract::Invalid
+          class Raw < Abstract::Invalid::Raw
+            def dispute
+              Ruling::Dispute(code, message: message, data: data)
+            end
+
+            def refute
+              Ruling::Refute(code, message: message, data: data)
+            end
+          end
+
+          def dispute
+            Ruling::Dispute(error)
+          end
+
+          def refute
+            Ruling::Refute(error)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/ruling/pass.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'abstract/valid'
+
+module Lite
+  module Validation
+    module Validator
+      module Ruling
+        class Pass
+          extend Abstract::Valid
+
+          def self.===(other)
+            equal?(other)
+          end
+        end
+      end
+    end
+  end
+end