dry-validation 0.13.3 → 1.3.1

data/lib/dry/validation/macro.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'dry/validation/constants'
+require 'dry/validation/function'
+
+module Dry
+  module Validation
+    # A wrapper for macro validation blocks
+    #
+    # @api public
+    class Macro < Function
+      # @!attribute [r] name
+      #   @return [Symbol]
+      #   @api public
+      param :name
+
+      # @!attribute [r] args
+      #   @return [Array]
+      #   @api public
+      option :args
+
+      # @!attribute [r] block
+      #   @return [Proc]
+      #   @api private
+      option :block
+
+      # @api private
+      def with(args)
+        self.class.new(name, args: args, block: block)
+      end
+
+      # @api private
+      def extract_block_options(options)
+        block_options.map { |key, value| [key, options[value]] }.to_h
+      end
+    end
+  end
+end

data/lib/dry/validation/macros.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'dry/container'
+require 'dry/validation/macro'
+
+module Dry
+  module Validation
+    # API for registering and accessing Rule macros
+    #
+    # @api public
+    module Macros
+      module Registrar
+        # Register a macro
+        #
+        # @example register a global macro
+        #   Dry::Validation.register_macro(:even_numbers) do
+        #     key.failure('all numbers must be even') unless values[key_name].all?(&:even?)
+        #   end
+        #
+        # @example register a contract macro
+        #   class MyContract < Dry::Validation::Contract
+        #     register_macro(:even_numbers) do
+        #       key.failure('all numbers must be even') unless values[key_name].all?(&:even?)
+        #     end
+        #   end
+        #
+        # @param [Symbol] name The name of the macro
+        # @param [Array] *args Optional default arguments for the macro
+        #
+        # @return [self]
+        #
+        # @see Macro
+        #
+        # @api public
+        def register_macro(name, *args, &block)
+          macros.register(name, *args, &block)
+          self
+        end
+      end
+
+      # Registry for macros
+      #
+      # @api public
+      class Container
+        include Dry::Container::Mixin
+
+        # Register a new macro
+        #
+        # @example in a contract class
+        #   class MyContract < Dry::Validation::Contract
+        #     register_macro(:even_numbers) do
+        #       key.failure('all numbers must be even') unless values[key_name].all?(&:even?)
+        #     end
+        #   end
+        #
+        # @param [Symbol] name The name of the macro
+        #
+        # @return [self]
+        #
+        # @api public
+        def register(name, *args, &block)
+          macro = Macro.new(name, args: args, block: block)
+          super(name, macro, call: false, &nil)
+          self
+        end
+      end
+
+      # Return a registered macro
+      #
+      # @param [Symbol] name The name of the macro
+      #
+      # @return [Proc]
+      #
+      # @api public
+      def self.[](name)
+        container[name]
+      end
+
+      # Register a global macro
+      #
+      # @see Container#register
+      #
+      # @return [Macros]
+      #
+      # @api public
+      def self.register(name, *args, &block)
+        container.register(name, *args, &block)
+        self
+      end
+
+      # @api private
+      def self.container
+        @container ||= Container.new
+      end
+    end
+
+    # Acceptance macro
+    #
+    # @api public
+    Macros.register(:acceptance) do
+      key.failure(:acceptance, key: key_name) unless values[key_name].equal?(true)
+    end
+  end
+end

data/lib/dry/validation/message.rb

@@ -1,98 +1,98 @@
+# frozen_string_literal: true
+
 require 'dry/equalizer'
 
+require 'dry/schema/constants'
+require 'dry/schema/message'
+
 module Dry
   module Validation
-    class Message
-      include Dry::Equalizer(:predicate, :path, :text, :options)
-
-      attr_reader :predicate, :path, :text, :rule, :args, :options
-
-      class Or
-        attr_reader :left
-
-        attr_reader :right
-
-        attr_reader :path
-
-        attr_reader :messages
-
-        def initialize(left, right, messages)
-          @left = left
-          @right = right
-          @messages = messages
-          @path = left.path
-        end
-
-        def hint?
-          false
-        end
-
-        def root?
-          path.empty?
-        end
-
-        def to_s
-          [left, right].uniq.join(" #{messages[:or].()} ")
+    # Message message
+    #
+    # @api public
+    class Message < Schema::Message
+      include Dry::Equalizer(:text, :path, :meta)
+
+      # The error message text
+      #
+      # @return [String] text
+      #
+      # @api public
+      attr_reader :text
+
+      # The path to the value with the error
+      #
+      # @return [Array<Symbol, Integer>]
+      #
+      # @api public
+      attr_reader :path
+
+      # Optional hash with meta-data
+      #
+      # @return [Hash]
+      #
+      # @api public
+      attr_reader :meta
+
+      # A localized message type
+      #
+      # Localized messsages can be translated to other languages at run-time
+      #
+      # @api public
+      class Localized < Message
+        # Evaluate message text using provided locale
+        #
+        # @example
+        #   result.errors[:email].evaluate(locale: :en, full: true)
+        #   # "email is invalid"
+        #
+        # @param [Hash] opts
+        # @option opts [Symbol] :locale Which locale to use
+        # @option opts [Boolean] :full Whether message text should include the key name
+        #
+        # @api public
+        def evaluate(**opts)
+          evaluated_text, rest = text.(opts)
+          Message.new(evaluated_text, path: path, meta: rest.merge(meta))
         end
       end
 
-      class Check < Message
-        def initialize(*args)
-          super
-          @path = [rule] unless rule.to_s.end_with?('?') || path.include?(rule)
-        end
+      # Build an error
+      #
+      # @return [Message, Message::Localized]
+      #
+      # @api private
+      def self.[](text, path, meta)
+        klass = text.respond_to?(:call) ? Localized : Message
+        klass.new(text, path: path, meta: meta)
       end
 
-      def self.[](predicate, path, text, options)
-        if options[:check]
-          Message::Check.new(predicate, path, text, options)
-        else
-          Message.new(predicate, path, text, options)
-        end
-      end
-
-      def initialize(predicate, path, text, options)
-        @predicate = predicate
-        @path = path
+      # Initialize a new error object
+      #
+      # @api private
+      def initialize(text, path:, meta: EMPTY_HASH)
         @text = text
-        @options = options
-        @rule = options[:rule]
-        @args = options[:args] || EMPTY_ARRAY
+        @path = Array(path)
+        @meta = meta
+      end
 
-        if predicate == :key?
-          @path << rule
-        end
+      # Check if this is a base error not associated with any key
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def base?
+        @base ||= path.compact.empty?
       end
 
+      # Dump error to a string
+      #
+      # @return [String]
+      #
+      # @api public
       def to_s
         text
       end
-
-      def signature
-        @signature ||= [predicate, args, path].hash
-      end
-
-      def hint?
-        false
-      end
-
-      def root?
-        path.empty?
-      end
-
-      def eql?(other)
-        other.is_a?(String) ? text == other : super
-      end
-    end
-
-    class Hint < Message
-      def self.[](predicate, path, text, options)
-        Hint.new(predicate, path, text, options)
-      end
-
-      def hint?
-        true
-      end
     end
   end
 end

data/lib/dry/validation/message_set.rb

@@ -1,122 +1,142 @@
-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) }).uniq,
+          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)
+        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.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