datacaster 3.1.1 → 3.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d563422d81d874ec9f74b4e95a3d24a7a59cf2c3f50ad709a226346616364882
-  data.tar.gz: e33c3dffdbff37e5ce711f56c0196e8955379764c98c2429ec391fd33819797d
+  metadata.gz: d7cd7191206c373ab38c5516505bf38cbbdc76a7b7c433f976498accda34b054
+  data.tar.gz: 0443edf8c8f494caeacfb55ba902cce19210a53cf9f726e8306f7e487de58fd8
 SHA512:
-  metadata.gz: d01eb486e4d11954f672e6958803b7ea4c60430c58850f2b4c8e8b16a500229c28a91ecadc45317775f7ff8098c4beddfb0373d415f72e5c917ccb1a93f589c8
-  data.tar.gz: c9bdb6f156a7de6eb81fa9cb87dcbf050fd47292d417afd4d085cb64a9e5460c4022b6471de723a1e112cd730a5b12e14c595e9ce248e30ff18fd84625a2cc8a
+  metadata.gz: 2f00d6cd8c2aae72cba3723dbea6b1c6cb9d760309e9fefa7897e5da691123459496348045849f47700f241df668e505120ba1d2e2f54c93a033e72b222dc3b9
+  data.tar.gz: 15c5d76c7cc7a16be05890bec3bcf549c0a5d103e9ba8bb42e2743c834e874bc1296fa5daa3af4feff93107d5acd8db2bd3b2da103f1c29aca1a169b86883c24

data/README.md

@@ -34,13 +34,14 @@ It is currently used in production in several projects (mainly as request parame
   - [Special types](#special-types)
     - [`absent(error_key = nil, on: nil)`](#absenterror_key--nil-on-nil)
     - [`any(error_key = nil)`](#anyerror_key--nil)
+    - [`attribute(*keys)`](#attributekeys)
     - [`default(default_value, on: nil)`](#defaultdefault_value-on-nil)
     - [`merge_message_keys(*keys)`](#merge_message_keyskeys)
     - [`must_be(klass, error_key = nil)`](#must_beklass-error_key--nil)
     - [`optional(base, on: nil)`](#optionalbase-on-nil)
     - [`pass`](#pass)
     - [`pass_if(base)`](#pass_ifbase)
-    - [`pick(key)`](#pickkey)
+    - [`pick(*keys)`](#pickkeys)
     - [`remove`](#remove)
     - [`responds_to(method, error_key = nil)`](#responds_tomethod-error_key--nil)
     - [`transform_to_value(value)`](#transform_to_valuevalue)
@@ -56,6 +57,8 @@ It is currently used in production in several projects (mainly as request parame
     - [`try(error_key = nil, catched_exception:) { |value| ... }`](#tryerror_key--nil-catched_exception--value--)
     - [`validate(active_model_validations, name = 'Anonymous')`](#validateactive_model_validations-name--anonymous)
     - [`compare(reference_value, error_key = nil)`](#comparereference_value-error_key--nil)
+    - [`included_in(*reference_values, error_key: nil)`](#included_inreference_values-error_key-nil)
+    - [`relate(left, op, right, error_key: nil)`](#relateleft-op-right-error_key-nil)
     - [`transform { |value| ... }`](#transform--value--)
     - [`transform_if_present { |value| ... }`](#transform_if_present--value--)
   - [Array schemas](#array-schemas)
@@ -175,10 +178,10 @@ array = Datacaster.schema { array }
 array.(nil)
 
 # In this README
-#=> Datacaster::ErrorResult(['should be an array'])
+# => Datacaster::ErrorResult(['should be an array'])
 
 # In reality
-#=> <Datacaster::ErrorResult([#<Datacaster::I18nValues::Key(.array, datacaster.errors.array) {:value=>nil}>])>
+# => <Datacaster::ErrorResult([#<Datacaster::I18nValues::Key(.array, datacaster.errors.array) {:value=>nil}>])>
 ```
 
 See [section on i18n](#internationalization-i18n) for details.
@@ -521,6 +524,26 @@ Returns ValidResult if and only if provided value is not `Datacaster.absent` (th
 
 I18n keys: `error_key`, `'.any'`, `'datacaster.errors.any'`
 
+#### `attribute(*keys)`
+
+Always returns ValidResult. Calls provided method(s) (recursively) on the value and returns their results. `*keys` should be specified in exactly the same manner as in [pick](#pickkeys).
+
+```ruby
+class User
+  def login
+    "Alex"
+  end
+end
+
+login = Datacaster.schema { attribute(:login) }
+
+# => Datacaster::ValidResult("Alex")
+login.(User.new)
+
+# => Datacaster::ValidResult(#<Datacaster.absent>)
+login.("test")
+```
+
 #### `default(default_value, on: nil)`
 
 Always returns ValidResult.
@@ -631,7 +654,7 @@ mapping.(
 
 See also `#cast_errors` for [error remapping](#error-remapping-cast_errors).
 
-See also `#pick` for [simpler picking of hash values](#pickkey).
+See also `#pick` for [simpler picking of hash values](#pickkeys).
 
 I18n keys:
 
@@ -684,15 +707,18 @@ Returns ValidResult if and only if base returns ValidResult. Returns base's erro
 
 Doesn't transform the value: if base succeeds returns the original value (not the one that base returned).
 
-#### `pick(key)`
+#### `pick(*keys)`
 
 Returns ValidResult if and only if the value `#is_a?(Enumerable)`.
 
-Transforms the value to/returns:
+Each argument should be a string, a Symbol, an integer or an array thereof. Each argument plays the role of key(s) to fetch from the value:
 
-* `value[key]` if key is set in the value
-* `nil` if `value[key]` is set and is nil
-* `Datacaster.absent` if key is not set
+* If the argument is an Array, value is extracted recursively
+* Otherwise, `value[argument]` is fetched and added to the result (or `Datacaster.absent` if is is impossible to fetch)
+
+If only one argument is provided to the `pick`, one fetched value is returned. If several arguments are provided, array is returned wherein each value corresponds to each argument.
+
+Fetching single key:
 
 ```ruby
 pick_name = Datacaster.schema { pick(:name) }
@@ -703,9 +729,7 @@ pick_name.(last_name: "Johnson") # => Datacaster::ValidResult(#<Datacaster.absen
 pick_name.("test")               # => Datacaster::ErrorResult(["is not Enumerable"])
 ```
 
-Alternative form could be used: `pick(*keys)`.
-
-In this case, an array of results is returned, each element in which corresponds to the element in `keys` array (i.e. is an argument of the `pick`) and evaluated in accordance with the above rules.
+Fetching multiple keys:
 
 ```ruby
 pick_name_and_age = Datacaster.schema { pick(:name, :age) }
@@ -716,6 +740,15 @@ pick_name_and_age.(last_name: "Johnson", age: 20) # => Datacaster::ValidResult([
 pick_name_and_age.("test")                        # => Datacaster::ErrorResult(["is not Enumerable"])
 ```
 
+Fetching deeply nested key:
+
+```ruby
+nested_hash_picker = Datacaster.schema { pick([:user, :age]) }
+
+nested_hash_picker.(user: { age: 21 })      # => Datacaster::ValidResult(21)
+nested_hash_picker.(user: { name: "Alex" }) # => Datacaster::ValidResult(#<Datacaster.absent>)
+```
+
 I18n keys:
 
 * not a Enumerable – `'.must_be'`, `'datacaster.errors.must_be'`.
@@ -882,8 +915,6 @@ I18n is performed by ActiveModel gem.
 
 #### `compare(reference_value, error_key = nil)`
 
-This type is the way to ensure some value in your schema is some predefined "constant".
-
 Returns ValidResult if and only if `reference_value` equals value.
 
 ```ruby
@@ -897,6 +928,50 @@ agreed_with_tos =
 
 I18n keys: `error_key`, `'.compare'`, `'datacaster.errors.compare'`. Adds `reference` i18n variable, setting it to `reference_value.to_s`.
 
+#### `included_in(*reference_values, error_key: nil)`
+
+Returns ValidResult if and only if `reference_values.include?` the value.
+
+I18n keys: `error_key`, `'.included_in'`, `'datacaster.errors.included_in'`. Adds `reference` i18n variable, setting it to `reference_values.map(&:to_s).join(', ')`.
+
+#### `relate(left, op, right, error_key: nil)`
+
+Returns ValidResult if and only if `left`, `right` and `op` returns valid result. Doesn't transform the value.
+
+Use `relate` to check relations between object keys:
+
+```ruby
+ordered =
+  # Check that hash[:a] < hash[:b]
+  Datacaster.schema do
+    transform_to_hash(
+      a: relate(:a, :<, :b) & pick(:a),
+      b: pick(:b)
+    )
+  end
+
+ordered.(a: 1, b: 2)
+# => Datacaster::ValidResult({:a=>1, :b=>2})
+
+ordered.(a: 2, b: 1)
+# => Datacaster::ErrorResult({:a=>["a should be < b"]})
+
+ordered.({})
+# => Datacaster::ErrorResult({:a=>["a should be < b"]})
+```
+
+Notice that shortcut definitions are available (illustrated in the example above) for the `relate` caster:
+
+* `:key` provided as 'left' or 'right' argument is exactly the same as `pick(:key)` (works for a string, a symbol or an integer)
+* `:method` provided as 'op' argument is exactly the same as `check { |(l, r)| l.respond_to?(method) && l.public_send(method, r) }` (works for a string or a symbol)
+
+Formally, `relate(left, op, right, error_key: error_key)` will:
+
+* call the `left` caster with the original value, return the result unless it's valid
+* call the `right` caster with the original value, return the result unless it's valid
+* call the `op` caster with the `[left_result, right_result]`, return the result unless it's valid
+* return the original value as valid result
+
 #### `transform { |value| ... }`
 
 Always returns ValidResult. Transforms the value: returns whatever the block has returned.
@@ -1278,7 +1353,7 @@ Note: in the "root" scope (immediately inside of `schema { ... }` block) the wor
 
 ### Mapping hashes: `transform_to_hash`
 
-One common task in processing compound data structures is to map one set of hash keys to another set. That's where `transform_to_hash` type comes to play (see also [`pick`](#pickkey) and [`remove`](#remove)).
+One common task in processing compound data structures is to map one set of hash keys to another set. That's where `transform_to_hash` type comes to play (see also [`pick`](#pickkeys) and [`remove`](#remove)).
 
 ```ruby
 city_with_distance =

data/config/locales/en.yml

@@ -11,10 +11,12 @@ en:
       empty: should not be empty
       float: is not a float
       hash_value: is not a hash
+      included_in: is not one of %{reference}
       integer: is not an integer
       integer32: is not a 32-bit integer
       iso8601: is not a string with ISO-8601 date and time
       must_be: "is not %{reference}"
+      relate: "%{left} should be %{op} %{right}"
       responds_to: "does not respond to %{reference}"
       string: is not a string
       to_boolean: does not look like a boolean

data/lib/datacaster/and_with_error_aggregation_node.rb

@@ -17,7 +17,7 @@ module Datacaster
         if right_result.valid?
           left_result
         else
-          Datacaster.ErrorResult(self.class.merge_errors(left_result.raw_errors, right_result.raw_errors))
+          Datacaster.ErrorResult(Utils.merge_errors(left_result.raw_errors, right_result.raw_errors))
         end
       end
     end

data/lib/datacaster/base.rb

@@ -1,97 +1,5 @@
 module Datacaster
   class Base
-    def self.merge_errors(left, right)
-      add_error_to_base = ->(hash, error) {
-        hash[:base] ||= []
-        hash[:base] = merge_errors(hash[:base], error)
-        hash
-      }
-
-      return [] if left.nil? && right.nil?
-      return right if left.nil?
-      return left if right.nil?
-
-      result = case [left.class, right.class]
-      when [Array, Array]
-        left | right
-      when [Array, Hash]
-        add_error_to_base.(right, left)
-      when [Hash, Hash]
-        (left.keys | right.keys).map do |k|
-          [k, merge_errors(left[k], right[k])]
-        end.to_h
-      when [Hash, Array]
-        add_error_to_base.(left, right)
-      else
-        raise ArgumentError.new("Expected failures to be Arrays or Hashes, left: #{left.inspect}, right: #{right.inspect}")
-      end
-
-      result
-    end
-
-    def &(other)
-      AndNode.new(self, other)
-    end
-
-    def |(other)
-      OrNode.new(self, other)
-    end
-
-    def *(other)
-      AndWithErrorAggregationNode.new(self, other)
-    end
-
-    def cast_errors(error_caster)
-      ContextNodes::ErrorsCaster.new(self, error_caster)
-    end
-
-    def then(other)
-      ThenNode.new(self, DefinitionDSL.expand(other))
-    end
-
-    def with_context(context)
-      unless context.is_a?(Hash)
-        raise "with_context expected Hash as argument, got #{context.inspect} instead"
-      end
-      ContextNodes::UserContext.new(self, context)
-    end
-
-    def call(object)
-      call_with_runtime(object, Runtimes::Base.new)
-    end
-
-    def call_with_runtime(object, runtime)
-      result = cast(object, runtime: runtime)
-      unless result.is_a?(Result)
-        raise RuntimeError.new("Caster should've returned Datacaster::Result, but returned #{result.inspect} instead")
-      end
-      result
-    end
-
-    def with_runtime(runtime)
-      ->(object) do
-        call_with_runtime(object, runtime)
-      end
-    end
-
-    def i18n_key(*keys, **args)
-      ContextNodes::I18n.new(self, I18nValues::Key.new(keys, args))
-    end
-
-    def i18n_map_keys(mapping)
-      ContextNodes::I18nKeysMapper.new(self, mapping)
-    end
-
-    def i18n_scope(scope, **args)
-      ContextNodes::I18n.new(self, I18nValues::Scope.new(scope, args))
-    end
-
-    def i18n_vars(vars)
-      ContextNodes::I18n.new(self, I18nValues::Scope.new(nil, vars))
-    end
-
-    def inspect
-      "#<Datacaster::Base>"
-    end
+    include Mixin
   end
 end

data/lib/datacaster/caster.rb

@@ -9,13 +9,13 @@ module Datacaster
     def cast(object, runtime:)
       result = Runtimes::Base.(runtime, @cast, object)
 
-      raise TypeError.new("Either Datacaster::Result or Dry::Monads::Result " \
-        "should be returned from cast block") unless [Datacaster::Result, Dry::Monads::Result].any? { |k| result.is_a?(k) }
-
-      if result.is_a?(Dry::Monads::Result)
+      if defined?(Dry::Monads::Result) && result.is_a?(Dry::Monads::Result)
         result = result.success? ? Datacaster.ValidResult(result.value!) : Datacaster.ErrorResult(result.failure)
       end
 
+      raise TypeError.new("Either Datacaster::Result or Dry::Monads::Result " \
+        "should be returned from cast block") unless result.is_a?(Datacaster::Result)
+
       result
     end
 

data/lib/datacaster/hash_mapper.rb

@@ -45,9 +45,9 @@ module Datacaster
           end
         else
           if key.is_a?(Array)
-            errors = self.class.merge_errors(errors, key.zip(new_value.raw_errors).to_h)
+            errors = Utils.merge_errors(errors, key.zip(new_value.raw_errors).to_h)
           else
-            errors = self.class.merge_errors(errors, {key => new_value.raw_errors})
+            errors = Utils.merge_errors(errors, {key => new_value.raw_errors})
           end
         end
       end

data/lib/datacaster/mixin.rb

@@ -0,0 +1,68 @@
+module Datacaster
+  module Mixin
+    def &(other)
+      AndNode.new(self, other)
+    end
+
+    def |(other)
+      OrNode.new(self, other)
+    end
+
+    def *(other)
+      AndWithErrorAggregationNode.new(self, other)
+    end
+
+    def cast_errors(error_caster)
+      ContextNodes::ErrorsCaster.new(self, error_caster)
+    end
+
+    def then(other)
+      ThenNode.new(self, DefinitionDSL.expand(other))
+    end
+
+    def with_context(context)
+      unless context.is_a?(Hash)
+        raise "with_context expected Hash as argument, got #{context.inspect} instead"
+      end
+      ContextNodes::UserContext.new(self, context)
+    end
+
+    def call(object)
+      call_with_runtime(object, Runtimes::Base.new)
+    end
+
+    def call_with_runtime(object, runtime)
+      result = cast(object, runtime: runtime)
+      unless result.is_a?(Result)
+        raise RuntimeError.new("Caster should've returned Datacaster::Result, but returned #{result.inspect} instead")
+      end
+      result
+    end
+
+    def with_runtime(runtime)
+      ->(object) do
+        call_with_runtime(object, runtime)
+      end
+    end
+
+    def i18n_key(*keys, **args)
+      ContextNodes::I18n.new(self, I18nValues::Key.new(keys, args))
+    end
+
+    def i18n_map_keys(mapping)
+      ContextNodes::I18nKeysMapper.new(self, mapping)
+    end
+
+    def i18n_scope(scope, **args)
+      ContextNodes::I18n.new(self, I18nValues::Scope.new(scope, args))
+    end
+
+    def i18n_vars(vars)
+      ContextNodes::I18n.new(self, I18nValues::Scope.new(nil, vars))
+    end
+
+    def inspect
+      "#<Datacaster::Base>"
+    end
+  end
+end

data/lib/datacaster/predefined.rb

@@ -89,6 +89,26 @@ module Datacaster
       check { |x| x != Datacaster.absent }.i18n_key(*error_keys)
     end
 
+    def attribute(*keys)
+      if keys.empty? || keys.any? { |k| !Datacaster::Utils.pickable?(k) }
+        raise RuntimeError, "each argument should be String, Symbol, Integer or an array thereof", caller
+      end
+
+      transform do |input|
+        result =
+          keys.map do |key|
+            Array(key).reduce(input) do |result, k|
+              if result.respond_to?(k)
+                result.public_send(k)
+              else
+                break Datacaster.absent
+              end
+            end
+          end
+        keys.length == 1 ? result.first : result
+      end
+    end
+
     def default(value, on: nil)
       transform do |x|
         if x == Datacaster.absent ||
@@ -100,55 +120,120 @@ module Datacaster
       end
     end
 
-    def transform_to_value(value)
-      transform { value }
-    end
-
-    def remove
-      transform { Datacaster.absent }
+    def merge_message_keys(*keys)
+      MessageKeysMerger.new(keys)
     end
 
-    def pass
-      transform(&:itself)
+    def must_be(klass, error_key = nil)
+      error_keys = ['.must_be', 'datacaster.errors.must_be']
+      error_keys.unshift(error_key) if error_key
+      check { |x| x.is_a?(klass) }.i18n_key(*error_keys, reference: klass.name)
     end
 
-    def switch(*base, **on_clauses)
-      switch =
-        if base.length == 0
-          SwitchNode.new
+    def optional(base, on: nil)
+      return absent | base if on == nil
+      cast do |x|
+        if x == Datacaster.absent ||
+          (!on.nil? && x.respond_to?(on) && x.public_send(on))
+          Datacaster.ValidResult(Datacaster.absent)
         else
-          SwitchNode.new(base)
+          base.(x)
         end
-      on_clauses.reduce(switch) do |result, (k, v)|
-        result.on(k, v)
       end
     end
 
+    def pass
+      transform(&:itself)
+    end
+
     def pass_if(base)
       ContextNodes::PassIf.new(base)
     end
 
-    def pick(*keys, strict: false)
-      raise RuntimeError.new("provide keys to pick, e.g. pick(:key)") if keys.empty?
+    def pick(*keys)
+      if keys.empty? || keys.any? { |k| !Datacaster::Utils.pickable?(k) }
+        raise RuntimeError, "each argument should be String, Symbol, Integer or an array thereof", caller
+      end
 
-      must_be(Enumerable) & transform { |value|
+      retrieve_key = -> (from, key) do
+        if from.respond_to?(:key?) && !from.key?(key)
+          Datacaster.absent
+        elsif from.respond_to?(:length) && key.is_a?(Integer) && key > 0 && key >= from.length
+          Datacaster.absent
+        elsif !from.respond_to?(:[])
+          Datacaster.absent
+        else
+          from[key]
+        end
+      end
+
+      must_be(Enumerable) & transform { |input|
         result =
           keys.map do |key|
-            if value.respond_to?(:key?) && !value.key?(key)
-              Datacaster.absent
-            elsif value.respond_to?(:length) && key.is_a?(Integer) && key > 0 && key >= value.length
-              Datacaster.absent
-            else
-              value[key]
+            Array(key).reduce(input) do |result, k|
+              result = retrieve_key.(result, k)
+              break result if result == Datacaster.absent
+              result
             end
           end
-
         keys.length == 1 ? result.first : result
       }
     end
 
-    def merge_message_keys(*keys)
-      MessageKeysMerger.new(keys)
+    def relate(left, op, right, error_key: nil)
+      error_keys = ['.relate', 'datacaster.errors.relate']
+      additional_vars = {}
+
+      left_caster = left
+      if Datacaster::Utils.pickable?(left)
+        left_caster = pick(left)
+      elsif !Datacaster.instance?(left)
+        raise RuntimeError, "provide String, Symbol, Integer or array thereof instead of #{left.inspect}", caller
+      end
+
+      right_caster = right
+      if Datacaster::Utils.pickable?(right)
+        right_caster = pick(right)
+      elsif !Datacaster.instance?(right)
+        raise RuntimeError, "provide String, Symbol, Integer or array thereof instead of #{right.inspect}", caller
+      end
+
+      op_caster = op
+      if op.is_a?(String) || op.is_a?(Symbol)
+        op_caster = check { |(l, r)| l.respond_to?(op) && l.public_send(op, r) }
+      elsif !Datacaster.instance?(left)
+        raise RuntimeError, "provide String or Symbol instead of #{op.inspect}", caller
+      end
+
+      {left: left, op: op, right: right}.each do |k, v|
+        if [String, Symbol, Integer].any? { |c| v.is_a?(c) }
+          additional_vars[k] = v
+        end
+      end
+
+      if additional_vars.length == 3
+        error_keys.unshift(".#{left}.#{op}.#{right}")
+      end
+      error_keys.unshift(error_key) if error_key
+
+      cast do |value|
+        left_result = left_caster.(value)
+        next left_result unless left_result.valid?
+        i18n_var!(:left, left_result.value) unless additional_vars.key?(:left)
+
+        right_result = right_caster.(value)
+        next right_result unless right_result.valid?
+        i18n_var!(:right, right_result.value) unless additional_vars.key?(:right)
+
+        result = op_caster.([left_result.value, right_result.value])
+        next Datacaster.ErrorResult([I18nValues::Key.new(error_keys)]) unless result.valid?
+
+        Datacaster.ValidResult(value)
+      end.i18n_vars(additional_vars)
+    end
+
+    def remove
+      transform { Datacaster.absent }
     end
 
     def responds_to(method, error_key = nil)
@@ -157,22 +242,15 @@ module Datacaster
       check { |x| x.respond_to?(method) }.i18n_key(*error_keys, reference: method.to_s)
     end
 
-    def must_be(klass, error_key = nil)
-      error_keys = ['.must_be', 'datacaster.errors.must_be']
-      error_keys.unshift(error_key) if error_key
-      check { |x| x.is_a?(klass) }.i18n_key(*error_keys, reference: klass.name)
+    def switch(base = nil, **on_clauses)
+      switch = SwitchNode.new(base)
+      on_clauses.reduce(switch) do |result, (k, v)|
+        result.on(k, v)
+      end
     end
 
-    def optional(base, on: nil)
-      return absent | base if on == nil
-      cast do |x|
-        if x == Datacaster.absent ||
-          (!on.nil? && x.respond_to?(on) && x.public_send(on))
-          Datacaster.ValidResult(Datacaster.absent)
-        else
-          base.(x)
-        end
-      end
+    def transform_to_value(value)
+      transform { value }
     end
 
     # Strict types
@@ -205,13 +283,19 @@ module Datacaster
     def hash_value(error_key = nil)
       error_keys = ['.hash_value', 'datacaster.errors.hash_value']
       error_keys.unshift(error_key) if error_key
-      check(error_key) { |x| x.is_a?(Hash) }
+      check { |x| x.is_a?(Hash) }.i18n_key(*error_keys)
     end
 
     def hash_with_symbolized_keys(error_key = nil)
       hash_value(error_key) & transform { |x| x.symbolize_keys }
     end
 
+    def included_in(*values, error_key: nil)
+      error_keys = ['.included_in', 'datacaster.errors.included_in']
+      error_keys.unshift(error_key) if error_key
+      check { |x| values.include?(x) }.i18n_key(*error_keys, reference: values.map(&:to_s).join(', '))
+    end
+
     def integer(error_key = nil)
       error_keys = ['.integer', 'datacaster.errors.integer']
       error_keys.unshift(error_key) if error_key

data/lib/datacaster/switch_node.rb

@@ -1,16 +1,14 @@
 module Datacaster
   class SwitchNode < Base
     def initialize(base = nil, on_casters = [], else_caster = nil)
-      base = base[0] if base.is_a?(Array) && base.length == 1
+      @base = base
 
-      case base
-      when nil
-        @base = nil
-      when Datacaster::Base
-        @base = base
-      when String, Symbol, Array
-        @base = Datacaster::Predefined.pick(base)
-      else
+      if Datacaster::Utils.pickable?(@base)
+        @base = Datacaster::Predefined.pick(@base)
+      end
+
+      if !@base.nil? && !Datacaster.instance?(@base)
+        puts @base.inspect
         raise RuntimeError, "provide a Datacaster::Base instance, a hash key, or an array of keys to switch(...) caster", caller
       end
 

data/lib/datacaster/utils.rb

@@ -0,0 +1,40 @@
+module Datacaster
+  module Utils
+    extend self
+
+    def merge_errors(left, right)
+      add_error_to_base = ->(hash, error) {
+        hash[:base] ||= []
+        hash[:base] = merge_errors(hash[:base], error)
+        hash
+      }
+
+      return [] if left.nil? && right.nil?
+      return right if left.nil?
+      return left if right.nil?
+
+      result = case [left.class, right.class]
+      when [Array, Array]
+        left | right
+      when [Array, Hash]
+        add_error_to_base.(right, left)
+      when [Hash, Hash]
+        (left.keys | right.keys).map do |k|
+          [k, merge_errors(left[k], right[k])]
+        end.to_h
+      when [Hash, Array]
+        add_error_to_base.(left, right)
+      else
+        raise ArgumentError.new("Expected failures to be Arrays or Hashes, left: #{left.inspect}, right: #{right.inspect}")
+      end
+
+      result
+    end
+
+    def pickable?(value)
+      is_literal = ->(v) { [String, Symbol, Integer].any? { |c| v.is_a?(c) } }
+      is_literal.(value) ||
+        value.is_a?(Array) && !value.empty? && value.all? { |v| is_literal.(v) }
+    end
+  end
+end

data/lib/datacaster/version.rb

@@ -1,3 +1,3 @@
 module Datacaster
-  VERSION = "3.1.1"
+  VERSION = "3.1.3"
 end

data/lib/datacaster.rb

@@ -24,6 +24,10 @@ module Datacaster
     Datacaster::Absent.instance
   end
 
+  def instance?(object)
+    object.is_a?(Mixin)
+  end
+
   private
 
   def build_schema(i18n_scope: nil, &block)
@@ -31,7 +35,7 @@ module Datacaster
 
     datacaster = DefinitionDSL.eval(&block)
 
-    unless datacaster.is_a?(Base)
+    unless Datacaster.instance?(datacaster)
       raise "Datacaster instance should be returned from a block (e.g. result of 'hash_schema(...)' call)"
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: datacaster
 version: !ruby/object:Gem::Version
-  version: 3.1.1
+  version: 3.1.3
 platform: ruby
 authors:
 - Eugene Zolotarev
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-10-02 00:00:00.000000000 Z
+date: 2023-10-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -150,6 +150,7 @@ files:
 - lib/datacaster/i18n_values/key.rb
 - lib/datacaster/i18n_values/scope.rb
 - lib/datacaster/message_keys_merger.rb
+- lib/datacaster/mixin.rb
 - lib/datacaster/or_node.rb
 - lib/datacaster/predefined.rb
 - lib/datacaster/result.rb
@@ -162,6 +163,7 @@ files:
 - lib/datacaster/then_node.rb
 - lib/datacaster/transformer.rb
 - lib/datacaster/trier.rb
+- lib/datacaster/utils.rb
 - lib/datacaster/validator.rb
 - lib/datacaster/version.rb
 homepage: https://github.com/EugZol/datacaster