dry-validation 1.5.1

data/lib/dry/validation/function.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "dry/initializer"
+require "dry/validation/constants"
+
+module Dry
+  module Validation
+    # Abstract class for handling rule blocks
+    #
+    # @see Rule
+    # @see Macro
+    #
+    # @api private
+    class Function
+      extend Dry::Initializer
+
+      # @!attribute [r] block
+      #   @return [Proc]
+      #   @api private
+      option :block
+
+      # @!attribute [r] block_options
+      #   @return [Hash]
+      #   @api private
+      option :block_options, default: -> { block ? map_keywords(block) : EMPTY_HASH }
+
+      private
+
+      # Extract options for the block kwargs
+      #
+      # @param [Proc] block Callable
+      # @return Hash
+      #
+      # @api private
+      def map_keywords(block)
+        block
+          .parameters
+          .select { |arg,| arg.equal?(:keyreq) }
+          .map { |_, name| [name, BLOCK_OPTIONS_MAPPINGS[name]] }
+          .to_h
+      end
+    end
+  end
+end

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 positional 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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "dry/equalizer"
+
+require "dry/schema/constants"
+require "dry/schema/message"
+
+module Dry
+  module Validation
+    # 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
+
+      # 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
+
+      # Initialize a new error object
+      #
+      # @api private
+      def initialize(text, path:, meta: EMPTY_HASH)
+        @text = text
+        @path = Array(path)
+        @meta = meta
+      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
+    end
+  end
+end

data/lib/dry/validation/message_set.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "dry/schema/message_set"
+
+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)
+        @locale = options[:locale]
+        @source_messages = options.fetch(:source) { messages.dup }
+        super
+      end
+
+      # 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
+
+      # 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
+        self
+      end
+
+      # 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
+
+      # @api private
+      def freeze
+        source_messages.select { |err| err.respond_to?(:evaluate) }.each do |err|
+          idx = messages.index(err) || source_messages.index(err)
+          msg = err.evaluate(locale: locale, full: options[:full])
+          messages[idx] = msg
+        end
+        to_h
+        self
+      end
+    end
+  end
+end

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

@@ -0,0 +1,118 @@
+# 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[->(**opts) { [message_text(message, path, **opts), meta] }, 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
+        def message_text(message, path, locale: nil, full: false, **opts)
+          keys = path.to_a.compact
+          msg_opts = EMPTY_HASH.merge(path: keys, locale: locale || messages.default_locale)
+
+          full ? "#{messages.rule(keys.last, msg_opts) || keys.last} #{message}" : message
+        end
+
+        # 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