dry-validation 1.5.1

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2020 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
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+[gem]: https://rubygems.org/gems/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://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]
+[![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]
+
+## Links
+
+* [User documentation](http://dry-rb.org/gems/dry-validation)
+* [API documentation](http://rubydoc.info/gems/dry-validation)
+
+## Supported Ruby versions
+
+This library officially supports the following Ruby versions:
+
+* MRI >= `2.4`
+* jruby >= `9.2`
+
+## License
+
+See `LICENSE` file.

data/config/errors.yml

@@ -0,0 +1,4 @@
+en:
+  dry_validation:
+    errors:
+      acceptance: "must accept %{key}"

data/dry-validation.gemspec

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+# this file is managed by dry-rb/devtools 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.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.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.4.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.4"
+  spec.add_runtime_dependency "dry-equalizer", "~> 0.2"
+  spec.add_runtime_dependency "dry-initializer", "~> 3.0"
+  spec.add_runtime_dependency "dry-schema", "~> 1.5"
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/lib/dry-validation.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "dry/validation"

data/lib/dry/validation.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "dry/validation/constants"
+require "dry/validation/contract"
+require "dry/validation/macros"
+
+# Main namespace
+#
+# @api public
+module Dry
+  # Main library namespace
+  #
+  # @api public
+  module Validation
+    extend Dry::Core::Extensions
+    extend Macros::Registrar
+
+    register_extension(:monads) do
+      require "dry/validation/extensions/monads"
+    end
+
+    register_extension(:hints) do
+      require "dry/validation/extensions/hints"
+    end
+
+    register_extension(:predicates_as_macros) do
+      require "dry/validation/extensions/predicates_as_macros"
+    end
+
+    # Define a contract and build its instance
+    #
+    # @example
+    #   my_contract = Dry::Validation.Contract do
+    #     params do
+    #       required(:name).filled(:string)
+    #     end
+    #   end
+    #
+    #   my_contract.call(name: "Jane")
+    #
+    # @param [Hash] options Contract options
+    #
+    # @see Contract
+    #
+    # @return [Contract]
+    #
+    # @api public
+    #
+    def self.Contract(options = EMPTY_HASH, &block)
+      Contract.build(options, &block)
+    end
+
+    # This is needed by Macros::Registrar
+    #
+    # @api private
+    def self.macros
+      Macros
+    end
+  end
+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, Macros::Container.new, &:dup
+
+      # @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.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require "concurrent/map"
+
+require "dry/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] 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
+      #
+      # @return [Result]
+      #
+      # @api public
+      def call(input)
+        Result.new(schema.(input), Concurrent::Map.new) 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.error?(path)
+
+        path
+          .to_a[0..-2]
+          .any? { |key|
+            curr_path = Schema::Path[path.keys[0..path.keys.index(key)]]
+
+            return false unless result.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/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