datacaster 2.0.2 → 3.1.0

data/lib/datacaster/result.rb

@@ -1,14 +1,12 @@
-require 'dry/monads'
-
 module Datacaster
   class Result
-    attr_accessor :meta
-    include Dry::Monads[:result]
-
-    def initialize(valid, value_or_errors, meta: nil)
+    def initialize(valid, value_or_errors)
       @value_or_errors = value_or_errors
+      if !valid && !@value_or_errors.is_a?(Hash) && !@value_or_errors.is_a?(Array)
+        @value_or_errors = Array(@value_or_errors)
+      end
+
       @valid = !!valid
-      @meta = meta || {}
     end
 
     def valid?
@@ -19,13 +17,19 @@ module Datacaster
       @valid ? @value_or_errors : nil
     end
 
-    def errors
-      unless @value_or_errors.is_a?(Hash) || @value_or_errors.is_a?(Array)
-        @value_or_errors = Array(@value_or_errors)
-      end
+    def value!
+      raise "Tried to unwrap value of error result: #{inspect}" unless valid?
+      value
+    end
+
+    def raw_errors
       @valid ? nil : @value_or_errors
     end
 
+    def errors
+      @errors ||= @valid ? nil : resolve_i18n(raw_errors)
+    end
+
     def inspect
       if @valid
         "#<Datacaster::ValidResult(#{@value_or_errors.inspect})>"
@@ -35,27 +39,44 @@ module Datacaster
     end
 
     def to_dry_result
-      @valid ? Success(@value_or_errors) : Failure(@value_or_errors)
+      if @valid
+        Dry::Monads::Result::Success.new(@value_or_errors)
+      else
+        Dry::Monads::Result::Failure.new(errors)
+      end
+    end
+
+    private
+
+    def resolve_i18n(o)
+      case o
+      when Array
+        o.map { |x| resolve_i18n(x) }
+      when Hash
+        o.transform_values { |x| resolve_i18n(x) }
+      when I18nValues::Base
+        o.resolve
+      else
+        o
+      end
     end
   end
 
-  def self.ValidResult(object, meta: nil)
+  def self.ValidResult(object)
     if object.is_a?(Result)
       raise "Can't create valid result from error #{object.inspect}" unless object.valid?
-      object.meta = meta if meta
       object
     else
-      Result.new(true, object, meta: meta)
+      Result.new(true, object)
     end
   end
 
-  def self.ErrorResult(object, meta: nil)
+  def self.ErrorResult(object)
     if object.is_a?(Result)
       raise "Can't create error result from valid #{object.inspect}" if object.valid?
-      object.meta = meta if meta
       object
     else
-      Result.new(false, object, meta: meta)
+      Result.new(false, object)
     end
   end
 end

data/lib/datacaster/runtimes/base.rb

@@ -0,0 +1,47 @@
+module Datacaster
+  module Runtimes
+    class Base
+      def self.call(r, proc, *args)
+        r.instance_exec(*args, &proc)
+      end
+
+      def self.send_to_parent(r, m, *args, &block)
+        parent = r.instance_variable_get(:@parent)
+        not_found!(m) if parent.nil?
+        call(parent, -> { public_send(m, *args, &block) })
+      end
+
+      def self.not_found!(m)
+        raise NoMethodError.new("Method #{m.inspect} is not available in current runtime context")
+      end
+
+      def initialize(parent = nil)
+        @parent = parent
+      end
+
+      def method_missing(m, *args, &block)
+        self.class.send_to_parent(self, m, *args, &block)
+      end
+
+      def respond_to_missing?(m, include_private = false)
+        !@parent.nil? && @parent.respond_to?(m, include_private)
+      end
+
+      def inspect
+        "#<#{self.class.name} parent: #{@parent.inspect}>"
+      end
+
+      def to_s
+        inspect
+      end
+
+      def Success(v)
+        Datacaster.ValidResult(v)
+      end
+
+      def Failure(v)
+        Datacaster.ErrorResult(v)
+      end
+    end
+  end
+end

data/lib/datacaster/runtimes/i18n.rb

@@ -0,0 +1,20 @@
+module Datacaster
+  module Runtimes
+    class I18n < Base
+      attr_reader :args
+
+      def initialize(*)
+        super
+        @args = {}
+      end
+
+      def i18n_var!(name, value)
+        @args[name] = value
+      end
+
+      def i18n_vars!(map)
+        @args.merge!(map)
+      end
+    end
+  end
+end

data/lib/datacaster/runtimes/structure_cleaner.rb

@@ -0,0 +1,47 @@
+module Datacaster
+  module Runtimes
+    class StructureCleaner < Base
+      attr_reader :checked_schema
+
+      def initialize(*)
+        super
+        @checked_schema = {}
+        @should_check_stack = [false]
+        @pointer_stack = [@checked_schema]
+      end
+
+      # Array checked schema are the same as hash one, where
+      # instead of keys there are array indicies
+      def checked_key!(key)
+        if @ignore
+          return yield if block_given?
+          return
+        end
+
+        @pointer_stack.last[key] ||= {}
+        @pointer_stack.push(@pointer_stack.last[key])
+        @should_check_stack.push(false)
+        result = yield if block_given?
+        was_checked = @should_check_stack.pop
+        @pointer_stack.pop
+        @pointer_stack.last[key] = true unless was_checked
+        result
+      end
+
+      def will_check!
+        @should_check_stack[-1] = true
+      end
+
+      def ignore_checks!(&block)
+        @ignore = true
+        result = yield
+        @ignore = false
+        result
+      end
+
+      def unchecked?
+        @should_check_stack == [false]
+      end
+    end
+  end
+end

data/lib/datacaster/runtimes/user_context.rb

@@ -0,0 +1,39 @@
+require 'ostruct'
+
+module Datacaster
+  module Runtimes
+    class UserContext < Base
+      class ContextStruct
+        def initialize(context, node)
+          @context = context
+          @node = node
+        end
+
+        def method_missing(m, *args)
+          if !args.empty? || block_given?
+            return super
+          end
+
+          if @context.key?(m)
+            return @context[m]
+          end
+
+          begin
+            @node.class.send_to_parent(@node, :context).public_send(m)
+          rescue NoMethodError
+            raise NoMethodError.new("Key #{m.inspect} is not found in the context")
+          end
+        end
+      end
+
+      def initialize(parent, user_context)
+        super(parent)
+        @context_struct = ContextStruct.new(user_context, self)
+      end
+
+      def context
+        @context_struct
+      end
+    end
+  end
+end

data/lib/datacaster/substitute_i18n.rb

@@ -0,0 +1,48 @@
+require 'yaml'
+
+module Datacaster
+  module SubstituteI18n
+    @load_path = []
+
+    def self.exists?(key)
+      !fetch(key).nil?
+    end
+
+    def self.fetch(key)
+      keys = [locale] + key.split('.')
+
+      @translations.each do |hash|
+        result = hash.dig(*keys)
+        return result unless result.nil?
+      end
+      nil
+    end
+
+    def self.load_path
+      @load_path
+    end
+
+    def self.load_path=(array)
+      @load_path = array
+      @translations = array.map { |x| YAML.load_file(x) }
+    end
+
+    def self.locale
+      'en'
+    end
+
+    def self.locale=(*)
+      raise NotImplementedError.new("Setting locale is not supported, use ruby-i18n instead of datacaster's built-in")
+    end
+
+    def self.t(key, **args)
+      string = fetch(key)
+      return "Translation missing #{key}" unless string
+
+      args.each do |from, to|
+        string = string.gsub("%{#{from}}", to.to_s)
+      end
+      string
+    end
+  end
+end

data/lib/datacaster/switch_node.rb

@@ -0,0 +1,72 @@
+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
+
+      case base
+      when nil
+        @base = nil
+      when Datacaster::Base
+        @base = base
+      when String, Symbol, Array
+        @base = Datacaster::Predefined.pick(base)
+      else
+        raise RuntimeError, "provide a Datacaster::Base instance, a hash key, or an array of keys to switch(...) caster", caller
+      end
+
+      @ons = on_casters
+      @else = else_caster
+    end
+
+    def on(caster_or_value, clause)
+      caster =
+        case caster_or_value
+        when Datacaster::Base
+          caster_or_value
+        else
+          Datacaster::Predefined.compare(caster_or_value)
+        end
+
+      clause = DefinitionDSL.expand(clause)
+
+      self.class.new(@base, @ons + [[caster, clause]], @else)
+    end
+
+    def else(else_caster)
+      raise ArgumentError, "Datacaster: double else clause is not permitted", caller if @else
+      self.class.new(@base, @ons, else_caster)
+    end
+
+    def cast(object, runtime:)
+      if @ons.empty?
+        raise RuntimeError, "switch caster requires at least one 'on' statement: switch(...).on(condition, cast)", caller
+      end
+
+      if @base.nil?
+        switch_result = object
+      else
+        switch_result = @base.with_runtime(runtime).(object)
+        return switch_result unless switch_result.valid?
+        switch_result = switch_result.value
+      end
+
+      @ons.each do |check, clause|
+        result = check.with_runtime(runtime).(switch_result)
+        next unless result.valid?
+
+        return clause.with_runtime(runtime).(object)
+      end
+
+      # all 'on'-s have failed
+      return @else.with_runtime(runtime).(object) if @else
+
+      Datacaster.ErrorResult(
+        I18nValues::Key.new(['.switch', 'datacaster.errors.switch'], value: object)
+      )
+    end
+
+    def inspect
+      "#<Datacaster::SwitchNode base: #{@base.inspect} on: #{@ons.inspect} else: #{@else.inspect}>"
+    end
+  end
+end

data/lib/datacaster/then_node.rb

@@ -1,29 +1,28 @@
 module Datacaster
   class ThenNode < Base
-    def initialize(left, then_caster)
+    def initialize(left, then_caster, else_caster = nil)
       @left = left
       @then = then_caster
+      @else = else_caster
     end
 
     def else(else_caster)
       raise ArgumentError.new("Datacaster: double else clause is not permitted") if @else
 
-      @else = else_caster
-      self
+      self.class.new(@left, @then, DefinitionDSL.expand(else_caster))
     end
 
-    def cast(object)
+    def cast(object, runtime:)
       unless @else
         raise ArgumentError.new('Datacaster: use "a & b" instead of "a.then(b)" when there is no else-clause')
       end
 
-      object = super(object)
-      left_result = @left.(object)
+      left_result = @left.with_runtime(runtime).(object)
 
       if left_result.valid?
-        @then.(left_result)
+        @then.with_runtime(runtime).(left_result.value)
       else
-        @else.(object)
+        @else.with_runtime(runtime).(object)
       end
     end
 

data/lib/datacaster/transformer.rb

@@ -1,21 +1,17 @@
 module Datacaster
   class Transformer < Base
-    def initialize(name, &block)
+    def initialize(&block)
       raise "Expected block" unless block_given?
 
-      @name = name
       @transform = block
     end
 
-    def cast(object)
-      intermediary_result = super(object)
-      object = intermediary_result.value
-
-      Datacaster.ValidResult(@transform.(object))
+    def cast(object, runtime:)
+      Datacaster.ValidResult(Runtimes::Base.(runtime, @transform, object))
     end
 
     def inspect
-      "#<Datacaster::#{@name}Transformer>"
+      "#<Datacaster::Transformer>"
     end
   end
 end

data/lib/datacaster/trier.rb

@@ -1,27 +1,25 @@
 module Datacaster
   class Trier < Base
-    def initialize(name, error, catched_exception, &block)
+    def initialize(catched_exception, error_key = nil, &block)
       raise "Expected block" unless block_given?
 
-      @name = name
-      @error = error
       @catched_exception = Array(catched_exception)
-      @transform = block
-    end
+      @try = block
 
-    def cast(object)
-      intermediary_result = super(object)
-      object = intermediary_result.value
+      @error_keys = ['.try', 'datacaster.errors.try']
+      @error_keys.unshift(error_key) if error_key
+    end
 
+    def cast(object, runtime:)
       begin
-        Datacaster.ValidResult(@transform.(object))
+        Datacaster.ValidResult(Runtimes::Base.(runtime, @try, object))
       rescue *@catched_exception
-        Datacaster.ErrorResult([@error])
+        Datacaster.ErrorResult(I18nValues::Key.new(@error_keys, value: object))
       end
     end
 
     def inspect
-      "#<Datacaster::#{@name}Trier>"
+      "#<Datacaster::Trier>"
     end
   end
 end

data/lib/datacaster/validator.rb

@@ -1,5 +1,3 @@
-require 'active_model'
-
 module Datacaster
   class Validator < Base
     @@validations = {}
@@ -21,21 +19,22 @@ module Datacaster
         end.new
     end
 
-    def initialize(validations, name)
-      @name = name
+    def initialize(validations)
+      require 'active_model'
+
+      if Config.i18n_module == SubstituteI18n
+        raise NotImplementedError, "Using ActiveModel validations requires ruby-i18n or another i18n gem instead of datacaster's built-in", caller
+      end
       @validator = self.class.create_active_model(validations)
     end
 
-    def cast(object)
-      intermediary_result = super(object)
-      object = intermediary_result.value
-
+    def cast(object, runtime:)
       @validator.value = object
       @validator.valid? ? Datacaster.ValidResult(object) : Datacaster.ErrorResult(@validator.errors[:value])
     end
 
     def inspect
-      "#<Datacaster::#{@name}Validator>"
+      "#<Datacaster::Validator>"
     end
   end
 end

data/lib/datacaster/version.rb

@@ -1,3 +1,3 @@
 module Datacaster
-  VERSION = "2.0.2"
+  VERSION = "3.1.0"
 end

data/lib/datacaster.rb

@@ -1,41 +1,23 @@
+require 'zeitwerk'
+loader = Zeitwerk::Loader.for_gem
+loader.inflector.inflect('definition_dsl' => 'DefinitionDSL')
+loader.setup
+
 require_relative 'datacaster/result'
-require_relative 'datacaster/version'
-
-require_relative 'datacaster/absent'
-require_relative 'datacaster/base'
-require_relative 'datacaster/predefined'
-require_relative 'datacaster/definition_context'
-require_relative 'datacaster/terminator'
-require_relative 'datacaster/config'
-
-require_relative 'datacaster/array_schema'
-require_relative 'datacaster/caster'
-require_relative 'datacaster/checker'
-require_relative 'datacaster/comparator'
-require_relative 'datacaster/hash_mapper'
-require_relative 'datacaster/hash_schema'
-require_relative 'datacaster/message_keys_merger'
-require_relative 'datacaster/transformer'
-require_relative 'datacaster/trier'
-
-require_relative 'datacaster/and_node'
-require_relative 'datacaster/and_with_error_aggregation_node'
-require_relative 'datacaster/or_node'
-require_relative 'datacaster/then_node'
 
 module Datacaster
   extend self
 
-  def schema(&block)
-    build_schema(Terminator::Raising.instance, &block)
+  def schema(i18n_scope: nil, &block)
+    ContextNodes::StructureCleaner.new(build_schema(i18n_scope: i18n_scope, &block), :fail)
   end
 
-  def choosy_schema(&block)
-    build_schema(Terminator::Sweeping.instance, &block)
+  def choosy_schema(i18n_scope: nil, &block)
+    ContextNodes::StructureCleaner.new(build_schema(i18n_scope: i18n_scope, &block), :remove)
   end
 
-  def partial_schema(&block)
-    build_schema(nil, &block)
+  def partial_schema(i18n_scope: nil, &block)
+    ContextNodes::StructureCleaner.new(build_schema(i18n_scope: i18n_scope, &block), :pass)
   end
 
   def absent
@@ -44,19 +26,17 @@ module Datacaster
 
   private
 
-  def build_schema(terminator, &block)
+  def build_schema(i18n_scope: nil, &block)
     raise "Expected block" unless block
 
-    definition_context = DefinitionContext.new
-
-    datacaster = definition_context.instance_exec(&block)
+    datacaster = DefinitionDSL.eval(&block)
 
     unless datacaster.is_a?(Base)
       raise "Datacaster instance should be returned from a block (e.g. result of 'hash_schema(...)' call)"
     end
 
-    datacaster = (datacaster & terminator) if terminator
-    datacaster.set_definition_context(definition_context)
+    datacaster = datacaster.i18n_scope(i18n_scope) if i18n_scope
+
     datacaster
   end
 end