dry-validation 1.5.1

data/lib/dry/validation/evaluator.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+require "dry/initializer"
+require "dry/core/deprecations"
+
+require "dry/validation/constants"
+require "dry/validation/failures"
+
+module Dry
+  module Validation
+    # Evaluator is the execution context for rules
+    #
+    # Evaluators expose an API for setting failure messages and forward
+    # method calls to the contracts, so that you can use your contract
+    # methods within rule blocks
+    #
+    # @api public
+    class Evaluator
+      extend Dry::Initializer
+      extend Dry::Core::Deprecations[:'dry-validation']
+
+      deprecate :error?, :schema_error?
+
+      # @!attribute [r] _contract
+      #   @return [Contract]
+      #   @api private
+      param :_contract
+
+      # @!attribute [r] result
+      #   @return [Result]
+      #   @api private
+      option :result
+
+      # @!attribute [r] keys
+      #   @return [Array<String, Symbol, Hash>]
+      #   @api private
+      option :keys
+
+      # @!attribute [r] macros
+      #   @return [Array<Symbol>]
+      #   @api private
+      option :macros, optional: true, default: proc { EMPTY_ARRAY.dup }
+
+      # @!attribute [r] _context
+      #   @return [Concurrent::Map]
+      #   @api private
+      option :_context
+
+      # @!attribute [r] path
+      #   @return [Dry::Schema::Path]
+      #   @api private
+      option :path, default: proc { Dry::Schema::Path[(key = keys.first) ? key : ROOT_PATH] }
+
+      # @!attribute [r] values
+      #   @return [Object]
+      #   @api private
+      option :values
+
+      # @!attribute [r] block_options
+      #   @return [Hash<Symbol=>Symbol>]
+      #   @api private
+      option :block_options, default: proc { EMPTY_HASH }
+
+      # @return [Hash]
+      attr_reader :_options
+
+      # Initialize a new evaluator
+      #
+      # @api private
+      def initialize(contract, **options, &block)
+        super(contract, **options)
+
+        @_options = options
+
+        if block
+          exec_opts = block_options.map { |key, value| [key, _options[value]] }.to_h
+          instance_exec(**exec_opts, &block)
+        end
+
+        macros.each do |args|
+          macro = macro(*args.flatten(1))
+          instance_exec(**macro.extract_block_options(_options.merge(macro: macro)), &macro.block)
+        end
+      end
+
+      # Get `Failures` object for the default or provided path
+      #
+      # @param [Symbol,String,Hash,Array<Symbol>] path
+      #
+      # @return [Failures]
+      #
+      # @see Failures#failure
+      #
+      # @api public
+      def key(path = self.path)
+        (@key ||= EMPTY_HASH.dup)[path] ||= Failures.new(path)
+      end
+
+      # Get `Failures` object for base errors
+      #
+      # @return [Failures]
+      #
+      # @see Failures#failure
+      #
+      # @api public
+      def base
+        @base ||= Failures.new
+      end
+
+      # Return aggregated failures
+      #
+      # @return [Array<Hash>]
+      #
+      # @api private
+      def failures
+        @failures ||= []
+        @failures += @base.opts if defined?(@base)
+        @failures.concat(@key.values.flat_map(&:opts)) if defined?(@key)
+        @failures
+      end
+
+      # @api private
+      def with(new_opts, &block)
+        self.class.new(_contract, **_options, **new_opts, &block)
+      end
+
+      # Return default (first) key name
+      #
+      # @return [Symbol]
+      #
+      # @api public
+      def key_name
+        @key_name ||= keys.first
+      end
+
+      # Return the value found under the first specified key
+      #
+      # This is a convenient method that can be used in all the common cases
+      # where a rule depends on just one key and you want a quick access to
+      # the value
+      #
+      # @example
+      #   rule(:age) do
+      #     key.failure(:invalid) if value < 18
+      #   end
+      #
+      # @return [Object]
+      #
+      # @api public
+      def value
+        values[key_name]
+      end
+
+      # Return if the value under the default key is available
+      #
+      # This is useful when dealing with rules for optional keys
+      #
+      # @example
+      #   rule(:age) do
+      #     key.failure(:invalid) if key? && value < 18
+      #   end
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def key?
+        values.key?(key_name)
+      end
+
+      # Check if there are any errors on the schema under the provided path
+      #
+      # @param path [Symbol, String, Array] A Path-compatible spec
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def schema_error?(path)
+        result.error?(path)
+      end
+
+      # Check if there are any errors on the current rule
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def rule_error?
+        !key(path).empty?
+      end
+
+      # @api private
+      def respond_to_missing?(meth, include_private = false)
+        super || _contract.respond_to?(meth, true)
+      end
+
+      private
+
+      # Forward to the underlying contract
+      #
+      # @api private
+      def method_missing(meth, *args, &block)
+        # yes, we do want to delegate to private methods too
+        if _contract.respond_to?(meth, true)
+          _contract.__send__(meth, *args, &block)
+        else
+          super
+        end
+      end
+      ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Dry
+  module Validation
+    # Hints extension
+    #
+    # @example
+    #   Dry::Validation.load_extensions(:hints)
+    #
+    #   contract = Dry::Validation::Contract.build do
+    #     schema do
+    #       required(:name).filled(:string, min_size?: 2..4)
+    #     end
+    #   end
+    #
+    #   contract.call(name: "fo").hints
+    #   # {:name=>["size must be within 2 - 4"]}
+    #
+    #   contract.call(name: "").messages
+    #   # {:name=>["must be filled", "size must be within 2 - 4"]}
+    #
+    # @api public
+    module Hints
+      # Hints extensions for Result
+      #
+      # @api public
+      module ResultExtensions
+        # Return error messages excluding hints
+        #
+        # @macro errors-options
+        # @return [MessageSet]
+        #
+        # @api public
+        def errors(new_options = EMPTY_HASH)
+          opts = new_options.merge(hints: false)
+          @errors.with(schema_errors(opts), opts)
+        end
+
+        # Return errors and hints
+        #
+        # @macro errors-options
+        #
+        # @return [MessageSet]
+        #
+        # @api public
+        def messages(new_options = EMPTY_HASH)
+          errors.with(hints(new_options).to_a, options.merge(**new_options))
+        end
+
+        # Return hint messages
+        #
+        # @macro errors-options
+        #
+        # @return [MessageSet]
+        #
+        # @api public
+        def hints(new_options = EMPTY_HASH)
+          schema_result.hints(new_options)
+        end
+      end
+
+      Dry::Schema.load_extensions(:hints)
+
+      Result.prepend(ResultExtensions)
+    end
+  end
+end

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

@@ -0,0 +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
+
+      # Returns a result monad
+      #
+      # @return [Dry::Monads::Result]
+      #
+      # @api public
+      def to_monad
+        success? ? Success(self) : Failure(self)
+      end
+    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,70 @@
+# 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
+
+      # @api private
+      def empty?
+        opts.empty?
+      end
+    end
+  end
+end