dry-validation 0.13.3 → 1.4.2

data/lib/dry/validation/extensions/monads.rb

@@ -1,18 +1,34 @@
+# frozen_string_literal: true
+
 require 'dry/monads/result'
 
 module Dry
   module Validation
+    # Monad extension for contract results
+    #
+    # @example
+    #   Dry::Validation.load_extensions(:monads)
+    #
+    #   contract = Dry::Validation::Contract.build do
+    #     schema do
+    #       required(:name).filled(:string)
+    #     end
+    #   end
+    #
+    #   contract.call(name: nil).to_monad
+    #
+    # @api public
     class Result
       include Dry::Monads::Result::Mixin
 
-      def to_monad(options = EMPTY_HASH)
-        if success?
-          Success(output)
-        else
-          Failure(messages(options))
-        end
+      # Returns a result monad
+      #
+      # @return [Dry::Monads::Result]
+      #
+      # @api public
+      def to_monad
+        success? ? Success(self) : Failure(self)
       end
-      alias_method :to_either, :to_monad
     end
   end
 end

data/lib/dry/validation/extensions/predicates_as_macros.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'dry/schema/predicate_registry'
+require 'dry/validation/contract'
+
+module Dry
+  module Validation
+    # Predicate registry with additional needed methods.
+    class PredicateRegistry < Schema::PredicateRegistry
+      # List of predicates to be imported by `:predicates_as_macros`
+      # extension.
+      #
+      # @see Dry::Validation::Contract
+      WHITELIST = %i[
+        filled? format? gt? gteq? included_in? includes? inclusion? is? lt?
+        lteq? max_size? min_size? not_eql? odd? respond_to? size? true?
+        uuid_v4?
+      ].freeze
+
+      # @api private
+      def arg_names(name)
+        arg_list(name).map(&:first)
+      end
+
+      # @api private
+      def call(name, args)
+        self[name].(*args)
+      end
+
+      # @api private
+      def message_opts(name, arg_values)
+        arg_names(name).zip(arg_values).to_h
+      end
+    end
+
+    # Extension to use dry-logic predicates as macros.
+    #
+    # @see Dry::Validation::PredicateRegistry::WHITELIST Available predicates
+    #
+    # @example
+    #   Dry::Validation.load_extensions(:predicates_as_macros)
+    #
+    #   class ApplicationContract < Dry::Validation::Contract
+    #     import_predicates_as_macros
+    #   end
+    #
+    #   class AgeContract < ApplicationContract
+    #     schema do
+    #       required(:age).filled(:integer)
+    #     end
+    #
+    #     rule(:age).validate(gteq?: 18)
+    #   end
+    #
+    #   AgeContract.new.(age: 17).errors.first.text
+    #   # => 'must be greater than or equal to 18'
+    #
+    # @api public
+    class Contract
+      # Make macros available for self and its descendants.
+      def self.import_predicates_as_macros
+        registry = PredicateRegistry.new
+
+        PredicateRegistry::WHITELIST.each do |name|
+          register_macro(name) do |macro:|
+            predicate_args = [*macro.args, value]
+            message_opts = registry.message_opts(name, predicate_args)
+
+            key.failure(name, message_opts) unless registry.(name, predicate_args)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/validation/failures.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'dry/schema/path'
+require 'dry/validation/constants'
+
+module Dry
+  module Validation
+    # Failure accumulator object
+    #
+    # @api public
+    class Failures
+      # The path for messages accumulated by failures object
+      #
+      # @return [Dry::Schema::Path]
+      #
+      # @api private
+      attr_reader :path
+
+      # Options for messages
+      #
+      # These options are used by MessageResolver
+      #
+      # @return [Hash]
+      #
+      # @api private
+      attr_reader :opts
+
+      # @api private
+      def initialize(path = ROOT_PATH)
+        @path = Dry::Schema::Path[path]
+        @opts = EMPTY_ARRAY.dup
+      end
+
+      # Set failure
+      #
+      # @overload failure(message)
+      #   Set message text explicitly
+      #   @param message [String] The message text
+      #   @example
+      #     failure('this failed')
+      #
+      # @overload failure(id)
+      #   Use message identifier (needs localized messages setup)
+      #   @param id [Symbol] The message id
+      #   @example
+      #     failure(:taken)
+      #
+      # @overload failure(meta_hash)
+      #   Use meta_hash[:text] as a message (either explicitely or as an identifier),
+      #   setting the rest of the hash as error meta attribute
+      #   @param meta [Hash] The hash containing the message as value for the :text key
+      #   @example
+      #     failure({text: :invalid, key: value})
+      #
+      # @see Evaluator#key
+      # @see Evaluator#base
+      #
+      # @api public
+      def failure(message, tokens = EMPTY_HASH)
+        opts << { message: message, tokens: tokens, path: path }
+        self
+      end
+    end
+  end
+end

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