dry-validation 0.12.0 → 1.6.0

data/lib/dry/validation/result.rb

@@ -1,82 +1,224 @@
-require 'dry/equalizer'
+# frozen_string_literal: true
+
+require "concurrent/map"
+require "dry/equalizer"
+
+require "dry/validation/constants"
+require "dry/validation/message_set"
+require "dry/validation/values"
 
 module Dry
   module Validation
+    # Result objects are returned by contracts
+    #
+    # @api public
     class Result
-      include Dry::Equalizer(:output, :errors)
-      include Enumerable
-
-      attr_reader :output
-      attr_reader :results
-      attr_reader :message_compiler
-      attr_reader :path
-
-      alias_method :to_hash, :output
-      alias_method :to_h, :output # for MRI 2.0, remove it when drop support
+      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
 
-      def initialize(output, results, message_compiler, path)
-        @output = output
-        @results = results
-        @message_compiler = message_compiler
-        @path = path
+      # Context that's shared between rules
+      #
+      # @return [Concurrent::Map]
+      #
+      # @api public
+      attr_reader :context
+
+      # Result from contract's schema
+      #
+      # @return [Dry::Schema::Result]
+      #
+      # @api private
+      attr_reader :schema_result
+
+      # Result options
+      #
+      # @return [Hash]
+      #
+      # @api private
+      attr_reader :options
+
+      # Initialize a new result
+      #
+      # @api private
+      def initialize(schema_result, context, options)
+        @schema_result = schema_result
+        @context = context
+        @options = options
+        @errors = initialize_errors
       end
 
-      def each(&block)
-        output.each(&block)
+      # Return values wrapper with the input processed by schema
+      #
+      # @return [Values]
+      #
+      # @api public
+      def values
+        @values ||= Values.new(schema_result.to_h)
       end
 
-      def [](name)
-        output.fetch(name)
+      # 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?
-        results.empty?
+        @errors.empty?
       end
 
+      # Check if result is not successful
+      #
+      # @return [Bool]
+      #
+      # @api public
       def failure?
         !success?
       end
 
-      def messages(options = EMPTY_HASH)
-        message_set(options).dump
+      # 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
+
+      # Check if the rules includes an error for the provided key
+      #
+      # @api private
+      def rule_error?(key)
+        !schema_error?(key) && error?(key)
       end
 
-      def errors(options = EMPTY_HASH)
-        message_set(options.merge(hints: false)).dump
+      # 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
 
-      def hints(options = EMPTY_HASH)
-        message_set(options.merge(failures: false)).dump
+      # Add a new error for the provided key
+      #
+      # @api private
+      def add_error(error)
+        @errors.add(error)
+        self
       end
 
-      def message_set(options = EMPTY_HASH)
-        message_compiler.with(options).(result_ast)
+      # Read a value under provided key
+      #
+      # @param [Symbol] key
+      #
+      # @return [Object]
+      #
+      # @api public
+      def [](key)
+        values[key]
       end
 
-      def to_ast
-        if name
-          [type, [name, [:set, result_ast]]]
+      # 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
-          ast
+          "#<#{self.class}#{to_h} errors=#{errors.to_h} context=#{context.each.to_h}>"
         end
       end
 
-      def ast(*)
-        [:set, result_ast]
+      # Freeze result and its error set
+      #
+      # @api private
+      def freeze
+        values.freeze
+        errors.freeze
+        super
       end
 
-      def name
-        Array(path).last
+      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
 
       private
 
-      def type
-        success? ? :success : :failure
+      # @api private
+      def initialize_errors(options = self.options)
+        MessageSet.new(schema_errors(options), options)
       end
 
-      def result_ast
-        @result_ast ||= results.map(&:to_ast)
+      # @api private
+      def schema_errors(options)
+        schema_result.message_set(options).to_a
       end
     end
   end

data/lib/dry/validation/rule.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require "dry/equalizer"
+
+require "dry/validation/constants"
+require "dry/validation/function"
+
+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
+
+      # 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
+
+      # 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
+
+      # Return a nice string representation
+      #
+      # @return [String]
+      #
+      # @api public
+      def inspect
+        %(#<#{self.class} keys=#{keys.inspect}>)
+      end
+
+      # 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
+
+      def add_macro_from_hash(macros, spec)
+        spec.each do |k, v|
+          macros << [k, v.is_a?(Array) ? v : [v]]
+        end
+      end
+    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,104 @@
+# frozen_string_literal: true
+
+require "dry/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
+      def key?(key, hash = data)
+        return hash.key?(key) if key.is_a?(Symbol)
+
+        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
+
+        true
+      end
+
+      # @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