dry-validation 0.12.0 → 1.6.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/evaluator.rb

@@ -0,0 +1,224 @@
+# 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 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
+
+      # @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