datacaster 2.0.2 → 3.1.0

data/lib/datacaster/hash_mapper.rb

@@ -13,21 +13,18 @@ module Datacaster
       @fields = fields
     end
 
-    def cast(object)
-      object = super(object)
-      # return Datacaster.ErrorResult(["must be hash"]) unless object.value.is_a?(Hash)
-
-      checked_schema = object.meta[:checked_schema].dup || {}
-
+    def cast(object, runtime:)
       errors = {}
       result = {}
 
+      runtime.will_check!
+
       @fields.each do |key, validator|
-        new_value = validator.(object)
+        new_value = runtime.ignore_checks! { validator.with_runtime(runtime).(object) }
 
         # transform_to_hash([:a, :b, :c] => pick(:a, :b, :c) & ...)
         if key.is_a?(Array)
-          unwrapped = new_value.valid? ? new_value.value : new_value.errors
+          unwrapped = new_value.valid? ? new_value.value : new_value.raw_errors
 
           if key.length != unwrapped.length
             raise TypeError.new("When using transform_to_hash([:a, :b, :c] => validator), validator should return Array "\
@@ -40,17 +37,17 @@ module Datacaster
           if key.is_a?(Array)
             key.zip(new_value.value) do |new_key, new_key_value|
               result[new_key] = new_key_value
-              checked_schema[new_key] = true
+              runtime.checked_key!(new_key)
             end
           else
             result[key] = new_value.value
-            checked_schema[key] = true
+            runtime.checked_key!(key)
           end
         else
           if key.is_a?(Array)
-            errors = self.class.merge_errors(errors, key.zip(new_value.errors).to_h)
+            errors = self.class.merge_errors(errors, key.zip(new_value.raw_errors).to_h)
           else
-            errors = self.class.merge_errors(errors, {key => new_value.errors})
+            errors = self.class.merge_errors(errors, {key => new_value.raw_errors})
           end
         end
       end
@@ -58,17 +55,17 @@ module Datacaster
       errors.delete_if { |_, v| v.empty? }
 
       if errors.empty?
-        # All unchecked key-value pairs of initial hash are passed through, and eliminated by Terminator
+        # All unchecked key-value pairs of initial hash are passed through, and eliminated by ContextNode
         # at the end of the chain. If we weren't dealing with the hash, then ignore that.
         result_hash =
-          if object.value.is_a?(Hash)
-            object.value.merge(result)
+          if object.is_a?(Hash)
+            object.merge(result)
           else
             result
           end
 
         result_hash.keys.each { |k| result_hash.delete(k) if result_hash[k] == Datacaster.absent }
-        Datacaster.ValidResult(result_hash, meta: {checked_schema: checked_schema})
+        Datacaster.ValidResult(result_hash)
       else
         Datacaster.ErrorResult(errors)
       end

data/lib/datacaster/hash_schema.rb

@@ -1,43 +1,42 @@
 module Datacaster
   class HashSchema < Base
-    def initialize(fields)
+    def initialize(fields, error_key = nil)
       @fields = fields
-      # support of shortcut nested validation definitions, e.g. array_schema(a: [integer], b: {c: integer})
-      @fields.transform_values! { |validator| shortcut_definition(validator) }
+
+      @error_keys = ['.hash_value', 'datacaster.errors.hash_value']
+      @error_keys.unshift(error_key) if error_key
     end
 
-    def cast(object)
-      object = super(object)
-      return Datacaster.ErrorResult(["must be hash"]) unless object.value.is_a?(Hash)
+    def cast(object, runtime:)
+      return Datacaster.ErrorResult(I18nValues::Key.new(@error_keys, value: object)) unless object.is_a?(Hash)
 
-      checked_schema = object.meta[:checked_schema].dup || {}
+      runtime.will_check!
 
       errors = {}
       result = {}
 
       @fields.each do |key, validator|
         value =
-          if object.value.key?(key)
-            object.value[key]
+          if object.key?(key)
+            object[key]
           else
             Datacaster.absent
           end
 
-        new_value = validator.(value)
+        new_value = runtime.checked_key!(key) { validator.with_runtime(runtime).(value) }
         if new_value.valid?
           result[key] = new_value.value
-          checked_schema[key] = new_value.meta[:checked_schema].dup || true
         else
-          errors[key] = new_value.errors
+          errors[key] = new_value.raw_errors
         end
       end
 
       if errors.empty?
-        # All unchecked key-value pairs are passed through, and eliminated by Terminator
+        # All unchecked key-value pairs are passed through, and eliminated by ContextNode
         # at the end of the chain
-        result_hash = object.value.merge(result)
+        result_hash = object.merge(result)
         result_hash.keys.each { |k| result_hash.delete(k) if result_hash[k] == Datacaster.absent }
-        Datacaster.ValidResult(result_hash, meta: {checked_schema: checked_schema})
+        Datacaster.ValidResult(result_hash)
       else
         Datacaster.ErrorResult(errors)
       end

data/lib/datacaster/i18n_values/base.rb

@@ -0,0 +1,87 @@
+module Datacaster
+  module I18nValues
+    class Base
+      attr_reader :args
+
+      def *(other, additional_scope = [])
+        # To allow redefine array/hash errors with #i18n_key
+        other = other.first if other.is_a?(Array) && other.length == 1
+        result = apply(other, additional_scope)
+
+        result = [result] unless result.is_a?(Array) || result.is_a?(Hash)
+        result
+      end
+
+      def ==(other)
+        self.class == other.class && @args == other.args
+      end
+
+      private
+
+      def apply(other, additional_scope = [])
+        if !other.is_a?(Base)
+          return apply_to_literal(other, additional_scope)
+        end
+
+        # Key(...) * Scope(...) -> error
+        if is_a?(Key) && !other.is_a?(Key)
+          raise RuntimeError.new("Can not apply #{inspect} to #{other.inspect}")
+        end
+
+        merged_args = other.args.merge(@args)
+
+        # Key(...) * Key(...) -> left
+        if is_a?(Key) && other.is_a?(Key)
+          return Key.new(@keys, merged_args)
+        end
+
+        # Scope('x') * Key(['.relative', 'full_path']) = Key(['x.relative', 'full_path'])
+        if is_a?(Scope) && other.is_a?(Key)
+          scoped_keys =
+            other.keys.flat_map do |x|
+              next x if x[0] != '.'
+
+              keys = ["#{@scope}#{x}"]
+              next keys if x.count('.') > 1
+
+              accumulator = ""
+              additional_scope.each do |k|
+                accumulator << ".#{k}"
+                keys.unshift "#{@scope}#{accumulator}#{x}"
+              end
+
+              keys
+            end
+          return Key.new(scoped_keys, merged_args)
+        end
+
+        # Scope(...) * Scope(...) -> error
+        raise RuntimeError.new("Can not apply #{inspect} to #{other.inspect}")
+      end
+
+      def apply_to_literal(other, additional_scope = [])
+        # Base * Other -> Other
+        return other if !other.is_a?(Hash) && !other.is_a?(Array)
+
+        # Key(...) * Array -> Array
+        # Key(...) * Hash -> Hash
+        return other if is_a?(Key)
+
+        # Scope(...) * Array -> map
+        return other.map { |x| self.*(x, additional_scope) } if other.is_a?(Array)
+
+        # Scope(...) * Hash -> map values
+        other.map do |(k, v)|
+          new_value =
+            case k
+            when String, Symbol
+              self.*(v, [*additional_scope, k])
+            else
+              self.*(v, [*additional_scope])
+            end
+          [k, new_value]
+        end.to_h
+      end
+    end
+  end
+end

data/lib/datacaster/i18n_values/key.rb

@@ -0,0 +1,34 @@
+module Datacaster
+  module I18nValues
+    class Key < Base
+      attr_reader :keys
+
+      def initialize(keys_or_key, args = {})
+        keys = Array(keys_or_key)
+        @keys = keys
+        @args = args
+      end
+
+      def ==(other)
+        super && @keys == other.keys
+      end
+
+      def resolve
+        keys = @keys.select { |x| x[0] != '.' }
+        if keys.empty?
+          raise RuntimeError.new("No absolute keys among #{@keys.inspect}. Use #i18n_key in addition to #i18n_scope.")
+        end
+        key = keys.find(&Config.i18n_exists?) || keys.first
+        Config.i18n_t.(key, **@args)
+      end
+
+      def with_args(args)
+        self.class.new(@keys, @args.merge(args))
+      end
+
+      def inspect
+        "#<#{self.class.name}(#{@keys.inspect}) #{@args.inspect}>"
+      end
+    end
+  end
+end

data/lib/datacaster/i18n_values/scope.rb

@@ -0,0 +1,28 @@
+module Datacaster
+  module I18nValues
+    class Scope < Base
+      attr_reader :scope
+
+      def initialize(scope, args = {})
+        @scope = scope
+        @args = args
+      end
+
+      def ==(other)
+        super && @scope == other.scope
+      end
+
+      def resolve
+        raise RuntimeError.new("Tried to resolve i18n scope #{@scope.inspect}. Use #i18n_key in addition to #i18n_scope.")
+      end
+
+      def with_args(args)
+        self.class.new(@scope, @args.merge(args))
+      end
+
+      def inspect
+        "#<#{self.class.name}(#{@scope.inspect}) #{@args.inspect}>"
+      end
+    end
+  end
+end

data/lib/datacaster/message_keys_merger.rb

@@ -4,11 +4,8 @@ module Datacaster
       @keys = keys
     end
 
-    def cast(object)
-      intermediary_result = super(object)
-      object = intermediary_result.value
-
-      return Datacaster.ErrorResult(["must be Hash"]) unless object.is_a?(Hash)
+    def cast(object, runtime:)
+      return Datacaster.ErrorResult(I18nValues::Key.new(['.hash_value', 'datacaster.errors.hash_value'], value: object)) unless object.is_a?(Hash)
 
       result = set_initial_value(object)
 
@@ -35,7 +32,7 @@ module Datacaster
     end
 
     def need_hash_merger?(object)
-      @need_hash_merger = 
+      @need_hash_merger =
         @need_hash_merger.nil? ? @keys.any? { |k| object[k].is_a?(Hash) } : @need_hash_merger
     end
 
@@ -44,7 +41,7 @@ module Datacaster
       unit = [unit] unless unit.is_a?(Array)
 
       result = clean(unit | merge_with)
-      result.uniq == [nil] || result == [] ? Datacaster.absent : result
+      result == [] ? Datacaster.absent : result
     end
 
     def value_or(value, default)
@@ -54,12 +51,8 @@ module Datacaster
     def merge_hash_with_hash(result, merge_with)
       if merge_with.is_a?(Hash)
         merge_with.each do |k, v|
-          if merge_with.is_a?(Hash)
-            result = value_or(result, {})
-            result[k] = merge_hash_with_hash(result[k], v)
-          else
-            result[k] = merge_array_or_scalar(value_or(result[k], []), v)
-          end
+          result = value_or(result, {})
+          result[k] = merge_hash_with_hash(result[k], v)
         end
 
         result
@@ -85,12 +78,12 @@ module Datacaster
       when Array
         value.delete_if do |v|
           clean(v) if v.is_a?(Hash) || v.is_a?(Array)
-          v == Datacaster.absent
+          v == Datacaster.absent || v == nil
         end
       when Hash
         value.delete_if do |_k, v|
           clean(v) if v.is_a?(Hash) || v.is_a?(Array)
-          v == Datacaster.absent
+          v == Datacaster.absent || v == nil
         end
       end
     end

data/lib/datacaster/or_node.rb

@@ -5,13 +5,12 @@ module Datacaster
       @right = right
     end
 
-    def cast(object)
-      object = super(object)
-      left_result = @left.(object)
+    def cast(object, runtime:)
+      left_result = @left.with_runtime(runtime).(object)
 
       return left_result if left_result.valid?
 
-      @right.(object)
+      @right.with_runtime(runtime).(object)
     end
 
     def inspect

data/lib/datacaster/predefined.rb

@@ -4,73 +4,124 @@ module Datacaster
 
     # Base types
 
-    def cast(name = 'Anonymous', &block)
-      Caster.new(name, &block)
+    def cast(&block)
+      Caster.new(&block)
     end
 
-    def check(name = 'Anonymous', error = 'is invalid', &block)
-      Checker.new(name, error, &block)
+    def check(error_key = nil, &block)
+      Checker.new(error_key, &block)
     end
 
-    def compare(value, name = 'Anonymous', error = nil)
-      Comparator.new(value, name, error)
+    def compare(value, error_key = nil)
+      Comparator.new(value, error_key)
     end
 
-    def transform(name = 'Anonymous', &block)
-      Transformer.new(name, &block)
+    def transform(&block)
+      Transformer.new(&block)
     end
 
-    def transform_if_present(name = 'Anonymous', &block)
+    def transform_if_present(&block)
       raise 'Expected block' unless block_given?
 
-      Transformer.new(name) { |v| v == Datacaster.absent ? v : block.(v) }
+      Transformer.new { |v| v == Datacaster.absent ? v : block.(v) }
     end
 
-    def try(name = 'Anonymous', error = 'is invalid', catched_exception:, &block)
-      Trier.new(name, error, catched_exception, &block)
+    def try(error_key = nil, catched_exception:, &block)
+      Trier.new(catched_exception, error_key, &block)
     end
 
-    def array_schema(element_caster)
-      ArraySchema.new(element_caster)
+    def array_schema(element_caster, error_keys = {})
+      ArraySchema.new(DefinitionDSL.expand(element_caster), error_keys)
     end
     alias_method :array_of, :array_schema
 
-    def hash_schema(fields)
-      HashSchema.new(fields)
+    def hash_schema(fields, error_key = nil)
+      unless fields.is_a?(Hash)
+        raise "Expected field definitions in a form of Hash for hash_schema, got #{fields.inspect} instead"
+      end
+      HashSchema.new(
+        fields.transform_values { |f| DefinitionDSL.expand(f) },
+        error_key
+      )
     end
 
     def transform_to_hash(fields)
-      HashMapper.new(fields)
+      HashMapper.new(fields.transform_values { |x| DefinitionDSL.expand(x) })
+    end
+
+    def validate(active_model_validations)
+      Validator.new(active_model_validations)
+    end
+
+    def schema(base)
+      ContextNodes::StructureCleaner.new(base, strategy: :fail)
+    end
+
+    def choosy_schema(base)
+      ContextNodes::StructureCleaner.new(base, strategy: :remove)
     end
 
-    def validate(active_model_validations, name = 'Anonymous')
-      Validator.new(active_model_validations, name)
+    def partial_schema(base)
+      ContextNodes::StructureCleaner.new(base, strategy: :pass)
     end
 
     # 'Meta' types
 
-    def absent
-      check('Absent', 'must be absent') { |x| x == Datacaster.absent }
+    def absent(error_key = nil)
+      error_keys = ['.absent', 'datacaster.errors.absent']
+      error_keys.unshift(error_key) if error_key
+      check { |x| x == Datacaster.absent }.i18n_key(*error_keys)
     end
 
-    def any
-      check('Any', 'must be set') { |x| x != Datacaster.absent }
+    def any(error_key = nil)
+      error_keys = ['.any', 'datacaster.errors.any']
+      error_keys.unshift(error_key) if error_key
+      check { |x| x != Datacaster.absent }.i18n_key(*error_keys)
+    end
+
+    def default(value, on: nil)
+      transform do |x|
+        if x == Datacaster.absent ||
+          (on && x.respond_to?(on) && x.public_send(on))
+          value
+        else
+          x
+        end
+      end
     end
 
     def transform_to_value(value)
-      transform('ToValue') { value }
+      transform { value }
     end
 
     def remove
-      transform('Remove') { Datacaster.absent }
+      transform { Datacaster.absent }
     end
 
     def pass
-      transform('Pass', &:itself)
+      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 pick(*keys)
-      must_be(Enumerable) & transform("Picker") { |value|
+    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)
@@ -90,12 +141,16 @@ module Datacaster
       MessageKeysMerger.new(keys)
     end
 
-    def responds_to(method)
-      check('RespondsTo', "must respond to #{method.inspect}") { |x| x.respond_to?(method) }
+    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)
-      check('MustBe', "must be #{klass.inspect}") { |x| x.is_a?(klass) }
+    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)
@@ -104,81 +159,111 @@ module Datacaster
 
     # Strict types
 
-    def decimal(digits = 8)
-      Trier.new('Decimal', 'must be decimal', [ArgumentError, TypeError]) do |x|
+    def decimal(digits = 8, error_key = nil)
+      error_keys = ['.decimal', 'datacaster.errors.decimal']
+      error_keys.unshift(error_key) if error_key
+
+      Trier.new([ArgumentError, TypeError]) do |x|
         # strictly validate format of string, BigDecimal() doesn't do that
         Float(x)
 
         BigDecimal(x, digits)
-      end
+      end.i18n_key(*error_keys)
     end
 
-    def array
-      check('Array', 'must be array') { |x| x.is_a?(Array) }
+    def array(error_key = nil)
+      error_keys = ['.array', 'datacaster.errors.array']
+      error_keys.unshift(error_key) if error_key
+      check { |x| x.is_a?(Array) }.i18n_key(*error_keys)
     end
 
-    def float
-      check('Float', 'must be float') {  |x| x.is_a?(Float) }
+    def float(error_key = nil)
+      error_keys = ['.float', 'datacaster.errors.float']
+      error_keys.unshift(error_key) if error_key
+      check { |x| x.is_a?(Float) }.i18n_key(*error_keys)
     end
 
-    # 'hash' is a bad method name, because it will overwrite built in Object#hash
-    def hash_value
-      check('Hash', 'must be hash') { |x| x.is_a?(Hash) }
+    # 'hash' would be a bad method name, because it would override built in Object#hash
+    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) }
     end
 
-    def hash_with_symbolized_keys
-      hash_value & transform("SymbolizeKeys") { |x| x.symbolize_keys }
+    def hash_with_symbolized_keys(error_key = nil)
+      hash_value(error_key) & transform { |x| x.symbolize_keys }
     end
 
-    def integer
-      check('Integer', 'must be integer') { |x| x.is_a?(Integer) }
+    def integer(error_key = nil)
+      error_keys = ['.integer', 'datacaster.errors.integer']
+      error_keys.unshift(error_key) if error_key
+      check { |x| x.is_a?(Integer) }.i18n_key(*error_keys)
     end
 
-    def integer32
-      integer & check('FourBytes', 'out of range') { |x| x.abs <= 2_147_483_647 }
+    def integer32(error_key = nil)
+      error_keys = ['.integer32', 'datacaster.errors.integer32']
+      error_keys.unshift(error_key) if error_key
+      integer(error_key) & check { |x| x.abs <= 2_147_483_647 }.i18n_key(*error_keys)
     end
 
-    def string
-      check('String', 'must be string') { |x| x.is_a?(String) }
+    def string(error_key = nil)
+      error_keys = ['.string', 'datacaster.errors.string']
+      error_keys.unshift(error_key) if error_key
+      check { |x| x.is_a?(String) }.i18n_key(*error_keys)
     end
 
-    def non_empty_string
-      string & check('NonEmptyString', 'must be present') { |x| !x.empty? }
+    def non_empty_string(error_key = nil)
+      error_keys = ['.non_empty_string', 'datacaster.errors.non_empty_string']
+      error_keys.unshift(error_key) if error_key
+      string(error_key) & check { |x| !x.empty? }.i18n_key(*error_keys)
     end
 
     # Form request types
 
-    def iso8601
-      string &
-        try('ISO8601', 'must be iso8601 string', catched_exception: [ArgumentError, TypeError]) { |x| DateTime.iso8601(x) }
+    def iso8601(error_key = nil)
+      error_keys = ['.iso8601', 'datacaster.errors.iso8601']
+      error_keys.unshift(error_key) if error_key
+
+      string(error_key) &
+        try(catched_exception: [ArgumentError, TypeError]) { |x| DateTime.iso8601(x) }.
+          i18n_key(*error_keys)
     end
 
-    def to_boolean
-      cast('ToBoolean') do |x|
+    def to_boolean(error_key = nil)
+      error_keys = ['.to_boolean', 'datacaster.errors.to_boolean']
+      error_keys.unshift(error_key) if error_key
+
+      cast do |x|
         if ['true', '1', true].include?(x)
           Datacaster.ValidResult(true)
         elsif ['false', '0', false].include?(x)
           Datacaster.ValidResult(false)
         else
-          Datacaster.ErrorResult(['must be boolean'])
+          Datacaster.ErrorResult(I18nValues::Key.new(error_keys, value: x))
         end
       end
     end
 
-    def to_float
-      Trier.new('ToFloat', 'must be float', [ArgumentError, TypeError]) do |x|
+    def to_float(error_key = nil)
+      error_keys = ['.to_float', 'datacaster.errors.to_float']
+      error_keys.unshift(error_key) if error_key
+
+      Trier.new([ArgumentError, TypeError]) do |x|
         Float(x)
-      end
+      end.i18n_key(*error_keys)
     end
 
-    def to_integer
-      Trier.new('ToInteger', 'must be integer', [ArgumentError, TypeError]) do |x|
+    def to_integer(error_key = nil)
+      error_keys = ['.to_integer', 'datacaster.errors.to_integer']
+      error_keys.unshift(error_key) if error_key
+
+      Trier.new([ArgumentError, TypeError]) do |x|
         Integer(x)
-      end
+      end.i18n_key(*error_keys)
     end
 
     def optional_param(base)
-      transform_if_present("optional_param(#{base.inspect})") { |x| x == '' ? Datacaster::Absent.instance : x } & (absent | base)
+      transform_if_present { |x| x == '' ? Datacaster::Absent.instance : x } & (absent | base)
     end
   end
 end