datacaster 5.0.1 → 6.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a0e209179b85f6f4ca1b63face9260b3d8c03e7c09796e124c4606e9f8ff0431
-  data.tar.gz: 15b4b5228319b5ff7d670dfd8f23883e714b1017ccc85dc0a3df920a142a0627
+  metadata.gz: f66df22c1ea20054ae2b16ea8ccbd778b8aac71e7898bc763036e3c4f9ba50da
+  data.tar.gz: bad95a5182fdbbefe72c5c8f5b724c433f26cc5d676a755dcb0af554e07d95ca
 SHA512:
-  metadata.gz: 966d31dc9b9b397ced3bece4e3a74f0c885e5b95dfebe3a35374a85c50afb4bd183222e56095730fbca3c52b079a277f8f43106c14d69192f95032d771a67a18
-  data.tar.gz: 12043768c2e341338af7f1178aca2dead9ffd43c8189f4a2df44ca1114768aaa8fbc465e3d23c4a8e2a41162c8f73c35d789b091e18cbe67e1b5afe90214f2bc
+  metadata.gz: f6f707de2a1555d6dbc7756b60e8a981de97f137787dc5212b78807060d43877e0c5b18f3ad191262eabb618bed356feb32e9d96d3adf93b14bbbbe73bf2452b
+  data.tar.gz: 8612f9609a9d1c9a8a9de4358ee66c30458158598917a3e59d09fb83582a8cdc68f7c395f577179363407fd63cbd9f72d4864b77ee957f4e4e63f6a2aad746f2

data/README.md

@@ -34,6 +34,7 @@ It is currently used in production in several projects (mainly as request parame
     - [`maximum(max, error_key = nil, inclusive: true)`](#maximummax-error_key--nil-inclusive-true)
     - [`minimum(min, error_key = nil, inclusive: true)`](#minimummin-error_key--nil-inclusive-true)
     - [`non_empty_string(error_key = nil)`](#non_empty_stringerror_key--nil)
+    - [`non_empty_array(error_keys = {}`](#non_empty_arrayerror_keys--)
     - [`pattern(regexp, error_key = nil)`](#patternregexp-error_key--nil)
     - [`uuid(error_key = nil)`](#uuiderror_key--nil)
   - [Special types](#special-types)
@@ -159,7 +160,7 @@ validator.("test")  # Datacaster::ErrorResult(["is invalid"])
 
 In the code above we ensure that validated value is:
 
-a) a string,  
+a) a string,\
 b) has length > 5.
 
 If first condition is not met, second one is not evaluated at all (i.e. evaluation is always "short-circuit", just as one might expect).
@@ -203,9 +204,9 @@ Validating hashes is the main case scenario for datacaster. Several specific con
 
 Let's assume we want to validate that a hash (which represents data about a person):
 
-a) is, in fact, a Hash;  
-b) has exactly 2 keys, `name` and `salary`,  
-c) key 'name' is a string,  
+a) is, in fact, a Hash;\
+b) has exactly 2 keys, `name` and `salary`,\
+c) key 'name' is a string,\
 d) key 'salary' is an integer:
 
 ```ruby
@@ -332,7 +333,7 @@ Notice that OR operator, if left-hand validation fails, passes the original valu
 
 #### *IF... THEN... ELSE operator*
 
-Let's support we want to run different validations depending on some value, e.g.:
+Let's suppose we want to run different validations depending on some value, e.g.:
 
 * if 'salary' is more than 100_000, check for the additional key, 'passport'
 * otherwise, ensure 'passport' key is absent
@@ -373,7 +374,7 @@ Formally, with `a.then(b).else(c)`:
 
 Note: this construct is *not* an equivalent of `a & b | c`.
 
-With `a.then(b).else(c)` if `a` and `b` fails, then `b`'s error is returned. With `a & b | c`, instead, `c`'s result would be returned.
+With `a.then(b).else(c)` if `a` passes and `b` fails, then `b`'s error is returned. With `a & b | c`, instead, `c`'s result would be returned.
 
 #### *SWITCH... ON... ELSE operator*
 
@@ -561,6 +562,15 @@ I18n keys:
 * not a string – `error_key`, `'.string'`, `'datacaster.errors.string'`
 * is empty – `error_key`, `'.non_empty_string'`, `'datacaster.errors.non_empty_string'`
 
+#### `non_empty_array(error_keys = {})`
+
+Returns ValidResult if and only if provided value is an array and is not empty. Doesn't transform the value.
+
+I18n keys:
+
+* not an array – `error_keys[:array]`, `'.array'`, `'datacaster.errors.array'`
+* empty array – `error_keys[:empty]`, `'.empty'`, `'datacaster.errors.empty'`
+
 #### `pattern(regexp, error_key = nil)`
 
 Returns ValidResult if and only if provided value is a string and satisfies regexp. Doesn't transform the value. Don't forget to provide start/end markers in the regexp if needed, e.g. `/\A\d+\z/` for digits-only string.
@@ -742,7 +752,7 @@ I18n keys:
 
 Returns ValidResult if and only if the value `#is_a?(klass)`. Doesn't transform the value.
 
-I18n keys: `error_key`,  `'.must_be'`, `'datacaster.errors.must_be'`. Adds `reference` i18n variable, setting it to `klass.name`. 
+I18n keys: `error_key`,  `'.must_be'`, `'datacaster.errors.must_be'`. Adds `reference` i18n variable, setting it to `klass.name`.
 
 #### `optional(base, on: nil)`
 
@@ -1128,13 +1138,13 @@ To define compound data type, array of 'something', use `array_schema(something)
 salaries = Datacaster.schema { array_of(integer) }
 
 salaries.([1000, 2000, 3000]) # Datacaster::ValidResult([1000, 2000, 3000])
+salaries.([])                 # Datacaster::ValidResult([])
 
 salaries.(["one thousand"])   # Datacaster::ErrorResult({0=>["is not an integer"]})
 salaries.(:not_an_array)      # Datacaster::ErrorResult(["should be an array"])
-salaries.([])                 # Datacaster::ErrorResult(["should not be empty"])
 ```
 
-To allow empty array use the following construct: `compare([]) | array_of(...)`.
+To disallow empty array use the following construct: `array_of(..., allow_empty: false)`.
 
 If you want to define an array of hashes, [shortcut definition](#shortcut-nested-definitions) could be used: instead of `array_of(hash_schema({...}))` use `array_of({...})`:
 
@@ -1162,12 +1172,12 @@ Notice that extra keys of inner hashes could be validated only if each element i
 
 Formally, `array_of(x, error_keys = {})` will return ValidResult if and only if:
 
-a) provided value implements basic array methods (`#map`, `#zip`),  
-b) provided value is not `#empty?`,  
+a) provided value implements basic array methods (`#map`, `#zip`),\
+b) provided value is not `#empty?`,\
 c) each element of the provided value passes validation of `x`.
 
-If a) fails, `ErrorResult(["should be an array"]) is returned. 
-If b) fails, `ErrorResult(["should not be empty"])` is returned.  
+If a) fails, `ErrorResult(["should be an array"])` is returned.\
+If b) fails, `ErrorResult(["should not be empty"])` is returned.\
 If c) fails, `ErrorResult({0 => ..., 1 => ...})` is returned. Wrapped hash contains keys which correspond to initial array's indices, and values correspond to failure returned from `x` validator, called for the corresponding element.
 
 Array schema transforms array if inner type (`x`) transforms element (in this case `array_schema` works more or less like `map` function). Otherwise, it doesn't transform.
@@ -1201,12 +1211,12 @@ person.(name: "John Smith", salary: "100_000")
 
 Formally, hash schema returns ValidResult if and only if:
 
-a) provided value `is_a?(Hash)`,  
-b) all values, fetched by keys mentioned in `hash_schema(...)` definition, pass corresponding validations,  
+a) provided value `is_a?(Hash)`,\
+b) all values, fetched by keys mentioned in `hash_schema(...)` definition, pass corresponding validations,\
 c) after all checks (including logical operators), there are no unchecked keys in the hash.
 
-If a) fails, `ErrorResult(["is not a hash"])` is returned.  
-if b) fails, `ErrorResult(key1 => [errors...], key2 => [errors...])` is returned. Each key of wrapped "error hash" corresponds to the key of validated hash, and each value of "error hash" contains array of errors, returned by the corresponding validator.  
+If a) fails, `ErrorResult(["is not a hash"])` is returned.\
+if b) fails, `ErrorResult(key1 => [errors...], key2 => [errors...])` is returned. Each key of wrapped "error hash" corresponds to the key of validated hash, and each value of "error hash" contains array of errors, returned by the corresponding validator.\
 If b) is fulfilled, then and only then validated hash is checked for extra keys. If they are found, `ErrorResult(extra_key_1 => ["should be absent"], ...)` is returned.
 
 I18n keys:
@@ -1371,11 +1381,11 @@ Had we used `schema` everywhere, `CommonFieldsValidator` would return failure fo
 
 As a rule of thumb, use `partial_schema` in any "intermediary" validators (extracted for the sake of clarity of code and reusability) and use `schema` in any "end" validators (ones which receive full record as input and use intermediary validators behind the scenes).
 
-Lastly, if you want to just delete extra unvalidated keys without returning a error, use `choosy_schema`.
+Lastly, if you want to just delete extra unvalidated keys without returning an error, use `choosy_schema`.
 
 #### AND with error aggregation (`*`)
 
-Often it is useful to run validator which are "further down the conveyor" (i.e. placed at the right-hand side of AND operator `&`) even if current (i.e. left-hand side) validator has failed.
+Often it is useful to run validators which are "further down the conveyor" (i.e. placed at the right-hand side of AND operator `&`) even if current (i.e. left-hand side) validator has failed.
 
 Let's say we have extracted some "common validations" and have some concrete validators, which utilize these reusable common validations (more or less repeating the motif of the previous example, shortening non-essential for this section parts for clarity):
 
@@ -1500,10 +1510,10 @@ Of course, order of keys in the definition hash doesn't change the result.
 
 Formally, `transform_to_hash`:
 
-a) transforms (any) value to hash;  
-b) this hash will contain keys listed in `transform_to_hash` definition;  
-c) value of these keys will be: initial value (*not the corresponding key of it, the value altogether*) transformed with the corresponding validator/type;  
-d) if any of the values from c) happen to be `Datacaster.absent`, this value *with its key* is removed from the resultant hash;  
+a) transforms (any) value to hash;\
+b) this hash will contain keys listed in `transform_to_hash` definition;\
+c) value of these keys will be: initial value (*not the corresponding key of it, the value altogether*) transformed with the corresponding validator/type;\
+d) if any of the values from c) happen to be `Datacaster.absent`, this value *with its key* is removed from the resultant hash;\
 e) if the initial value happens to also be a hash, all its unvalidated (unused) keys are merged to the resultant hash.
 
 `transform_to_hash` will return ValidResult if and only if all transformations return ValidResults.
@@ -1793,7 +1803,7 @@ All keyword arguments of `#i18n_key`, `#i18n_scope` and designed for that sole p
 
 It is possible to add i18n variables at the runtime (e.g. inside `check { ... }` block) by calling `i18n_vars!(variable: 'value')` or `i18n_var!(:variable, 'value')`.
 
-Outer calls of `#i18n_key` (`#i18n_scope`, `#i18n_vars`) have presedence before the inner if variable names collide. However, runtime calls of `#i18n_vars!` and `#i18n_var!` overwrite compile-time variables from the next nearest key, scope or vars on collision.
+Outer calls of `#i18n_key` (`#i18n_scope`, `#i18n_vars`) have precedence before the inner if variable names collide. However, runtime calls of `#i18n_vars!` and `#i18n_var!` overwrite compile-time variables from the next nearest key, scope or vars on collision.
 
 ## Registering custom 'predefined' types
 

data/lib/datacaster/array_schema.rb

@@ -1,6 +1,6 @@
 module Datacaster
   class ArraySchema < Base
-    def initialize(element_caster, error_keys = {}, allow_empty: false)
+    def initialize(element_caster, error_keys = {}, allow_empty: true)
       @element_caster = element_caster
       @allow_empty = allow_empty
 

data/lib/datacaster/predefined.rb

@@ -40,7 +40,7 @@ module Datacaster
       Trier.new(catched_exception, error_key, &block)
     end
 
-    def array_schema(element_caster, error_keys = {}, allow_empty: false)
+    def array_schema(element_caster, error_keys = {}, allow_empty: true)
       ArraySchema.new(DefinitionDSL.expand(element_caster), error_keys, allow_empty:)
     end
     alias_method :array_of, :array_schema
@@ -451,6 +451,10 @@ module Datacaster
       string(error_key) & check { |x| !x.empty? }.i18n_key(*error_keys)
     end
 
+    def non_empty_array(error_keys = {})
+      array_of(any, error_keys, allow_empty: false)
+    end
+
     def uuid(error_key = nil)
       error_keys = ['.uuid', 'datacaster.errors.uuid']
       error_keys.unshift(error_key) if error_key

data/lib/datacaster/version.rb

@@ -1,3 +1,3 @@
 module Datacaster
-  VERSION = "5.0.1"
+  VERSION = "6.0.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: datacaster
 version: !ruby/object:Gem::Version
-  version: 5.0.1
+  version: 6.0.2
 platform: ruby
 authors:
 - Eugene Zolotarev
-autorequire:
+autorequire: 
 bindir: exe
 cert_chain: []
-date: 2025-06-05 00:00:00.000000000 Z
+date: 2025-10-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -106,7 +106,7 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '3'
-description:
+description: 
 email:
 - eugzol@gmail.com
 executables: []
@@ -181,7 +181,7 @@ licenses:
 - MIT
 metadata:
   source_code_uri: https://github.com/EugZol/datacaster
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -196,8 +196,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.20
-signing_key:
+rubygems_version: 3.1.6
+signing_key: 
 specification_version: 4
 summary: Run-time type checker and transformer for Ruby
 test_files: []