kind 5.1.0 → 5.5.0

data/README.md

@@ -1,7 +1,6 @@
 <p align="center">
   <h1 align="center">🤷 kind</h1>
-  <p align="center"><i>A simple type system (at runtime) for Ruby - free of dependencies.</i></p>
-  <br>
+  <p align="center"><i>A development toolkit for Ruby with several small/cohesive abstractions to empower your development workflow - It's totally free of dependencies.</i></p>
 </p>
 
 <p align="center">
@@ -9,16 +8,18 @@
     <img alt="Gem" src="https://img.shields.io/gem/v/kind.svg?style=flat-square">
   </a>
 
-  <img src="https://img.shields.io/badge/ruby%20%3E=%202.1.0,%20%3C%203.1-ruby.svg?colorA=99004d&colorB=cc0066" alt="Ruby">
-
-  <img src="https://img.shields.io/badge/rails%20%3E=%203.2.0,%20%3C%207-rails.svg?colorA=8B0000&colorB=FF0000" alt="Rails">
-
-  <br />
-
   <a href="https://travis-ci.com/serradura/kind">
     <img alt="Build Status" src="https://travis-ci.com/serradura/kind.svg?branch=master">
   </a>
 
+  <br />
+
+  <img src="https://img.shields.io/badge/ruby%20%3E=%202.1,%20%3C%203.1-ruby.svg?colorA=99004d&colorB=cc0066" alt="Ruby">
+
+  <img src="https://img.shields.io/badge/rails%20%3E=%203.2.0,%20%3C%207.0-rails.svg?colorA=8B0000&colorB=FF0000" alt="Rails">
+
+  <br />
+
   <a href="https://codeclimate.com/github/serradura/kind/maintainability">
     <img alt="Maintainability" src="https://api.codeclimate.com/v1/badges/711329decb2806ccac95/maintainability">
   </a>
@@ -30,20 +31,22 @@
 
 **Motivation:**
 
-As a creator of Ruby gems, I have a common need that I have to handle in many of my projects: type checking of method arguments.
+This project was born to help me with a simple task, create a light and fast type checker (at runtime) for Ruby. The initial idea was to have something to raise an exception when a method or function (procs) received a wrong input.
+
+But through time it was natural the addition of more features to improve the development workflow, like monads ([`Kind::Maybe`](#kindmaybe), `Kind::Either` / `Kind::Result`),  enums (`Kind::Enum`), immutable objects (`Kind::ImmutableAttributes`), [type validation via ActiveModel::Validation](#kindvalidator-activemodelvalidations), and several abstractions to help the implementation of business logic (`Kind::Functional::Steps`, `Kind::Functional::Action`, `Kind::Action`).
 
-One of the goals of this project is to do simple type checking like `"some string".is_a?(String)`, but, exposing useful abstractions around this. e.g: [Kind.\<Type\> methods](#verifying-the-kind-of-some-object), [active model validations](#kindvalidator-activemodelvalidations), [maybe monad](#kindmaybe).
+So, I invite you to check out these features to see how they could be useful for you. Enjoy!
 
 ## Documentation <!-- omit in toc -->
 
 Version    | Documentation
 ---------- | -------------
-unreleased | https://github.com/serradura/u-case/blob/main/README.md
-5.1.0      | https://github.com/serradura/u-case/blob/v5.x/README.md
-4.1.0      | https://github.com/serradura/u-case/blob/v4.x/README.md
-3.1.0      | https://github.com/serradura/u-case/blob/v3.x/README.md
-2.3.0      | https://github.com/serradura/u-case/blob/v2.x/README.md
-1.9.0      | https://github.com/serradura/u-case/blob/v1.x/README.md
+unreleased | https://github.com/serradura/kind/blob/main/README.md
+5.5.0      | https://github.com/serradura/kind/blob/v5.x/README.md
+4.1.0      | https://github.com/serradura/kind/blob/v4.x/README.md
+3.1.0      | https://github.com/serradura/kind/blob/v3.x/README.md
+2.3.0      | https://github.com/serradura/kind/blob/v2.x/README.md
+1.9.0      | https://github.com/serradura/kind/blob/v1.x/README.md
 
 ## Table of Contents <!-- omit in toc -->
 - [Compatibility](#compatibility)
@@ -58,16 +61,16 @@ unreleased | https://github.com/serradura/u-case/blob/main/README.md
   - [Kind::\<Type\>.value()](#kindtypevalue-1)
   - [Kind::\<Type\>.maybe](#kindtypemaybe)
   - [Kind::\<Type\>?](#kindtype-2)
-  - [Kind::{Array,Hash,String,Set}.value_or_empty()](#kindarrayhashstringsetvalue_or_empty)
-  - [List of all type checkers](#list-of-all-type-checkers)
+  - [Kind::{Array,Hash,String,Set}.empty_or()](#kindarrayhashstringsetempty_or)
+  - [List of all type handlers](#list-of-all-type-handlers)
     - [Core](#core)
     - [Stdlib](#stdlib)
     - [Custom](#custom)
-  - [Creating type checkers](#creating-type-checkers)
+  - [Creating type handlers](#creating-type-handlers)
     - [Dynamic creation](#dynamic-creation)
       - [Using a class or a module](#using-a-class-or-a-module)
       - [Using an object which responds to ===](#using-an-object-which-responds-to-)
-    - [Kind::<Type> module](#kindtype-module)
+    - [Kind::<Type> object](#kindtype-object)
   - [Utility methods](#utility-methods)
     - [Kind.of_class?()](#kindof_class)
     - [Kind.of_module?()](#kindof_module)
@@ -119,14 +122,14 @@ unreleased | https://github.com/serradura/u-case/blob/main/README.md
 
 ## Compatibility
 
-| u-case         | branch  | ruby     |  activemodel   |
-| -------------- | ------- | -------- | -------------- |
-| unreleased     | main    | >= 2.1.0 | >= 3.2, <= 6.1 |
-| 5.1.0          | v5.x    | >= 2.1.0 | >= 3.2, <= 6.1 |
-| 4.1.0          | v4.x    | >= 2.2.0 | >= 3.2, <= 6.1 |
-| 3.1.0          | v3.x    | >= 2.2.0 | >= 3.2, <= 6.1 |
-| 2.3.0          | v2.x    | >= 2.2.0 | >= 3.2, <= 6.0 |
-| 1.9.0          | v1.x    | >= 2.2.0 | >= 3.2, <= 6.0 |
+| kind           | branch  | ruby               | activemodel    |
+| -------------- | ------- | ------------------ | -------------- |
+| unreleased     | main    | >= 2.1.0, <= 3.0.0 | >= 3.2, < 7.0  |
+| 5.5.0          | v5.x    | >= 2.1.0, <= 3.0.0 | >= 3.2, < 7.0  |
+| 4.1.0          | v4.x    | >= 2.2.0, <= 3.0.0 | >= 3.2, < 7.0  |
+| 3.1.0          | v3.x    | >= 2.2.0, <= 2.7   | >= 3.2, < 7.0  |
+| 2.3.0          | v2.x    | >= 2.2.0, <= 2.7   | >= 3.2, <= 6.0 |
+| 1.9.0          | v1.x    | >= 2.2.0, <= 2.7   | >= 3.2, <= 6.0 |
 
 > Note: The activemodel is an optional dependency, it is related with the [Kind::Validator](#kindvalidator-activemodelvalidations).
 
@@ -327,17 +330,17 @@ collection.select(&Kind::Enumerable?) # [{:number=>1}, {:number=>3}, [:number, 5
 
 [⬆️ &nbsp;Back to Top](#table-of-contents-)
 
-### Kind::{Array,Hash,String,Set}.value_or_empty()
+### Kind::{Array,Hash,String,Set}.empty_or()
 
-This method is available for some type checkers (`Kind::Array`, `Kind::Hash`, `Kind::String`, `Kind::Set`), and it will return an empty frozen value if the given one hasn't the expected kind.
+This method is available for some type handlers (`Kind::Array`, `Kind::Hash`, `Kind::String`, `Kind::Set`), and it will return an empty frozen value if the given one hasn't the expected kind.
 ```ruby
-Kind::Array.value_or_empty({})         # []
-Kind::Array.value_or_empty({}).frozen? # true
+Kind::Array.empty_or({})         # []
+Kind::Array.empty_or({}).frozen? # true
 ```
 
 [⬆️ &nbsp;Back to Top](#table-of-contents-)
 
-### List of all type checkers
+### List of all type handlers
 
 #### Core
 
@@ -376,9 +379,9 @@ Kind::Array.value_or_empty({}).frozen? # true
 
 [⬆️ &nbsp;Back to Top](#table-of-contents-)
 
-### Creating type checkers
+### Creating type handlers
 
-There are two ways to do this, you can create type checkers dynamically or defining a module.
+There are two ways to do this, you can create type handlers dynamically or defining a module.
 
 #### Dynamic creation
 
@@ -394,7 +397,7 @@ kind_of_user = Kind::Of(User)
 
 # kind_of_user.name
 # kind_of_user.kind
-# The type checker can return its kind and its name
+# The type handler can return its kind and its name
 kind_of_user.name # "User"
 kind_of_user.kind # User
 
@@ -464,7 +467,7 @@ PositiveInteger = Kind::Of(
 
 # PositiveInteger.name
 # PositiveInteger.kind
-# The type checker can return its kind and its name
+# The type handler can return its kind and its name
 PositiveInteger.name # "PositiveInteger"
 PositiveInteger.kind # #<Proc:0x0000.... >
 
@@ -525,9 +528,9 @@ PositiveInteger.maybe(2).value_or(1) # 2
 
 [⬆️ &nbsp;Back to Top](#table-of-contents-)
 
-#### Kind::<Type> module
+#### Kind::<Type> object
 
-The idea here is to create a type checker inside of the `Kind` namespace, so to do this, you will only need to use pure Ruby. e.g:
+The idea here is to create a type handler inside of the `Kind` namespace and to do this you will only need to use pure Ruby. e.g:
 
 ```ruby
 class User
@@ -535,9 +538,9 @@ end
 
 module Kind
   module User
-    extend self, TypeChecker
+    extend self, ::Kind::Object
 
-    # Define the expected kind of this type checker.
+    # Define the expected kind of this type handler.
     def kind; ::User; end
   end
 
@@ -547,7 +550,7 @@ module Kind
   end
 end
 
-# Doing this you will have the same methods of a standard type checker (like: `Kind::Symbol`).
+# Doing this you will have the same methods of a standard type handler (like: `Kind::Symbol`).
 
 user = User.new
 
@@ -565,7 +568,7 @@ The advantages of this approach are:
 
 The disadvantage is:
 
-1. You could overwrite some standard type checker or constant. I believe that this will be hard to happen, but must be your concern if you decide to use this kind of approach.
+1. You could overwrite some standard type handler or constant. I believe that this will be hard to happen, but must be your concern if you decide to use this kind of approach.
 
 [⬆️ &nbsp;Back to Top](#table-of-contents-)
 
@@ -1459,7 +1462,7 @@ Follows the list of constants if the alias was defined:
 
 ## Kind::Validator (ActiveModel::Validations)
 
-This module enables the capability to validate types via [`ActiveModel::Validations >= 3.2, < 6.1.0`](https://api.rubyonrails.org/classes/ActiveModel/Validations.html). e.g
+This module enables the capability to validate types via [`ActiveModel::Validations >= 3.2, < 7.0`](https://api.rubyonrails.org/classes/ActiveModel/Validations.html). e.g
 
 ```ruby
 class Person
@@ -1497,7 +1500,7 @@ Use an array to verify if the attribute is an instance of one of the classes/mod
 validates :status, kind: { of: [String, Symbol]}
 ```
 
-Because of kind verification be made via `===` you can use type checkers as the expected kinds.
+Because of kind verification be made via `===` you can use type handlers as the expected kinds.
 
 ```ruby
 validates :alive, kind: Kind::Boolean

data/kind.gemspec

@@ -6,8 +6,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ['Rodrigo Serradura']
   spec.email         = ['rodrigo.serradura@gmail.com']
 
-  spec.summary       = %q{A simple type system (at runtime) for Ruby.}
-  spec.description   = %q{A simple type system (at runtime) for Ruby - free of dependencies.}
+  spec.summary       = %q{A development toolkit for Ruby with several small/cohesive abstractions to empower your development workflow.}
+  spec.description   = %q{A development toolkit for Ruby with several small/cohesive abstractions (monads, enums, business logic, data validation...) to empower your development workflow - It's totally free of dependencies.}
   spec.homepage      = 'https://github.com/serradura/kind'
   spec.license       = 'MIT'
   spec.required_ruby_version = Gem::Requirement.new('>= 2.1.0')

data/lib/kind.rb

@@ -1,51 +1,4 @@
 # frozen_string_literal: true
 
-require 'set'
-require 'ostruct'
-
-module Kind
-  require 'kind/version'
-  require 'kind/core'
-
-  extend self
-
-  def is?(kind, arg)
-    KIND.is?(kind, arg)
-  end
-
-  alias is is?
-
-  def of?(kind, *args)
-    KIND.of?(kind, args)
-  end
-
-  def of_class?(value)
-    KIND.of_class?(value)
-  end
-
-  def of_module?(value)
-    KIND.of_module?(value)
-  end
-
-  def respond_to(value, *method_names)
-    method_names.each { |method_name| KIND.respond_to!(method_name, value) }
-
-    value
-  end
-
-  def of_module_or_class(value)
-    KIND.of_module_or_class!(value)
-  end
-
-  def of(kind, object)
-    KIND.of!(kind, object)
-  end
-
-  def value(kind, value, default:)
-    KIND.value(kind, value, of(kind, default))
-  end
-
-  def Of(kind, opt = Empty::HASH)
-    TypeChecker::Object.new(kind, opt)
-  end
-end
+require 'kind/basic'
+require 'kind/objects'

data/lib/kind/__lib__/action_steps.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Kind
+  module ACTION_STEPS
+    private
+
+      def Check(mthod); ->(value) { __Check(thod, value) }; end
+      def Step(mthod); ->(value) { __Step(mthod, value) }; end
+      def Map(mthod); ->(value) { __Map(mthod, value) }; end
+      def Tee(mthod); ->(value) { __Tee(mthod, value) }; end
+      def Try(mthod, opt = Empty::HASH)
+        ->(value) { __Try(mthod, value, opt) }
+      end
+
+      def Check!(mthod, value); __Check(mthod, value); end
+      def Step!(mthod, value); __Step(mthod, value); end
+      def Map!(mthod, value); __Map(mthod, value); end
+      def Tee!(mthod, value); __Tee(mthod, value); end
+      def Try!(mthod, value, opt = Empty::HASH); __Try(mthod, value, opt); end
+
+      def __Check(mthod, value) # :nodoc:
+        __resolve_step(mthod, value) ? Success(mthod, value) : Failure(mthod, value)
+      end
+
+      def __Step(mthod, value) # :nodoc:
+        __resolve_step(mthod, value)
+      end
+
+      def __Map(mthod, value) # :nodoc:
+        Success(mthod, __resolve_step(mthod, value))
+      end
+
+      def __Tee(mthod, value) # :nodoc:
+        __resolve_step(mthod, value)
+
+        Success(mthod, value)
+      end
+
+      def __Try(mthod, value, opt = Empty::HASH) # :nodoc:
+        begin
+          Success(mthod, __resolve_step(mthod, value))
+        rescue opt.fetch(:catch, StandardError) => e
+          Failure(mthod, __map_step_exception(e))
+        end
+      end
+
+      def __resolve_step(mthod, value) # :nodoc:
+        send(mthod, value)
+      end
+
+      def __map_step_exception(value) # :nodoc:
+        value
+      end
+  end
+
+  private_constant :ACTION_STEPS
+end

data/lib/kind/__lib__/attributes.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'kind/__lib__/kind'
+require 'kind/__lib__/undefined'
+
+module Kind
+  module ATTRIBUTES
+    extend self
+
+    def name!(name)
+      STRICT.kind_of(::Symbol, name)
+    end
+
+    def value(kind, default, visibility = :private)
+      [kind, default, visibility]
+    end
+
+    def value_to_assign(kind, default, hash, name)
+      raw_value = hash[name]
+
+      return raw_value if kind.nil? && UNDEFINED == default
+
+      value = resolve_value_to_assign(kind, default, raw_value)
+
+      (kind.nil? || kind === value) ? value : nil
+    end
+
+    def value!(kind, default)
+      return value(kind, default) unless kind.nil?
+
+      raise Error.new("kind expected to not be nil")
+    end
+
+    def value_to_assign!(kind, default, hash, name)
+      value = resolve_value_to_assign(kind, default, hash[name])
+
+      Kind.of(kind, value, label: name)
+    end
+
+    private
+
+      def resolve_value_to_assign(kind, default, value)
+        if kind == ::Proc
+          UNDEFINED == default ? value : KIND.value(kind, value, default)
+        else
+          default_is_a_callable = default.respond_to?(:call)
+
+          default_value =
+            if default_is_a_callable
+              default_fn = Proc === default ? default : default.method(:call)
+
+              default_fn.arity != 0 ? default_fn.call(value) : default_fn.call
+            else
+              default
+            end
+
+          return value if UNDEFINED == default_value
+          return default_value || value if kind.nil?
+
+          default_is_a_callable ? KIND.value(kind, default_value, value) : KIND.value(kind, value, default_value)
+        end
+      end
+  end
+
+  private_constant :ATTRIBUTES
+end

data/lib/kind/__lib__/kind.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'kind/__lib__/strict'
+
+module Kind
+  module KIND
+    extend self
+
+    def nil_or_undefined?(value) # :nodoc:
+      value.nil? || Undefined == value
+    end
+
+    def of?(kind, values) # :nodoc:
+      of_kind = -> value { kind === value }
+
+      values.empty? ? of_kind : values.all?(&of_kind)
+    end
+
+    def respond_to!(method_name, value) # :nodoc:
+      return value if value.respond_to?(method_name)
+
+      raise Error.new("expected #{value} to respond to :#{method_name}")
+    end
+
+    def interface?(method_names, value) # :nodoc:
+      method_names.all? { |method_name| value.respond_to?(method_name) }
+    end
+
+    def value(kind, arg, default) # :nodoc:
+      kind === arg ? arg : default
+    end
+
+    def is?(expected, value) # :nodoc:
+      is(STRICT.module_or_class(expected), value)
+    end
+
+    private
+
+      def is(expected_kind, value) # :nodoc:
+        kind = STRICT.module_or_class(value)
+
+        if OF.class?(kind)
+          kind <= expected_kind || expected_kind == ::Class
+        else
+          kind == expected_kind || kind.kind_of?(expected_kind)
+        end
+      end
+  end
+
+  private_constant :KIND
+end