dry-validation 0.13.3 → 1.4.2

data/lib/dry/validation/message_set.rb

@@ -1,122 +1,143 @@
-module Dry
-  module Validation
-    class MessageSet
-      include Enumerable
+# frozen_string_literal: true
 
-      HINT_EXCLUSION = %i(
-        key? filled? none? bool?
-        str? int? float? decimal?
-        date? date_time? time? hash?
-        array? format?
-      ).freeze
+require 'dry/schema/message_set'
 
-      attr_reader :messages, :failures, :hints, :paths, :placeholders, :options
-
-      def self.[](messages, options = EMPTY_HASH)
-        new(messages.flatten, options)
-      end
+require 'dry/validation/constants'
+require 'dry/validation/message'
 
+module Dry
+  module Validation
+    # MessageSet is a specialized message set for handling validation messages
+    #
+    # @api public
+    class MessageSet < Schema::MessageSet
+      # Return the source set of messages used to produce final evaluated messages
+      #
+      # @return [Array<Message, Message::Localized, Schema::Message>]
+      #
+      # @api private
+      attr_reader :source_messages
+
+      # Configured locale
+      #
+      # @return [Symbol]
+      #
+      # @api public
+      attr_reader :locale
+
+      # @api private
       def initialize(messages, options = EMPTY_HASH)
-        @messages = messages
-        @hints = messages.select(&:hint?)
-        @failures = messages - hints
-        @paths = failures.map(&:path).uniq
-        @options = options
-
-        initialize_hints!
-        initialize_placeholders!
-      end
-
-      def dump
-        root? ? to_a : to_h
+        @locale = options[:locale]
+        @source_messages = options.fetch(:source) { messages.dup }
+        super
       end
 
-      def failures?
-        options[:failures].equal?(true)
+      # Return a new message set using updated options
+      #
+      # @return [MessageSet]
+      #
+      # @api private
+      def with(other, new_options = EMPTY_HASH)
+        return self if new_options.empty? && other.eql?(messages)
+
+        self.class.new(
+          other | select { |err| err.is_a?(Message) },
+          options.merge(source: source_messages, **new_options)
+        ).freeze
       end
 
-      def empty?
-        messages.empty?
-      end
-
-      def root?
-        !empty? && failures.all?(&:root?)
+      # Add a new message
+      #
+      # This is used when result is being prepared
+      #
+      # @return [MessageSet]
+      #
+      # @api private
+      def add(message)
+        @empty = nil
+        source_messages << message
+        messages << message
+        initialize_placeholders!
+        self
       end
 
-      def each(&block)
-        return to_enum unless block
-        messages.each(&block)
+      # Filter message set using provided predicates
+      #
+      # This method is open to any predicate because messages can be anything that
+      # implements Message API, thus they can implement whatever predicates you
+      # may need.
+      #
+      # @example get a list of base messages
+      #   message_set = contract.(input).errors
+      #   message_set.filter(:base?)
+      #
+      # @param [Array<Symbol>] predicates
+      #
+      # @return [MessageSet]
+      #
+      # @api public
+      def filter(*predicates)
+        messages = select { |msg|
+          predicates.all? { |predicate| msg.respond_to?(predicate) && msg.public_send(predicate) }
+        }
+        self.class.new(messages)
       end
 
-      def to_h
-        if root?
-          { nil => failures.map(&:to_s) }
-        else
-          failures? ? messages_map : hints_map
+      # @api private
+      def freeze
+        source_messages.select { |err| err.respond_to?(:evaluate) }.each do |err|
+          idx = source_messages.index(err)
+          msg = err.evaluate(locale: locale, full: options[:full])
+          messages[idx] = msg
         end
-      end
-      alias_method :to_hash, :to_h
-
-      def to_a
-        to_h.values.flatten
+        to_h
+        self
       end
 
       private
 
-      def messages_map
-        failures.group_by(&:path).reduce(placeholders) do |hash, (path, msgs)|
-          node = path.reduce(hash) { |a, e| a[e] }
-
-          msgs.each do |msg|
-            node << msg
-
-            msg_hints = hint_groups[msg.path]
-            node.concat(msg_hints) if msg_hints
-          end
-
-          node.map!(&:to_s)
-
-          hash
-        end
+      # @api private
+      def unique_paths
+        source_messages.uniq(&:path).map(&:path)
       end
 
-      def hints_map
-        hints.group_by(&:path).reduce(placeholders) do |hash, (path, msgs)|
-          node = path.reduce(hash) { |a, e| a[e] }
-
-          msgs.each do |msg|
-            node << msg
-          end
-
-          node.map!(&:to_s)
-
+      # @api private
+      def messages_map
+        @messages_map ||= reduce(placeholders) { |hash, msg|
+          node = msg.path.reduce(hash) { |a, e| a.is_a?(Hash) ? a[e] : a.last[e] }
+          (node[0].is_a?(::Array) ? node[0] : node) << msg.dump
           hash
-        end
-      end
-
-      def hint_groups
-        @hint_groups ||= hints.group_by(&:path)
-      end
-
-      def initialize_hints!
-        hints.reject! { |hint| HINT_EXCLUSION.include?(hint.predicate) }
+        }
       end
 
+      # @api private
+      #
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/PerceivedComplexity
       def initialize_placeholders!
-        @placeholders = paths.reduce({}) do |hash, path|
+        @placeholders = unique_paths.sort_by(&:size).each_with_object(EMPTY_HASH.dup) { |path, hash|
           curr_idx = 0
           last_idx = path.size - 1
           node = hash
 
-          while curr_idx <= last_idx do
+          while curr_idx <= last_idx
             key = path[curr_idx]
-            node = (node[key] || node[key] = curr_idx < last_idx ? {} : [])
+
+            next_node =
+              if node.is_a?(Array) && key.is_a?(Symbol)
+                node_hash = (node << [] << {}).last
+                node_hash[key] || (node_hash[key] = curr_idx < last_idx ? {} : [])
+              else
+                node[key] || (node[key] = curr_idx < last_idx ? {} : [])
+              end
+
+            node = next_node
             curr_idx += 1
           end
-
-          hash
-        end
+        }
       end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/PerceivedComplexity
     end
   end
 end

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

@@ -0,0 +1,106 @@
+# 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
+        # If message argument is a Hash, then it MUST have a :text key,
+        # which value will be used as the message value
+        #
+        # @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) { |key|
+              raise ArgumentError, <<~STR
+                +message+ Hash must contain :#{key} key (#{message.inspect} given)
+              STR
+            }
+
+            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
+
+          parsed_tokens = parse_tokens(tokens)
+          text = template.(template.data(parsed_tokens))
+
+          [full ? "#{messages.rule(keys.last, msg_opts)} #{text}" : text, meta]
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        private
+
+        def parse_tokens(tokens)
+          Hash[
+            tokens.map do |key, token|
+              [key, parse_token(token)]
+            end
+          ]
+        end
+
+        def parse_token(token)
+          case token
+          when Array
+            token.join(', ')
+          else
+            token
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/validation/result.rb

@@ -1,82 +1,210 @@
+# 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
+
+      # 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
+
+      # Add a new error for the provided key
+      #
+      # @api private
+      def add_error(error)
+        @errors.add(error)
+        self
       end
 
-      def errors(options = EMPTY_HASH)
-        message_set(options.merge(hints: false)).dump
+      # Read a value under provided key
+      #
+      # @param [Symbol] key
+      #
+      # @return [Object]
+      #
+      # @api public
+      def [](key)
+        values[key]
       end
 
-      def hints(options = EMPTY_HASH)
-        message_set(options.merge(failures: false)).dump
+      # Check if a key was set
+      #
+      # @param [Symbol] key
+      #
+      # @return [Bool]
+      #
+      # @api public
+      def key?(key)
+        values.key?(key)
       end
 
-      def message_set(options = EMPTY_HASH)
-        message_compiler.with(options).(result_ast)
+      # Coerce to a hash
+      #
+      # @api public
+      def to_h
+        values.to_h
       end
 
-      def to_ast
-        if name
-          [type, [name, [:set, result_ast]]]
+      # 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