dry-validation 1.3.1

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2019 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,30 @@
+[gem]: https://rubygems.org/gems/dry-validation
+[travis]: https://travis-ci.com/dry-rb/dry-validation
+[codeclimate]: https://codeclimate.com/github/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]
+[![Build Status](https://travis-ci.com/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]
+[![Inline docs](http://inch-ci.org/github/dry-rb/dry-validation.svg?branch=master)][inchpages]
+
+## Links
+
+* [User documentation](https://dry-rb.org/gems/dry-validation)
+* [API documentation](http://rubydoc.info/gems/dry-validation)
+* [Guidelines for contributing](CONTRIBUTING.md)
+
+## Supported Ruby versions
+
+This library officially supports 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/lib/dry-validation.rb

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

data/lib/dry/validation.rb

@@ -0,0 +1,62 @@
+# 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
+    #
+    # rubocop:disable Naming/MethodName
+    def self.Contract(options = EMPTY_HASH, &block)
+      Contract.build(options, &block)
+    end
+    # rubocop:enable Naming/MethodName
+
+    # 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,223 @@
+# 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_schema = nil, &block)
+          define(:Params, external_schema, &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_schema = nil, &block)
+          define(:JSON, external_schema, &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_schema = nil, &block)
+          define(:schema, external_schema, &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
+        # rubocop:disable Metrics/AbcSize
+        def ensure_valid_keys(*keys)
+          valid_paths = key_map.to_dot_notation.map { |value| Schema::Path[value] }
+
+          invalid_keys = keys
+            .map { |key|
+              [key, Schema::Path[key]]
+            }
+            .map { |(key, path)|
+              if (last = path.last).is_a?(Array)
+                last.map { |last_key|
+                  path_key = [*path.to_a[0..-2], last_key]
+                  [path_key, Schema::Path[path_key]]
+                }
+              else
+                [[key, path]]
+              end
+            }
+            .flatten(1)
+            .reject { |(_, path)|
+              valid_paths.any? { |valid_path| valid_path.include?(path) }
+            }
+            .map(&:first)
+
+          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
+        # rubocop:enable Metrics/AbcSize
+
+        # @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_schema, &block)
+          return __schema__ if external_schema.nil? && 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_schema) if external_schema
+
+          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