dry-validation 0.1.0 → 1.8.0

data/lib/dry/validation/contract/class_interface.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+require "dry/schema"
+require "dry/schema/messages"
+require "dry/schema/path"
+require "dry/schema/key_map"
+
+require "dry/validation/constants"
+require "dry/validation/macros"
+require "dry/validation/schema_ext"
+
+module Dry
+  module Validation
+    class Contract
+      # Contract's class interface
+      #
+      # @see Contract
+      #
+      # @api public
+      module ClassInterface
+        include Macros::Registrar
+
+        # @api private
+        def inherited(klass)
+          super
+          klass.instance_variable_set("@config", config.dup)
+        end
+
+        # Configuration
+        #
+        # @example
+        #   class MyContract < Dry::Validation::Contract
+        #     config.messages.backend = :i18n
+        #   end
+        #
+        # @return [Config]
+        #
+        # @api public
+        def config
+          @config ||= Validation::Config.new
+        end
+
+        # Return macros registered for this class
+        #
+        # @return [Macros::Container]
+        #
+        # @api public
+        def macros
+          config.macros
+        end
+
+        # Define a params schema for your contract
+        #
+        # This type of schema is suitable for HTTP parameters
+        #
+        # @return [Dry::Schema::Params,NilClass]
+        # @see https://dry-rb.org/gems/dry-schema/params/
+        #
+        # @api public
+        def params(*external_schemas, &block)
+          define(:Params, external_schemas, &block)
+        end
+
+        # Define a JSON schema for your contract
+        #
+        # This type of schema is suitable for JSON data
+        #
+        # @return [Dry::Schema::JSON,NilClass]
+        # @see https://dry-rb.org/gems/dry-schema/json/
+        #
+        # @api public
+        def json(*external_schemas, &block)
+          define(:JSON, external_schemas, &block)
+        end
+
+        # Define a plain schema for your contract
+        #
+        # This type of schema does not offer coercion out of the box
+        #
+        # @return [Dry::Schema::Processor,NilClass]
+        # @see https://dry-rb.org/gems/dry-schema/
+        #
+        # @api public
+        def schema(*external_schemas, &block)
+          define(:schema, external_schemas, &block)
+        end
+
+        # Define a rule for your contract
+        #
+        # @example using a symbol
+        #   rule(:age) do
+        #     failure('must be at least 18') if values[:age] < 18
+        #   end
+        #
+        # @example using a path to a value and a custom predicate
+        #   rule('address.street') do
+        #     failure('please provide a valid street address') if valid_street?(values[:street])
+        #   end
+        #
+        # @return [Rule]
+        #
+        # @api public
+        def rule(*keys, &block)
+          ensure_valid_keys(*keys) if __schema__
+
+          Rule.new(keys: keys, block: block).tap do |rule|
+            rules << rule
+          end
+        end
+
+        # A shortcut that can be used to define contracts that won't be reused or inherited
+        #
+        # @example
+        #   my_contract = Dry::Validation::Contract.build do
+        #     params do
+        #       required(:name).filled(:string)
+        #     end
+        #   end
+        #
+        #   my_contract.call(name: "Jane")
+        #
+        # @return [Contract]
+        #
+        # @api public
+        def build(options = EMPTY_HASH, &block)
+          Class.new(self, &block).new(**options)
+        end
+
+        # @api private
+        def __schema__
+          @__schema__ if defined?(@__schema__)
+        end
+
+        # Return rules defined in this class
+        #
+        # @return [Array<Rule>]
+        #
+        # @api private
+        def rules
+          @rules ||= EMPTY_ARRAY
+            .dup
+            .concat(superclass.respond_to?(:rules) ? superclass.rules : EMPTY_ARRAY)
+        end
+
+        # Return messages configured for this class
+        #
+        # @return [Dry::Schema::Messages]
+        #
+        # @api private
+        def messages
+          @messages ||= Schema::Messages.setup(config.messages)
+        end
+
+        private
+
+        # @api private
+        def ensure_valid_keys(*keys)
+          valid_paths = key_map.to_dot_notation
+          key_paths = key_paths(keys)
+
+          invalid_keys = key_paths.map { |(key, path)|
+            unless valid_paths.any? { |vp| vp.include?(path) || vp.include?("#{path}[]") }
+              key
+            end
+          }.compact.uniq
+
+          return if invalid_keys.empty?
+
+          raise InvalidKeysError, <<~STR.strip
+            #{name}.rule specifies keys that are not defined by the schema: #{invalid_keys.inspect}
+          STR
+        end
+
+        # @api private
+        def key_paths(keys)
+          keys.map { |key|
+            case key
+            when Hash
+              path = Schema::Path[key]
+              if path.multi_value?
+                *head, tail = Array(path)
+                [key].product(
+                  tail.map { |el| [*head, *el] }.map { |parts| parts.join(DOT) }
+                )
+              else
+                [[key, path.to_a.join(DOT)]]
+              end
+            when Array
+              [[key, Schema::Path[key].to_a.join(DOT)]]
+            else
+              [[key, key.to_s]]
+            end
+          }.flatten(1)
+        end
+
+        # @api private
+        def key_map
+          __schema__.key_map
+        end
+
+        # @api private
+        def core_schema_opts
+          {parent: superclass&.__schema__, config: config}
+        end
+
+        # @api private
+        def define(method_name, external_schemas, &block)
+          return __schema__ if external_schemas.empty? && block.nil?
+
+          unless __schema__.nil?
+            raise ::Dry::Validation::DuplicateSchemaError, "Schema has already been defined"
+          end
+
+          schema_opts = core_schema_opts
+
+          schema_opts.update(parent: external_schemas) if external_schemas.any?
+
+          case method_name
+          when :schema
+            @__schema__ = Schema.define(**schema_opts, &block)
+          when :Params
+            @__schema__ = Schema.Params(**schema_opts, &block)
+          when :JSON
+            @__schema__ = Schema.JSON(**schema_opts, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/validation/contract.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require "concurrent/map"
+
+require "dry/core/equalizer"
+require "dry/initializer"
+require "dry/schema/path"
+
+require "dry/validation/config"
+require "dry/validation/constants"
+require "dry/validation/rule"
+require "dry/validation/evaluator"
+require "dry/validation/messages/resolver"
+require "dry/validation/result"
+require "dry/validation/contract/class_interface"
+
+module Dry
+  module Validation
+    # Contract objects apply rules to input
+    #
+    # A contract consists of a schema and rules. The schema is applied to the
+    # input before rules are applied, this way you can be sure that your rules
+    # won't be applied to values that didn't pass schema checks.
+    #
+    # It's up to you how exactly you're going to separate schema checks from
+    # your rules.
+    #
+    # @example
+    #   class NewUserContract < Dry::Validation::Contract
+    #     params do
+    #       required(:email).filled(:string)
+    #       required(:age).filled(:integer)
+    #       optional(:login).maybe(:string, :filled?)
+    #       optional(:password).maybe(:string, min_size?: 10)
+    #       optional(:password_confirmation).maybe(:string)
+    #     end
+    #
+    #     rule(:password) do
+    #       key.failure('is required') if values[:login] && !values[:password]
+    #     end
+    #
+    #     rule(:age) do
+    #       key.failure('must be greater or equal 18') if values[:age] < 18
+    #     end
+    #   end
+    #
+    #   new_user_contract = NewUserContract.new
+    #   new_user_contract.call(email: 'jane@doe.org', age: 21)
+    #
+    # @api public
+    class Contract
+      include Dry::Equalizer(:schema, :rules, :messages, inspect: false)
+
+      extend Dry::Initializer
+      extend ClassInterface
+
+      config.messages.top_namespace = DEFAULT_ERRORS_NAMESPACE
+      config.messages.load_paths << DEFAULT_ERRORS_PATH
+
+      # @!attribute [r] config
+      #   @return [Config] Contract's configuration object
+      #   @api public
+      option :config, default: -> { self.class.config }
+
+      # @!attribute [r] macros
+      #   @return [Macros::Container] Configured macros
+      #   @see Macros::Container#register
+      #   @api public
+      option :macros, default: -> { config.macros }
+
+      # @!attribute [r] default_context
+      #   @return [Hash] Default context for rules
+      #   @api public
+      option :default_context, default: -> { EMPTY_HASH }
+
+      # @!attribute [r] schema
+      #   @return [Dry::Schema::Params, Dry::Schema::JSON, Dry::Schema::Processor]
+      #   @api private
+      option :schema, default: -> { self.class.__schema__ || raise(SchemaMissingError, self.class) }
+
+      # @!attribute [r] rules
+      #   @return [Hash]
+      #   @api private
+      option :rules, default: -> { self.class.rules }
+
+      # @!attribute [r] message_resolver
+      #   @return [Messages::Resolver]
+      #   @api private
+      option :message_resolver, default: -> { Messages::Resolver.new(messages) }
+
+      # Apply the contract to an input
+      #
+      # @param [Hash] input The input to validate
+      # @param [Hash] context Initial context for rules
+      #
+      # @return [Result]
+      #
+      # @api public
+      # rubocop: disable Metrics/AbcSize
+      def call(input, context = EMPTY_HASH)
+        context_map = Concurrent::Map.new.tap do |map|
+          default_context.each { |key, value| map[key] = value }
+          context.each { |key, value| map[key] = value }
+        end
+
+        Result.new(schema.(input), context_map) do |result|
+          rules.each do |rule|
+            next if rule.keys.any? { |key| error?(result, key) }
+
+            rule_result = rule.(self, result)
+
+            rule_result.failures.each do |failure|
+              result.add_error(message_resolver.(**failure))
+            end
+          end
+        end
+      end
+      # rubocop: enable Metrics/AbcSize
+
+      # Return a nice string representation
+      #
+      # @return [String]
+      #
+      # @api public
+      def inspect
+        %(#<#{self.class} schema=#{schema.inspect} rules=#{rules.inspect}>)
+      end
+
+      private
+
+      # @api private
+      def error?(result, spec)
+        path = Schema::Path[spec]
+
+        if path.multi_value?
+          return path.expand.any? { |nested_path| error?(result, nested_path) }
+        end
+
+        return true if result.schema_error?(path)
+
+        path
+          .to_a[0..-2]
+          .any? { |key|
+            curr_path = Schema::Path[path.keys[0..path.keys.index(key)]]
+
+            return false unless result.schema_error?(curr_path)
+
+            result.errors.any? { |err|
+              (other = Schema::Path[err.path]).same_root?(curr_path) && other == curr_path
+            }
+          }
+      end
+
+      # Get a registered macro
+      #
+      # @return [Proc,#to_proc]
+      #
+      # @api private
+      def macro(name, *args)
+        (macros.key?(name) ? macros[name] : Macros[name]).with(args)
+      end
+
+      # Return configured messages backend
+      #
+      # @return [Dry::Schema::Messages::YAML, Dry::Schema::Messages::I18n]
+      #
+      # @api private
+      def messages
+        self.class.messages
+      end
+    end
+  end
+end

data/lib/dry/validation/evaluator.rb

@@ -0,0 +1,233 @@
+# 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.transform_values { _options[_1] }
+          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 use the default key name
+      #   rule(:age) do
+      #     key.failure(:invalid) if key? && value < 18
+      #   end
+      #
+      # @example specify the key name
+      #   rule(:start_date, :end_date) do
+      #     if key?(:start_date) && !key?(:end_date)
+      #       key(:end_date).failure("must provide an end_date with start_date")
+      #     end
+      #   end
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def key?(name = key_name)
+        values.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.schema_error?(path)
+      end
+
+      # Check if there are any errors on the current rule
+      #
+      # @param path [Symbol, String, Array] A Path-compatible spec
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def rule_error?(path = nil)
+        if path.nil?
+          !key(self.path).empty?
+        else
+          result.rule_error?(path)
+        end
+      end
+
+      # Check if there are any base rule errors
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def base_rule_error?
+        !base.empty? || result.base_rule_error?
+      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