datacaster 0.9.1

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "datacaster"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/datacaster.gemspec

@@ -0,0 +1,30 @@
+require_relative 'lib/datacaster/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'datacaster'
+  spec.version       = Datacaster::VERSION
+  spec.authors       = ['Eugene Zolotarev']
+  spec.email         = ['eugzol@gmail.com']
+
+  spec.summary       = %q{Run-time type checker and transformer for Ruby}
+  spec.license       = 'MIT'
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.3.0')
+
+  spec.metadata['source_code_uri'] = 'https://github.com/EugZol/datacaster'
+  spec.homepage    = 'https://github.com/EugZol/datacaster'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'activemodel', '>= 5.2'
+  spec.add_development_dependency 'rake', '~> 12.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+
+  spec.add_runtime_dependency 'dry-monads', '>= 1.3', '< 1.4'
+end

data/lib/datacaster.rb

@@ -0,0 +1,50 @@
+require_relative 'datacaster/result'
+require_relative 'datacaster/version'
+
+require_relative 'datacaster/absent'
+require_relative 'datacaster/base'
+require_relative 'datacaster/predefined'
+require_relative 'datacaster/runner_context'
+require_relative 'datacaster/terminator'
+
+require_relative 'datacaster/caster'
+require_relative 'datacaster/checker'
+require_relative 'datacaster/comparator'
+require_relative 'datacaster/array_schema'
+require_relative 'datacaster/hash_schema'
+require_relative 'datacaster/hash_mapper'
+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
+  def self.schema(&block)
+    raise "Expected block" unless block
+
+    datacaster = RunnerContext.instance.instance_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 & Terminator.instance
+  end
+
+  def self.partial_schema(&block)
+    raise "Expected block" unless block
+
+    datacaster = RunnerContext.instance.instance_eval(&block)
+    unless datacaster.is_a?(Base)
+      raise "Datacaster instance should be returned from a block (e.g. result of 'hash(...)' call)"
+    end
+
+    datacaster
+  end
+
+  def self.absent
+    Datacaster::Absent.instance
+  end
+end

data/lib/datacaster/absent.rb

@@ -0,0 +1,19 @@
+require 'singleton'
+
+module Datacaster
+  class Absent
+    include Singleton
+
+    def blank?
+      true
+    end
+
+    def inspect
+      "#<Datacaster.absent>"
+    end
+
+    def present?
+      false
+    end
+  end
+end

data/lib/datacaster/and_node.rb

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

data/lib/datacaster/and_with_error_aggregation_node.rb

@@ -0,0 +1,31 @@
+module Datacaster
+  class AndWithErrorAggregationNode < Base
+    def initialize(left, right)
+      @left = left
+      @right = right
+    end
+
+    # Works like AndNode, but doesn't stop at first error — in order to aggregate all Failures
+    # Makes sense only for Hash Schemas
+    def call(object)
+      object = super(object)
+
+      left_result = @left.(object)
+
+      if left_result.valid?
+        @right.(left_result)
+      else
+        right_result = @right.(object)
+        if right_result.valid?
+          left_result
+        else
+          Datacaster.ErrorResult(self.class.merge_errors(left_result.errors, right_result.errors))
+        end
+      end
+    end
+
+    def inspect
+      "#<Datacaster::AndWithErrorAggregationNode L: #{@left.inspect} R: #{@right.inspect}>"
+    end
+  end
+end

data/lib/datacaster/array_schema.rb

@@ -0,0 +1,35 @@
+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) # & Terminator.instance
+    end
+
+    def call(object)
+      object = super(object)
+      checked_schema = object.meta[:checked_schema] || []
+
+      array = object.value
+
+      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?
+
+      result =
+        array.zip(checked_schema).map do |x, schema|
+          x = Datacaster.ValidResult(x, meta: {checked_schema: schema})
+          @element_caster.(x)
+        end
+
+      if result.all?(&:valid?)
+        checked_schema = result.map { |x| x.meta[:checked_schema] }
+        Datacaster.ValidResult(result.map(&:value), meta: {checked_schema: checked_schema})
+      else
+        Datacaster.ErrorResult(result.each.with_index.reject { |x, _| x.valid? }.map { |x, i| [i, x.errors] }.to_h)
+      end
+    end
+
+    def inspect
+      "#<Datacaster::ArraySchema [#{@element_caster.inspect}]>"
+    end
+  end
+end

data/lib/datacaster/base.rb

@@ -0,0 +1,77 @@
+module Datacaster
+  class Base
+    def self.merge_errors(left, right)
+      add_error_to_base = ->(hash, error) {
+        hash[:base] ||= []
+        hash[:base] = merge_errors(hash[:base], error)
+        hash
+      }
+
+      return [] if left.nil? && right.nil?
+      return right if left.nil?
+      return left if right.nil?
+
+      result = case [left.class, right.class]
+      when [Array, Array]
+        left | right
+      when [Array, Hash]
+        add_error_to_base.(right, left)
+      when [Hash, Hash]
+        (left.keys | right.keys).map do |k|
+          [k, merge_errors(left[k], right[k])]
+        end.to_h
+      when [Hash, Array]
+        add_error_to_base.(left, right)
+      else
+        raise ArgumentError.new("Expected failures to be Arrays or Hashes, left: #{left.inspect}, right: #{right.inspect}")
+      end
+
+      result
+    end
+
+    def &(other)
+      AndNode.new(self, other)
+    end
+
+    def |(other)
+      OrNode.new(self, other)
+    end
+
+    def *(other)
+      AndWithErrorAggregationNode.new(self, other)
+    end
+
+    def then(other)
+      ThenNode.new(self, other)
+    end
+
+    def call(object)
+      Datacaster.ValidResult(object)
+    end
+
+    def inspect
+      "#<Datacaster::Base>"
+    end
+
+    private
+
+    # 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: shorcut 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
+    end
+  end
+end

data/lib/datacaster/caster.rb

@@ -0,0 +1,30 @@
+module Datacaster
+  class Caster < Base
+    def initialize(name, &block)
+      raise "Expected block" unless block_given?
+
+      @name = name
+      @cast = block
+    end
+
+    def call(object)
+      intermediary_result = super(object)
+      object = intermediary_result.value
+
+      result = @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) }
+
+      if result.is_a?(Dry::Monads::Result)
+        result = result.success? ? Datacaster.ValidResult(result.value!) : Datacaster.ErrorResult(result.failure)
+      end
+
+      result
+    end
+
+    def inspect
+      "#<Datacaster::#{@name}Caster>"
+    end
+  end
+end

data/lib/datacaster/checker.rb

@@ -0,0 +1,26 @@
+module Datacaster
+  class Checker < Base
+    def initialize(name, error, &block)
+      raise "Expected block" unless block_given?
+
+      @name = name
+      @error = error
+      @check = block
+    end
+
+    def call(object)
+      intermediary_result = super(object)
+      object = intermediary_result.value
+
+      if @check.(object)
+        Datacaster.ValidResult(object)
+      else
+        Datacaster.ErrorResult([@error])
+      end
+    end
+
+    def inspect
+      "#<Datacaster::#{@name}Checker>"
+    end
+  end
+end

data/lib/datacaster/comparator.rb

@@ -0,0 +1,24 @@
+module Datacaster
+  class Comparator < Base
+    def initialize(value, name, error = nil)
+      @value = value
+      @name = name
+      @error = error || "must be equal to #{value.inspect}"
+    end
+
+    def call(object)
+      intermediary_result = super(object)
+      object = intermediary_result.value
+
+      if @value == object
+        Datacaster.ValidResult(object)
+      else
+        Datacaster.ErrorResult([@error])
+      end
+    end
+
+    def inspect
+      "#<Datacaster::#{@name}Comparator>"
+    end
+  end
+end

data/lib/datacaster/hash_mapper.rb

@@ -0,0 +1,70 @@
+module Datacaster
+  class HashMapper < Base
+    def initialize(fields)
+      @fields = fields
+    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|
+        new_value = validator.(object)
+
+        # transform_to_hash([:a, :b, :c] => pick(:a, :b, :c) & ...)
+        keys = Array(key)
+        values_or_errors = Array(new_value.value || new_value.errors)
+        if keys.length != values_or_errors.length
+          raise TypeError.new("When using transform_to_hash([:a, :b, :c] => validator), validator should return Array "\
+            "with number of elements equal to the number of elements in left-hand-side array.\n" \
+            "Got the following (values or errors) instead: #{keys.inspect} => #{values_or_errors.inspect}.")
+        end
+
+        if new_value.valid?
+          keys.each.with_index do |key, i|
+            result[key] = values_or_errors[i]
+            checked_schema[key] = true
+          end
+
+          single_returned_schema = new_value.meta[:checked_schema].dup
+          checked_schema[keys.first] = single_returned_schema if keys.length == 1 && single_returned_schema
+        else
+          errors.merge!(keys.zip(values_or_errors).to_h)
+        end
+      end
+
+      errors.delete_if { |_, v| v.empty? }
+
+      if errors.empty?
+        # All unchecked key-value pairs of initial hash are passed through, and eliminated by Terminator
+        # 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)
+          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})
+      else
+        Datacaster.ErrorResult(errors)
+      end
+    end
+
+    def inspect
+      field_descriptions =
+        @fields.map do |k, v|
+          "#{k.inspect} => #{v.inspect}"
+        end
+
+      "#<Datacaster::HashMapper {#{field_descriptions.join(', ')}}>"
+    end
+  end
+end