lib/datacaster/predefined.rb in datacaster-3.1.5 vs lib/datacaster/predefined.rb in datacaster-3.2.0

@@ -14,10 +14,14 @@
 
     def compare(value, error_key = nil)
       Comparator.new(value, error_key)
     end
 
+    def run(&block)
+      Runner.new(&block)
+    end
+
     def transform(&block)
       Transformer.new(&block)
     end
 
     def transform_if_present(&block)
@@ -43,10 +47,18 @@
         fields.transform_values { |f| DefinitionDSL.expand(f) },
         error_key
       )
     end
 
+    def strict_hash_schema(fields, error_key = nil)
+      schema(hash_schema(fields, error_key))
+    end
+
+    def choosy_hash_schema(fields, error_key = nil)
+      choosy_schema(hash_schema(fields, error_key))
+    end
+
     def transform_to_hash(fields)
       HashMapper.new(fields.transform_values { |x| DefinitionDSL.expand(x) })
     end
 
     def validate(active_model_validations)
@@ -63,10 +75,16 @@
 
     def partial_schema(base)
       ContextNodes::StructureCleaner.new(base, :pass)
     end
 
+    # 'Around' types
+
+    def cast_around(&block)
+      AroundNodes::Caster.new(&block)
+    end
+
     # 'Meta' types
 
     def absent(error_key = nil, on: nil)
       error_keys = ['.absent', 'datacaster.errors.absent']
       error_keys.unshift(error_key) if error_key
@@ -149,14 +167,18 @@
     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
+      if keys.empty?
+        raise RuntimeError, "pick(key, ...) accepts at least one argument", caller
       end
 
+      if wrong = keys.find { |k| !Datacaster::Utils.pickable?(k) }
+        raise RuntimeError, "each argument should be String, Symbol, Integer or an array thereof, instead got #{wrong.inspect}", 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
@@ -240,18 +262,36 @@
       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 steps(*casters)
+      AndNode.new(*casters)
+    end
+
     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 transform_to_value(value)
       transform { value }
+    end
+
+    def with(keys, caster)
+      keys = Array(keys)
+
+      unless Datacaster::Utils.pickable?(keys)
+        raise RuntimeError, "provide String, Symbol, Integer or an array thereof instead of #{keys.inspect}", caller
+      end
+
+      if keys.length == 1
+        return transform_to_hash(keys[0] => pick(keys[0]) & caster)
+      end
+
+      with(keys[0], must_be(Enumerable) & with(keys[1..-1], caster))
     end
 
     # Strict types
 
     def decimal(digits = 8, error_key = nil)