dry-validation 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6acd14c8b93a29eed518ef8934921cf35d0faf17
-  data.tar.gz: 83c9f549fb92f5ff4cf3f5c95ec8029e81c045d2
+  metadata.gz: ee26d9a3fbca2ae3faf18827ad28f02bd323239b
+  data.tar.gz: a007eccefbc3456f8a481549512896074dcf3f86
 SHA512:
-  metadata.gz: b7411edfe3d00dbc645d9c48a7df9dd952bf36c01e59f1a55e39114e0a757afd6b4e66b57a07380b658a146b2757651f4a1b47d61f29565d464d2b7896cdb04f
-  data.tar.gz: 50201382e0ed26bcebcf19f1d9dafe2c7c3ee260c9654afdb3b6002ce7cbf4bc83ad549e6ffff9f6636ca1fb9aa6eaadea1371044a08e33425443768eef2e512
+  metadata.gz: fe7c8c42376862ea8fbe14d3563ad65f7e3bc3f8d9b8bbbb9bff2fc239b7e16bfb9a11fd6cba5f2d0957650cd365470beaacb158a5a078998a589a15d92ca571
+  data.tar.gz: 8d337dd7bbf3fef8ca79f41ea962bc692ac6dd25b6fd93fca7c55559f0f3723f37e1bdd5fea804d3fcccbda1358f0360c8576268ecf766eed589208ac4771a31

data/.travis.yml

@@ -19,6 +19,7 @@ matrix:
   allow_failures:
     - rvm: ruby-head
     - rvm: jruby-head
+    - rvm: jruby-9000
 notifications:
   email: false
   webhooks:

data/CHANGELOG.md

@@ -1,3 +1,26 @@
+# v0.2.0 to-be-released
+
+### Added
+
+* `Schema::Form` with a built-in coercer inferred from type-check predicates  (solnic)
+* Ability to pass a block to predicate check in the DSL ie `value.hash? { ... }` (solnic)
+* Optional keys using `option(:key_name) { ... }` interface in the DSL (solnic)
+* New predicates:
+  - `bool?`
+  - `date?`
+  - `date_time?`
+  - `time?`
+  - `float?`
+  - `decimal?`
+  - `hash?`
+  - `array?`
+
+### Fixed
+
+* Added missing `and` / `or` interfaces to composite rules (solnic)
+
+[Compare v0.1.0...HEAD](https://github.com/dryrb/dry-validation/compare/v0.1.0...HEAD)
+
 # v0.1.0 2015-11-25
 
 First public release

data/README.md

@@ -1,10 +1,18 @@
-# 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>
-
-<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>
+[gem]: https://rubygems.org/gems/dry-validation
+[travis]: https://travis-ci.org/dryrb/dry-validation
+[gemnasium]: https://gemnasium.com/dryrb/dry-validation
+[codeclimate]: https://codeclimate.com/github/dryrb/dry-validation
+[coveralls]: https://coveralls.io/r/dryrb/dry-validation
+[inchpages]: http://inch-ci.org/github/dryrb/dry-validation
+
+# dry-validation [![Join the chat at https://gitter.im/dryrb/chat](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/dryrb/chat)
+
+[![Gem Version](https://badge.fury.io/rb/dry-validation.svg)][gem]
+[![Build Status](https://travis-ci.org/dryrb/dry-validation.svg?branch=master)][travis]
+[![Dependency Status](https://gemnasium.com/dryrb/dry-validation.svg)][gemnasium]
+[![Code Climate](https://codeclimate.com/github/dryrb/dry-validation/badges/gpa.svg)][codeclimate]
+[![Test Coverage](https://codeclimate.com/github/dryrb/dry-validation/badges/coverage.svg)][codeclimate]
+[![Inline docs](http://inch-ci.org/github/dryrb/dry-validation.svg?branch=master)][inchpages]
 
 Data validation library based on predicate logic and rule composition.
 
@@ -87,6 +95,84 @@ A couple of remarks:
 * 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
 
+### Optional Keys
+
+You can define which keys are optional and define rules for their values:
+
+``` ruby
+require 'dry-validation'
+
+class Schema < Dry::Validation::Schema
+  key(:email) { |email| email.filled? }
+
+  optional(:age) do |age|
+    age.int? & age.gt?(18)
+  end
+end
+
+schema = Schema.new
+
+errors = schema.messages(email: 'jane@doe.org')
+
+puts errors.inspect
+# []
+
+errors = schema.messages(email: 'jane@doe.org', age: 17)
+
+puts errors.inspect
+# [[:age, ["age must be greater than 18 (17 was given)"]]]
+```
+
+### Optional Values
+
+When it is valid for a given value to be `nil` you can use `none?` predicate:
+
+``` ruby
+require 'dry-validation'
+
+class Schema < Dry::Validation::Schema
+  key(:email) { |email| email.filled? }
+
+  key(:age) do |age|
+    age.none? | (age.int? & age.gt?(18))
+  end
+end
+
+schema = Schema.new
+
+errors = schema.messages(email: 'jane@doe.org', age: nil)
+
+puts errors.inspect
+# []
+
+errors = schema.messages(email: 'jane@doe.org', age: 19)
+
+puts errors.inspect
+# []
+
+errors = schema.messages(email: 'jane@doe.org', age: 17)
+
+puts errors.inspect
+# [[:age, ["age must be greater than 18 (17 was given)"]]]
+```
+
+### Optional Key vs Value
+
+We make a clear distinction between specifying an optional `key` and an optional
+`value`. This gives you a way of being very specific about validation rules. You
+can define a schema which can give you precise errors when a key was missing or
+key was present but the value was nil.
+
+This also comes with the benefit of being explicit about the type expectation.
+In the example above we explicitly state that `:age` *can be nil* or it *can be an integer*
+and when it *is an integer* we specify that it *must be greater than 18*.
+
+Another benefit is that we can infer specific coercion rules when types are specified.
+In example [`Schema::Form`](https://github.com/dryrb/dry-validation#form-validation-with-coercions)
+will use `form.nil` type from dry-data to coerce empty strings into `nil` for you
+whenever you specify `value.none? | value.int?`. Furthermore it will try to coerce
+to `int` since that is our type expectation.
+
 ### Nested Hash
 
 We are free to define validations for anything, including deeply nested structures:
@@ -96,17 +182,19 @@ 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?)
+    address.hash? do
+      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
 end
@@ -124,6 +212,74 @@ puts errors.inspect
 # [[:address, [[:street, ["street is missing"]], [:country, ["country is missing"]]]]]
 ```
 
+### Array Elements
+
+You can use `each` rule for validating each element in an array:
+
+``` ruby
+class Schema < Dry::Validation::Schema
+  key(:phone_numbers) do |phone_numbers|
+    phone_numbers.array? do
+      phone_numbers.each(&:str?)
+    end
+  end
+end
+
+schema = Schema.new
+
+errors = schema.messages(phone_numbers: '')
+
+puts errors.inspect
+# [[:phone_numbers, ["phone_numbers must be an array"]]]
+
+errors = schema.messages(phone_numbers: ['123456789', 123456789])
+
+puts errors.inspect
+# [[:phone_numbers, [[:phone_numbers, ["phone_numbers must be a string"]]]]]
+```
+
+### Form Validation With Coercions
+
+Probably the most common use case is to validate form params. This is a special
+kind of a validation for a couple of reasons:
+
+* The input is a hash with stringified keys
+* The input include values that are strings, hashes or arrays
+* Prior validation, we need to coerce values and symbolize keys based on the
+  information from rules
+
+For that reason, `dry-validation` ships with `Schema::Form` class:
+
+``` ruby
+require 'dry-validation'
+require 'dry/validation/schema/form'
+
+class UserFormSchema < Dry::Validation::Schema::Form
+  key(:email) { |value| value.str? & value.filled? }
+
+  key(:age) { |value| value.int? & value.gt?(18) }
+end
+
+schema = UserFormSchema.new
+
+errors = schema.messages('email' => '', 'age' => '18')
+
+puts errors.inspect
+
+# [[:email, ["email must be filled"]], [:age, ["age must be greater than 18 (18 was given)"]]]
+```
+
+There are few major differences between how it works here and in `ActiveModel`:
+
+* We have type checking as predicates, ie `gt?(18)` will not be applied if the value
+  is not an integer
+* Thus, error messages are provided *only for the rules that failed*
+* There's a planned feature for generating "validation hints" which lists information
+  about all possible rules
+* Coercion is handled by `dry-data` coercible hash using its `form.*` types that
+  are dedicated for this type of coercions
+* It's very easy to add your own types and coercions (more info/docs coming soon)
+
 ### Defining Custom Predicates
 
 You can simply define predicate methods on your schema object:
@@ -158,25 +314,46 @@ class Schema < Dry::Validation::Schema
 end
 ```
 
+You need to provide error messages for your custom predicates if you want them
+to work with `Schem#messages` interface.
+
+You can learn how to do that in the [Error Messages](https://github.com/dryrb/dry-validation#error-messages) section.
+
 ## List of Built-In Predicates
 
-* `empty?`
+### Basic
+
+* `none?`
 * `eql?`
-* `exclusion?`
+* `key?`
+
+### Types
+
+* `str?`
+* `int?`
+* `float?`
+* `decimal?`
+* `bool?`
+* `date?`
+* `date_time?`
+* `time?`
+* `array?`
+* `hash?`
+
+### Number, String, Collection
+
+* `empty?`
 * `filled?`
-* `format?`
 * `gt?`
 * `gteq?`
-* `inclusion?`
-* `int?`
-* `key?`
 * `lt?`
 * `lteq?`
 * `max_size?`
 * `min_size?`
-* `nil?`
 * `size?`
-* `str?`
+* `format?`
+* `inclusion?`
+* `exclusion?`
 
 ## Error Messages
 

data/config/errors.yml

@@ -1,3 +1,5 @@
+array?: "%{name} must be an array"
+
 empty?: "%{name} cannot be empty"
 
 exclusion?: "%{name} must not be one of: %{list}"
@@ -12,10 +14,24 @@ gt?: "%{name} must be greater than %{num} (%{value} was given)"
 
 gteq?: "%{name} must be greater than or equal to %{num}"
 
+hash?: "%{name} must be a hash"
+
 inclusion?: "%{name} must be one of: %{list}"
 
+bool?: "%{name} must be boolean"
+
 int?: "%{name} must be an integer"
 
+float?: "%{name} must be a float"
+
+decimal?: "%{name} must be a decimal"
+
+date?: "%{name} must be a date"
+
+date_time?: "%{name} must be a date time"
+
+time?: "%{name} must be a time"
+
 key?: "%{name} is missing"
 
 lt?: "%{name} must be less than %{num} (%{value} was given)"

data/dry-validation.gemspec

@@ -18,6 +18,7 @@ Gem::Specification.new do |spec|
   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_runtime_dependency 'dry-data', '~> 0.2', '>= 0.2.1'
 
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake'

data/examples/each.rb

@@ -0,0 +1,19 @@
+require 'dry-validation'
+
+class Schema < Dry::Validation::Schema
+  key(:phone_numbers) do |phone_numbers|
+    phone_numbers.array? do
+      phone_numbers.each(&:str?)
+    end
+  end
+end
+
+schema = Schema.new
+
+errors = schema.messages(phone_numbers: '')
+
+puts errors.inspect
+
+errors = schema.messages(phone_numbers: ['123456789', 123456789])
+
+puts errors.inspect

data/examples/form.rb

@@ -0,0 +1,15 @@
+require 'dry-validation'
+require 'dry/validation/schema/form'
+
+class UserFormSchema < Dry::Validation::Schema::Form
+  key(:email) { |value| value.str? & value.filled? }
+
+  key(:age) { |value| value.int? & value.gt?(18) }
+end
+
+schema = UserFormSchema.new
+
+errors = schema.messages('email' => '', 'age' => '18')
+
+puts errors.inspect
+# [[:email, ["email must be filled"]], [:age, ["age must be greater than 18 (18 was given)"]]]

data/examples/nested.rb

@@ -2,17 +2,19 @@ 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?)
+    address.hash? do
+      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
 end

data/lib/dry/validation.rb

@@ -6,6 +6,11 @@ require 'dry-container'
 # a common task in Ruby
 module Dry
   module Validation
+    def self.symbolize_keys(hash)
+      hash.each_with_object({}) do |(k, v), r|
+        r[k.to_sym] = v.is_a?(Hash) ? symbolize_keys(v) : v
+      end
+    end
   end
 end
 

data/lib/dry/validation/error_compiler.rb

@@ -42,10 +42,6 @@ module Dry
         { name: args[0][0] }
       end
 
-      def visit_empty?(*args, value)
-        { value: value }
-      end
-
       def visit_exclusion?(*args, value)
         { list: args[0][0].join(', ') }
       end
@@ -96,20 +92,8 @@ module Dry
         end
       end
 
-      def visit_str?(*args, value)
-        { value: value }
-      end
-
-      def visit_format?(*args, value)
-        {}
-      end
-
-      def visit_nil?(*args, value)
-        {}
-      end
-
-      def visit_filled?(*args)
-        {}
+      def method_missing(meth, *args)
+        { value: args[1] }
       end
     end
   end