datacaster 0.9.1

data/lib/datacaster/hash_schema.rb

@@ -0,0 +1,56 @@
+module Datacaster
+  class HashSchema < Base
+    def initialize(fields)
+      @fields = fields
+      # support of shortcut nested validation definitions, e.g. array_schema(a: [integer], b: {c: integer})
+      @fields.transform_values! { |validator| shortcut_definition(validator) }
+    end
+
+    def call(object)
+      object = super(object)
+
+      return Datacaster.ErrorResult(["must be hash"]) unless object.value.is_a?(Hash)
+
+      checked_schema = object.meta[:checked_schema].dup || {}
+
+      errors = {}
+      result = {}
+
+      @fields.each do |key, validator|
+        value =
+          if object.value.key?(key)
+            object.value[key]
+          else
+            Datacaster.absent
+          end
+
+        new_value = validator.(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
+        end
+      end
+
+      if errors.empty?
+        # All unchecked key-value pairs are passed through, and eliminated by Terminator
+        # at the end of the chain
+        result_hash = object.value.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})
+      else
+        Datacaster.ErrorResult(errors)
+      end
+    end
+
+    def inspect
+      field_descriptions =
+        @fields.map do |k, v|
+          "#{k.inspect} => #{v.inspect}"
+        end
+
+      "#<Datacaster::HashSchema {#{field_descriptions.join(', ')}}>"
+    end
+  end
+end

data/lib/datacaster/or_node.rb

@@ -0,0 +1,22 @@
+module Datacaster
+  class OrNode < Base
+    def initialize(left, right)
+      @left = left
+      @right = right
+    end
+
+    def call(object)
+      object = super(object)
+
+      left_result = @left.(object)
+
+      return left_result if left_result.valid?
+
+      @right.(object)
+    end
+
+    def inspect
+      "#<Datacaster::OrNode L: #{@left.inspect} R: #{@right.inspect}>"
+    end
+  end
+end

data/lib/datacaster/predefined.rb

@@ -0,0 +1,179 @@
+module Datacaster
+  module Predefined
+    extend self
+
+    # Base types
+
+    def cast(name = 'Anonymous', &block)
+      Caster.new(name, &block)
+    end
+
+    def check(name = 'Anonymous', error = 'is invalid', &block)
+      Checker.new(name, error, &block)
+    end
+
+    def compare(value, name = 'Anonymous', error = nil)
+      Comparator.new(value, name, error)
+    end
+
+    def transform(name = 'Anonymous', &block)
+      Transformer.new(name, &block)
+    end
+
+    def transform_if_present(name = 'Anonymous', &block)
+      raise 'Expected block' unless block_given?
+
+      Transformer.new(name) { |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)
+    end
+
+    def array_schema(element_caster)
+      ArraySchema.new(element_caster)
+    end
+
+    def hash_schema(fields)
+      HashSchema.new(fields)
+    end
+
+    def transform_to_hash(fields)
+      HashMapper.new(fields)
+    end
+
+    def validate(active_model_validations, name = 'Anonymous')
+      Validator.new(active_model_validations, name)
+    end
+
+    # 'Meta' types
+
+    def absent
+      check('Absent', 'must be absent') { |x| x == Datacaster.absent }
+    end
+
+    def any
+      check('Any', 'must be set') { |x| x != Datacaster.absent }
+    end
+
+    def transform_to_value(value)
+      transform('ToValue') { value }
+    end
+
+    def remove
+      transform('Remove') { Datacaster.absent }
+    end
+
+    def pass
+      transform('Pass', &:itself)
+    end
+
+    def pick(*keys)
+      must_be(Enumerable) & transform("Picker") { |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 responds_to(method)
+      check('RespondsTo', "must respond to #{method.inspect}") { |x| x.respond_to?(method) }
+    end
+
+    def must_be(klass)
+      check('MustBe', "must be #{klass.inspect}") { |x| x.is_a?(klass) }
+    end
+
+    def optional(base)
+      absent | base
+    end
+
+    # Strict types
+
+    def decimal(digits = 8)
+      Trier.new('Decimal', 'must be decimal', [ArgumentError, TypeError]) do |x|
+        # strictly validate format of string, BigDecimal() doesn't do that
+        Float(x)
+
+        BigDecimal(x, digits)
+      end
+    end
+
+    def array
+      check('Array', 'must be array') { |x| x.is_a?(Array) }
+    end
+
+    def float
+      check('Float', 'must be float') {  |x| x.is_a?(Float) }
+    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) }
+    end
+
+    def hash_with_symbolized_keys
+      hash_value & transform("SymbolizeKeys") { |x| x.symbolize_keys }
+    end
+
+    def integer
+      check('Integer', 'must be integer') { |x| x.is_a?(Integer) }
+    end
+
+    def integer32
+      integer & check('FourBytes', 'out of range') { |x| x.abs <= 2_147_483_647 }
+    end
+
+    def string
+      check('String', 'must be string') { |x| x.is_a?(String) }
+    end
+
+    def non_empty_string
+      string & check('NonEmptyString', 'must be present') { |x| !x.empty? }
+    end
+
+    # Form request types
+
+    def iso8601
+      string &
+        try('ISO8601', 'must be iso8601 string', catched_exception: [ArgumentError, TypeError]) { |x| DateTime.iso8601(x) }
+    end
+
+    def to_boolean
+      cast('ToBoolean') 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'])
+        end
+      end
+    end
+
+    def to_float
+      Trier.new('ToFloat', 'must be float', [ArgumentError, TypeError]) do |x|
+        Float(x)
+      end
+    end
+
+    def to_integer
+      Trier.new('ToInteger', 'must be integer', [ArgumentError, TypeError]) do |x|
+        Integer(x)
+      end
+    end
+
+    def optional_param(base)
+      transform_if_present("optional_param(#{base.inspect})") { |x| x == '' ? Datacaster::Absent.instance : x } & (absent | base)
+    end
+  end
+end

data/lib/datacaster/result.rb

@@ -0,0 +1,61 @@
+require 'dry/monads'
+
+module Datacaster
+  class Result
+    attr_accessor :meta
+    include Dry::Monads[:result]
+
+    def initialize(valid, value_or_errors, meta: nil)
+      @value_or_errors = value_or_errors
+      @valid = !!valid
+      @meta = meta || {}
+    end
+
+    def valid?
+      @valid
+    end
+
+    def value
+      @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
+      @valid ? nil : @value_or_errors
+    end
+
+    def inspect
+      if @valid
+        "#<Datacaster::ValidResult(#{@value_or_errors.inspect})>"
+      else
+        "#<Datacaster::ErrorResult(#{@value_or_errors.inspect})>"
+      end
+    end
+
+    def to_dry_result
+      @valid ? Success(@value_or_errors) : Failure(@value_or_errors)
+    end
+  end
+
+  def self.ValidResult(object, meta: nil)
+    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)
+    end
+  end
+
+  def self.ErrorResult(object, meta: nil)
+    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)
+    end
+  end
+end

data/lib/datacaster/runner_context.rb

@@ -0,0 +1,21 @@
+require 'bigdecimal'
+require 'date'
+
+module Datacaster
+  class RunnerContext
+    include Singleton
+    include Datacaster::Predefined
+    include Dry::Monads[:result]
+
+    alias_method :array_of, :array_schema
+
+    def m(definition)
+      raise 'not implemented'
+    end
+
+    def method_missing(m, *args)
+      arg_string = args.empty? ? '' : "(#{args.map(&:inspect).join(', ')})"
+      raise "Datacaster: unknown definition '#{m}#{arg_string}'"
+    end
+  end
+end

data/lib/datacaster/terminator.rb

@@ -0,0 +1,77 @@
+require 'singleton'
+require 'dry-monads'
+
+module Datacaster
+  class Terminator < Base
+    include Singleton
+    include Dry::Monads[:result]
+
+    def call(object, checked_schema = nil)
+      object = super(object)
+      checked_schema ||= object.meta[:checked_schema]
+
+      case object.value
+      when Array
+        check_array(object.value, checked_schema)
+      when Hash
+        check_hash(object.value, checked_schema)
+      else
+        Datacaster.ValidResult(object.value)
+      end
+    end
+
+    def inspect
+      "#<Datacaster::Terminator>"
+    end
+
+    private
+
+    def check_array(array, checked_schema)
+      return Datacaster.ValidResult(array) unless checked_schema
+
+      result = array.zip(checked_schema).map { |x, schema| call(x, schema) }
+
+      if result.all?(&:valid?)
+        Datacaster.ValidResult(result.map(&:value))
+      else
+        Datacaster.ErrorResult(result.each.with_index.reject { |x, _| x.valid? }.map { |x, i| [i, x.errors] }.to_h)
+      end
+    end
+
+    def check_hash(hash, checked_schema)
+      return Datacaster.ValidResult(hash) unless checked_schema
+
+      errors = {}
+      result = {}
+
+      hash.each do |(k, v)|
+        if v == Datacaster.absent
+          next
+        end
+
+        unless checked_schema.key?(k)
+          errors[k] = ["must be absent"]
+          next
+        end
+
+        if checked_schema[k] == true
+          result[k] = v
+          next
+        end
+
+        nested_value = call(v, checked_schema[k])
+        if nested_value.valid?
+          result[k] = nested_value.value
+        else
+          errors[k] = nested_value.errors
+        end
+      end
+
+      if errors.empty?
+        Datacaster.ValidResult(result)
+      else
+        Datacaster.ErrorResult(errors)
+      end
+    end
+  end
+end

data/lib/datacaster/then_node.rb

@@ -0,0 +1,35 @@
+module Datacaster
+  class ThenNode < Base
+    def initialize(left, then_caster)
+      @left = left
+      @then = then_caster
+    end
+
+    def else(else_caster)
+      raise ArgumentError.new('Datacaster: double else clause is not permitted') if @else
+
+      @else = else_caster
+      self
+    end
+
+    def call(object)
+      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)
+
+      if left_result.valid?
+        @then.(left_result)
+      else
+        @else.(object)
+      end
+    end
+
+    def inspect
+      "#<Datacaster::ThenNode Then: #{@then.inspect} Else: #{@else.inspect}>"
+    end
+  end
+end