datacaster 2.0.2 → 3.0.0

data/config/locales/en.yml

@@ -0,0 +1,24 @@
+en:
+  datacaster:
+    errors:
+      absent: should be absent
+      any: should be present
+      array: should be an array
+      cast: is invalid
+      check: is invalid
+      compare: "does not equal %{reference}"
+      decimal: is not a decimal number
+      empty: should not be empty
+      float: is not a float
+      hash_value: is not a hash
+      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}"
+      responds_to: "does not respond to %{reference}"
+      string: is not a string
+      to_boolean: does not look like a boolean
+      to_float: does not look like a float
+      to_integer: does not look like an integer
+      non_empty_string: should be non-empty string
+      try: raised an error

data/datacaster.gemspec

@@ -25,6 +25,8 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'activemodel', '>= 5.2'
   spec.add_development_dependency 'rake', '~> 12.0'
   spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'i18n', '~> 1.14'
 
   spec.add_runtime_dependency 'dry-monads', '>= 1.3', '< 1.4'
+  spec.add_runtime_dependency 'zeitwerk', '>= 2', '< 3'
 end

data/lib/datacaster/absent.rb

@@ -12,6 +12,10 @@ module Datacaster
       "#<Datacaster.absent>"
     end
 
+    def to_s
+      ""
+    end
+
     def present?
       false
     end

data/lib/datacaster/and_node.rb

@@ -5,13 +5,11 @@ 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 unless left_result.valid?
 
-      @right.(left_result)
+      @right.with_runtime(runtime).(left_result.value)
     end
 
     def inspect

data/lib/datacaster/and_with_error_aggregation_node.rb

@@ -7,18 +7,17 @@ module Datacaster
 
     # Works like AndNode, but doesn't stop at first error — in order to aggregate all Failures
     # Makes sense only for Hash Schemas
-    def cast(object)
-      object = super(object)
-      left_result = @left.(object)
+    def cast(object, runtime:)
+      left_result = @left.with_runtime(runtime).(object)
 
       if left_result.valid?
-        @right.(left_result)
+        @right.with_runtime(runtime).(left_result.value)
       else
-        right_result = @right.(object)
+        right_result = @right.with_runtime(runtime).(object)
         if right_result.valid?
           left_result
         else
-          Datacaster.ErrorResult(self.class.merge_errors(left_result.errors, right_result.errors))
+          Datacaster.ErrorResult(self.class.merge_errors(left_result.raw_errors, right_result.raw_errors))
         end
       end
     end

data/lib/datacaster/array_schema.rb

@@ -1,30 +1,32 @@
 module Datacaster
   class ArraySchema < Base
-    def initialize(element_caster)
-      # support of shortcut nested validation definitions, e.g. array_schema({a: [integer], b: {c: integer}})
-      @element_caster = shortcut_definition(element_caster)
-    end
+    def initialize(element_caster, error_keys = {})
+      @element_caster = element_caster
+
+      @not_array_error_keys = ['.array', 'datacaster.errors.array']
+      @not_array_error_keys.unshift(error_keys[:array]) if error_keys[:array]
 
-    def cast(object)
-      object = super(object)
-      checked_schema = object.meta[:checked_schema] || []
+      @empty_error_keys = ['.empty', 'datacaster.errors.empty']
+      @error_keys.unshift(error_keys[:empty]) if error_keys[:empty]
+    end
 
-      array = object.value
+    def cast(array, runtime:)
+      return Datacaster.ErrorResult(I18nValues::Key.new(@not_array_error_keys, value: array)) if !array.respond_to?(:map) || !array.respond_to?(:zip)
+      return Datacaster.ErrorResult(I18nValues::Key.new(@empty_error_keys, value: array)) if array.empty?
 
-      return Datacaster.ErrorResult(["must be array"]) if !array.respond_to?(:map) || !array.respond_to?(:zip)
-      return Datacaster.ErrorResult(["must not be empty"]) if array.empty?
+      runtime.will_check!
 
       result =
-        array.zip(checked_schema).map do |x, schema|
-          x = Datacaster.ValidResult(x, meta: {checked_schema: schema})
-          @element_caster.(x)
+        array.map.with_index do |x, i|
+          runtime.checked_key!(i) do
+            @element_caster.with_runtime(runtime).(x)
+          end
         end
 
       if result.all?(&:valid?)
-        checked_schema = result.map { |x| x.meta[:checked_schema] }
-        Datacaster.ValidResult(result.map(&:value), meta: {checked_schema: checked_schema})
+        Datacaster.ValidResult(result.map!(&:value))
       else
-        Datacaster.ErrorResult(result.each.with_index.reject { |x, _| x.valid? }.map { |x, i| [i, x.errors] }.to_h)
+        Datacaster.ErrorResult(result.each.with_index.reject { |x, _| x.valid? }.map { |x, i| [i, x.raw_errors] }.to_h)
       end
     end
 

data/lib/datacaster/base.rb

@@ -1,5 +1,3 @@
-require "ostruct"
-
 module Datacaster
   class Base
     def self.merge_errors(left, right)
@@ -43,66 +41,57 @@ module Datacaster
       AndWithErrorAggregationNode.new(self, other)
     end
 
-    def then(other)
-      ThenNode.new(self, other)
+    def cast_errors(error_caster)
+      ContextNodes::ErrorsCaster.new(self, error_caster)
     end
 
-    def set_definition_context(definition_context)
-      @definition_context = definition_context
+    def then(other)
+      ThenNode.new(self, other)
     end
 
-    def with_context(additional_context)
-      @definition_context.context = OpenStruct.new(additional_context)
-      self
+    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)
-      object = cast(object)
-
-      return object if object.valid? || @cast_errors.nil?
-
-      error_cast = @cast_errors.(object.errors)
+      call_with_runtime(object, Runtimes::Base.new)
+    end
 
-      raise "#cast_errors must return Datacaster.ValidResult, currently it is #{error_cast.inspect}" unless error_cast.valid?
+    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
 
-      Datacaster.ErrorResult(
-        @cast_errors.(object.errors).value,
-        meta: object.meta
-      )
+    def with_runtime(runtime)
+      ->(object) do
+        call_with_runtime(object, runtime)
+      end
     end
 
-    def cast_errors(object)
-      @cast_errors = shortcut_definition(object)
-      self
+    def i18n_key(*keys, **args)
+      ContextNodes::I18n.new(self, I18nValues::Key.new(keys, args))
     end
 
-    def inspect
-      "#<Datacaster::Base>"
+    def i18n_map_keys(mapping)
+      ContextNodes::I18nKeysMapper.new(self, mapping)
     end
 
-    private
+    def i18n_scope(scope, **args)
+      ContextNodes::I18n.new(self, I18nValues::Scope.new(scope, args))
+    end
 
-    def cast(object)
-      Datacaster.ValidResult(object)
+    def i18n_vars(vars)
+      ContextNodes::I18n.new(self, I18nValues::Scope.new(nil, vars))
     end
 
-    # Translates hashes like {a: <IntegerChecker>} to <HashSchema {a: <IntegerChecker>}>
-    #   and arrays like [<IntegerChecker>] to <ArraySchema <IntegerChecker>>
-    def shortcut_definition(definition)
-      case definition
-      when Datacaster::Base
-        definition
-      when Array
-        if definition.length != 1
-          raise ArgumentError.new("Datacaster: shortcut array definitions must have exactly 1 element in the array, e.g. [integer]")
-        end
-        ArraySchema.new(definition.first)
-      when Hash
-        HashSchema.new(definition)
-      else
-        return definition if definition.respond_to?(:call)
-        raise ArgumentError.new("Datacaster: Unknown definition #{definition.inspect}, which doesn't respond to #call")
-      end
+    def inspect
+      "#<Datacaster::Base>"
     end
   end
 end

data/lib/datacaster/caster.rb

@@ -1,17 +1,13 @@
 module Datacaster
   class Caster < Base
-    def initialize(name, &block)
+    def initialize(&block)
       raise "Expected block" unless block_given?
 
-      @name = name
       @cast = block
     end
 
-    def cast(object)
-      intermediary_result = super(object)
-      object = intermediary_result.value
-
-      result = @cast.(object)
+    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) }
@@ -24,7 +20,7 @@ module Datacaster
     end
 
     def inspect
-      "#<Datacaster::#{@name}Caster>"
+      "#<Datacaster::Caster>"
     end
   end
 end

data/lib/datacaster/checker.rb

@@ -1,26 +1,24 @@
 module Datacaster
   class Checker < Base
-    def initialize(name, error, &block)
+    def initialize(error_key = nil, &block)
       raise "Expected block" unless block_given?
 
-      @name = name
-      @error = error
+      @error_keys = ['.check', 'datacaster.errors.check']
+      @error_keys.unshift(error_key) if error_key
+
       @check = block
     end
 
-    def cast(object)
-      intermediary_result = super(object)
-      object = intermediary_result.value
-
-      if @check.(object)
+    def cast(object, runtime:)
+      if Runtimes::Base.(runtime, @check, object)
         Datacaster.ValidResult(object)
       else
-        Datacaster.ErrorResult([@error])
+        Datacaster.ErrorResult(I18nValues::Key.new(@error_keys, value: object))
       end
     end
 
     def inspect
-      "#<Datacaster::#{@name}Checker>"
+      "#<Datacaster::Checker>"
     end
   end
 end

data/lib/datacaster/comparator.rb

@@ -1,24 +1,24 @@
 module Datacaster
   class Comparator < Base
-    def initialize(value, name, error = nil)
+    def initialize(value, error_key = nil)
       @value = value
-      @name = name
-      @error = error || "must be equal to #{value.inspect}"
-    end
 
-    def cast(object)
-      intermediary_result = super(object)
-      object = intermediary_result.value
+      @error_keys = ['.compare', 'datacaster.errors.compare']
+      @error_keys.unshift(error_key) if error_key
+    end
 
+    def cast(object, runtime:)
       if @value == object
         Datacaster.ValidResult(object)
       else
-        Datacaster.ErrorResult([@error])
+        Datacaster.ErrorResult(
+          I18nValues::Key.new(@error_keys, reference: @value.inspect, value: object)
+        )
       end
     end
 
     def inspect
-      "#<Datacaster::#{@name}Comparator>"
+      "#<Datacaster::Comparator>"
     end
   end
 end

data/lib/datacaster/config.rb

@@ -2,6 +2,10 @@ module Datacaster
   module Config
     extend self
 
+    attr_accessor :i18n_t
+    attr_accessor :i18n_exists
+    attr_accessor :i18n_module
+
     def add_predefined_caster(name, definition)
       caster =
         case definition
@@ -15,5 +19,29 @@ module Datacaster
 
       Predefined.define_method(name.to_sym) { caster }
     end
+
+    def i18n_t
+      if @i18n_t.nil? && @i18n_module.nil?
+        i18n_initialize!
+      end
+      @i18n_t || ->(*args, **kwargs) { @i18n_module.t(*args, **kwargs) }
+    end
+
+    def i18n_exists?
+      if @i18n_t.nil? && @i18n_module.nil?
+        i18n_initialize!
+      end
+      @i18n_exists || ->(*args, **kwargs) { @i18n_module.exists?(*args, **kwargs) }
+    end
+
+    def i18n_initialize!
+      @i18n_module ||=
+        if defined?(::I18n)
+          I18n
+        else
+          SubstituteI18n
+        end
+      @i18n_module.load_path += [__dir__ + '/../../config/locales/en.yml']
+    end
   end
 end

data/lib/datacaster/context_node.rb

@@ -0,0 +1,43 @@
+module Datacaster
+  class ContextNode < Base
+    def initialize(base)
+      @base = base
+    end
+
+    def cast(object, runtime:)
+      @runtime = create_runtime(runtime)
+      result = @base.with_runtime(@runtime).call(object)
+      transform_result(result)
+    end
+
+    def inspect
+      "#<#{self.class.name} base: #{@base.inspect}>"
+    end
+
+    private
+
+    def create_runtime(parent)
+      parent
+    end
+
+    def runtime
+      @runtime
+    end
+
+    def transform_result(result)
+      if result.valid?
+        Datacaster.ValidResult(transform_success(result.value))
+      else
+        Datacaster.ErrorResult(transform_errors(result.raw_errors))
+      end
+    end
+
+    def transform_success(value)
+      value
+    end
+
+    def transform_errors(errors)
+      errors
+    end
+  end
+end

data/lib/datacaster/context_nodes/errors_caster.rb

@@ -0,0 +1,21 @@
+module Datacaster
+  module ContextNodes
+    class ErrorsCaster < Datacaster::ContextNode
+      def initialize(base, error_caster)
+        super(base)
+        @caster = error_caster
+      end
+
+      private
+
+      def transform_errors(errors)
+        result = @caster.with_runtime(@runtime).(errors)
+        if result.valid?
+          result.value
+        else
+          raise RuntimeError.new("Error caster tried to cast these errors: #{errors.inspect}, but didn't return ValidResult: #{result.inspect}")
+        end
+      end
+    end
+  end
+end

data/lib/datacaster/context_nodes/i18n.rb

@@ -0,0 +1,20 @@
+module Datacaster
+  module ContextNodes
+    class I18n < Datacaster::ContextNode
+      def initialize(base, i18n_value)
+        super(base)
+        @i18n_value = i18n_value
+      end
+
+      private
+
+      def create_runtime(parent)
+        Runtimes::I18n.new(parent)
+      end
+
+      def transform_errors(errors)
+        @i18n_value.with_args(runtime.args) * errors
+      end
+    end
+  end
+end

data/lib/datacaster/context_nodes/i18n_keys_mapper.rb

@@ -0,0 +1,27 @@
+module Datacaster
+  module ContextNodes
+    class I18nKeysMapper < Datacaster::ContextNode
+      def initialize(base, mapping)
+        super(base)
+        @mapping = mapping
+        @from_keys = @mapping.keys
+      end
+
+      private
+
+      def transform_errors(errors)
+        return errors unless errors.length == 1 && errors.is_a?(Array)
+
+        error = errors.first
+        return errors unless error.is_a?(I18nValues::Key) || error.is_a?(I18nValues::Key)
+
+        keys = error.respond_to?(:keys) ? error.keys : [error.key]
+        key_to_remap = keys.find { |x| @from_keys.include?(x) }
+        return errors if key_to_remap.nil?
+        new_key = @mapping[key_to_remap]
+
+        [I18nValues::Key.new(new_key, error.args)]
+      end
+    end
+  end
+end

data/lib/datacaster/context_nodes/structure_cleaner.rb

@@ -0,0 +1,103 @@
+module Datacaster
+  module ContextNodes
+    class StructureCleaner < Datacaster::ContextNode
+      def initialize(base, strategy = :fail)
+        super(base)
+
+        unless %i[fail remove pass].include?(strategy)
+          raise ArgumentError.new("Strategy should be :fail (return error on extra keys), :remove (remove extra keys) or :pass (ignore presence of extra keys)")
+        end
+
+        @strategy = strategy
+      end
+
+      def inspect
+        "#<#{self.class.name}(#{@strategy}) base: #{@base.inspect}>"
+      end
+
+      private
+
+      def create_runtime(parent)
+        Runtimes::StructureCleaner.new(parent)
+      end
+
+      def transform_result(result)
+        return result unless result.valid?
+        cast_success(result)
+      end
+
+      def cast_success(result)
+        return result if @strategy == :pass
+        return result if @runtime.unchecked?
+
+        cast_value(result, @runtime.checked_schema)
+      end
+
+      def cast_value(result, schema)
+        return result if schema == true
+
+        case result.value!
+        when Array
+          cast_array(result, schema)
+        when Hash
+          cast_hash(result, schema)
+        else
+          raise "Expected hash or array when checking #{value.inspect}"
+        end
+      end
+
+      def cast_array(result, schema)
+        value = result.value!
+
+        unchecked_indicies = value.each_index.to_a - schema.keys
+        if unchecked_indicies.any?
+          return Datacaster.ErrorResult(unchecked_indicies.map { |i| [i, 'must be absent'] }.to_h)
+        end
+
+        output =
+          value.map.with_index do |x, i|
+            cast_value(Datacaster.ValidResult(x), schema[i])
+          end
+
+        if output.all?(&:valid?)
+          Datacaster.ValidResult(output.map(&:value))
+        else
+          Datacaster.ErrorResult(output.each.with_index.reject { |x, _| x.valid? }.map { |x, i| [i, x.raw_errors] }.to_h)
+        end
+      end
+
+      def cast_hash(result, schema)
+        errors = {}
+        output = {}
+        value = result.value!
+
+        value.each do |(k, v)|
+          next if v == Datacaster.absent
+
+          unless schema.key?(k)
+            errors[k] = ['must be absent'] if @strategy == :fail
+            next
+          end
+
+          if schema[k] == true
+            output[k] = v
+            next
+          end
+
+          nested_value = cast_value(Datacaster.ValidResult(v), schema[k])
+          if nested_value.valid?
+            output[k] = nested_value.value
+          else
+            errors[k] = nested_value.raw_errors
+          end
+        end
+
+        if errors.empty?
+          Datacaster.ValidResult(output)
+        else
+          Datacaster.ErrorResult(errors)
+        end
+      end
+    end
+  end
+end

data/lib/datacaster/context_nodes/user_context.rb

@@ -0,0 +1,20 @@
+module Datacaster
+  module ContextNodes
+    class UserContext < Datacaster::ContextNode
+      def initialize(base, user_context)
+        super(base)
+        @user_context = user_context
+      end
+
+      def inspect
+        "#<#{self.class.name}(#{@user_context.inspect}) base: #{@base.inspect}>"
+      end
+
+      private
+
+      def create_runtime(parent)
+        Runtimes::UserContext.new(parent, @user_context)
+      end
+    end
+  end
+end

data/lib/datacaster/definition_dsl.rb

@@ -0,0 +1,37 @@
+require 'bigdecimal'
+require 'date'
+
+module Datacaster
+  class DefinitionDSL
+    include Datacaster::Predefined
+    include Dry::Monads[:result]
+
+    # Translates hashes like {a: <IntegerChecker>} to <HashSchema {a: <IntegerChecker>}>
+    #   and arrays like [<IntegerChecker>] to <ArraySchema <IntegerChecker>>
+    def self.expand(definition)
+      case definition
+      when Datacaster::Base
+        definition
+      when Array
+        if definition.length != 1
+          raise ArgumentError.new("Datacaster: DSL array definitions must have exactly 1 element in the array, e.g. [integer]")
+        end
+        ArraySchema.new(expand(definition.first))
+      when Hash
+        HashSchema.new(definition.transform_values { |x| expand(x) })
+      else
+        return definition if definition.respond_to?(:call)
+        raise ArgumentError.new("Datacaster: Unknown definition #{definition.inspect}, which doesn't respond to #call")
+      end
+    end
+
+    def self.eval(&block)
+      new.instance_exec(&block)
+    end
+
+    def method_missing(m, *args)
+      arg_string = args.empty? ? "" : "(#{args.map(&:inspect).join(', ')})"
+      raise RuntimeError, "Datacaster: unknown definition '#{m}#{arg_string}'", caller
+    end
+  end
+end