lite-validation 0.0.1

data/lib/lite/validation/validator/adapters/interfaces/default.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative '../../result'
+require_relative '../../option'
+
+module Lite
+  module Validation
+    module Validator
+      module Adapters
+        module Interfaces
+          module Default
+            def self.success(value)
+              Result::Committed.instance(value)
+            end
+
+            def self.failure(error)
+              Result::Refuted.instance(error)
+            end
+
+            def self.some(value)
+              Option.some(value)
+            end
+
+            def self.none
+              Option.none
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/adapters/interfaces/dry.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative '../../../adapters/interfaces/dry'
+
+module Lite
+  module Validation
+    module Validator
+      module Adapters
+        module Interfaces
+          module Dry
+            extend Validation::Adapters::Interfaces::Dry
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/adapters/predicates/dry/adapter.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'dry-logic'
+
+require_relative '../../../predicate/foreign/adapter/input'
+require_relative '../../../predicate/foreign/adapter/ruling'
+
+module Lite
+  module Validation
+    module Validator
+      module Adapters
+        module Predicates
+          module Dry
+            class Adapter
+              extend Forwardable
+
+              Lite::Data.define(self, args: %i[error_adapter input_adapter ruling_adapter])
+
+              def self.instance(error_adapter, arity, severity)
+                new(
+                  error_adapter,
+                  Predicate::Foreign::Adapter::Input.instance(arity),
+                  Predicate::Foreign::Adapter::Ruling.instance(severity)
+                )
+              end
+
+              def_delegator :input_adapter, :pass_in
+              def_delegator :ruling_adapter, :severity
+
+              def to_ruling(result, rule, value)
+                return Validator::Ruling::Pass() if result.success?
+
+                ruling_adapter.to_ruling(error_adapter.call(rule, value))
+              end
+
+              def dispute
+                severity == :dispute ? self : with(ruling_adapter: ruling_adapter.dispute)
+              end
+
+              def refute
+                severity == :refute ? self : with(ruling_adapter: ruling_adapter.refute)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/adapters/predicates/dry/builder.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'dry-logic'
+require 'forwardable'
+
+require_relative '../../../predicate/foreign/engine'
+require_relative 'adapter'
+
+module Lite
+  module Validation
+    module Validator
+      module Adapters
+        module Predicates
+          module Dry
+            class Builder
+              def initialize(error_adapter, arity, severity: :dispute)
+                @error_adapter = error_adapter
+                @arity = arity
+                @severity = severity
+              end
+
+              def call(&block)
+                rule = ::Dry::Logic::Builder.call(&block)
+
+                Predicate::Foreign::Variant.new(rule, adapter_instance)
+              end
+
+              def severity(severity)
+                @severity = severity
+                self
+              end
+
+              private
+
+              attr_reader :error_adapter, :arity
+
+              def adapter_instance
+                Adapter.instance(error_adapter, arity, @severity)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/adapters/predicates/dry/engine.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'builder'
+require_relative '../../../predicate/registry'
+
+module Lite
+  module Validation
+    module Validator
+      module Adapters
+        module Predicates
+          module Dry
+            class Engine < Predicate::Foreign::Engine
+              def self.instance(error_adapter)
+                new error_adapter
+              end
+
+              def build_contextual(keys, context, &block)
+                definite = block.call(Builder.new(error_adapter, keys.length), context)
+                Predicate::Foreign::Variants.new(definite: definite)
+              end
+
+              def build(keys, severity: :dispute, &block)
+                definite = Builder.new(error_adapter, keys.length, severity: severity).call(&block)
+                Predicate::Foreign::Variants.new(definite: definite)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/adapters/predicates/dry.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'dry/engine'

data/lib/lite/validation/validator/coordinator/builder.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require_relative 'errors/builder'
+
+require_relative 'default'
+require_relative '../node/root'
+
+module Lite
+  module Validation
+    module Validator
+      module Coordinator
+        class Builder
+          include Ruling::Constructors
+
+          def self.define(&block)
+            new.tap { _1.instance_eval(&block) }.build
+          end
+
+          def initialize
+            @validation_error_adapter = nil
+            @final_error_adapter = nil
+            @interface_adapter = nil
+          end
+
+          def validation_error_adapter(&block)
+            if block
+              raise(Error, 'Validation error adapter already set') unless @validation_error_adapter.nil?
+
+              @validation_error_adapter = Errors::Builder.define(&block)
+
+            else
+              @validation_error_adapter
+            end
+          end
+
+          def final_error_adapter(*args)
+            case args.length
+            when 1
+              raise(Error, 'Final error adapter already set') unless @final_error_adapter.nil?
+
+              @final_error_adapter = args[0]
+            when 0
+              @final_error_adapter
+            else raise Error, "Unexpected arguments to builder: #{args.inspect}"
+            end
+          end
+
+          def interface_adapter(*args)
+            case args.length
+            when 1
+              raise(Error, 'Monads adapter already set') unless @interface_adapter.nil?
+
+              @interface_adapter = args[0]
+
+            when 0 then @interface_adapter
+            else raise Error, "Unexpected arguments to builder: #{args.inspect}"
+            end
+          end
+
+          def build
+            result = validate
+            raise Error, "Builder invalid: #{result.error.message}" unless result.success?
+
+            Coordinator::Instance.new(
+              interface: interface_adapter,
+              validation_error: validation_error_adapter.build,
+              final_error: final_error_adapter
+            )
+          end
+
+          def validate # rubocop:disable Metrics/AbcSize
+            coordinator = Coordinator::Default.instance(Errors::Flat)
+
+            Validator::Node::Root.initial(self, coordinator).at do |builder|
+              builder.validate(:interface_adapter) do |adapter|
+                Refute(coordinator.internal_error(:value_missing)) if adapter.nil?
+              end.validate(:final_error_adapter) do |adapter|
+                Refute(coordinator.internal_error(:value_missing)) if adapter.nil?
+              end.at(:validation_error_adapter) do |errors|
+                errors.validate do |adapter|
+                  Refute(coordinator.internal_error(:value_missing)) if adapter.nil?
+                end.validate(:structured_error) do |proc|
+                  Refute(coordinator.internal_error(:value_missing)) if proc.nil?
+                end
+              end
+            end.to_result
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/coordinator/default.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative '../adapters/errors/default'
+require_relative '../adapters/interfaces/default'
+require_relative 'instance'
+
+module Lite
+  module Validation
+    module Validator
+      module Coordinator
+        class Default < Instance
+          def self.instance(error_building_strategy)
+            monads = Adapters::Interfaces::Default
+            errors = Adapters::Errors::Default
+            new interface: monads, validation_error: errors, final_error: error_building_strategy
+          end
+
+          def_delegator :validation_error, :structured_error
+
+          def build_final_error(result)
+            errors = final_error.build(result)
+            message = errors.flat_map do |(key, errors)|
+              key.empty? ? errors.join(', ') : "#{key}: #{errors.map(&:code).join(', ')}"
+            end.join(', ')
+
+            structured_error(:invalid, message: message, data: errors)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/coordinator/errors/builder.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative '../../../error'
+require_relative 'dry'
+require_relative 'flat'
+require_relative 'hierarchical'
+
+module Lite
+  module Validation
+    module Validator
+      module Coordinator
+        module Errors
+          class Builder
+            def self.define(&block)
+              new.tap { _1.instance_eval(&block) }
+            end
+
+            def initialize
+              @internal_error = nil
+              @structured_error = nil
+            end
+
+            def build
+              builder = self
+
+              Module.new do
+                define_singleton_method :internal_error, &builder.internal_error || builder.structured_error
+                define_singleton_method :structured_error, &builder.structured_error
+              end
+            end
+
+            def internal_error(&block)
+              if block
+                raise(Error, 'Internal error proc already set') unless @internal_error.nil?
+
+                @internal_error = block
+              else
+                @internal_error
+              end
+            end
+
+            def structured_error(&block)
+              if block
+                raise(Error, 'Structured error proc already set') unless @structured_error.nil?
+
+                @structured_error = block
+              else
+                @structured_error
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/coordinator/errors/dry.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Lite
+  module Validation
+    module Validator
+      module Coordinator
+        module Errors
+          module Dry
+            def self.build(result)
+              root_errors = result.send(:errors_root)
+              children = result.send(:children).each_with_object({}) do |(key, child), acc|
+                child_errors = build(child)
+                acc[key] = child_errors unless child_errors.empty?
+              end
+
+              if children.empty?
+                root_errors
+              elsif root_errors.empty?
+                children
+              else
+                [root_errors, children]
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/coordinator/errors/flat.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Lite
+  module Validation
+    module Validator
+      module Coordinator
+        module Errors
+          module Flat
+            def self.build(result)
+              build_recursively(result)
+            end
+
+            def self.build_recursively(result, path: [])
+              errors_root = result.send(:errors_root)
+              return build_nested(result, path) if errors_root.empty?
+
+              [[stringify_path(path), errors_root], *build_nested(result, path)]
+            end
+
+            def self.build_nested(result, path)
+              result.send(:children).flat_map do |key, child|
+                build_recursively(child, path: [*path, key])
+              end
+            end
+
+            def self.stringify_path(path)
+              case path
+              when Array then path.map { stringify_key(_1) }.join('.')
+              else path.to_s.freeze
+              end
+            end
+
+            def self.stringify_key(key)
+              case key
+              when Array then "(#{key.map { stringify_path(_1) }.join(',')})"
+              else key.to_s.freeze
+              end
+            end
+
+            private_class_method :build_recursively, :build_nested
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/coordinator/errors/hierarchical.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Lite
+  module Validation
+    module Validator
+      module Coordinator
+        module Errors
+          module Hierarchical
+            def self.build(result)
+              root_errors = result.send(:errors_root)
+              children = result.send(:children).each_with_object({}) do |(key, child), acc|
+                child_errors = build(child)
+                acc[key] = child_errors unless child_errors.empty?
+              end
+
+              if children.empty?
+                { errors: root_errors }
+              elsif root_errors.empty?
+                { children: children }
+              else
+                { errors: root_errors, children: children }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/coordinator/instance.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'lite/data'
+require 'forwardable'
+
+module Lite
+  module Validation
+    module Validator
+      module Coordinator
+        class Instance
+          extend Forwardable
+
+          Lite::Data.define(self, kwargs: %i[interface validation_error final_error])
+
+          def_delegator :interface, :failure
+          def_delegator :interface, :success
+          def_delegator :interface, :none
+          def_delegator :interface, :some
+          def_delegator :interface, :handle_result
+          def_delegator :validation_error, :internal_error
+          def_delegator :validation_error, :structured_error
+
+          def build_final_error(result)
+            final_error.build(result)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative 'coordinator/builder'
+
+module Lite
+  module Validation
+    module Validator
+      module Coordinator
+      end
+    end
+  end
+end

data/lib/lite/validation/validator/helpers/path.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative '../../error'
+
+module Lite
+  module Validation
+    module Validator
+      module Helpers
+        module Path
+          class InvalidPath < Error::Fatal; end
+
+          def self.expand_path(path, base_path)
+            return [base_path] if path.empty?
+
+            element, *rest = path
+
+            case element
+            when ::Array
+              raise InvalidPath, <<~ERR.chomp unless rest.empty?
+                Can't follow path into a tuple: #{element} -> #{rest.map(&:inspect).join(', ')}
+              ERR
+
+              expand_tuple(element, base_path)
+            else
+              expand_path(rest, [*base_path, element])
+            end
+          end
+
+          def self.expand_tuple(tuple, base_path)
+            tuple.flat_map do |element|
+              expand_element(element, base_path)
+            end
+          end
+
+          def self.expand_element(element, base_path)
+            case element
+            when ::Array
+              raise InvalidPath, "Empty path in a tuple: #{base_path.join(', ')}" if element.empty?
+
+              expand_path(element, base_path)
+            else
+              [[*base_path, element]]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative '../abstract'
+
+module Lite
+  module Validation
+    module Validator
+      module Node
+        module Abstract
+          module Branch
+            include Abstract
+
+            def inspect
+              "Branch #{super}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'lite/data'
+
+module Lite
+  module Validation
+    module Validator
+      module Node
+        module Abstract
+          class Instance
+            Lite::Data.define(self, args: %i[parent path option result state])
+
+            def self.instance(parent, path, option, result, state)
+              new(parent, path.freeze, option, result, state)
+            end
+
+            def coordinator
+              state.coordinator
+            end
+
+            def value
+              state.unwrap_strategy.unwrap(option, coordinator)
+            end
+
+            def merge_strategy
+              state.merge_strategy
+            end
+
+            def context
+              state.context
+            end
+
+            def inspect
+              "#{display_path(true)} result=#{result.inspect} option=#{option.inspect} state=#{state.inspect}"
+            end
+
+            private :option, :state, :with
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative '../abstract'
+
+module Lite
+  module Validation
+    module Validator
+      module Node
+        module Abstract
+          module Leaf
+            include Abstract
+
+            def branch
+              self.class::Branch.instance parent, path, option.to_complex, result, state
+            end
+
+            def inspect
+              "Leaf #{super}"
+            end
+
+            private
+
+            def dig(*path, from: nil, &block)
+              if path.empty?
+                super
+              else
+                branch.dig(*path, from: from, &block)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end