lite-validation 0.0.1

data/bench/calibrational.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'benchmark'
+require 'dry/validation'
+require 'byebug'
+
+require_relative '../spec/validation/validator/result/support/test_reducer'
+
+module Lite
+  module Validation
+    module Validator
+      module Benchmark
+        module Calibrational
+          module Iteration
+            def self.run(n, k) # rubocop:disable Naming/MethodParameterName, Metrics/AbcSize
+              runs = {}
+
+              runs[:ValidArrayValues] = proc do |_idx|
+                ValidArrayValues.call(data(k), block)
+              end
+
+              runs[:ValidArrayTuples] = proc do |_idx|
+                ValidArrayTuples.call(data(k), block)
+              end
+
+              runs[:ValidHash] = proc do |_idx|
+                ValidHash.call(data(k), block)
+              end
+
+              runs.to_a.each do |key, proc|
+                result = ::Benchmark.measure { n.times { proc.call } }
+                puts "#{key}: #{result}"
+              end
+            end
+
+            def self.data(k) # rubocop:disable Naming/MethodParameterName
+              k.times.map do
+                Random.rand(0...100)
+              end
+            end
+
+            def self.block
+              lambda { |_iterable, _key, value, result, _context|
+                if value.negative?
+                  result
+                else
+                  [result.commit(value + 1), nil]
+                end
+              }
+            end
+
+            module ValidArrayValues
+              def self.call(data, block)
+                iterable = Result::Valid::Iterable::Array::Values.instance
+                Node::TestReducer.reduce(iterable, data, block).navigable
+              end
+            end
+
+            module ValidArrayTuples
+              def self.call(data, block)
+                iterable = Result::Valid::Iterable::Array::Tuples.instance(:hash)
+                Node::TestReducer.reduce(iterable, data, block).navigable
+              end
+            end
+
+            module ValidHash
+              def self.call(data, block)
+                iterable = Result::Valid::Iterable::Hash.instance(:hash, {})
+                Node::TestReducer.reduce(iterable, data, block).navigable
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+N = 10_000
+
+k = 3
+puts "------------------------------- #{N}, #{k} -------------------------------"
+Lite::Validation::Validator::Benchmark::Calibrational::Iteration.run(N, k)
+k = 30
+puts "------------------------------- #{N}, #{k} -------------------------------"
+Lite::Validation::Validator::Benchmark::Calibrational::Iteration.run(N, k)
+k = 300
+puts "------------------------------- #{N}, #{k} -------------------------------"
+Lite::Validation::Validator::Benchmark::Calibrational::Iteration.run(N, k)

data/bench/comparative.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require 'benchmark'
+require 'active_model'
+require 'dry/validation'
+require 'byebug'
+
+require_relative '../spec/validation/validator/support/functional/contracts/hash'
+require_relative '../spec/validation/validator/support/functional/coordinators/dry'
+require_relative '../spec/validation/validator/support/shared/predicates/dry'
+
+module Lite
+  module Validation
+    module Validator
+      module Benchmark
+        module Comparative
+          class DryBench < Dry::Validation::Contract
+            option(:limit)
+
+            json do
+              required(:id).filled(:string)
+              required(:price).value(:integer, gteq?: 0)
+              required(:dates).schema do
+                required(:issued).value(:date_time)
+                required(:due).value(:date_time)
+              end
+              required(:payments).array do
+                schema do
+                  required(:amount).value(:integer, gteq?: 0)
+                  required(:type).value(:string, included_in?: %w[card cash])
+                end
+              end
+              required(:items).array do
+                schema do
+                  required(:id).filled(:string)
+                  required(:name).filled(:string)
+                  required(:price).value(:integer, gteq?: 0)
+                  required(:qty).value(:integer, gteq?: 0)
+                end
+              end
+            end
+
+            rule(dates: %i[issued due]) do
+              next if value[0] <= value[1]
+
+              key.failure('first must be less than or equal to the second')
+            end
+
+            rule(:price) do
+              next if value <= limit
+
+              key.failure('is excessive')
+            end
+          end
+
+          class ActiveModelBench < Dry::Validation::Contract
+            def self.call(data, limit:)
+              model ||= BenchModel.instance(data, limit: limit)
+              model.valid? ? nil : model.errors
+            end
+
+            class BenchModel
+              def self.instance(data, limit:)
+                dates = Dates.new(**data[:dates])
+                items = data[:items].map { Item.new(**data.slice(:id, :name, :price, :qty)) }
+                payments = data[:payments].map { Payment.new(**data.slice(:amount, :type)) }
+
+                BenchModel.new(dates: dates, items: items, payments: payments, limit: limit, **data.slice(:id, :price))
+              end
+
+              class Dates
+                include ActiveModel::Model
+                include ActiveModel::Attributes
+                include ActiveModel::Validations
+
+                attribute :issued, :datetime
+                attribute :due, :datetime
+
+                validates :issued, presence: true
+                validates :due, presence: true
+
+                validate do
+                  next if issued < due
+
+                  errors.add('(issued,due)', 'first must be less than or equal to the second')
+                end
+              end
+
+              class Payment
+                include ActiveModel::Model
+                include ActiveModel::Attributes
+                include ActiveModel::Validations
+
+                attribute :amount, :integer
+                attribute :type, :string
+
+                validates :amount, presence: true, numericality: { greater_than: 0 }
+                validates :type, presence: true, inclusion: %w[cash card]
+              end
+
+              class Item
+                include ActiveModel::Model
+                include ActiveModel::Attributes
+                include ActiveModel::Validations
+
+                attribute :id, :string
+                attribute :name, :string
+                attribute :price, :integer
+                attribute :qty, :integer
+
+                validates :price, presence: true, numericality: { greater_than: 0 }
+                validates :qty, presence: true, numericality: { greater_than: 0 }
+              end
+
+              include ActiveModel::Model
+              include ActiveModel::Attributes
+              include ActiveModel::Validations
+
+              attribute :id, :string
+              attribute :price, :integer
+              attribute :limit, :integer
+              attribute :dates
+              attribute :items
+              attribute :payments
+
+              validates :id, presence: true
+              validates :price, presence: true
+
+              validate do
+                next if dates.valid?
+
+                dates.errors.messages.each { |attr, msg| errors.add("dates.#{attr}", msg) }
+              end
+
+              validate do
+                items.each_with_index do |item, idx|
+                  next if item.valid?
+
+                  item.errors.messages.each { |attr, msg| errors.add("items.#{idx}.#{attr}", msg) }
+                end
+              end
+
+              validate do
+                payments.each_with_index do |payment, idx|
+                  next if payment.valid?
+
+                  payment.errors.messages.each { |attr, msg| errors.add("payments.#{idx}.#{attr}", msg) }
+                end
+              end
+
+              validate do
+                errors.add(:price, 'is excessive') if price > limit
+              end
+            end
+          end
+
+          LiteBench = Support::Functional::Contracts::Hash
+
+          VALID = LiteBench::VALID
+          INVALID = LiteBench::INVALID
+          CONTEXT = LiteBench::CONTEXT
+
+          def self.run(n) # rubocop:disable Naming/MethodParameterName, Metrics/AbcSize
+            runs = {}
+
+            runs[:ActiveModel] = proc do |idx|
+              ActiveModelBench.call(data(idx), **CONTEXT)
+            end
+
+            runs[:Dry] = proc do |idx|
+              DryBench.new(**CONTEXT).call(data(idx))
+            end
+
+            runs[:Lite] = proc do |idx|
+              LiteBench.call(
+                data(idx),
+                Support::Functional::Coordinators::Dry::Flat,
+                CONTEXT
+              ).to_result
+            end
+
+            runs.to_a.shuffle.each do |key, proc|
+              result = ::Benchmark.measure { n.times { |idx| proc.call(idx) } }
+              puts "#{key}: #{result}"
+            end
+          end
+
+          def self.data(idx)
+            (idx % 5).zero? ? INVALID : VALID
+          end
+        end
+      end
+    end
+  end
+end
+
+Lite::Validation::Validator::Benchmark::Comparative.run(1000)

data/bench/functional.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'benchmark'
+require 'dry/validation'
+require 'byebug'
+
+require_relative '../lib/lite/validation/validator'
+require_relative '../spec/validation/validator/support/functional/coordinators/dry'
+require_relative '../spec/validation/validator/support/shared/predicates/dry'
+
+module Lite
+  module Validation
+    module Validator
+      module Benchmark
+        module Functional
+          module Iteration
+            def self.run(n) # rubocop:disable Naming/MethodParameterName, Metrics/AbcSize
+              runs = {}
+
+              runs[:IndirectValidate] = proc do |_idx|
+                IndirectIterationValidate.call(validate_data)
+              end
+
+              runs[:DirectValidate] = proc do |_idx|
+                DirectIterationValidate.call(validate_data)
+              end
+
+              runs[:DirectSatisfy] = proc do |_idx|
+                DirectIterationSatisfy.call(satisfy_data)
+              end
+
+              runs.to_a.shuffle.each do |key, proc|
+                result = ::Benchmark.measure { n.times { |idx| proc.call(idx) } }
+                puts "#{key}: #{result}"
+              end
+            end
+
+            def self.validate_data
+              array = 100.times.map do
+                rand = rand()
+                case rand
+                when 11 then nil
+                else rand
+                end
+              end
+
+              { array: array }
+            end
+
+            def self.satisfy_data
+              { array: 100.times.map { rand } }
+            end
+
+            def self.rand
+              Random.rand(-1..11)
+            end
+
+            module IndirectIterationValidate
+              extend Ruling::Constructors
+
+              def self.call(data, coordinator: Support::Functional::Coordinators::Dry::Flat)
+                Validator
+                  .instance(data, coordinator)
+                  .each_at(:array, commit: :array) do |node|
+                  node
+                    .validate(commit: true) do |value, _ctx|
+                    next Refute(:blank) if value.nil?
+
+                    Dispute(:negative) if value.negative?
+                  end
+                end.auto_commit(as: :hash)
+              end
+            end
+
+            module DirectIterationValidate
+              extend Ruling::Constructors
+
+              def self.call(data, coordinator: Support::Functional::Coordinators::Dry::Flat)
+                Validator
+                  .instance(data, coordinator)
+                  .each_at(:array, commit: :array).validate(commit: true) do |value, _ctx|
+                  next Refute(:blank) if value.nil?
+
+                  Dispute(:negative) if value.negative?
+                end.auto_commit(as: :hash)
+              end
+            end
+
+            module DirectIterationSatisfy
+              extend Ruling::Constructors
+
+              def self.call(data, coordinator: Support::Functional::Coordinators::Dry::Flat)
+                Validator
+                  .instance(data, coordinator, context: { min: 0, max: 10 })
+                  .each_at(:array, commit: :array).satisfy(using: :dry, commit: true) do |builder, context|
+                  builder.call { gteq?(context[:min]) & lteq?(context[:max]) }
+                end.auto_commit(as: :array)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Lite::Validation::Validator::Benchmark::Functional::Iteration.run(2000)

data/bench/profile.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'ruby-prof'
+require 'byebug'
+
+require_relative '../spec/validation/validator/support/functional/contracts/hash'
+require_relative '../spec/validation/validator/support/functional/coordinators/dry'
+require_relative '../spec/validation/validator/support/shared/predicates/dry'
+
+module Lite
+  module Validation
+    module Validator
+      module Benchmark
+        module Profile
+          LiteProf = Support::Functional::Contracts::Hash
+
+          VALID = LiteProf::VALID
+          INVALID = LiteProf::INVALID
+          CONTEXT = LiteProf::CONTEXT
+
+          def self.run(n) # rubocop:disable Naming/MethodParameterName
+            result = RubyProf::Profile.profile do
+              n.times do |idx|
+                LiteProf.call(
+                  data(idx),
+                  Support::Functional::Coordinators::Dry::Flat,
+                  CONTEXT
+                ).to_result
+              end
+            end
+
+            printer = RubyProf::GraphPrinter.new(result)
+            printer.print($stdout, {})
+          end
+
+          def self.data(idx)
+            (idx % 5).zero? ? INVALID : VALID
+          end
+        end
+      end
+    end
+  end
+end
+
+Lite::Validation::Validator::Benchmark::Profile.run(1000)

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'dry-monads'
+
+module Lite
+  module Validation
+    module Adapters
+      module Interfaces
+        module Dry
+          def success(value)
+            ::Dry::Monads::Result::Success.new(value)
+          end
+
+          def failure(error)
+            ::Dry::Monads::Result::Failure.new(error)
+          end
+
+          def some(value)
+            ::Dry::Monads::Result::Success.new(value)
+          end
+
+          def none
+            ::Dry::Monads::Result::Failure.new(::Dry::Monads::Unit)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Lite
+  module Validation
+    class Error < StandardError
+      class Fatal < Error; end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative '../abstract'
+
+module Lite
+  module Validation
+    module Result
+      module Abstract
+        module Disputable
+          def dispute(_error)
+            raise NotImplementedError, "#{self.class.name}##{__method__} unimplemented"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Lite
+  module Validation
+    module Result
+      module Abstract
+        module Failure
+          def failure?
+            true
+          end
+
+          def to_result(coordinator)
+            coordinator.failure(coordinator.build_final_error(self))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative '../abstract'
+
+module Lite
+  module Validation
+    module Result
+      module Abstract
+        module Refutable
+          def refute(_error)
+            raise NotImplementedError, "#{self.class.name}##{__method__} unimplemented"
+          end
+
+          def refuted?
+            raise NotImplementedError, "#{self.class.name}##{__method__} unimplemented"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Lite
+  module Validation
+    module Result
+      module Abstract
+        module Success
+          def failure?
+            false
+          end
+
+          def to_result(coordinator)
+            coordinator.success(success)
+          end
+
+          private
+
+          def success
+            raise NotImplementedError, "#{self.class.name}##{__method__} unimplemented"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative 'abstract/failure'
+require_relative 'abstract/success'
+
+module Lite
+  module Validation
+    module Result
+      module Abstract
+        def success?
+          !failure?
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/structured_error/record.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'lite/data'
+
+require_relative '../structured_error'
+
+module Lite
+  module Validation
+    module StructuredError
+      class Record
+        include StructuredError
+
+        Lite::Data.define(self, args: %i[code message data])
+
+        def self.instance(code, message: nil, data: nil)
+          new(code.to_sym, message&.to_s.freeze, data.freeze)
+        end
+
+        def display_message(*)
+          message
+        end
+
+        def inspect
+          "#<#{self.class.name} '#{message || code}'>"
+        end
+
+        def to_hash
+          { code: code }.tap do |hash|
+            hash[:message] = message unless message.nil?
+            hash[:data] = data unless data.nil?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lite/validation/structured_error.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Lite
+  module Validation
+    module StructuredError
+      def code
+        raise NotImplementedError, "#{self.class.name}##{__method__} unimplemented"
+      end
+
+      def message
+        nil
+      end
+
+      def display_message(*)
+        nil
+      end
+
+      def data
+        nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative '../../../structured_error/record'
+require_relative '../../coordinator/errors/flat'
+
+module Lite
+  module Validation
+    module Validator
+      module Adapters
+        module Errors
+          module Default
+            def self.internal_error(id, message: nil, data: nil)
+              structured_error(id, message: message, data: data)
+            end
+
+            def self.structured_error(code, message: nil, data: nil)
+              StructuredError::Record.instance(code, message: message, data: data)
+            end
+          end
+        end
+      end
+    end
+  end
+end