datacaster 0.9.1 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0945e72cd8cba6c89e6eed3b202e8241eb25ecc12e4a1c44bfeca2be78206306'
-  data.tar.gz: 9c02c5a237e1d2853a804fa1e31fd2fc13b4e46c5fc207b16461fb5ce9f30570
+  metadata.gz: 2d6493682ec13481f878adb35c36562ac7f38dd9fa761a7447d6f05f2812c98c
+  data.tar.gz: 32ca64152333af7cf9e9125ddeb01783f06249e2949dfdd139ca6bcb12fe4790
 SHA512:
-  metadata.gz: f0a9b9b2aca6f58001550631cd31c381f38b95d95ea652e2a3d1184698fe82cc24bdf8a79074a606a4b3d5437d0cf1f31e8fee997765b83cac6cb4d4ce6670c5
-  data.tar.gz: eb99b873a43d7c73eeebade0d9a25111c47d3dcd32686f718c2ba1aaa738aca69aece76c096f0c48e21c4f55cd1d754683d02d0c8618c270a4515d039f29c5f4
+  metadata.gz: 8f354a530cb8371fe744b851cfd81714ffbac336ac6df79c09fe6e75ca14ccfff77a30efebf84205495f1262ec860c2c8a415734f945af256bb6f84698d52003
+  data.tar.gz: 3232aeaa2d583530e3402d61fb321e3f99f0333a0a676defb9e2ae3a8f42e1de358f169b844924737d764514787e498286e6ff7271dcbad8432347e4434670ad

data/.github/workflows/rspec.yml

@@ -0,0 +1,17 @@
+name: Rspec
+on: [push, pull_request]
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version: ['3.1', '2.7']
+    steps:
+    - uses: actions/checkout@v3
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+    - name: Install dependencies
+      run: bundle install
+    - name: Run tests
+      run: bundle exec rspec

data/.gitignore

@@ -6,6 +6,7 @@
 /pkg/
 /spec/reports/
 /tmp/
+Gemfile.lock
 
 # rspec failure tracking
 .rspec_status

data/.gitlab-ci.yml

@@ -0,0 +1,8 @@
+image: ruby:latest
+
+before_script:
+  - bundle install
+
+rspec:
+  script:
+    - bundle exec rspec

data/README.md

@@ -4,6 +4,70 @@ This gem provides run-time type checking and mapping of composite data structure
 
 Its main use is in the validation and preliminary transformation of API params requests.
 
+
+# Table of contents
+
+- [Installing](#installing)
+- [Why not ...](#why-not-)
+- [Basics](#basics)
+  - [Conveyor belt](#conveyor-belt)
+  - [Result value](#result-value)
+  - [Hash schema](#hash-schema)
+  - [Logical operators](#logical-operators)
+    - [*AND operator*:](#and-operator)
+    - [*OR operator*:](#or-operator)
+    - [*IF... THEN... ELSE operator*:](#if-then-else-operator)
+- [Built-in types](#built-in-types)
+  - [Basic types](#basic-types)
+    - [`string`](#string)
+    - [`integer`](#integer)
+    - [`float`](#float)
+    - [`decimal([digits = 8])`](#decimaldigits--8)
+    - [`array`](#array)
+    - [`hash_value`](#hash_value)
+  - [Convenience types](#convenience-types)
+    - [`non_empty_string`](#non_empty_string)
+    - [`hash_with_symbolized_keys`](#hash_with_symbolized_keys)
+    - [`integer32`](#integer32)
+  - [Special types](#special-types)
+    - [`absent`](#absent)
+    - [`any`](#any)
+    - [`transform_to_value(value)`](#transform_to_valuevalue)
+    - [`remove`](#remove)
+    - [`pass`](#pass)
+    - [`responds_to(method)`](#responds_tomethod)
+    - [`must_be(klass)`](#must_beklass)
+    - [`optional(base)`](#optionalbase)
+    - [`pick(key)`](#pickkey)
+    - [`merge_message_keys(*keys)`](#merge_message_keyskeys)
+  - ["Web-form" types](#web-form-types)
+    - [`to_integer`](#to_integer)
+    - [`to_float`](#to_float)
+    - [`to_boolean`](#to_boolean)
+    - [`iso8601`](#iso8601)
+    - [`optional_param(base)`](#optional_parambase)
+  - [Custom and fundamental types](#custom-and-fundamental-types)
+    - [`cast(name = 'Anonymous') { |value| ... }`](#castname--anonymous--value--)
+    - [`check(name = 'Anonymous', error = 'is invalid') { |value| ... }`](#checkname--anonymous-error--is-invalid--value--)
+    - [`try(name = 'Anonymous', error = 'is invalid', catched_exception:) { |value| ... }`](#tryname--anonymous-error--is-invalid-catched_exception--value--)
+    - [`validate(active_model_validations, name = 'Anonymous')`](#validateactive_model_validations-name--anonymous)
+    - [`compare(reference_value, name = 'Anonymous', error = nil)`](#comparereference_value-name--anonymous-error--nil)
+    - [`transform(name = 'Anonymous') { |value| ... }`](#transformname--anonymous--value--)
+    - [`transform_if_present(name = 'Anonymous') { |value| ... }`](#transform_if_presentname--anonymous--value--)
+  - [Passing additional context to schemas](#passing-additional-context-to-schemas)
+  - [Array schemas](#array-schemas)
+  - [Hash schemas](#hash-schemas)
+    - [Absent is not nil](#absent-is-not-nil)
+    - [Schema vs Partial schema](#schema-vs-partial-schema)
+    - [AND with error aggregation (`*`)](#and-with-error-aggregation-)
+  - [Shortcut nested definitions](#shortcut-nested-definitions)
+  - [Mapping hashes: `transform_to_hash`](#mapping-hashes-transform_to_hash)
+- [Error remapping](#error-remapping)
+- [Registering custom 'predefined' types](#registering-custom-predefined-types)
+- [Contributing](#contributing)
+- [Ideas/TODO](#ideastodo)
+- [License](#license)
+
 ## Installing
 
 Add to your Gemfile:
@@ -50,7 +114,7 @@ validator.(1).value       # nil
 validator.(1).errors      # ["must be string"]
 ```
 
-Datacaster instances are created with a call to `Datacaster.schema { ... }` or `Datacaster.partial_schema { ... }` (described later in this file).
+Datacaster instances are created with a call to `Datacaster.schema { ... }`, `Datacaster.partial_schema { ... }` or `Datacaster.choosy_schema { ... }` (described later in this file).
 
 Datacaster validators' results could be converted to [dry result monad](https://dry-rb.org/gems/dry-monads/1.0/result/):
 
@@ -103,9 +167,9 @@ Validating hashes is the main case scenario for datacaster. Several specific con
 Let's assume we want to validate that a hash (which represents data about a person):
 
 a) is, in fact, a Hash;  
-a) has exactly 2 keys, `name` and `salary`,  
-b) key 'name' is a string,  
-c) key 'salary' is an integer:
+b) has exactly 2 keys, `name` and `salary`,  
+c) key 'name' is a string,  
+d) key 'salary' is an integer:
 
 ```ruby
 person_validator =
@@ -135,7 +199,7 @@ person_validator.(name: "John Smith", salary: 100_000, title: "developer")
 # => Datacaster::ErrorResult({:title=>["must be absent"]})
 ```
 
-`Datacaster.schema` definitions don't permit, as you likely noticed from the example above, extra fields in the hash. In fact, `Datacaster.schema` automatically adds special built-in validator, called `Datacaster::Terminator`, at the end of your validation chain, which function is to ensure that all hash keys had been validated.
+`Datacaster.schema` definitions don't permit, as you likely noticed from the example above, extra fields in the hash. In fact, `Datacaster.schema` automatically adds special built-in validator, called `Datacaster::Terminator::Raising`, at the end of your validation chain, which function is to ensure that all hash keys had been validated.
 
 If you want to permit your hashes to contain extra fields, use `Datacaster.partial_schema` (it's the only difference between `.schema` and `.partial_schema`):
 
@@ -152,6 +216,21 @@ person_with_extra_keys_validator.(name: "John Smith", salary: 100_000, title: "d
 # => Datacaster::ValidResult({:name=>"John Smith", :salary=>100000, :title=>"developer"})
 ```
 
+Also if you want to delete extra fields, use `Datacaster.choosy_schema`:
+
+```ruby
+person_with_extra_keys_validator =
+  Datacaster.choosy_schema do
+    hash_schema(
+      name: string,
+      salary: integer
+    )
+  end
+
+person_with_extra_keys_validator.(name: "John Smith", salary: 100_000, age: 18)
+# => Datacaster::ValidResult({:name=>"John Smith", :salary=>100000})
+```
+
 Datacaster 'hash schema' makes strict difference between absent and nil values, allows to use shortcuts for defining nested schemas (with no limitation on the level of nesting), and has convinient 'AND with error aggregation' (`*`, same symbol as in numbers multiplication) for joining validation errors of multiple failures. See below in the corresponding sections.
 
 ### Logical operators
@@ -177,7 +256,7 @@ even_number.(2)
 even_number.(3)
 # => Datacaster::ErrorResult(["is invalid"])
 even_number.("test")
-# => #<Datacaster::ErrorResult(["must be integer"])>
+# => Datacaster::ErrorResult(["must be integer"])
 ```
 
 If left-hand validation of AND operator passes, *its result* (not the original value) is passed to the right-hand validation. See below in this file section on transformations where this might be relevant.
@@ -200,7 +279,7 @@ Notice that OR operator, if left-hand validation fails, passes the original valu
 
 Let's suppose we want to validate that incoming hash is either 'person' or 'entity', where
 
-- 'person' is a hash with 3 keys (kind: `:person`, name: string, salary: integer),  
+- 'person' is a hash with 3 keys (kind: `:person`, name: string, salary: integer),
 - 'entity' is a hash with 4 keys (kind: `:entity`, title: string, form: string, revenue: integer).
 
 ```ruby
@@ -325,7 +404,7 @@ max_concurrent_connections = Datacaster.schema { compare(nil).then(transform_to_
 
 max_concurrent_connections.(9)   # => Datacaster::ValidResult(9)
 max_concurrent_connections.("9") # => Datacaster::ErrorResult(["must be integer"])
-max_concurrent_connections.(nil) #=> #<Datacaster::ValidResult(5)>
+max_concurrent_connections.(nil) # => Datacaster::ValidResult(5)
 ```
 
 #### `remove`
@@ -398,6 +477,101 @@ pick_name_and_age.(last_name: "Johnson", age: 20) # => Datacaster::ValidResult([
 pick_name_and_age.("test")                        # => Datacaster::ErrorResult(["must be Enumerable"])
 ```
 
+#### `merge_message_keys(*keys)`
+
+Returns ValidResult only if value `#is_a?(Hash)`.
+
+Maps incoming hash to Datacaster styled messages.
+
+```ruby
+mapper =
+  Datacaster.schema do
+    merge_message_keys(:a, :b)
+  end
+
+mapper.(a: "1", b: "2") # => Datacaster::ValidResult(["1", "2"])
+```
+
+Arrays are merged. Merging `["1", "2"]` and `["2", "3"]` will produce `["1", "2", "3"]`.
+
+Hash values are merged recursively (deeply) with one another:
+
+```ruby
+mapper = Datacaster.schema do
+  transform_to_hash(
+    resourse: merge_message_keys(:resourse),
+    user: merge_message_keys(:user, :login_params),
+    login_params: remove
+  )
+end
+
+mapper.(
+  resourse: "request was rejected",
+  user: {
+    age: "too young", password: "too long"
+  },
+  login_params: {
+    password: "should contain special characters",
+    nickname: "too short"
+  }
+)
+# => Datacaster::ValidResult({
+#     :resourse=>["request was rejected"],
+#     :user=>{
+#       :age=>["too young"],
+#       :password=>["too long", "should contain special characters"],
+#       :nickname=>["too short"]
+#     }
+#   })
+```
+
+Hash value merges non-Hash value by merging it with `:base` key (added if absent):
+
+```ruby
+mapping = Datacaster.schema do
+  transform_to_hash(
+    resourse: merge_message_keys(:resourse),
+    user: merge_message_keys(:user, :user_error),
+    user_error: remove
+  )
+end
+
+mapping.(
+  resourse: "request was rejected",
+  user: {age: "too young", nickname: "too long"},
+  user_error: "user is invalid"
+)
+# => Datacaster::ValidResult({
+#      :resourse=>["request was rejected"],
+#      :user=>{
+#        :age=>["too young"],
+#        :nickname=>["too long"],
+#        :base=>["user is invalid"]
+#      }
+# })
+```
+
+Hash keys with `nil` and `[]` values are deeply ignored:
+
+```ruby
+mapping = Datacaster.schema do
+  transform_to_hash(
+    user: merge_message_keys(:user),
+  )
+end
+
+mapping.(
+  user: {
+    age: "too young", nickname: [], user_error: nil
+  }
+)
+# => Datacaster::ValidResult({
+#      :user=> {
+#        :age=>["too young"]
+#      }
+#    })
+```
+
 ### "Web-form" types
 
 These types are convenient to parse and validate POST forms and decode JSON requests.
@@ -572,6 +746,49 @@ city.(name: "Denver", distance: "2.5") # => Datacaster::ValidResult({:name=>"Den
 
 Always returns ValidResult. If the value is `Datacaster.absent` (singleton instance, see below section on hash schemas), then `Datacaster.absent` is returned (block isn't called). Otherwise, works like `transform`.
 
+###  Passing additional context to schemas
+
+You can pass `context` to schema using `.with_context` method
+
+```ruby
+# class User < ApplicationRecord
+#  ...
+# end
+#
+# class Post < ApplicationRecord
+#   belongs_to :user
+#   ...
+# end
+
+schema =
+  Datacaster.schema do
+    hash_schema(
+      post_id: to_integer & check { |id| Post.where(id: id, user_id: context.current_user).exists? }
+    )
+  end
+
+current_user = ...
+
+schema.with_context(current_user: current_user).(post_id: 15)
+```
+
+`context` is an [OpenStruct](https://ruby-doc.org/stdlib-3.1.0/libdoc/ostruct/rdoc/OpenStruct.html) instance which is initialized in `.with_context`
+
+**Note**
+
+`context` can be accesed only in types' blocks:
+```ruby
+mail_transformer = Datacaster.schema { transform { |v| "#{v}#{context.postfix}" } }
+
+mail_transformer.with_context(postfix: "@domen.com").("admin")
+# => #<Datacaster::ValidResult("admin@domen.com")>
+```
+It can't be used in schema definition block itself:
+```ruby
+Datacaster.schema { context.error }
+# leads to `NoMethodError`
+```
+
 ### Array schemas
 
 To define compound data type, array of 'something', use `array_schema(something)` (or, synonymically, `array_of(something)`). There is no way to define array wherein each element is of different type.
@@ -660,7 +877,7 @@ If a) fails, `ErrorResult(["must be hash"])` is returned.
 if b) fails, `ErrorResult(key1 => [errors...], key2 => [errors...])` is returned. Each key of wrapped "error hash" corresponds to the key of validated hash, and each value of "error hash" contains array of errors, returned by the corresponding validator.  
 If b) fulfilled, then and only then validated hash is checked for extra keys. If they are found, `ErrorResult(extra_key_1 => ["must be absent"], ...)` is returned.
 
-Technically, last part is implemented with special singleton validator, called `#<Datacaster::Terminator>`, which is automatically added to the validation chain (with the use of `&` operator) by `Datacaster.schema` method. Don't be scared if you see it in the output of `#inspect` method of your validators (e.g. in `irb`).
+Technically, last part is implemented with special singleton validator, called `#<Datacaster::Terminator::Raising>`, which is automatically added to the validation chain (with the use of `&` operator) by `Datacaster.schema` method. Don't be scared if you see it in the output of `#inspect` method of your validators (e.g. in `irb`).
 
 #### Absent is not nil
 
@@ -735,7 +952,7 @@ Sometimes it is necessary to omit that requirement and allow for hash to contain
 
 Let's say we have:
 
-* 'people' (hashes with `name: string`, `description: string` and `kind: 'person'` fields),  
+* 'people' (hashes with `name: string`, `description: string` and `kind: 'person'` fields),
 * 'entities' (hash with `title: string`, `description: string` and `kind: 'entity'` fields).
 
 In other words, we have some polymorphic resource, which type is defined by `kind` field, and which has common fields for all its "sub-kinds" (in this example: `description`), and also fields specific to each "kind" (in database we often model this as [STI](https://api.rubyonrails.org/v6.0.3.2/classes/ActiveRecord/Base.html#class-ActiveRecord::Base-label-Single+table+inheritance)).
@@ -967,6 +1184,77 @@ Here is what is happening when `city_with_distance` (from the example above) is
 
 Note: because of point e) above we need to explicitly delete `distance_in_meters` key, because otherwise `transform_to_hash` will copy it to the resultant hash without validation. And all non-validated keys at the end of `Datacaster.schema` block (as explained above in section on partial schemas) result in error.
 
+## Error remapping
+
+In some cases it might be useful to remap resulting `Datacaster::ErrorResult`:
+
+```ruby
+schema =
+  Datacaster.schema do
+    transform = transform_to_hash(
+      posts: pick(:user_id) & to_integer & transform { |user| Posts.where(user_id: user.id).to_a },
+      user_id: remove
+    )
+  end
+
+schema.(user_id: 'wrong')  # => #<Datacaster::ErrorResult({:posts=>["must be integer"]})>
+# Instead of #<Datacaster::ErrorResult({:user_id=>["must be integer"]})>
+```
+
+`.cast_errors` can be used in such case:
+
+```ruby
+schema =
+  Datacaster.schema do
+    transform = transform_to_hash(
+      posts: pick(:user_id) & to_integer & transform { |user| Posts.where(user_id: user.id).to_a },
+      user_id: remove
+    )
+
+    transform.cast_errors(
+      transform_to_hash(
+        user_id: pick(:posts),
+        posts: remove
+      )
+    )
+  end
+
+schema.(user_id: 'wrong')  # => #<Datacaster::ErrorResult({:user_id=>["must be integer"]})>
+```
+any instance of `Datacaster` can be passed to `.cast_errors`
+
+
+## Registering custom 'predefined' types
+
+In order to extend `Datacaster` functionality, custom types can be added
+
+There are two ways to add cutsom types to `Datacaster`:
+
+1\. Using lambda definition:
+
+```ruby
+Datacaster::Config.add_predefined_caster(:time_string, -> {
+  string & validate(format: { with: /\A(0[0-9]|1[0-9]|2[0-3]):[03]0\z/ })
+})
+
+schema = Datacaster.schema { time_string }
+
+schema.("23:00") # => #<Datacaster::ValidResult("23:00")>
+schema.("no_time_string") # => #<Datacaster::ErrorResult(["is invalid"])>
+```
+
+2\. Using `Datacaster` instance:
+
+```ruby
+css_color = Datacaster.partial_schema { string & validate(format: { with: /\A#(?:\h{3}){1,2}\z/ }) }
+Datacaster::Config.add_predefined_caster(:css_color, css_color)
+
+schema = Datacaster.schema { css_color }
+
+schema.("#123456") # => #<Datacaster::ValidResult("#123456")>
+schema.("no_css_color") #  => #<Datacaster::ErrorResult(["is invalid"])>
+```
+
 ## Contributing
 
 Fork, create issues and make PRs as usual.

data/lib/datacaster/and_node.rb

@@ -5,11 +5,10 @@ module Datacaster
       @right = right
     end
 
-    def call(object)
+    def cast(object)
       object = super(object)
 
       left_result = @left.(object)
-
       return left_result unless left_result.valid?
 
       @right.(left_result)

data/lib/datacaster/and_with_error_aggregation_node.rb

@@ -7,9 +7,8 @@ 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 call(object)
+    def cast(object)
       object = super(object)
-
       left_result = @left.(object)
 
       if left_result.valid?

data/lib/datacaster/array_schema.rb

@@ -2,10 +2,10 @@ 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
+      @element_caster = shortcut_definition(element_caster)
     end
 
-    def call(object)
+    def cast(object)
       object = super(object)
       checked_schema = object.meta[:checked_schema] || []
 

data/lib/datacaster/base.rb

@@ -1,3 +1,5 @@
+require "ostruct"
+
 module Datacaster
   class Base
     def self.merge_errors(left, right)
@@ -45,8 +47,33 @@ module Datacaster
       ThenNode.new(self, other)
     end
 
+    def set_definition_context(definition_context)
+      @definition_context = definition_context
+    end
+
+    def with_context(additional_context)
+      @definition_context.context = OpenStruct.new(additional_context)
+      self
+    end
+
     def call(object)
-      Datacaster.ValidResult(object)
+      object = cast(object)
+
+      return object if object.valid? || @cast_errors.nil?
+
+      error_cast = @cast_errors.(object.errors)
+
+      raise "#cast_errors must return Datacaster.ValidResult, currently it is #{error_cast.inspect}" unless error_cast.valid?
+
+      Datacaster.ErrorResult(
+        @cast_errors.(object.errors).value,
+        meta: object.meta
+      )
+    end
+
+    def cast_errors(object)
+      @cast_errors = shortcut_definition(object)
+      self
     end
 
     def inspect
@@ -55,6 +82,10 @@ module Datacaster
 
     private
 
+    def cast(object)
+      Datacaster.ValidResult(object)
+    end
+
     # Translates hashes like {a: <IntegerChecker>} to <HashSchema {a: <IntegerChecker>}>
     #   and arrays like [<IntegerChecker>] to <ArraySchema <IntegerChecker>>
     def shortcut_definition(definition)
@@ -63,7 +94,7 @@ module Datacaster
         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]")
+          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

data/lib/datacaster/caster.rb

@@ -7,7 +7,7 @@ module Datacaster
       @cast = block
     end
 
-    def call(object)
+    def cast(object)
       intermediary_result = super(object)
       object = intermediary_result.value
 

data/lib/datacaster/checker.rb

@@ -8,7 +8,7 @@ module Datacaster
       @check = block
     end
 
-    def call(object)
+    def cast(object)
       intermediary_result = super(object)
       object = intermediary_result.value
 

data/lib/datacaster/comparator.rb

@@ -6,7 +6,7 @@ module Datacaster
       @error = error || "must be equal to #{value.inspect}"
     end
 
-    def call(object)
+    def cast(object)
       intermediary_result = super(object)
       object = intermediary_result.value
 

data/lib/datacaster/config.rb

@@ -0,0 +1,19 @@
+module Datacaster
+  module Config
+    extend self
+
+    def add_predefined_caster(name, definition)
+      caster =
+        case definition
+        when Proc
+          Datacaster.partial_schema(&definition)
+        when Base
+          definition
+        else
+          raise ArgumentError.new("Expected Datacaster defintion lambda or Datacaster instance")
+        end
+
+      Predefined.define_method(name.to_sym) { caster }
+    end
+  end
+end

data/lib/datacaster/{runner_context.rb → definition_context.rb}

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

data/lib/datacaster/hash_mapper.rb

@@ -1,12 +1,20 @@
 module Datacaster
   class HashMapper < Base
     def initialize(fields)
+      keys = fields.keys.flatten
+      if keys.length != keys.uniq.length
+        intersection = keys.select { |k| keys.count(k) > 1 }.uniq.sort
+        raise ArgumentError.new("When using transform_to_hash([:a, :b, :c] => validator), " \
+          "each key should not be mentioned more than once on the left-hand-side. Instead, got these " \
+          "keys mentioned twice or more: #{intersection.inspect}."
+        )
+      end
+
       @fields = fields
     end
 
-    def call(object)
+    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 || {}
@@ -18,24 +26,32 @@ module Datacaster
         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}.")
+        if key.is_a?(Array)
+          unwrapped = new_value.valid? ? new_value.value : new_value.errors
+
+          if key.length != unwrapped.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
         end
 
         if new_value.valid?
-          keys.each.with_index do |key, i|
-            result[key] = values_or_errors[i]
+          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
+            end
+          else
+            result[key] = new_value.value
             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)
+          if key.is_a?(Array)
+            errors = self.class.merge_errors(errors, key.zip(new_value.errors).to_h)
+          else
+            errors = self.class.merge_errors(errors, {key => new_value.errors})
+          end
         end
       end
 

data/lib/datacaster/hash_schema.rb

@@ -6,9 +6,8 @@ module Datacaster
       @fields.transform_values! { |validator| shortcut_definition(validator) }
     end
 
-    def call(object)
+    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 || {}

data/lib/datacaster/message_keys_merger.rb

@@ -0,0 +1,98 @@
+module Datacaster
+  class MessageKeysMerger < Base
+    def initialize(keys)
+      @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)
+
+      result = set_initial_value(object)
+
+      @keys.each do |k|
+        result =
+          if need_hash_merger?(object)
+            merge_hash(result, object[k])
+          else
+            merge_array_or_scalar(result, object[k])
+          end
+      end
+
+      result = clean(result)
+
+      Datacaster.ValidResult(
+        result.nil? ? Datacaster.absent : result
+      )
+    end
+
+    private
+
+    def set_initial_value(object)
+      need_hash_merger?(object) ? {} : []
+    end
+
+    def need_hash_merger?(object)
+      @need_hash_merger = 
+        @need_hash_merger.nil? ? @keys.any? { |k| object[k].is_a?(Hash) } : @need_hash_merger
+    end
+
+    def merge_array_or_scalar(unit, merge_with)
+      merge_with = [merge_with] unless merge_with.is_a?(Array)
+      unit = [unit] unless unit.is_a?(Array)
+
+      result = clean(unit | merge_with)
+      result.uniq == [nil] || result == [] ? Datacaster.absent : result
+    end
+
+    def value_or(value, default)
+      value.nil? ? default : value
+    end
+
+    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
+        end
+
+        result
+      else
+        result = merge_array_or_scalar(value_or(result, []), merge_with)
+      end
+    end
+
+    def merge_hash(result, merge_with)
+      if merge_with.is_a?(Hash)
+        merge_with.each do |k, v|
+          result[k] = merge_hash_with_hash(result[k], v)
+        end
+      else
+        result[:base] = merge_array_or_scalar(value_or(result[:base], []), merge_with)
+      end
+
+      result
+    end
+
+    def clean(value)
+      case value
+      when Array
+        value.delete_if do |v|
+          clean(v) if v.is_a?(Hash) || v.is_a?(Array)
+          v == Datacaster.absent
+        end
+      when Hash
+        value.delete_if do |_k, v|
+          clean(v) if v.is_a?(Hash) || v.is_a?(Array)
+          v == Datacaster.absent
+        end
+      end
+    end
+  end
+end

data/lib/datacaster/or_node.rb

@@ -5,9 +5,8 @@ module Datacaster
       @right = right
     end
 
-    def call(object)
+    def cast(object)
       object = super(object)
-
       left_result = @left.(object)
 
       return left_result if left_result.valid?

data/lib/datacaster/predefined.rb

@@ -33,6 +33,7 @@ module Datacaster
     def array_schema(element_caster)
       ArraySchema.new(element_caster)
     end
+    alias_method :array_of, :array_schema
 
     def hash_schema(fields)
       HashSchema.new(fields)
@@ -85,6 +86,10 @@ module Datacaster
       }
     end
 
+    def merge_message_keys(*keys)
+      MessageKeysMerger.new(keys)
+    end
+
     def responds_to(method)
       check('RespondsTo', "must respond to #{method.inspect}") { |x| x.respond_to?(method) }
     end

data/lib/datacaster/terminator.rb

@@ -2,75 +2,96 @@ 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)
+  class Terminator
+    module TerminatorBase
+      include Dry::Monads[:result]
+
+      def self.included(klass)
+        klass.include Singleton
       end
-    end
 
-    def inspect
-      "#<Datacaster::Terminator>"
-    end
+      def cast(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
 
-    private
+      def inspect
+        "#<Datacaster::Terminator>"
+      end
 
-    def check_array(array, checked_schema)
-      return Datacaster.ValidResult(array) unless checked_schema
+      private
 
-      result = array.zip(checked_schema).map { |x, schema| call(x, schema) }
+      def check_array(array, checked_schema)
+        return Datacaster.ValidResult(array) unless checked_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)
+        result = array.zip(checked_schema).map { |x, schema| cast(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
-    end
 
-    def check_hash(hash, checked_schema)
-      return Datacaster.ValidResult(hash) unless checked_schema
+      def check_hash(hash, checked_schema)
+        return Datacaster.ValidResult(hash) unless checked_schema
 
-      errors = {}
-      result = {}
+        errors = {}
+        result = {}
 
-      hash.each do |(k, v)|
-        if v == Datacaster.absent
-          next
-        end
+        hash.each do |(k, v)|
+          if v == Datacaster.absent
+            next
+          end
 
-        unless checked_schema.key?(k)
-          errors[k] = ["must be absent"]
-          next
-        end
+          unless checked_schema.key?(k)
+            errors[k] = ["must be absent"] if is_a?(Raising)
+            next
+          end
+
+          if checked_schema[k] == true
+            result[k] = v
+            next
+          end
 
-        if checked_schema[k] == true
-          result[k] = v
-          next
+          nested_value = cast(v, checked_schema[k])
+          if nested_value.valid?
+            result[k] = nested_value.value
+          else
+            errors[k] = nested_value.errors
+          end
         end
 
-        nested_value = call(v, checked_schema[k])
-        if nested_value.valid?
-          result[k] = nested_value.value
+        if errors.empty?
+          Datacaster.ValidResult(result)
         else
-          errors[k] = nested_value.errors
+          Datacaster.ErrorResult(errors)
         end
       end
+    end
+
+    class Raising < Base
+      include TerminatorBase
+  
+      def inspect
+        "#<Datacaster::Terminator::Raising>"
+      end
+    end
 
-      if errors.empty?
-        Datacaster.ValidResult(result)
-      else
-        Datacaster.ErrorResult(errors)
+    class Sweeping < Base
+      include TerminatorBase
+  
+      def inspect
+        "#<Datacaster::Terminator::Sweeping>"
       end
     end
   end

data/lib/datacaster/then_node.rb

@@ -6,19 +6,18 @@ module Datacaster
     end
 
     def else(else_caster)
-      raise ArgumentError.new('Datacaster: double else clause is not permitted') if @else
+      raise ArgumentError.new("Datacaster: double else clause is not permitted") if @else
 
       @else = else_caster
       self
     end
 
-    def call(object)
+    def cast(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?

data/lib/datacaster/transformer.rb

@@ -7,7 +7,7 @@ module Datacaster
       @transform = block
     end
 
-    def call(object)
+    def cast(object)
       intermediary_result = super(object)
       object = intermediary_result.value
 

data/lib/datacaster/trier.rb

@@ -9,7 +9,7 @@ module Datacaster
       @transform = block
     end
 
-    def call(object)
+    def cast(object)
       intermediary_result = super(object)
       object = intermediary_result.value
 

data/lib/datacaster/validator.rb

@@ -26,7 +26,7 @@ module Datacaster
       @validator = self.class.create_active_model(validations)
     end
 
-    def call(object)
+    def cast(object)
       intermediary_result = super(object)
       object = intermediary_result.value
 

data/lib/datacaster/version.rb

@@ -1,3 +1,3 @@
 module Datacaster
-  VERSION = "0.9.1"
+  VERSION = "2.0.1"
 end

data/lib/datacaster.rb

@@ -4,15 +4,17 @@ require_relative 'datacaster/version'
 require_relative 'datacaster/absent'
 require_relative 'datacaster/base'
 require_relative 'datacaster/predefined'
-require_relative 'datacaster/runner_context'
+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/array_schema'
-require_relative 'datacaster/hash_schema'
 require_relative 'datacaster/hash_mapper'
+require_relative 'datacaster/hash_schema'
+require_relative 'datacaster/message_keys_merger'
 require_relative 'datacaster/transformer'
 require_relative 'datacaster/trier'
 
@@ -22,29 +24,39 @@ require_relative 'datacaster/or_node'
 require_relative 'datacaster/then_node'
 
 module Datacaster
-  def self.schema(&block)
-    raise "Expected block" unless block
+  extend self
 
-    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
+  def schema(&block)
+    build_schema(Terminator::Raising.instance, &block)
+  end
+
+  def choosy_schema(&block)
+    build_schema(Terminator::Sweeping.instance, &block)
+  end
 
-    datacaster & Terminator.instance
+  def partial_schema(&block)
+    build_schema(nil, &block)
   end
 
-  def self.partial_schema(&block)
+  def absent
+    Datacaster::Absent.instance
+  end
+
+  private
+
+  def build_schema(terminator, &block)
     raise "Expected block" unless block
 
-    datacaster = RunnerContext.instance.instance_eval(&block)
+    definition_context = DefinitionContext.new
+
+    datacaster = definition_context.instance_exec(&block)
+
     unless datacaster.is_a?(Base)
-      raise "Datacaster instance should be returned from a block (e.g. result of 'hash(...)' call)"
+      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
   end
-
-  def self.absent
-    Datacaster::Absent.instance
-  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: datacaster
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 2.0.1
 platform: ruby
 authors:
 - Eugene Zolotarev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-08-14 00:00:00.000000000 Z
+date: 2023-03-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -79,11 +79,12 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/rspec.yml"
 - ".gitignore"
+- ".gitlab-ci.yml"
 - ".rspec"
 - ".travis.yml"
 - Gemfile
-- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -99,12 +100,14 @@ files:
 - lib/datacaster/caster.rb
 - lib/datacaster/checker.rb
 - lib/datacaster/comparator.rb
+- lib/datacaster/config.rb
+- lib/datacaster/definition_context.rb
 - lib/datacaster/hash_mapper.rb
 - lib/datacaster/hash_schema.rb
+- lib/datacaster/message_keys_merger.rb
 - lib/datacaster/or_node.rb
 - lib/datacaster/predefined.rb
 - lib/datacaster/result.rb
-- lib/datacaster/runner_context.rb
 - lib/datacaster/terminator.rb
 - lib/datacaster/then_node.rb
 - lib/datacaster/transformer.rb
@@ -131,7 +134,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.4.1
 signing_key: 
 specification_version: 4
 summary: Run-time type checker and transformer for Ruby

data/Gemfile.lock

@@ -1,59 +0,0 @@
-PATH
-  remote: .
-  specs:
-    datacaster (0.9.0)
-      dry-monads (>= 1.3, < 1.4)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    activemodel (6.0.3.2)
-      activesupport (= 6.0.3.2)
-    activesupport (6.0.3.2)
-      concurrent-ruby (~> 1.0, >= 1.0.2)
-      i18n (>= 0.7, < 2)
-      minitest (~> 5.1)
-      tzinfo (~> 1.1)
-      zeitwerk (~> 2.2, >= 2.2.2)
-    concurrent-ruby (1.1.6)
-    diff-lcs (1.3)
-    dry-core (0.4.9)
-      concurrent-ruby (~> 1.0)
-    dry-equalizer (0.3.0)
-    dry-monads (1.3.5)
-      concurrent-ruby (~> 1.0)
-      dry-core (~> 0.4, >= 0.4.4)
-      dry-equalizer
-    i18n (1.8.3)
-      concurrent-ruby (~> 1.0)
-    minitest (5.14.1)
-    rake (12.3.3)
-    rspec (3.9.0)
-      rspec-core (~> 3.9.0)
-      rspec-expectations (~> 3.9.0)
-      rspec-mocks (~> 3.9.0)
-    rspec-core (3.9.2)
-      rspec-support (~> 3.9.3)
-    rspec-expectations (3.9.2)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.9.0)
-    rspec-mocks (3.9.1)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.9.0)
-    rspec-support (3.9.3)
-    thread_safe (0.3.6)
-    tzinfo (1.2.7)
-      thread_safe (~> 0.1)
-    zeitwerk (2.3.0)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  activemodel (>= 5.2)
-  datacaster!
-  rake (>= 12.0)
-  rspec (~> 3.0)
-
-BUNDLED WITH
-   2.1.4