dry-validation 0.13.3 → 1.3.1

data/lib/dry/validation/messages/resolver.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'dry/validation/message'
+
+module Dry
+  module Validation
+    module Messages
+      # Resolve translated messages from failure arguments
+      #
+      # @api public
+      class Resolver
+        # @!attribute [r] messages
+        #   @return [Messages::I18n, Messages::YAML] messages backend
+        #   @api private
+        attr_reader :messages
+
+        # @api private
+        def initialize(messages)
+          @messages = messages
+        end
+
+        # Resolve Message object from provided args and path
+        #
+        # This is used internally by contracts when rules are applied
+        #
+        # @return [Message, Message::Localized]
+        #
+        # @api public
+        def call(message:, tokens:, path:, meta: EMPTY_HASH)
+          case message
+          when Symbol
+            Message[->(**opts) { message(message, path: path, tokens: tokens, **opts) }, path, meta]
+          when String
+            Message[message, path, meta]
+          when Hash
+            meta = message.dup
+            text = meta.delete(:text)
+            call(message: text, tokens: tokens, path: path, meta: meta)
+          else
+            raise ArgumentError, <<~STR
+              +message+ must be either a Symbol, String or Hash (#{message.inspect} given)
+            STR
+          end
+        end
+        alias_method :[], :call
+
+        # Resolve a message
+        #
+        # @return [String]
+        #
+        # @api public
+        #
+        # rubocop:disable Metrics/AbcSize
+        def message(rule, tokens: EMPTY_HASH, locale: nil, full: false, path:)
+          keys = path.to_a.compact
+          msg_opts = tokens.merge(path: keys, locale: locale || messages.default_locale)
+
+          if keys.empty?
+            template, meta = messages["rules.#{rule}", msg_opts]
+          else
+            template, meta = messages[rule, msg_opts.merge(path: keys.join(DOT))]
+            template, meta = messages[rule, msg_opts.merge(path: keys.last)] unless template
+          end
+
+          unless template
+            raise MissingMessageError, <<~STR
+              Message template for #{rule.inspect} under #{keys.join(DOT).inspect} was not found
+            STR
+          end
+
+          text = template.(template.data(tokens))
+
+          [full ? "#{messages.rule(keys.last, msg_opts)} #{text}" : text, meta]
+        end
+        # rubocop:enable Metrics/AbcSize
+      end
+    end
+  end
+end

data/lib/dry/validation/result.rb

@@ -1,82 +1,194 @@
+# 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 private
+      def error?(key)
+        schema_result.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]
+
+          return false 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]]]
-        else
-          ast
-        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
 
-      def ast(*)
-        [:set, result_ast]
+      # Return a string representation
+      #
+      # @api public
+      def inspect
+        if context.empty?
+          "#<#{self.class}#{to_h} errors=#{errors.to_h}>"
+        else
+          "#<#{self.class}#{to_h} errors=#{errors.to_h} context=#{context.each.to_h}>"
+        end
       end
 
-      def name
-        Array(path).last
+      # Freeze result and its error set
+      #
+      # @api private
+      def freeze
+        values.freeze
+        errors.freeze
+        super
       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,129 @@
+# 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
+      #     key.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.error?(path)
+
+              evaluator = with(macros: macros, keys: [path], &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
+            spec.each { |k, v| macros << [k, Array(v)] }
+          else
+            macros << Array(spec)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/validation/schema_ext.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'dry/schema/key'
+require 'dry/schema/key_map'
+
+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
+
+    # @api private
+    #
+    # TODO: this should be moved to dry-schema at some point
+    class Key
+      # @api private
+      def to_dot_notation
+        [name.to_s]
+      end
+
+      # @api private
+      class Hash < Key
+        # @api private
+        def to_dot_notation
+          [name].product(members.map(&:to_dot_notation).flatten(1)).map { |e| e.join(DOT) }
+        end
+      end
+    end
+
+    # @api private
+    class KeyMap
+      # @api private
+      def to_dot_notation
+        @to_dot_notation ||= map(&:to_dot_notation).flatten
+      end
+    end
+  end
+end