smart_types 0.1.0.alpha3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fc4e623d3f8d313b11dbd7e483989b3f2b94904a9e3a1ec27edb85095fdc418b
-  data.tar.gz: 3514c7ecfcd83963744f66ce92dfd648bd680b61ad34aaf4c2b0a9207cd842ad
+  metadata.gz: d5f0c7f2b54ceaa7fe20e85d7d280b64b8310eb5f4fa802d11052074e6b10f96
+  data.tar.gz: 021c3c6194fb4f54246f4a44a7c548ce9da0790a66b95e0a060547e73efeaf3f
 SHA512:
-  metadata.gz: a21d4a5a20575cba14a000440c6da87aab465b2aa7c02b2697f13c422fc3c6dbe873c4b2d0fcfec1e5ee182db7a356b8ca0f3bf7beae0f5787b10610d4a3bfca
-  data.tar.gz: 80c82999c44edab7225b5169cbff0586254c5d817efbfb4c5df4f6906f0b794280dd52c7342fe732b30a6b339c96cf24b40d8c79915a679b87fca9e91a3ac6fa
+  metadata.gz: 6e2fc86bcea2292570d2c51e9b95ead6ecc30f8251db75a61fda088c1a84bdb15cea65fdc478728869fb5e5e56b7cddb774938cae38c60e4dee70197e6c1c7f3
+  data.tar.gz: c7b27e2f70f3f8eac851f63365b3287a2c7aeb8f7f999679daa715d5ff7de93b32bd6204ea67f6af2c2ea1e5ccd569027051674c9266c62ff7d425c55692619a

data/.rubocop.yml

@@ -5,7 +5,8 @@ inherit_gem:
     - lib/rubocop.rspec.yml
 
 AllCops:
-  TargetRubyVersion: 2.4.9
+  TargetRubyVersion: 2.7.2
+  NewCops: enable
   Include:
     - lib/**/*.rb
     - spec/**/*.rb
@@ -13,3 +14,11 @@ AllCops:
     - Rakefile
     - smart_types.gemspec
     - bin/console
+
+# 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/.travis.yml

@@ -2,17 +2,18 @@
 language: ruby
 cache: bundler
 os: linux
-before_install: gem install bundler -v 2.1.2
+dist: xenial
+before_install: gem install bundler
 script:
 - bundle exec rake rubocop
 - bundle exec rake rspec
 jobs:
   fast_finish: true
   include:
-  - rvm: 2.4.9
-  - rvm: 2.5.7
-  - rvm: 2.6.5
-  - rvm: 2.7.0
+  - rvm: 2.4.10
+  - rvm: 2.5.8
+  - rvm: 2.6.6
+  - rvm: 2.7.1
   - rvm: ruby-head
   - rvm: jruby-head
   allow_failures:

data/CHANGELOG.md

@@ -1,2 +1,19 @@
 # Changelog
 All notable changes to this project will be documented in this file.
+
+## [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,77 +1,103 @@
 PATH
   remote: .
   specs:
-    smart_types (0.1.0.alpha3)
-      smart_engine (~> 0.5)
+    smart_types (0.2.0)
+      smart_engine (~> 0.7)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    armitage-rubocop (0.79.0)
-      rubocop (= 0.79.0)
-      rubocop-performance (= 1.5.2)
-      rubocop-rails (= 2.4.1)
-      rubocop-rake (= 0.5.0)
-      rubocop-rspec (= 1.37.1)
-    ast (2.4.0)
-    diff-lcs (1.3)
+    activesupport (6.0.3.4)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+      zeitwerk (~> 2.2, >= 2.2.2)
+    armitage-rubocop (1.3.1.1)
+      rubocop (= 1.3.1)
+      rubocop-performance (= 1.9.0)
+      rubocop-rails (= 2.8.1)
+      rubocop-rake (= 0.5.1)
+      rubocop-rspec (= 2.0.0)
+    ast (2.4.1)
+    coderay (1.1.3)
+    concurrent-ruby (1.1.7)
+    diff-lcs (1.4.4)
     docile (1.3.2)
-    jaro_winkler (1.5.4)
-    json (2.3.0)
-    parallel (1.19.1)
-    parser (2.7.0.2)
-      ast (~> 2.4.0)
-    rack (2.1.1)
+    i18n (1.8.5)
+      concurrent-ruby (~> 1.0)
+    method_source (1.0.0)
+    minitest (5.14.2)
+    parallel (1.20.0)
+    parser (2.7.2.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)
-    rspec (3.9.0)
-      rspec-core (~> 3.9.0)
-      rspec-expectations (~> 3.9.0)
-      rspec-mocks (~> 3.9.0)
-    rspec-core (3.9.1)
-      rspec-support (~> 3.9.1)
-    rspec-expectations (3.9.0)
+    regexp_parser (1.8.2)
+    rexml (3.2.4)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.0)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.0)
       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.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.9.0)
-    rspec-support (3.9.2)
-    rubocop (0.79.0)
-      jaro_winkler (~> 1.5.1)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.0)
+    rubocop (1.3.1)
       parallel (~> 1.10)
-      parser (>= 2.7.0.1)
+      parser (>= 2.7.1.5)
       rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8)
+      rexml
+      rubocop-ast (>= 1.1.1)
       ruby-progressbar (~> 1.7)
-      unicode-display_width (>= 1.4.0, < 1.7)
-    rubocop-performance (1.5.2)
-      rubocop (>= 0.71.0)
-    rubocop-rails (2.4.1)
+      unicode-display_width (>= 1.4.0, < 2.0)
+    rubocop-ast (1.1.1)
+      parser (>= 2.7.1.5)
+    rubocop-performance (1.9.0)
+      rubocop (>= 0.90.0, < 2.0)
+      rubocop-ast (>= 0.4.0)
+    rubocop-rails (2.8.1)
+      activesupport (>= 4.2.0)
       rack (>= 1.1)
-      rubocop (>= 0.72.0)
-    rubocop-rake (0.5.0)
+      rubocop (>= 0.87.0)
+    rubocop-rake (0.5.1)
       rubocop
-    rubocop-rspec (1.37.1)
-      rubocop (>= 0.68.1)
+    rubocop-rspec (2.0.0)
+      rubocop (~> 1.0)
+      rubocop-ast (>= 1.1.0)
     ruby-progressbar (1.10.1)
-    simplecov (0.17.1)
+    simplecov (0.19.1)
       docile (~> 1.1)
-      json (>= 1.8, < 3)
-      simplecov-html (~> 0.10.0)
-    simplecov-html (0.10.2)
-    smart_engine (0.5.0)
-    unicode-display_width (1.6.0)
+      simplecov-html (~> 0.11)
+    simplecov-html (0.12.3)
+    smart_engine (0.8.0)
+    thread_safe (0.3.6)
+    tzinfo (1.2.8)
+      thread_safe (~> 0.1)
+    unicode-display_width (1.7.0)
+    zeitwerk (2.4.1)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  armitage-rubocop (~> 0.78)
+  armitage-rubocop (~> 1.3)
   bundler (~> 2.1)
+  pry (~> 0.13)
   rake (~> 13.0)
-  rspec (~> 3.9)
-  simplecov (~> 0.17)
+  rspec (~> 3.10)
+  simplecov (~> 0.19)
   smart_types!
 
 BUNDLED WITH
-   2.1.2
+   2.1.4

data/README.md

@@ -2,12 +2,10 @@
 
 > A set of objects that acts like types (type checking and type casting) with a support for basic type algebra.
 
-Full-featured type system for any ruby project. Supports custom type definitioning,
+Minimalistic type system for any ruby project. Supports custom type definitioning,
 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.
 
-Just add and use :) Enjoy! :)
-
 ## Installation
 
 ```ruby
@@ -41,77 +39,349 @@ type4 = type1 & type2
 
 ## Supported types
 
-- Primitive Value Types:
+- Primitives
 
 ```ruby
 SmartCore::Types::Value::Any
+SmartCore::Types::Value::Nil
 SmartCore::Types::Value::String
 SmartCore::Types::Value::Symbol
 SmartCore::Types::Value::Text
 SmartCore::Types::Value::Integer
 SmartCore::Types::Value::Float
 SmartCore::Types::Value::Numeric
+SmartCore::Types::Value::BigDecimal
 SmartCore::Types::Value::Boolean
 SmartCore::Types::Value::Array
 SmartCore::Types::Value::Hash
 SmartCore::Types::Value::Proc
 SmartCore::Types::Value::Class
 SmartCore::Types::Value::Module
+SmartCore::Types::Value::Time
+SmartCore::Types::Value::DateTime
+SmartCore::Types::Value::Date
+SmartCore::Types::Value::TimeBased
 ```
 
 ---
 
 ## Nilable types
 
+- invoke `.nilable` on any type object:
+
 ```ruby
-SmartCore::Types::Value::Any.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::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
+# -- or --
+SmartCore::Types::Value::Time.nilable
+# and etc.
 ```
 
 ---
 
-## Type validation and type casting
+## 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|
+    value.is_a?(::String)
+  end
+
+  type.define_caster do |value|
+    value.to_s
+  end
+end
+```
+
+#### With type invariants
+
+```ruby
+SmartCore::Types::Value.define_type(:String) do |type|
+  type.define_checker do |value|
+    value.is_a?(::String)
+  end
+
+  type.define_caster do |value|
+    value.to_s
+  end
+
+  # NOTE:
+  #    invariant defined out from chain does not depends on other invariants
+  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]+/) }
+    # NOTE:
+    #   inside a chain each next invariant invokation
+    #   depends on previous successful invariant check
+  end
+end
 ```
 
 ---
 
-## Custom type definition
+## 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 :)
+
 
 ```ruby
-# documentation is coming
+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
+
+```
+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
 ```
 
 ---
 
-## Type system integration
+## Roadmap
+
+- type configuration:
 
 ```ruby
-# documentation is coming
+SmartCore::Types::Value.type(:Time) do |type|
+  type.configuration do |config| # config definition
+    setting :iso, :rfc2822
+    # TODO: think about a more convinient DSL
+  end
+
+  type.define_caster do |value, config| # config usage
+    case config.standard
+    when :rfc2822
+      ::Time.rfc2822(value)
+    else
+      # ...
+    end
+  end
+end
 ```
 
----
+- pipelined type caster definition for the sum-based types:
+
+```ruby
+SmartCore::Types::Value::TimeLike = SmartCore::Types::System.type_sum(
+  SmartCore::Types::Time,
+  SmartCore::Types::DateTime,
+  SmartCore::Types::Date,
+) do |type|
+  type.define_caster(:pipelined) # try Time.cast => try DateTime.cast => try Date.cast
+end
+```
+
+- namespaced type errors:
+
+```ruby
+# before:
+SmartCore::Types::Value::Boolean.validate!(123)
+# => SmartCore::Types::TypeError
+SmartCore::Types::Value::Class.cast(123)
+# => SmartCore::Types::TypeCastingError
+
+# after:
+SmartCore::Types::Value::Boolean.validate!(123)
+# => SmartCore::Types::Value::Boolean::TypeError
+# (inheritance tree: Types::Value::<Type>::TypeError => Types::Value::TypeError => Types::TypeError)
+
+SmartCore::Types::Value::Class.cast(123)
+# => SmartCore::Types::Value::Class::TypeCastingError
+# (inheritance tree: the same as above)
+```
+
+- type refinements:
+
+```ruby
+SmartCore::Types::Value::Time.refine_checker do |value, original_checker|
+  # new type checker
+end
+
+SmartCore::Types::Value::Time.refine_caster do |value, original_caster|
+  # new type caster
+end
+
+# .refine_invariant
+# .refine_invariant_chain
+```
+
+- options for type casters:
+
+```ruby
+SmartCore::Types::Value.define_type(:Date) do |type|
+  type.define_caster do |value, options = {}| # options goes here
+    iso = options.fetch(:iso, nil)
+    iso ? ::Date.pasre(value, iso) : ::Date.parse(value)
+  end
+end
+
+# usage:
+SmartCore::Types::Value::Date.cast('2020-01-01', { iso: :rfc3339 })
+```
+
+- new types:
+
+```ruby
+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::Set
+SmartCore::Types::Value::SortedSet
+SmartCore::Types::Value::IO
+SmartCore::Types::Value::StringIO
+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
+```
+
+- 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