composable_validations 0.0.9 → 0.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 859b71a70691f26e28d171883bd5297af8897692
-  data.tar.gz: a2e612c3c41de11b37a828a4cf8466c01a6682b3
+  metadata.gz: dbb778464163c80eb1df8ec60299ce2d2d399ffd
+  data.tar.gz: f4e54cf70891ae58da5485e1662fe4233ef41865
 SHA512:
-  metadata.gz: 35890438972b2e2898fe20aea2a8e25184b19ff863df5a69208ae4da10d66996cdc50c2b6dff42efb5cd6bb517c02a3b62f2b3cf928baf00564add5b1463ad67
-  data.tar.gz: 1613d3040d41f1fdbbefbfe4098bf4c901711e1a4eeee76a5d4a651da0f5846e57e8266228c5f04480d6a3c07e9f49dd7967409e2eb78a7dfaa64e334c665b15
+  metadata.gz: 45e7ec65e32b08f8bd25834d5fcd513a4514813b5a57780b688dc80f176192df81a458fefd15e66b0f388356ef1e5dd666fb2b4b5657018e3c40e789ce82dbc6
+  data.tar.gz: 100912344daee564a5c1770f48cccc16124f2599a42b5edd6fdb574cde320e3211c9cda90be3ffbeeb565825b11327cbb73b53a3de166c33f491c636b2b3528b

data/README.md

@@ -66,9 +66,11 @@ end
 ```
 In the example above the payload is invalid and as a result `valid` has value
 `false` and `errors` contains:
+
 ```
 {"person/name"=>["must be a string"], "person/age"=>["must be an integer"]}
 ```
+
 Note that invalid elements of the payload are identified by exact path within
 the payload.
 
@@ -123,6 +125,7 @@ end
 The previous examples showed validation of a JSON object. We can also
 validate JSON arrays. Let's add list of hobbies to our person object from
 the previous examples:
+
 ```ruby
 {
   "person" => {
@@ -132,8 +135,10 @@ the previous examples:
   }
 }
 ```
+
 We will also not accept people with fewer than two hobbies. Validator for this
 payload:
+
 ```ruby
 a_hash(
   allowed_keys("person"),
@@ -145,13 +150,17 @@ a_hash(
       min_size(2),
       each(non_empty_string))))))
 ```
+
 Try to apply this validator to the payload containing invalid list of hobbies
+
 ```
 ...
 "hobbies" => ["knitting", {"not" => "allowed"}, "horse riding"]
 ...
 ```
+
 and you'll get errors specifying exactly where the invalid element is:
+
 ```
 {"person/hobbies/1"=>["must be a string"]}
 ```
@@ -175,9 +184,11 @@ validators](#custom-validators).
 ### Validators
 
 Validator is a function returning boolean value and having following signature:
+
 ```ruby
 lambda { |validated_object, errors_hash, path| ... }
 ```
+
 * `errors_hash` is mutated while errors are collected by validators.
 * `path` represents a path to the invalid element within the JSON object. It is
   an array of strings (keys in hash map) and integers (indexes of an array).
@@ -209,45 +220,60 @@ be further composed into more powerful validation rules.
 
 We want to validate object representing opening hours of a store. E.g. store
 opened from 9am to 5pm would be represented by
+
 ```ruby
 {"from" => 9, "to" => 17}
 ```
+
 Let's start by building validator ensuring that payload is a hash where both
 `from` and `to` are integers:
+
 ```ruby
 a_hash(
   key("from", integer),
   key("to", integer))
 ```
+
 We also want to make sure that extra keys like
+
 ```ruby
 {"from" => 9, "to" => 17, "something" => "wrong"}
 ```
+
 are not allowed. Let's fix it by using `allowed_keys` validator:
+
 ```ruby
 a_hash(
   allowed_keys("from", "to"),
   key("from", integer),
   key("to", integer))
 ```
+
 Better, but we don't want to allow negative hours like this:
+
 ```ruby
 {"from" => -1, "to" => 17}
 ```
+
 We can fix it by using more specific integer validator:
+
 ```ruby
 a_hash(
   allowed_keys("from", "to"),
   key("from", non_negative_integer),
   key("to", non_negative_integer))
 ```
+
 Let's assume here that we represent store opened all day as
+
 ```ruby
 {"from" => 0, "to" => 24}
 ```
+
 so hours greater than 24 should also be invalid. We can validate hour by
 composing `non_negative_integer` validator with `less_or_equal` using
 `fail_fast` combinator:
+
 ```ruby
 hour = fail_fast(non_negative_integer, less_or_equal(24))
 
@@ -256,17 +282,23 @@ a_hash(
   key("from", hour),
   key("to", hour))
 ```
+
 This validator still has a little problem. Opening hours like this are not
 rejected:
+
 ```ruby
 {"from" => 21, "to" => 1}
 ```
+
 We have to make sure that closing is not before opening. We can do it by using
 `key_greater_than_key` validator:
+
 ```ruby
 key_greater_than_key("to", "from")
 ```
+
 and our validator will look like this:
+
 ```ruby
 a_hash(
   allowed_keys("from", "to"),
@@ -274,15 +306,19 @@ a_hash(
   key("to", hour),
   key_greater_than_key("to", "from"))
 ```
+
 That looks good, but it's not complete yet. `a_hash` validator applies all
 validators to the provided payload by using `run_all` combinator. This
 behaviour is problematic if our `from` or `to` keys are missing or are not
 valid integers. Payload
+
 ```ruby
 {"from" => "abc", "to" => 17}
 ```
+
 will cause an exception as `key_greater_than_key` can not compare string to
 integer. Let's fix it by using `fail_fast` and `run_all` combinators:
+
 ```ruby
 a_hash(
   allowed_keys("from", "to"),
@@ -292,6 +328,7 @@ a_hash(
       key("to", hour)),
     key_greater_than_key("to", "from")))
 ```
+
 This way if `from` and `to` are not both valid hours we will not be comparing
 them.
 
@@ -326,6 +363,7 @@ store = {
 ```
 
 Definition of the store validator (using `from_to` built in the [previous section](#composability)):
+
 ```ruby
 hour = fail_fast(non_negative_integer, less_or_equal(24))
 
@@ -359,21 +397,27 @@ store_validator = a_hash(
 
 Let's say we try to validate store that has Wednesday opening hours invalid
 (closing time before opening time) like this:
+
 ```ruby
 ...
 "wednesday"=> {"from" => 9, "to" => 7},
 ...
 ```
+
 Now we use store validator to fill in the collection of errors using default
 error messages:
+
 ```ruby
   errors = {}
   result = default_errors(store_validator).call(store, errors)
 ```
+
 Result is `false` and we get validation error in the `errors` hash:
+
 ```ruby
 {"store/opening_hours/wednesday/to" => ["must be greater than from"]}
 ```
+
 You can find this example in
 [functional spec](https://github.com/shutl/composable_validations/blob/master/spec/functional/composable_validations_spec.rb)
 ready for experiments.
@@ -387,11 +431,13 @@ There are few ways to provide your own error messages.
 ### Local override
 
 You can override error message when building your validator:
+
 ```ruby
 a_hash(
   key("from", integer("custom error message")),
   key("to", integer("another custom error message")))
 ```
+
 This approach is good if you need just few specialized error messages for
 different parts of your payload.
 
@@ -400,6 +446,7 @@ different parts of your payload.
 If you need to change some of the error messages across all your validators you
 can provide map of error messages. Keys in the map are symbols matching names
 of basic validators:
+
 ```ruby
   error_overrides = {
     string:  "not a string",
@@ -410,9 +457,11 @@ of basic validators:
   errors_container = ComposableValidations::Errors.new(errors, error_overrides)
   result = validator.call(valid_data, errors_container, nil)
 ```
+
 Note that your error messages don't need to be strings. You could for example
 use rendering function that returns combination of error code, error context
 and human readable message:
+
 ```ruby
  error_overrides = {
     key_greater_than_key: lambda do |validated_object, path, key1, key2|
@@ -428,7 +477,9 @@ and human readable message:
   errors_container = ComposableValidations::Errors.new(errors, error_overrides)
   result = validator.call(valid_data, errors_container, nil)
 ```
+
 And when applied to invalid payload your validator will return an error:
+
 ```ruby
   {
     "store/opening_hours/wednesday/to"=>
@@ -441,15 +492,18 @@ And when applied to invalid payload your validator will return an error:
       ]
   }
 ```
+
 You can experiment with this example in the [specs](https://github.com/shutl/composable_validations/blob/master/spec/functional/error_overrides_spec.rb#L19).
 
 ### Override error container
 
 You can override error container class and provide any error collecting
 behaviour you need. The only method error container must provide is:
+
 ```ruby
 def add(msg, path, object)
 ```
+
 where
 * `msg` is a symbol of an error or an array where first element is a symbol of
 error and remaining elements are context needed to render the error message.
@@ -458,6 +512,7 @@ error and remaining elements are context needed to render the error message.
 * `object` is a validated object.
 
 Example of error container that just collects error paths:
+
 ```ruby
 class CollectPaths
   attr_reader :paths
@@ -475,18 +530,23 @@ validator = ...
 errors_container = CollectPaths.new
 result = validator.call(valid_data, errors_container, nil)
 ```
+
 and example of the value of `errors_container.paths` after getting an error:
+
 ```ruby
 [["store", "opening_hours", "wednesday", "to"]]
 ```
+
 You can experiment with this example in the [spec](https://github.com/shutl/composable_validations/blob/master/spec/functional/error_overrides_spec.rb#L80).
 
 ## Custom validators
 
 You can create your own validators as functions returning lambdas with signature
+
 ```ruby
 lambda { |validated_object, errors_hash, path| ... }
 ```
+
 Use `error` helper function to add errors to the error container and
 functions `validate`, `precheck` and `nil_or` to avoid boilerplate.
 
@@ -494,10 +554,13 @@ functions `validate`, `precheck` and `nil_or` to avoid boilerplate.
 
 Let's say we have an ActiveRecord model Store and API allowing update of the
 store name. We will be receiving payload:
+
 ```ruby
 { name: 'new store name' }
 ```
+
 We can build validator ensuring uniqueness of the store name:
+
 ```ruby
 a_hash(
   allowed_keys('name'),
@@ -505,7 +568,9 @@ a_hash(
     non_empty_string,
     unique_store_name))
 ```
+
 where `unique_store_name` is defined as:
+
 ```ruby
 def unique_store_name
   lambda do |store_name, errors, path|
@@ -517,7 +582,9 @@ def unique_store_name
   end
 end
 ```
+
 Note that we could simplify this code by using `validate` helper method:
+
 ```ruby
 def unique_store_name
   validate("has already been taken") do |store_name|
@@ -525,8 +592,10 @@ def unique_store_name
   end
 end
 ```
+
 We could also generalize this function and end up with generic ActiveModel
 attribute uniqueness validator ready to be reused:
+
 ```ruby
 def unique(klass, attr_name)
   validate("has already been taken") do |attr_value|
@@ -565,12 +634,14 @@ a_hash(
   default implementation of the error collection object. Returned function is
   not a composable validator so it should only be applied to the top level
   validator right before applying it to the object. Example:
+
   ```ruby
   errors = {}
   default_errors(validator).call(validated_object, errors)
   ```
 
 * `each_in_slice(range, validator)` - applies `validator` to each slice of the array. Example:
+
   ```ruby
   array(
     each_in_slice(0..-2, normal_element_validator),
@@ -699,6 +770,7 @@ a_hash(
   returns `true` if `&blk` returns `true` or applies all `validators` using
   `run_all` combinator if `&blk` returns `false`. Example - validate that value
   is a number but also allow value "infinity":
+
   ```ruby
   precheck(float) { |v| v == 'infinity' }
   ```
@@ -730,6 +802,8 @@ a_hash(
   returns `true` if `&blk` returns `true` and `false` otherwise. `msg` is an
   error message added to the error container when validation returns `false`.
   Example - ensure that validated object is equal "hello":
+
   ```ruby
   validate('must be "hello"') { |v| v == 'hello' }
   ```
+

data/lib/composable_validations/version.rb

@@ -1,3 +1,3 @@
 module ComposableValidations
-  VERSION = '0.0.9'
+  VERSION = '0.0.10'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: composable_validations
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.0.10
 platform: ruby
 authors:
 - Kajetan Bojko
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-09 00:00:00.000000000 Z
+date: 2016-02-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec