datacaster 3.1.2 → 3.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 22f1741420c172f91fba9bf20a341a785f609a7e0132e74bcd3a07e6069eaca4
-  data.tar.gz: 641fb863b7a40931f481d066e09062cddff1a4e3ff642d5981dacf9bfaa036eb
+  metadata.gz: 29c3f6c825f2c2d9a664e370079cde58df4ce9685d34d8428fb29aa7b98c52f3
+  data.tar.gz: 7d90ad442a4bd32ae4526d403629676c3aec9566973486bacd6565e8cb3d7bbd
 SHA512:
-  metadata.gz: 2a3573aac6a44ef0a5849da04325c9089119ad529cc6f6384d18bb6dda97f66358081c27d1fc260d95f7adaec5937bda7769cd9207ea9be6b01f2547f4425659
-  data.tar.gz: '04765854fbe156b3418728d4d2392b78ce0837ead8e1e72b76a51d55e6227bb68eebf8a98e672c924205bbe731610f21c72a1be355c51c2f014886ab160efdb7'
+  metadata.gz: acc11fefd17414ba1400bd98d2105b194301ac63f4d6b4204f001f918984326ab711c92d89133b475fd09d51b10c5d6427f6d6f516742a4ceb0a3eb2cf07f983
+  data.tar.gz: 07f288ab4e44e0b7a931aa43b34bac1a98d34d68f9d72241fc34f1648aeedc0412b51bdbe1113d9c34674a283e5fc6c559d4d2c5c385f5ec55c65d3b8345fb73

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)
@@ -414,6 +415,7 @@ Notice that shortcut definitions are available (illustrated in the example above
 
 * `switch(:key)` is exactly the same as `switch(pick(:key))` (works for a string, a symbol, or an array thereof)
 * `on(:key, ...)` is exactly the same as `on(compare(:key), ...)` (works for a string or a symbol)
+* `on(:key, ...)` will match on `:key` and `'key'` value, and the same is true for `on('key', ...)` (to disable that behavior provide `strict: true` keyword arg: `on('key', ..., strict: true)`)
 * `switch([caster], on_check => on_caster, ...)` is exactly the same as `switch([caster]).on(on_check, on_caster).on(...)`
 
 `switch()` without a `base` argument will pass the incoming value to the `.on(...)` casters.
@@ -523,6 +525,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.
@@ -633,7 +655,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:
 
@@ -686,15 +708,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:
+
+* 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.
 
-* `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
+Fetching single key:
 
 ```ruby
 pick_name = Datacaster.schema { pick(:name) }
@@ -705,9 +730,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) }
@@ -718,6 +741,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'`.
@@ -1322,7 +1354,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/lib/datacaster/config.rb

@@ -7,17 +7,14 @@ module Datacaster
     attr_accessor :i18n_module
 
     def add_predefined_caster(name, definition)
-      caster =
-        case definition
-        when Proc
-          Datacaster.partial_schema(&definition)
-        when Base
-          definition
-        else
-          raise ArgumentError.new("Expected Datacaster defintion lambda or Datacaster instance")
-        end
-
-      Predefined.define_method(name.to_sym) { caster }
+      case definition
+      when Proc
+        Predefined.define_method(name.to_sym, &definition)
+      when Base
+        Predefined.define_method(name.to_sym) { definition }
+      else
+        raise ArgumentError.new("Expected Datacaster defintion lambda or Datacaster instance")
+      end
     end
 
     def i18n_t

data/lib/datacaster/predefined.rb

@@ -54,15 +54,15 @@ module Datacaster
     end
 
     def schema(base)
-      ContextNodes::StructureCleaner.new(base, strategy: :fail)
+      ContextNodes::StructureCleaner.new(base, :fail)
     end
 
     def choosy_schema(base)
-      ContextNodes::StructureCleaner.new(base, strategy: :remove)
+      ContextNodes::StructureCleaner.new(base, :remove)
     end
 
     def partial_schema(base)
-      ContextNodes::StructureCleaner.new(base, strategy: :pass)
+      ContextNodes::StructureCleaner.new(base, :pass)
     end
 
     # 'Meta' types
@@ -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,46 +120,108 @@ module Datacaster
       end
     end
 
-    def transform_to_value(value)
-      transform { value }
+    def merge_message_keys(*keys)
+      MessageKeysMerger.new(keys)
+    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)
+    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
     end
 
-    # min_amount: has_relation(:min_amount, :>, :max_amount)
+    def pass
+      transform(&:itself)
+    end
+
+    def pass_if(base)
+      ContextNodes::PassIf.new(base)
+    end
+
+    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
+
+      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|
+            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 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
-        elsif !Datacaster.instance?(v)
-          raise RuntimeError, "expected #{k} to be String, Symbol, Integer or Datacaster::Base, but got #{v.inspect}", caller
         end
       end
 
-      if op.is_a?(Integer)
-        raise RuntimeError, "expected op to be String, Symbol or Datacaster::Base, but got #{op.inspect}", caller
-      end
-
-      if [left, op, right].none? { |x| Datacaster.instance?(x) }
+      if additional_vars.length == 3
         error_keys.unshift(".#{left}.#{op}.#{right}")
       end
       error_keys.unshift(error_key) if error_key
 
-      left = pick(left) unless Datacaster.instance?(left)
-      right = pick(right) unless Datacaster.instance?(right)
-      op_caster = op
-      unless Datacaster.instance?(op_caster)
-        op_caster = check { |(l, r)| l.respond_to?(op) && l.public_send(op, r) }
-      end
-
       cast do |value|
-        left_result = left.(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.(value)
+        right_result = right_caster.(value)
         next right_result unless right_result.valid?
         i18n_var!(:right, right_result.value) unless additional_vars.key?(:right)
 
@@ -154,71 +236,21 @@ module Datacaster
       transform { Datacaster.absent }
     end
 
-    def pass
-      transform(&:itself)
-    end
-
-    def switch(*base, **on_clauses)
-      switch =
-        if base.length == 0
-          SwitchNode.new
-        else
-          SwitchNode.new(base)
-        end
-      on_clauses.reduce(switch) do |result, (k, v)|
-        result.on(k, v)
-      end
-    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?
-
-      must_be(Enumerable) & transform { |value|
-        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]
-            end
-          end
-
-        keys.length == 1 ? result.first : result
-      }
-    end
-
-    def merge_message_keys(*keys)
-      MessageKeysMerger.new(keys)
-    end
-
     def responds_to(method, error_key = nil)
       error_keys = ['.responds_to', 'datacaster.errors.responds_to']
       error_keys.unshift(error_key) if error_key
       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

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
 
@@ -18,11 +16,18 @@ module Datacaster
       @else = else_caster
     end
 
-    def on(caster_or_value, clause)
+    def on(caster_or_value, clause, strict: false)
       caster =
         case caster_or_value
         when Datacaster::Base
           caster_or_value
+        when String, Symbol
+          if strict
+            Datacaster::Predefined.compare(caster_or_value)
+          else
+            Datacaster::Predefined.compare(caster_or_value.to_s) |
+              Datacaster::Predefined.compare(caster_or_value.to_sym)
+          end
         else
           Datacaster::Predefined.compare(caster_or_value)
         end

data/lib/datacaster/utils.rb

@@ -30,5 +30,11 @@ module Datacaster
 
       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.2"
+  VERSION = "3.1.5"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: datacaster
 version: !ruby/object:Gem::Version
-  version: 3.1.2
+  version: 3.1.5
 platform: ruby
 authors:
 - Eugene Zolotarev
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-10-05 00:00:00.000000000 Z
+date: 2023-10-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel