dry-validation 0.1.0 → 1.8.0

data/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2014 Ruby Object Mapper
+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,296 +1,29 @@
-# dry-validation <a href="https://gitter.im/dryrb/chat" target="_blank">![Join the chat at https://gitter.im/dryrb/chat](https://badges.gitter.im/Join%20Chat.svg)</a>
+<!--- this file is synced from dry-rb/template-gem project -->
+[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
 
-<a href="https://rubygems.org/gems/dry-validation" target="_blank">![Gem Version](https://badge.fury.io/rb/dry-validation.svg)</a>
-<a href="https://travis-ci.org/dryrb/dry-validation" target="_blank">![Build Status](https://travis-ci.org/dryrb/dry-validation.svg?branch=master)</a>
-<a href="https://gemnasium.com/dryrb/dry-validation" target="_blank">![Dependency Status](https://gemnasium.com/dryrb/dry-validation.svg)</a>
-<a href="https://codeclimate.com/github/dryrb/dry-validation" target="_blank">![Code Climate](https://codeclimate.com/github/dryrb/dry-validation/badges/gpa.svg)</a>
-<a href="http://inch-ci.org/github/dryrb/dry-validation" target="_blank">![Documentation Status](http://inch-ci.org/github/dryrb/dry-validation.svg?branch=master&style=flat)</a>
+# dry-validation [![Join the chat at https://dry-rb.zulipchat.com](https://img.shields.io/badge/dry--rb-join%20chat-%23346b7a.svg)][chat]
 
-Data validation library based on predicate logic and rule composition.
+[![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]
 
-## Overview
+## Links
 
-Unlike other, well known, validation solutions in Ruby, `dry-validation` takes
-a different approach and focuses a lot on explicitness, clarity and preciseness
-of validation logic. It is designed to work with any data input, whether it's a
-simple hash, an array or a complex object with deeply nested data.
+* [User documentation](https://dry-rb.org/gems/dry-validation)
+* [API documentation](http://rubydoc.info/gems/dry-validation)
 
-It is based on a simple idea that each validation is encapsulated by a simple,
-stateless predicate, that receives some input and returns either `true` or `false`.
+## Supported Ruby versions
 
-Those predicates are encapsulated by `rules` which can be composed together using
-`predicate logic`. This means you can use the common logic operators to build up
-a validation `schema`.
+This library officially supports the following Ruby versions:
 
-It's very explicit, powerful and extendible.
-
-Validations can be described with great precision, `dry-validation` eliminates
-ambigious concepts like `presence` validation where we can't really say whether
-some attribute or key is *missing* or it's just that the value is `nil`.
-
-There's also the concept of type-safety, completely missing in other validation
-libraries, which is quite important and useful. It means you can compose a validation
-that does rely on the type of a given value. In example it makes no sense to validate
-each element of an array when it turns out to be an empty string.
-
-## The DSL
-
-The core of `dry-validation` is rules composition and predicate logic. The DSL
-is a simple front-end for that. It only allows you to define the rules by using
-predicate identifiers. There are no magical options, conditionals and custom
-validation blocks known from other libraries. The focus is on pure validation
-logic.
-
-## Examples
-
-### Basic
-
-Here's a basic example where we validate following things:
-
-* The input *must have a key* called `:email`
-  * Provided the email key is present, its value *must be filled*
-* The input *must have a key* called `:age`
-  * Provided the age key is present, its value *must be an integer* and it *must be greater than 18*
-
-This can be easily expressed through the DSL:
-
-``` ruby
-require 'dry-validation'
-
-class Schema < Dry::Validation::Schema
-  key(:email) { |email| email.filled? }
-
-  key(:age) do |age|
-    age.int? & age.gt?(18)
-  end
-end
-
-schema = Schema.new
-
-errors = schema.messages(email: 'jane@doe.org', age: 19)
-
-puts errors.inspect
-# []
-
-errors = schema.messages(email: nil, age: 19)
-
-puts errors.inspect
-# [[:email, ["email must be filled"]]]
-```
-
-A couple of remarks:
-
-* `key` assumes that we want to use the `:key?` predicate to check the existance of that key
-* `age.gt?(18)` translates to calling a predicate like this: `schema[:gt?].(18, age)`
-* `age.int? & age.gt?(18)` is a conjunction, so we don't bother about `gt?` unless `int?` returns `true`
-* You can also use `|` for disjunction
-* Schema object does not carry the input as its state, nor does it know how to access the input values, we
-  pass the input to `call` and get error set as the response
-
-### Nested Hash
-
-We are free to define validations for anything, including deeply nested structures:
-
-``` ruby
-require 'dry-validation'
-
-class Schema < Dry::Validation::Schema
-  key(:address) do |address|
-    address.key(:city) do |city|
-      city.min_size?(3)
-    end
-
-    address.key(:street) do |street|
-      street.filled?
-    end
-
-    address.key(:country) do |country|
-      country.key(:name, &:filled?)
-      country.key(:code, &:filled?)
-    end
-  end
-end
-
-schema = Schema.new
-
-errors = schema.messages({})
-
-puts errors.inspect
-# [[:address, ["address is missing"]]]
-
-errors = schema.messages(address: { city: 'NYC' })
-
-puts errors.inspect
-# [[:address, [[:street, ["street is missing"]], [:country, ["country is missing"]]]]]
-```
-
-### Defining Custom Predicates
-
-You can simply define predicate methods on your schema object:
-
-``` ruby
-class Schema < Dry::Validation::Schema
-  key(:email) { |value| value.str? & value.email? }
-
-  def email?(value)
-    ! /magical-regex-that-matches-emails/.match(value).nil?
-  end
-end
-```
-
-You can also re-use a predicate container across multiple schemas:
-
-``` ruby
-module MyPredicates
-  include Dry::Validation::Predicates
-
-  predicate(:email?) do |input|
-    ! /magical-regex-that-matches-emails/.match(value).nil?
-  end
-end
-
-class Schema < Dry::Validation::Schema
-  configure do |config|
-    config.predicates = MyPredicates
-  end
-
-  key(:email) { |value| value.str? & value.email? }
-end
-```
-
-## List of Built-In Predicates
-
-* `empty?`
-* `eql?`
-* `exclusion?`
-* `filled?`
-* `format?`
-* `gt?`
-* `gteq?`
-* `inclusion?`
-* `int?`
-* `key?`
-* `lt?`
-* `lteq?`
-* `max_size?`
-* `min_size?`
-* `nil?`
-* `size?`
-* `str?`
-
-## Error Messages
-
-By default `dry-validation` comes with a set of pre-defined error messages for
-every built-in predicate. They are defined in [a yaml file](https://github.com/dryrb/dry-validation/blob/master/config/errors.yml)
-which is shipped with the gem.
-
-You can provide your own messages and configure your schemas to use it like that:
-
-``` ruby
-class Schema < Dry::Validation::Schema
-  configure { |config| config.messages_file = '/path/to/my/errors.yml' }
-end
-```
-
-You can also provide a namespace per-schema that will be used by default:
-
-``` ruby
-class Schema < Dry::Validation::Schema
-  configure { |config| config.namespace = :user }
-end
-```
-
-Lookup rules:
-
-``` yaml
-filled?: "%{name} must be filled"
-
-attributes:
-  email:
-    filled?: "the email is missing"
-
-user:
-  filled?: "%{name} name cannot be blank"
-
-  attributes:
-    address:
-      filled?: "You gotta tell us where you live"
-```
-
-Given the yaml file above, messages lookup works as follows:
-
-``` ruby
-messages = Dry::Validation::Messages.load('/path/to/our/errors.yml')
-
-messages.lookup(:filled?, :age) # => "age must be filled"
-messages.lookup(:filled?, :address) # => "address must be filled"
-messages.lookup(:filled?, :email) # => "the email is missing"
-
-# with namespaced messages
-user_messages = messages.namespaced(:user)
-
-user_messages.lookup(:filled?, :age) # "age cannot be blank"
-user_messages.lookup(:filled?, :address) # "You gotta tell us where you live"
-```
-
-By configuring `messages_file` and/or `namespace` in a schema, default messages
-are going to be automatically merged with your overrides and/or namespaced.
-
-## I18n Integration
-
-Coming (very) soon...
-
-## Rule AST
-
-Internally, `dry-validation` uses a simple AST representation of rules and errors
-to produce rule objects and error messages. If you would like to programatically
-generate rules, it is a very simple process:
-
-``` ruby
-ast = [
-  [
-    :and,
-    [
-      [:key, [:age, [:predicate, [:key?, []]]]],
-      [
-        :and,
-        [
-          [:val, [:age, [:predicate, [:filled?, []]]]],
-          [:val, [:age, [:predicate, [:gt?, [18]]]]]
-        ]
-      ]
-    ]
-  ]
-]
-
-compiler = Dry::Validation::RuleCompiler.new(Dry::Validation::Predicates)
-
-# compile an array of rule objects
-rules = compiler.call(ast)
-
-puts rules.inspect
-# [
-#   #<Dry::Validation::Rule::Conjunction
-#     left=#<Dry::Validation::Rule::Key name=:age predicate=#<Dry::Validation::Predicate id=:key?>>
-#     right=#<Dry::Validation::Rule::Conjunction
-#       left=#<Dry::Validation::Rule::Value name=:age predicate=#<Dry::Validation::Predicate id=:filled?>>
-#       right=#<Dry::Validation::Rule::Value name=:age predicate=#<Dry::Validation::Predicate id=:gt?>>>>
-# ]
-
-# dump it back to ast
-puts rules.map(&:to_ary).inspect
-# [[:and, [:key, [:age, [:predicate, [:key?, [:age]]]]], [[:and, [:val, [:age, [:predicate, [:filled?, []]]]], [[:val, [:age, [:predicate, [:gt?, [18]]]]]]]]]]
-```
-
-Complete docs for the AST format are coming soon, for now please refer to
-[this spec](https://github.com/dryrb/dry-validation/blob/master/spec/unit/rule_compiler_spec.rb).
-
-## Status and Roadmap
-
-This library is in a very early stage of development but you are encauraged to
-try it out and provide feedback.
-
-For planned features check out [the issues](https://github.com/dryrb/dry-validation/labels/feature).
+* MRI `>= 2.7.0`
+* jruby `>= 9.3` (postponed until 2.7 is supported)
 
 ## License
 

data/config/errors.yml

@@ -1,35 +1,4 @@
-empty?: "%{name} cannot be empty"
-
-exclusion?: "%{name} must not be one of: %{list}"
-
-eql?: "%{name} must be equal to %{eql_value}"
-
-filled?: "%{name} must be filled"
-
-format?: "%{name} is in invalid format"
-
-gt?: "%{name} must be greater than %{num} (%{value} was given)"
-
-gteq?: "%{name} must be greater than or equal to %{num}"
-
-inclusion?: "%{name} must be one of: %{list}"
-
-int?: "%{name} must be an integer"
-
-key?: "%{name} is missing"
-
-lt?: "%{name} must be less than %{num} (%{value} was given)"
-
-lteq?: "%{name} must be less than or equal to %{num}"
-
-max_size?: "%{name} size cannot be greater than %{num}"
-
-min_size?: "%{name} size cannot be less than %{num}"
-
-nil?: "%{name} cannot be nil"
-
-size?:
-  range: "%{name} size must be within %{left} - %{right}"
-  default: "%{name} size must be %{num}"
-
-str?: "%{name} must be a string"
+en:
+  dry_validation:
+    errors:
+      acceptance: "must accept %{key}"

data/dry-validation.gemspec

@@ -1,25 +1,41 @@
-# coding: utf-8
-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/dryrb/dry-validation'
-  spec.license       = 'MIT'
-
-  spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ['lib']
-
-  spec.add_runtime_dependency 'dry-configurable', '~> 0.1'
-  spec.add_runtime_dependency 'dry-container', '~> 0.2', '>= 0.2.6'
-  spec.add_runtime_dependency 'dry-equalizer', '~> 0.2'
-
-  spec.add_development_dependency 'bundler'
-  spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'rspec'
+  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.7.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.9", ">= 1.9.1"
+
+  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