dry-validation 0.13.3 → 1.7.0

data/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2015 Dryrb Team
+Copyright (c) 2015-2021 dry-rb team
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in

data/README.md

@@ -1,25 +1,29 @@
+<!--- this file is synced from dry-rb/template-gem project -->
 [gem]: https://rubygems.org/gems/dry-validation
-[travis]: https://travis-ci.org/dry-rb/dry-validation
-[codeclimate]: https://codeclimate.com/github/dry-rb/dry-validation
-[coveralls]: https://coveralls.io/r/dry-rb/dry-validation
+[actions]: https://github.com/dry-rb/dry-validation/actions
+[codacy]: https://www.codacy.com/gh/dry-rb/dry-validation
+[chat]: https://dry-rb.zulipchat.com
 [inchpages]: http://inch-ci.org/github/dry-rb/dry-validation
 
-# dry-validation [![Join the chat at https://gitter.im/dry-rb/chat](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/dry-rb/chat)
+# dry-validation [![Join the chat at https://dry-rb.zulipchat.com](https://img.shields.io/badge/dry--rb-join%20chat-%23346b7a.svg)][chat]
 
 [![Gem Version](https://badge.fury.io/rb/dry-validation.svg)][gem]
-[![Build Status](https://travis-ci.org/dry-rb/dry-validation.svg?branch=master)][travis]
-[![Code Climate](https://codeclimate.com/github/dry-rb/dry-validation/badges/gpa.svg)][codeclimate]
-[![Test Coverage](https://codeclimate.com/github/dry-rb/dry-validation/badges/coverage.svg)][codeclimate]
+[![CI Status](https://github.com/dry-rb/dry-validation/workflows/CI/badge.svg)][actions]
+[![Codacy Badge](https://api.codacy.com/project/badge/Grade/f30e3ff5ec304c55a73868cdbf055c67)][codacy]
+[![Codacy Badge](https://api.codacy.com/project/badge/Coverage/f30e3ff5ec304c55a73868cdbf055c67)][codacy]
 [![Inline docs](http://inch-ci.org/github/dry-rb/dry-validation.svg?branch=master)][inchpages]
 
-## Status
+## Links
 
-We're working on a new foundation for dry-validation, called dry-schema. You can see progress in [this PR](https://github.com/dry-rb/dry-schema/pull/3). This will result in a partial rewrite for 1.0.0 version. Currently known bugs/issues will be addressed in 1.0.0, **not in 0.x** due to lack of time. More info about 1.0.0 plans can be found [in this thread](https://discourse.dry-rb.org/t/plans-for-dry-validation-dry-schema-a-new-gem/215/3).
+* [User documentation](https://dry-rb.org/gems/dry-validation)
+* [API documentation](http://rubydoc.info/gems/dry-validation)
 
-## Links
+## Supported Ruby versions
+
+This library officially supports the following Ruby versions:
 
-* [Documentation](http://dry-rb.org/gems/dry-validation)
-* [Guidelines for contributing](CONTRIBUTING.md)
+* MRI `>= 2.6.0`
+* ~~jruby~~ `>= 9.3` (we are waiting for [2.6 support](https://github.com/jruby/jruby/issues/6161))
 
 ## License
 

data/config/errors.yml

@@ -1,89 +1,4 @@
 en:
-  errors:
-    or: "or"
-    array?: "must be an array"
-
-    empty?: "must be empty"
-
-    excludes?: "must not include %{value}"
-
-    excluded_from?:
-      arg:
-        default: "must not be one of: %{list}"
-        range: "must not be one of: %{list_left} - %{list_right}"
-    exclusion?: "must not be one of: %{list}"
-
-    eql?: "must be equal to %{left}"
-
-    not_eql?: "must not be equal to %{left}"
-
-    filled?: "must be filled"
-
-    format?: "is in invalid format"
-
-    number?: "must be a number"
-
-    odd?: "must be odd"
-
-    even?: "must be even"
-
-    gt?: "must be greater than %{num}"
-
-    gteq?: "must be greater than or equal to %{num}"
-
-    hash?: "must be a hash"
-
-    included_in?:
-      arg:
-        default: "must be one of: %{list}"
-        range: "must be one of: %{list_left} - %{list_right}"
-    inclusion?: "must be one of: %{list}"
-
-    includes?: "must include %{value}"
-
-    bool?: "must be boolean"
-
-    true?: "must be true"
-
-    false?: "must be false"
-
-    int?: "must be an integer"
-
-    float?: "must be a float"
-
-    decimal?: "must be a decimal"
-
-    date?: "must be a date"
-
-    date_time?: "must be a date time"
-
-    time?: "must be a time"
-
-    key?: "is missing"
-
-    attr?: "is missing"
-
-    lt?: "must be less than %{num}"
-
-    lteq?: "must be less than or equal to %{num}"
-
-    max_size?: "size cannot be greater than %{num}"
-
-    min_size?: "size cannot be less than %{num}"
-
-    none?: "cannot be defined"
-
-    str?: "must be a string"
-
-    type?: "must be %{type}"
-
-    size?:
-      arg:
-        default: "size must be %{size}"
-        range: "size must be within %{size_left} - %{size_right}"
-
-      value:
-        string:
-          arg:
-            default: "length must be %{size}"
-            range: "length must be within %{size_left} - %{size_right}"
+  dry_validation:
+    errors:
+      acceptance: "must accept %{key}"

data/dry-validation.gemspec

@@ -1,28 +1,41 @@
-require File.expand_path('../lib/dry/validation/version', __FILE__)
+# frozen_string_literal: true
+
+# this file is synced from dry-rb/template-gem project
+
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "dry/validation/version"
 
 Gem::Specification.new do |spec|
-  spec.name          = 'dry-validation'
-  spec.version       = Dry::Validation::VERSION
-  spec.authors       = ['Andy Holland', 'Piotr Solnica']
-  spec.email         = ['andyholland1991@aol.com', 'piotr.solnica@gmail.com']
-  spec.summary       = 'A simple validation library'
-  spec.homepage      = 'https://github.com/dry-rb/dry-validation'
-  spec.license       = 'MIT'
-
-  spec.files         = `git ls-files -z`.split("\x0") - ['bin/console']
+  spec.name          = "dry-validation"
+  spec.authors       = ["Piotr Solnica"]
+  spec.email         = ["piotr.solnica@gmail.com"]
+  spec.license       = "MIT"
+  spec.version       = Dry::Validation::VERSION.dup
+
+  spec.summary       = "Validation library"
+  spec.description   = spec.summary
+  spec.homepage      = "https://dry-rb.org/gems/dry-validation"
+  spec.files         = Dir["CHANGELOG.md", "LICENSE", "README.md", "dry-validation.gemspec", "lib/**/*", "config/*.yml"]
+  spec.bindir        = "bin"
   spec.executables   = []
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ['lib']
-  spec.required_ruby_version = ">= 2.4.0"
-
-  spec.add_runtime_dependency 'concurrent-ruby', '~> 1.0'
-  spec.add_runtime_dependency 'dry-configurable', '~> 0.1', '>= 0.1.3'
-  spec.add_runtime_dependency 'dry-equalizer', '~> 0.2'
-  spec.add_runtime_dependency 'dry-logic', '~> 0.5', '>= 0.5.0'
-  spec.add_runtime_dependency 'dry-types', '~> 0.14.0'
-  spec.add_runtime_dependency 'dry-core', '~> 0.2', '>= 0.2.1'
-
-  spec.add_development_dependency 'bundler'
-  spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'rspec'
+  spec.require_paths = ["lib"]
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  spec.metadata["changelog_uri"]     = "https://github.com/dry-rb/dry-validation/blob/master/CHANGELOG.md"
+  spec.metadata["source_code_uri"]   = "https://github.com/dry-rb/dry-validation"
+  spec.metadata["bug_tracker_uri"]   = "https://github.com/dry-rb/dry-validation/issues"
+
+  spec.required_ruby_version = ">= 2.6.0"
+
+  # to update dependencies edit project.yml
+  spec.add_runtime_dependency "concurrent-ruby", "~> 1.0"
+  spec.add_runtime_dependency "dry-container", "~> 0.7", ">= 0.7.1"
+  spec.add_runtime_dependency "dry-core", "~> 0.5", ">= 0.5"
+  spec.add_runtime_dependency "dry-initializer", "~> 3.0"
+  spec.add_runtime_dependency "dry-schema", "~> 1.8", ">= 1.8.0"
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
 end

data/lib/dry/validation/config.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "dry/schema/config"
+require "dry/validation/macros"
+
+module Dry
+  module Validation
+    # Configuration for contracts
+    #
+    # @see Contract#config
+    #
+    # @api public
+    class Config < Schema::Config
+      setting :macros, default: Macros::Container.new, constructor: :dup.to_proc
+
+      # @api private
+      def dup
+        config = super
+        config.macros = macros.dup
+        config
+      end
+    end
+  end
+end

data/lib/dry/validation/constants.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "dry/core/constants"
+
+module Dry
+  module Validation
+    include Dry::Core::Constants
+
+    DOT = "."
+
+    # Root path is used for base errors in hash representation of error messages
+    ROOT_PATH = [nil].freeze
+
+    # Path to the default errors locale file
+    DEFAULT_ERRORS_NAMESPACE = "dry_validation"
+
+    # Path to the default errors locale file
+    DEFAULT_ERRORS_PATH = Pathname(__FILE__).join("../../../../config/errors.yml").realpath.freeze
+
+    # Mapping for block kwarg options used by block_options
+    #
+    # @see Rule#block_options
+    BLOCK_OPTIONS_MAPPINGS = Hash.new { |_, key| key }.update(context: :_context).freeze
+
+    # Error raised when `rule` specifies one or more keys that the schema doesn't specify
+    InvalidKeysError = Class.new(StandardError)
+
+    # Error raised when a localized message was not found
+    MissingMessageError = Class.new(StandardError)
+
+    # Error raised when trying to define a schema in a contract class that already has a schema
+    DuplicateSchemaError = Class.new(StandardError)
+
+    # Error raised during initialization of a contract that has no schema defined
+    SchemaMissingError = Class.new(StandardError) do
+      # @api private
+      def initialize(klass)
+        super("#{klass} cannot be instantiated without a schema defined")
+      end
+    end
+  end
+end

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,171 @@
+# 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
+      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
+
+      # 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