smart_types 0.1.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 12c87a28e4cb88c84907c5d811253c4cb70e3e4aad462010c47c1a6d88c21d81
-  data.tar.gz: af0155909d10f02369aa5b60c97de4b0b91fbfad92ba79d1f94b5b3333ede373
+  metadata.gz: 7d46db58ce368955b324f4acb5fbfa74100789abe263c8e83fa8a73c482b6dd4
+  data.tar.gz: f5377e4cc8693855b885d197f1d5b8429ba78efc30b781703a2ba95230d58d2b
 SHA512:
-  metadata.gz: aa5eb3001d7909b30e9fe2df27b92bff6ee22d9e92ef27f37dfbe11c18f968ee932cf0e064ecb2db808d8a0913d3c5fe7650d0d7b15af51bbe4591afeef39670
-  data.tar.gz: e0fa90c1783113d8d702414596cf001e0e54b786c6d21248e52f5e2401901eddebb09d182349abccda301998782242fa02d4a94e61eb2a3f301fe982a7d5ceff
+  metadata.gz: 294f3ef4a287aef01cbf48c6250ece9190effee142b42596a453657f7ed541080d964c4d22e56113c8a7fc80298f2dfd5fefe92159a8499829b34d5a993b0ddb
+  data.tar.gz: a515dad1255bf4b3e757d12011f8c4eedde8a79fd265e5acba10e5a19282c40f3f61d85aa094cb962c1029329b06cd225a828aa9bd23bfaec6e575b89bd945a0

data/.rubocop.yml

@@ -5,7 +5,8 @@ inherit_gem:
     - lib/rubocop.rspec.yml
 
 AllCops:
-  TargetRubyVersion: 2.7.1
+  TargetRubyVersion: 3.0.0
+  NewCops: enable
   Include:
     - lib/**/*.rb
     - spec/**/*.rb
@@ -17,3 +18,7 @@ AllCops:
 # NOTE: support for old ruby versions
 Style/RedundantBegin:
   Enabled: false
+
+# NOTE: used only in specs and it is ok in specs
+Lint/EmptyBlock:
+  Enabled: false

data/CHANGELOG.md

@@ -1,2 +1,59 @@
 # Changelog
 All notable changes to this project will be documented in this file.
+
+# [0.6.0] - 2021-04-29
+### Added
+- New type of `SmartCode::Types::Variadic` category:
+  - `SmartCore::Types::Variadic::ArrayOf` (`Array` with element types validation)
+
+
+# [0.5.0] - 2021-01-28
+### Added
+- New types of `SmartCore::Types::Variadic` category:
+  - `SmartCore::Types::Variadic::Enum` (a simple enumeration on plain values);
+
+# [0.4.0] - 2021-01-18
+### Added
+- Support for *Ruby 3*;
+
+## [0.3.0] - 2020-12-22
+### Added
+- Extended **Type Definition API**: support for **runtime attributes**:
+  - Type checkers, type casters and type invariants now receives runtime attributes (you can omit these);
+  - Type definitioning extended with `runtime_attribute_checker`-checker definition (runtime attributes validator);
+  - Types with incorrect runtime attributes will raise `SmartCore::Types::IncorrectRuntimeAttributesError` exception;
+  - Types which has no support for runtime attributes will raise `SmartCore::Types::RuntimeAttributesUnsupportedError` excpetion;
+  - All types by default has a method alias (`()`) which does not allow runtime attributes (for example: `SmartCore::Types::Value::String` has
+    a runtime-based alias `SmartCore::Types::Value::String()` which does not accept any attribute
+    (`SmartCore::Types::Value::String('test')` will raise `SmartCore::Types::RuntimeAttributesUnsupportedError` respectively));
+- Extended Internal **Type Development API**:
+  - all types has a reference to it's type category;
+- Brand new `SmartCore::Types::Protocol` type category and new types:
+  - `SmartCore::Types::Protocol::InstanceOf` (runtime-based type);
+- Brand new `SmartCore::Types::Variadic` type category and new types:
+  - `SmartCore::Types::Variadic::Tuple` (runtime-based type);
+- New types of `SmartCore::Types::Value` category:
+  - `SmartCore::Types::Value::Set` (based on `Set` type with a support for type casting);
+- Support for BasicObject values inside type checkers that can not be checked correctly via `#is_a?/#kind_of?` before;
+
+### Changed
+- Updated development dependencies;
+- Drop `Travis CI` (TODO: migrate to `Github Actions`);
+- **Ruby@2.4** is no longer supported;
+
+## [0.2.0] - 2020-11-21
+### Added
+- Brand new **Type invariant API**:
+  - globally refactored validation logic (with backward compatability for `#valid?(value)` method);
+  - new type definition DSL: `.invariant(name)` and `.invariant_chain(name)`;
+  - chained invariants will be invoked according to the definition order (second invokation
+    depends on previous successful invariant check);
+  - new validation API: `validate(value)` (with `#errors` support based on invariant names);
+  - at this moment Invariant API is supported only by primitive types (type sum and type multiplication support coming soon);
+
+### Changed
+
+- Updated `smart_engine` dependency (to `~> 0.7`) (need `SmartCore::Engine::Atom`);
+
+## [0.1.0] - 2020-05-05
+- Release :)

data/Gemfile.lock

@@ -1,92 +1,105 @@
 PATH
   remote: .
   specs:
-    smart_types (0.1.0)
-      smart_engine (~> 0.6)
+    smart_types (0.6.0)
+      smart_engine (~> 0.11)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (6.0.2.2)
+    activesupport (6.1.1)
       concurrent-ruby (~> 1.0, >= 1.0.2)
-      i18n (>= 0.7, < 2)
-      minitest (~> 5.1)
-      tzinfo (~> 1.1)
-      zeitwerk (~> 2.2)
-    armitage-rubocop (0.82.0.2)
-      rubocop (= 0.82.0)
-      rubocop-performance (= 1.5.2)
-      rubocop-rails (= 2.5.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+      zeitwerk (~> 2.3)
+    armitage-rubocop (1.7.0.1)
+      rubocop (= 1.7.0)
+      rubocop-performance (= 1.9.1)
+      rubocop-rails (= 2.9.1)
       rubocop-rake (= 0.5.1)
-      rubocop-rspec (= 1.39.0)
-    ast (2.4.0)
-    concurrent-ruby (1.1.6)
-    diff-lcs (1.3)
-    docile (1.3.2)
-    i18n (1.8.2)
+      rubocop-rspec (= 2.1.0)
+    ast (2.4.1)
+    coderay (1.1.3)
+    concurrent-ruby (1.1.7)
+    diff-lcs (1.4.4)
+    docile (1.3.5)
+    i18n (1.8.7)
       concurrent-ruby (~> 1.0)
-    jaro_winkler (1.5.4)
-    minitest (5.14.0)
-    parallel (1.19.1)
-    parser (2.7.1.2)
-      ast (~> 2.4.0)
-    rack (2.2.2)
+    method_source (1.0.0)
+    minitest (5.14.3)
+    parallel (1.20.1)
+    parser (3.0.0.0)
+      ast (~> 2.4.1)
+    pry (0.13.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    rack (2.2.3)
     rainbow (3.0.0)
-    rake (13.0.1)
+    rake (13.0.3)
+    regexp_parser (2.0.3)
     rexml (3.2.4)
-    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.1)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.9.0)
-    rspec-mocks (3.9.1)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.1)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.9.0)
-    rspec-support (3.9.3)
-    rubocop (0.82.0)
-      jaro_winkler (~> 1.5.1)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.1)
+    rubocop (1.7.0)
       parallel (~> 1.10)
-      parser (>= 2.7.0.1)
+      parser (>= 2.7.1.5)
       rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
       rexml
+      rubocop-ast (>= 1.2.0, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 1.4.0, < 2.0)
-    rubocop-performance (1.5.2)
-      rubocop (>= 0.71.0)
-    rubocop-rails (2.5.2)
-      activesupport
+    rubocop-ast (1.4.0)
+      parser (>= 2.7.1.5)
+    rubocop-performance (1.9.1)
+      rubocop (>= 0.90.0, < 2.0)
+      rubocop-ast (>= 0.4.0)
+    rubocop-rails (2.9.1)
+      activesupport (>= 4.2.0)
       rack (>= 1.1)
-      rubocop (>= 0.72.0)
+      rubocop (>= 0.90.0, < 2.0)
     rubocop-rake (0.5.1)
       rubocop
-    rubocop-rspec (1.39.0)
-      rubocop (>= 0.68.1)
-    ruby-progressbar (1.10.1)
-    simplecov (0.18.5)
+    rubocop-rspec (2.1.0)
+      rubocop (~> 1.0)
+      rubocop-ast (>= 1.1.0)
+    ruby-progressbar (1.11.0)
+    simplecov (0.21.2)
       docile (~> 1.1)
       simplecov-html (~> 0.11)
-    simplecov-html (0.12.2)
-    smart_engine (0.6.0)
-    thread_safe (0.3.6)
-    tzinfo (1.2.7)
-      thread_safe (~> 0.1)
+      simplecov_json_formatter (~> 0.1)
+    simplecov-html (0.12.3)
+    simplecov_json_formatter (0.1.2)
+    smart_engine (0.11.0)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
     unicode-display_width (1.7.0)
-    zeitwerk (2.3.0)
+    zeitwerk (2.4.2)
 
 PLATFORMS
-  ruby
+  x86_64-darwin-19
+  x86_64-darwin-20
 
 DEPENDENCIES
-  armitage-rubocop (~> 0.82)
+  armitage-rubocop (~> 1.7)
   bundler (~> 2.1)
+  pry (~> 0.13)
   rake (~> 13.0)
-  rspec (~> 3.9)
-  simplecov (~> 0.18)
+  rspec (~> 3.10)
+  simplecov (~> 0.21)
   smart_types!
 
 BUNDLED WITH
-   2.1.4
+   2.2.3

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2020 Rustam Ibragimov
+Copyright (c) 2020-2021 Rustam Ibragimov
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,4 +1,4 @@
-# SmartCore::Types · [![Gem Version](https://badge.fury.io/rb/smart_types.svg)](https://badge.fury.io/rb/smart_types) [![Build Status](https://travis-ci.org/smart-rb/smart_types.svg?branch=master)](https://travis-ci.org/smart-rb/smart_types)
+# SmartCore::Types · [![Supporting](https://github.com/Cado-Labs/cado-labs-logos/blob/main/cado_labs_badge.png)](https://github.com/Cado-Labs/) · [![Gem Version](https://badge.fury.io/rb/smart_types.svg)](https://badge.fury.io/rb/smart_types)
 
 > A set of objects that acts like types (type checking and type casting) with a support for basic type algebra.
 
@@ -6,6 +6,16 @@ Minimalistic type system for any ruby project. Supports custom type definitionin
 type validation, type casting and type categorizing. Provides a set of commonly used type
 categories and general purpose types. Has a flexible and simplest type definition toolchain.
 
+---
+
+<p>
+  <a href="https://github.com/Cado-Labs">
+    <img src="https://github.com/Cado-Labs/cado-labs-logos/blob/main/cado_labs_supporting.svg" alt="Supported by Cado Labs" />
+  </a>
+</p>
+
+---
+
 ## Installation
 
 ```ruby
@@ -24,7 +34,28 @@ require 'smart_core/types'
 
 ---
 
-## Type Interface
+## Usage
+
+- [Type interface and basic type algebra](#type-interface-and-basic-type-algebra)
+- [Supported types](#supported-types)
+  - [Primitives](#primitives) (`SmartCore::Types::Value`)
+  - [Protocols](#protocols) (`SmartCore::Types::Protocol`)
+  - [Variadic](#variadic) (`SmartCore::Types::Variadic`)
+- [Nilable types](#nilable-types)
+- [Custom type definition](#custom-type-definition)
+  - [Primitive type definition](#primitive-type-definition)
+  - [With type invariants](#with-type-invariants)
+- [Type validation](#type-validation)
+- [Type casting](#type-casting)
+- [Roadmap](#roadmap)
+- [Contributing](#contributing)
+- [Build](#build)
+- [License](#license)
+- [Authors](#authors)
+
+---
+
+## Type Interface and basic type algebra
 
 ```ruby
 # documentation is coming
@@ -37,9 +68,24 @@ type3 = type1 | type2
 type4 = type1 & type2
 ```
 
+Types with runtime:
+
+```ruby
+# get a type object with a custom runtime (instances of String or Symbol):
+type = SmartCore::Types::Protocol::InstanceOf(::String, ::Symbol)
+type.valid?(:test) # => true
+type.valid?('test') # => true
+type.valid?(123.456) # => false
+
+# another type object with a custom runtime (tuple (String, Integer, Time)):
+type = SmartCore::Types::Variadic::Tuple(::String, ::Integer, ::DateTime)
+type.valid?(['test', 1, DateTime.new]) # => true
+type.valid?([:test, 2]) # => false
+```
+
 ## Supported types
 
-- Primitive Value Types:
+#### Primitives:
 
 ```ruby
 SmartCore::Types::Value::Any
@@ -53,6 +99,7 @@ SmartCore::Types::Value::Numeric
 SmartCore::Types::Value::BigDecimal
 SmartCore::Types::Value::Boolean
 SmartCore::Types::Value::Array
+SmartCore::Types::Value::Set
 SmartCore::Types::Value::Hash
 SmartCore::Types::Value::Proc
 SmartCore::Types::Value::Class
@@ -65,52 +112,188 @@ SmartCore::Types::Value::TimeBased
 
 ---
 
-## Nilable types
+#### Protocols:
 
 ```ruby
-SmartCore::Types::Value::Any.nilable
-SmartCore::Types::Value::Nil.nilable
-SmartCore::Types::Value::String.nilable
-SmartCore::Types::Value::Symbol.nilable
-SmartCore::Types::Value::Text.nilable
-SmartCore::Types::Value::Integer.nilable
-SmartCore::Types::Value::Float.nilable
-SmartCore::Types::Value::Numeric.nilable
-SmartCore::Types::Value::BigDecimal.nilable
-SmartCore::Types::Value::Boolean.nilable
-SmartCore::Types::Value::Array.nilable
-SmartCore::Types::Value::Hash.nilable
-SmartCore::Types::Value::Proc.nilable
-SmartCore::Types::Value::Class.nilable
-SmartCore::Types::Value::Module.nilable
-SmartCore::Types::Value::Time.nilable.nilable
-SmartCore::Types::Value::DateTime.nilable
-SmartCore::Types::Value::Date.nilable
-SmartCore::Types::Value::TimeBased
+SmartCore::Types::Protocol::InstanceOf
+```
+
+```ruby
+# examples (SmartCore::Types::Protocol::InstanceOf):
+SmartCore::Types::Protocol::InstanceOf(::Integer) # only integer
+SmartCore::Types::Protocol::InstanceOf(::String, ::Symbol) # string or symbol
+SmartCore::Types::Protocol::InstanceOf(::Time, ::DateTime, ::Date) # time or datetime or date
 ```
 
 ---
 
-## Type validation and type casting
+#### Variadic:
 
 ```ruby
-# documentation is coming
+SmartCore::Types::Variadic::ArrayOf
+SmartCore::Types::Variadic::Enum
+SmartCore::Types::Variadic::Tuple
+```
 
-SmartCore::Types::Value::String.valid?('test') # => true
-SmartCore::Types::Value::String.valid?(123.45) # => false
+```ruby
+# example (SmartCore::Types::Variadic::ArrayOf):
+SmartCore::Types::Variadic::ArrayOf(::String, ::Array) # array of strings or arrays
 
-SmartCore::Types::Value::String.cast(123) # => "123"
-SmartCore::Types::Value::Float.cast('55') # => 55.0
+# example (SmartCore::Types::Variadic::Enum):
+SmartCore::Types::Variadic::Enum('string', 1337, :symbol) # one of enumerated values
+
+# examples (SmartCore::Types::Variadic::Tuple):
+SmartCore::Types::Variadic::Tuple(::String, ::Integer, ::Time) # array with signature [<string>, <integer>, <time>]
+SmartCore::Types::Variadic::Tuple(::Symbol, ::Float) # array with signature [<symbol>, <float>]
+```
+
+---
+
+## Nilable types
+
+- invoke `.nilable` on any type object:
+
+```ruby
+SmartCore::Types::Value::String.nilable
+# -- or --
+SmartCore::Types::Value::Time.nilable
+# and etc.
 ```
 
 ---
 
 ## Custom type definition
 
+Type definition is a composition of:
+
+- type checker (required);
+- type caster (optional);
+- type invariants (optional);
+- type invariant chains (optional);
+
+Invariant is a custom validation block that will work as a logical value checker. You can have as much invariants as you want.
+
+Type invariants does not depends on each other (invariant defined out from chain does not depends on other invariants);
+
+Invariants inside invariant chains will be invoked in order they was defined and each internal invariant depends on the valid previous invairant check.
+
+**!IMPORTANT!** Type sum and type multiplication does not support invariant checking and custom invariant definitioning at this moment.
+Type sum and type mult ignores type invariants in their validation logic (currently this functionality in development yet).
+
+Invariant checking is a special validation layer (see [#type validation](#type-validation) readme section). Invariant error code pattern:
+  - for invariant chains: `TypeName.invariant_chain_name.invariant_name`;
+  - for single invariant: `TypeName.invariant_name`;
+
+#### Primitive type definition
+
 ```ruby
 # documentation is coming
 
 # example:
+SmartCore::Types::Value.define_type(:String) do |type|
+  type.define_checker do |value, runtime_attrs| # runtime attributes are optional
+    value.is_a?(::String)
+  end
+
+  type.define_caster do |value, runtime_attrs| # runtime attributes are optional
+    value.to_s
+  end
+end
+
+# get a type object:
+SmartCore::Types::Value::String
+# --- or ---
+SmartCore::Types::Value::String() # without runtime attributes
+# --- or ---
+SmartCore::Types::Value::String('some_attr', :another_attr) # with runtime attributes
+
+# work with type object: see documentation below
+```
+
+#### With type invariants
+
+```ruby
+SmartCore::Types::Value.define_type(:String) do |type|
+  type.define_checker do |value, runtime_attrs|
+    value.is_a?(::String)
+  end
+
+  type.define_caster do |value, runtime_attrs|
+    value.to_s
+  end
+
+  # NOTE:
+  #    invariant defined out from chain does not depends on other invariants
+  type.invariant(:uncensored_content) do |value, runtime_attrs|
+    !value.include?('uncensored_word')
+  end
+
+  type.invariant(:filled) do |value, runtime_attrs|
+    value != ''
+  end
+
+  type.invariant_chain(:password) do
+    invariant(:should_present) do |value, runtime_attrs|
+      value != ''
+    end
+
+    invariant(:should_have_numbers) do |value, runtime_attrs|
+      v.match?(/[0-9]+/)
+    end
+
+    # NOTE:
+    #   inside a chain each next invariant invokation
+    #   depends on previous successful invariant check
+  end
+end
+```
+
+---
+
+## Type validation
+
+Type validation reflects on two APIs:
+
+- type checker ([how to define type checkers](#custom-type-definition));
+- type invariants (invariants and invariant chains) ([how to define type invariants](#custom-type-definition));
+
+Type invariants does not depends on each other (invariant defined out from the chain does not depends on other invariants);
+
+Invariants inside invariant chains will be invoked in order they was defined and each internal invariant depends on the valid previous invairant check.
+
+**!IMPORTANT!** Type sum and type multiplication does not support invariant checking and custom invariant definitioning at this moment.
+Type sum and type mult ignores type invariants in their validation logic (currently this functionality in development yet).
+
+Invariant checking is a special validation layer (see [#type validation](#type-validation) readme section) and represents a set of error codes in result object;
+
+Type valdiation interface:
+
+- `valid?(value)` - validates value and returns `true` or `false`;
+  - returns `ture` only if the type checker returns `true` and all invariants are valid;
+- `validate(value)` - validates value and returns the monadic result object:
+  - `SmartCore::Types::Primitive::Validator::Result` for primitive types;
+  - `SmartCore::Types::Primitive::SumValidator::Result` for sum-based types;
+  - `SmartCore::Types::Primitive::MultValidator::Result` for mult-based types;
+  - `SmartCore::Types::Primitive::NilableValidator::Result` for nilable types;
+- `validate!(value)` - validates value and returns nothing (for successful validation) or
+  raises an exception (`SmartCore::Types::TypeError`) (for unsuccessful validation);
+
+Validation result object interface:
+
+- `#success?` / `#failure?` (`#success?` is a combination of `valid_check? && valid_invariants?`; `#failure?` - is an opposite of `#success?`);
+- `#valid_check?` (valid type checker or not);
+- `#valid_invariants?` (`false` if at least one invariant is invalid);
+- `#errors` (the same as `#invariant_errors` and the same as `#error_codes`) - an array of failed invariant names;
+  - error code patterns:
+    - for invariant chains: `TypeName.invariant_chain_name.invariant_name`;
+    - for single invariant: `TypeName.invariant_name`;
+- `#checked_value` (the same as `#value`) - checked value :)
+
+---
+
+Imagine that we have `String` type like this:
+
+```ruby
 SmartCore::Types::Value.define_type(:String) do |type|
   type.define_checker do |value|
     value.is_a?(::String)
@@ -119,21 +302,94 @@ SmartCore::Types::Value.define_type(:String) do |type|
   type.define_caster do |value|
     value.to_s
   end
+
+  type.invariant(:uncensored_content) do |value|
+    !value.include?('uncensored_word')
+  end
+
+  type.invariant(:filled) do |value|
+    value != ''
+  end
+
+  type.invariant_chain(:password) do
+    invariant(:should_present) { |value| value != '' }
+    invariant(:should_have_numbers) { |value| v.match?(/[0-9]+/) }
+  end
 end
 ```
 
+Validation interface and usage:
+
+```ruby
+SmartCore::Types::Value::String.valid?('test123') # => true
+SmartCore::Types::Value::String.valid?(123.45) # => false
+```
+
+```ruby
+result = SmartCore::Types::Value::String.validate('test')
+
+result.checked_value # => 'test'
+# --- same as: ---
+result.value
+
+result.success? # => false (valid_check? && valid_invariants?)
+result.failure? # => true
+
+result.valid_check? # => true
+result.valid_invariants? # => false
+
+# invariant errors:
+result.errors # => ['String.password.should_have_numbers']
+# -- same as: ---
+result.invariant_errors
+# -- same as: ---
+result.error_codes
+```
+
+```ruby
+result = SmartCore::Types::Value::String.validate('test1234')
+result.success? # => true
+result.errors # => []
+```
+
+```ruby
+SmartCore::Types::Value::String.validate!('test') # => SmartCore::Types::TypeError
+```
+
+---
+
+## Type casting
+
+```ruby
+SmartCore::Types::Value::String.cast(123) # => "123"
+SmartCore::Types::Value::Float.cast('55') # => 55.0
+```
+
 ---
 
 ## Basic type algebra
 
+> (type sum and type multiplication does not support invariants at this moment (in development yet));
+
 ```ruby
 # documentation is coming
+
+# how to define primitive type sum:
+SmartCore::Types::Value::Text = SmartCore::Types::Value::String | SmartCore::Types::Value::Symbol
+SmartCore::Types::Value::Numeric = SmartCore::Types::Value::Float | SmartCore::Types::Value::Integer
+
+# how to define primitive type multiplication:
+SmartCore::Types::Value::CryptoString = SmartCore::Types::Value::NumberdString & SmartCore::Types::Value::SymbolicString
 ```
 
 ---
 
 ## Roadmap
 
+- migrate to `Github Actions`;
+
+- support for `block`-attribute in runtime attributes;
+
 - type configuration:
 
 ```ruby
@@ -195,6 +451,18 @@ end
 SmartCore::Types::Value::Time.refine_caster do |value, original_caster|
   # new type caster
 end
+
+SmartCore::Types::Value::Time.refine_runtime_attributes_checker do |value, original_checker|
+  # new runtime attribute checker
+end
+
+SmartCore::Types::Value::Time.refine_invariant(:name) do |value|
+  # new invariant
+end
+
+SmartCore::Types::Value::Time.refine_invariant_chain(:chain_name) do
+  # new invariant chain
+end
 ```
 
 - options for type casters:
@@ -218,23 +486,52 @@ SmartCore::Types::Value::Method
 SmartCore::Types::Value::UnboundMethod
 SmartCore::Types::Value::Enumerable
 SmartCore::Types::Value::Comparable
+SmartCore::Types::Value::Enumerator
+SmartCore::Types::Value::EnumeratorChain
+SmartCore::Types::Value::Range
+SmartCore::Types::Value::Rational
+SmartCore::Types::Value::SortedSet
+SmartCore::Types::Value::IO
+SmartCore::Types::Value::StringIO
+SmartCore::Types::Value::BasicObject
 SmartCore::Types::Struct::Schema
+SmartCore::Types::Struct::JSONSchema
 SmartCore::Types::Struct::StrictArray
 SmartCore::Types::Struct::StrictHash
 SmartCore::Types::Struct::Map
-SmartCore::Types::Variative::Enum
-SmartCore::Types::Variative::Variant
-SmartCore::Types::Protocol::InstanceOf
 SmartCore::Types::Protocol::Interface
 SmartCore::Types::Protocol::Ancestors
 SmartCore::Types::Protocol::Enumerable
 SmartCore::Types::Protocol::Comparable
 SmartCore::Types::Protocol::Forwardable
+SmartCore::Types::Protocol::Callable
 ```
 
-- constrained types;
+- `#sum` alias for `|` and `#mult` alias for `&` (with a support for type name definition and other API);
 
-- module-based integration;
+- type category in invariant error codes:
+```ruby
+# before:
+'String.password.should_contain_numbers' # `String` type from `Value` category
+
+# after:
+'Value.String.password.should_contain_numbers' # `Value::String`
+```
+
+- support for type of empty non-defined type (`SmartCore::Types::Primitive::Undefined`);
+- constrained types;
+- moudle-based type system integration;
+- constructor implementation and support;
+- support for invariant checking (and custom definitioning) in sum-types;
+  - to provide a type comparability and compatability between all passed types
+    you should provide `type.reconcilable { |value, *types| .... }`  setting;
+  - `type.reconcilable` should be accesible for type sum and type mult definitions;
+  - (**preliminarily**) invariants of the concrete passed type should be valid for sucessful invariant check;
+- support for invariant checking (and definitioning) in mult-types;
+  - to provide a type comparability and compatability between all passed types
+    you should provide `type.reconcilable { |value, *types| .... }`  setting;
+  - `type.reconcilable` should be accesible for type sum and type mult definitions;
+  - (**preliminarily**) all invariants of all types should be valid for sucessful invariant check;
 
 ## Contributing
 
@@ -244,10 +541,42 @@ SmartCore::Types::Protocol::Forwardable
 - Push to the branch (`git push origin feature/my-new-feature`)
 - Create new Pull Request
 
+## Build
+
+- run tests:
+
+```shell
+bundle exec rake rspec
+# --- or ---
+bundle exec rspec
+```
+
+- run code stye linting:
+
+```shell
+bundle exec rake rubocop
+# --- or ---
+bundle exec rubocop
+```
+
+- run code style linting with auto-correction:
+
+```shell
+bundle exec rake rubcoop -A
+# --- or ---
+bundle exec rubocop -A
+```
+
 ## License
 
 Released under MIT License.
 
+## Supporting
+
+<a href="https://github.com/Cado-Labs">
+  <img src="https://github.com/Cado-Labs/cado-labs-logos/blob/main/cado_labs_logo.png" alt="Supported by Cado Labs" />
+</a>
+
 ## Authors
 
 [Rustam Ibragimov](https://github.com/0exp)