dry-validation 0.1.0 → 1.8.0

data/lib/dry/validation/result.rb

@@ -1,63 +1,231 @@
+# frozen_string_literal: true
+
+require "concurrent/map"
+require "dry/core/equalizer"
+
+require "dry/validation/constants"
+require "dry/validation/message_set"
+require "dry/validation/values"
+
 module Dry
   module Validation
-    def self.Result(input, value, rule)
-      case value
-      when Array then Result::Set.new(input, value, rule)
-      else Result::Value.new(input, value, rule)
+    # Result objects are returned by contracts
+    #
+    # @api public
+    class Result
+      include Dry::Equalizer(:schema_result, :context, :errors, inspect: false)
+
+      # Build a new result
+      #
+      # @param [Dry::Schema::Result] schema_result
+      #
+      # @api private
+      def self.new(schema_result, context = ::Concurrent::Map.new, options = EMPTY_HASH)
+        result = super
+        yield(result) if block_given?
+        result.freeze
       end
-    end
 
-    class Result
-      include Dry::Equalizer(:success?, :input, :rule)
+      # Context that's shared between rules
+      #
+      # @return [Concurrent::Map]
+      #
+      # @api public
+      attr_reader :context
 
-      attr_reader :input, :value, :rule
+      # Result from contract's schema
+      #
+      # @return [Dry::Schema::Result]
+      #
+      # @api private
+      attr_reader :schema_result
 
-      class Set < Result
-        def success?
-          value.all?(&:success?)
-        end
+      # Result options
+      #
+      # @return [Hash]
+      #
+      # @api private
+      attr_reader :options
 
-        def to_ary
-          indices = value.map { |v| v.failure? ? value.index(v) : nil }.compact
-          [:input, [rule.name, input, value.values_at(*indices).map(&:to_ary)]]
-        end
+      # Initialize a new result
+      #
+      # @api private
+      def initialize(schema_result, context, options)
+        @schema_result = schema_result
+        @context = context
+        @options = options
+        @errors = initialize_errors
       end
 
-      class Value < Result
-        def to_ary
-          [:input, [rule.name, input, [rule.to_ary]]]
-        end
-        alias_method :to_a, :to_ary
+      # Return values wrapper with the input processed by schema
+      #
+      # @return [Values]
+      #
+      # @api public
+      def values
+        @values ||= Values.new(schema_result.to_h)
+      end
+
+      # Get error set
+      #
+      # @!macro errors-options
+      #   @param [Hash] new_options
+      #   @option new_options [Symbol] :locale Set locale for messages
+      #   @option new_options [Boolean] :hints Enable/disable hints
+      #   @option new_options [Boolean] :full Get messages that include key names
+      #
+      # @return [MessageSet]
+      #
+      # @api public
+      def errors(new_options = EMPTY_HASH)
+        new_options.empty? ? @errors : @errors.with(schema_errors(new_options), new_options)
+      end
+
+      # Check if result is successful
+      #
+      # @return [Bool]
+      #
+      # @api public
+      def success?
+        @errors.empty?
+      end
+
+      # Check if result is not successful
+      #
+      # @return [Bool]
+      #
+      # @api public
+      def failure?
+        !success?
+      end
+
+      # Check if values include an error for the provided key
+      #
+      # @api public
+      def error?(key)
+        errors.any? { |msg| Schema::Path[msg.path].include?(Schema::Path[key]) }
+      end
+
+      # Check if the base schema (without rules) includes an error for the provided key
+      #
+      # @api private
+      def schema_error?(key)
+        schema_result.error?(key)
       end
 
-      def initialize(input, value, rule)
-        @input = input
-        @value = value
-        @rule = rule
+      # Check if the rules includes an error for the provided key
+      #
+      # @api private
+      def rule_error?(key)
+        !schema_error?(key) && error?(key)
       end
 
-      def and(other)
-        if success?
-          other.(input)
+      # Check if the result contains any base rule errors
+      #
+      # @api private
+      def base_rule_error?
+        !errors.filter(:base?).empty?
+      end
+
+      # Check if there's any error for the provided key
+      #
+      # This does not consider errors from the nested values
+      #
+      # @api private
+      def base_error?(key)
+        schema_result.errors.any? { |error|
+          key_path = Schema::Path[key]
+          err_path = Schema::Path[error.path]
+
+          next unless key_path.same_root?(err_path)
+
+          key_path == err_path
+        }
+      end
+
+      # Add a new error for the provided key
+      #
+      # @api private
+      def add_error(error)
+        @errors.add(error)
+        self
+      end
+
+      # Read a value under provided key
+      #
+      # @param [Symbol] key
+      #
+      # @return [Object]
+      #
+      # @api public
+      def [](key)
+        values[key]
+      end
+
+      # Check if a key was set
+      #
+      # @param [Symbol] key
+      #
+      # @return [Bool]
+      #
+      # @api public
+      def key?(key)
+        values.key?(key)
+      end
+
+      # Coerce to a hash
+      #
+      # @api public
+      def to_h
+        values.to_h
+      end
+
+      # Return a string representation
+      #
+      # @api public
+      def inspect
+        if context.empty?
+          "#<#{self.class}#{to_h} errors=#{errors.to_h}>"
         else
-          self
+          "#<#{self.class}#{to_h} errors=#{errors.to_h} context=#{context.each.to_h}>"
         end
       end
 
-      def or(other)
-        if success?
-          self
-        else
-          other.(input)
+      # Freeze result and its error set
+      #
+      # @api private
+      def freeze
+        values.freeze
+        errors.freeze
+        super
+      end
+
+      if RUBY_VERSION >= "2.7"
+        # Pattern matching
+        #
+        # @api private
+        def deconstruct_keys(keys)
+          values.deconstruct_keys(keys)
+        end
+
+        # Pattern matching
+        #
+        # @api private
+        def deconstruct
+          [values, context.each.to_h]
         end
       end
 
-      def success?
-        @value
+      private
+
+      # @api private
+      def initialize_errors(options = self.options)
+        MessageSet.new(schema_errors(options), options)
       end
 
-      def failure?
-        ! success?
+      # @api private
+      def schema_errors(options)
+        schema_result.message_set(options).to_a
       end
     end
   end

data/lib/dry/validation/rule.rb

@@ -1,124 +1,134 @@
-require 'dry/validation/result'
+# frozen_string_literal: true
 
-module Dry
-  module Validation
-    class Rule
-      include Dry::Equalizer(:name, :predicate)
-
-      class Key < Rule
-        def self.new(name, predicate)
-          super(name, predicate.curry(name))
-        end
+require "dry/core/equalizer"
 
-        def type
-          :key
-        end
+require "dry/validation/constants"
+require "dry/validation/function"
 
-        def call(input)
-          Validation.Result(input[name], predicate.(input), self)
-        end
+module Dry
+  module Validation
+    # Rules capture configuration and evaluator blocks
+    #
+    # When a rule is applied, it creates an `Evaluator` using schema result and its
+    # block will be evaluated in the context of the evaluator.
+    #
+    # @see Contract#rule
+    #
+    # @api public
+    class Rule < Function
+      include Dry::Equalizer(:keys, :block, inspect: false)
+
+      # @!attribute [r] keys
+      #   @return [Array<Symbol, String, Hash>]
+      #   @api private
+      option :keys
+
+      # @!attribute [r] macros
+      #   @return [Array<Symbol>]
+      #   @api private
+      option :macros, default: proc { EMPTY_ARRAY.dup }
+
+      # Evaluate the rule within the provided context
+      #
+      # @param [Contract] contract
+      # @param [Result] result
+      #
+      # @api private
+      def call(contract, result)
+        Evaluator.new(
+          contract,
+          keys: keys,
+          macros: macros,
+          block_options: block_options,
+          result: result,
+          values: result.values,
+          _context: result.context,
+          &block
+        )
       end
 
-      class Value < Rule
-        def call(input)
-          Validation.Result(input, predicate.(input), self)
-        end
-
-        def type
-          :val
-        end
+      # Define which macros should be executed
+      #
+      # @see Contract#rule
+      # @return [Rule]
+      #
+      # @api public
+      def validate(*macros, &block)
+        @macros = parse_macros(*macros)
+        @block = block if block
+        self
       end
 
-      class Composite
-        include Dry::Equalizer(:left, :right)
-
-        attr_reader :name, :left, :right
-
-        def initialize(left, right)
-          @name = left.name
-          @left = left
-          @right = right
-        end
-
-        def to_ary
-          [type, left.to_ary, [right.to_ary]]
-        end
-        alias_method :to_a, :to_ary
+      # Define a validation function for each element of an array
+      #
+      # The function will be applied only if schema checks passed
+      # for a given array item.
+      #
+      # @example
+      #   rule(:nums).each do |index:|
+      #     key([:number, index]).failure("must be greater than 0") if value < 0
+      #   end
+      #   rule(:nums).each(min: 3)
+      #   rule(address: :city) do
+      #      key.failure("oops") if value != 'Munich'
+      #   end
+      #
+      # @return [Rule]
+      #
+      # @api public
+      def each(*macros, &block)
+        root = keys[0]
+        macros = parse_macros(*macros)
+        @keys = []
+
+        @block = proc do
+          unless result.base_error?(root) || !values.key?(root)
+            values[root].each_with_index do |_, idx|
+              path = [*Schema::Path[root].to_a, idx]
+
+              next if result.schema_error?(path)
+
+              evaluator = with(macros: macros, keys: [path], index: idx, &block)
+
+              failures.concat(evaluator.failures)
+            end
+          end
+        end
+
+        @block_options = map_keywords(block) if block
+
+        self
       end
 
-      class Conjunction < Composite
-        def call(input)
-          left.(input).and(right)
-        end
-
-        def type
-          :and
-        end
+      # Return a nice string representation
+      #
+      # @return [String]
+      #
+      # @api public
+      def inspect
+        %(#<#{self.class} keys=#{keys.inspect}>)
       end
 
-      class Disjunction < Composite
-        def call(input)
-          left.(input).or(right)
-        end
-
-        def type
-          :or
+      # Parse function arguments into macros structure
+      #
+      # @return [Array]
+      #
+      # @api private
+      def parse_macros(*args)
+        args.each_with_object([]) do |spec, macros|
+          case spec
+          when Hash
+            add_macro_from_hash(macros, spec)
+          else
+            macros << Array(spec)
+          end
         end
       end
 
-      class Each < Rule
-        def call(input)
-          Validation.Result(input, input.map { |element| predicate.(element) }, self)
+      def add_macro_from_hash(macros, spec)
+        spec.each do |k, v|
+          macros << [k, v.is_a?(Array) ? v : [v]]
         end
-
-        def type
-          :each
-        end
-      end
-
-      class Set < Rule
-        def call(input)
-          Validation.Result(input, predicate.map { |rule| rule.(input) }, self)
-        end
-
-        def type
-          :set
-        end
-
-        def at(*args)
-          self.class.new(name, predicate.values_at(*args))
-        end
-
-        def to_ary
-          [type, [name, predicate.map(&:to_ary)]]
-        end
-        alias_method :to_a, :to_ary
-      end
-
-      attr_reader :name, :predicate
-
-      def initialize(name, predicate)
-        @name = name
-        @predicate = predicate
-      end
-
-      def to_ary
-        [type, [name, predicate.to_ary]]
-      end
-      alias_method :to_a, :to_ary
-
-      def and(other)
-        Conjunction.new(self, other)
-      end
-      alias_method :&, :and
-
-      def or(other)
-        Disjunction.new(self, other)
-      end
-      alias_method :|, :or
-
-      def curry(*args)
-        self.class.new(name, predicate.curry(*args))
       end
     end
   end

data/lib/dry/validation/schema_ext.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "dry/schema/path"
+
+module Dry
+  module Schema
+    class Path
+      # @api private
+      def multi_value?
+        last.is_a?(Array)
+      end
+
+      # @api private
+      def expand
+        to_a[0..-2].product(last).map { |spec| self.class[spec] }
+      end
+    end
+  end
+end

data/lib/dry/validation/values.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "dry/core/equalizer"
+require "dry/schema/path"
+require "dry/validation/constants"
+
+module Dry
+  module Validation
+    # A convenient wrapper for data processed by schemas
+    #
+    # Values are available within the rule blocks. They act as hash-like
+    # objects and expose a convenient API for accessing data.
+    #
+    # @api public
+    class Values
+      include Enumerable
+      include Dry::Equalizer(:data)
+
+      # Schema's result output
+      #
+      # @return [Hash]
+      #
+      # @api private
+      attr_reader :data
+
+      # @api private
+      def initialize(data)
+        @data = data
+      end
+
+      # Read from the provided key
+      #
+      # @example
+      #   rule(:age) do
+      #     key.failure('must be > 18') if values[:age] <= 18
+      #   end
+      #
+      # @param args [Symbol, String, Hash, Array<Symbol>] If given as a single
+      #   Symbol, String, Array or Hash, build a key array using
+      #   {Dry::Schema::Path} digging for data. If given as positional
+      #   arguments, use these with Hash#dig on the data directly.
+      #
+      # @return [Object]
+      #
+      # @api public
+      def [](*args)
+        return data.dig(*args) if args.size > 1
+
+        case (key = args[0])
+        when Symbol, String, Array, Hash
+          keys = Schema::Path[key].to_a
+
+          return data.dig(*keys) unless keys.last.is_a?(Array)
+
+          last = keys.pop
+          vals = self.class.new(data.dig(*keys))
+          vals.fetch_values(*last) { nil }
+        else
+          raise ArgumentError, "+key+ must be a valid path specification"
+        end
+      end
+
+      # @api public
+      # rubocop: disable Metrics/PerceivedComplexity
+      def key?(key, hash = data)
+        return hash.key?(key) if key.is_a?(Symbol)
+
+        # rubocop: disable Lint/DuplicateBranch
+        Schema::Path[key].reduce(hash) do |a, e|
+          if e.is_a?(Array)
+            result = e.all? { |k| key?(k, a) }
+            return result
+          elsif e.is_a?(Symbol) && a.is_a?(Array)
+            return false
+          elsif a.nil?
+            return false
+          elsif a.is_a?(String)
+            return false
+          else
+            return false unless a.is_a?(Array) ? (e >= 0 && e < a.size) : a.key?(e)
+          end
+          a[e]
+        end
+        # rubocop: enable Lint/DuplicateBranch
+
+        true
+      end
+      # rubocop: enable Metrics/PerceivedComplexity
+
+      # @api private
+      def respond_to_missing?(meth, include_private = false)
+        super || data.respond_to?(meth, include_private)
+      end
+
+      private
+
+      # @api private
+      def method_missing(meth, *args, &block)
+        if data.respond_to?(meth)
+          data.public_send(meth, *args, &block)
+        else
+          super
+        end
+      end
+      ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
+    end
+  end
+end

data/lib/dry/validation/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Dry
   module Validation
-    VERSION = '0.1.0'.freeze
+    VERSION = "1.8.0"
   end
 end