kind 5.1.0 → 5.2.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>
 
 <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>
@@ -38,12 +39,12 @@ One of the goals of this project is to do simple type checking like `"some strin
 
 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.2.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 +59,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,10 +120,10 @@ unreleased | https://github.com/serradura/u-case/blob/main/README.md
 
 ## Compatibility
 
-| u-case         | branch  | ruby     |  activemodel   |
+| kind           | branch  | ruby     |  activemodel   |
 | -------------- | ------- | -------- | -------------- |
 | unreleased     | main    | >= 2.1.0 | >= 3.2, <= 6.1 |
-| 5.1.0          | v5.x    | >= 2.1.0 | >= 3.2, <= 6.1 |
+| 5.2.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 |
@@ -327,17 +328,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 +377,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 +395,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 +465,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 +526,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 +536,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 +548,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 +566,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 +1460,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 +1498,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/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__/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)
+      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,71 @@
+# frozen_string_literal: true
+
+module Kind
+  module KIND
+    extend self
+
+    def null?(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 of!(kind, value, kind_name = nil) # :nodoc:
+      return value if kind === value
+
+      error!(kind_name || kind.name, value)
+    end
+
+    def error!(kind_name, value, label = nil) # :nodoc:
+      raise Error.new(kind_name, value, label: label)
+    end
+
+    def of_class?(value) # :nodoc:
+      value.kind_of?(::Class)
+    end
+
+    def of_module?(value) # :nodoc:
+      ::Module == value || (value.kind_of?(::Module) && !of_class?(value))
+    end
+
+    def of_module_or_class!(value) # :nodoc:
+      of!(::Module, value, 'Module/Class')
+    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(of_module_or_class!(expected), value)
+    end
+
+    private
+
+      def is(expected_kind, value) # :nodoc:
+        kind = of_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

data/lib/kind/__lib__/undefined.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Kind
+  UNDEFINED = Object.new.tap do |undefined|
+    def undefined.inspect
+      @inspect ||= 'UNDEFINED'.freeze
+    end
+
+    undefined.inspect
+    undefined.freeze
+  end
+
+  private_constant :UNDEFINED
+end

data/lib/kind/action.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'kind/basic'
+require 'kind/result'
+require 'kind/immutable_attributes'
+
+module Kind
+  module Action
+    CALL_TMPL = [
+      'def self.call(arg)',
+      '  new(Kind.of!(::Hash, arg)).call',
+      'end',
+      '',
+      'def call',
+      '  result = call!',
+      '',
+      '  return result if Kind::Result::Monad === result',
+      '',
+      '  raise Kind::Error, "#{self.class.name}#call! must return a Success() or Failure()"',
+      'end'
+    ].join("\n").freeze
+
+    module ClassMethods
+      include ImmutableAttributes::ClassMethods
+
+      def to_proc
+        @to_proc ||= ->(arg) { call(arg) }
+      end
+
+      ATTRIBUTE_METHODS = [
+        :attributes, :attribute,
+        :attribute?, :attribute!,
+        :with_attribute, :with_attributes,
+        :nil_attributes, :nil_attributes?
+      ]
+
+      private_constant :ATTRIBUTE_METHODS
+
+      def kind_action!
+        return self if respond_to?(:call)
+
+        public_methods = self.public_instance_methods - ::Object.new.methods
+
+        remaining_methods = public_methods - (__attributes__.keys + ATTRIBUTE_METHODS)
+
+        unless remaining_methods.include?(:call!)
+          raise Kind::Error.new("expected #{self} to implement `#call!`")
+        end
+
+        if remaining_methods.size > 1
+          raise Kind::Error.new("#{self} can only have `#call!` as its public method")
+        end
+
+        call_parameters = public_instance_method(:call!).parameters
+
+        unless call_parameters.empty?
+          raise ArgumentError, "#{self.name}#call! must receive no arguments"
+        end
+
+        def self.inherited(_)
+          raise RuntimeError, "#{self.name} is a Kind::Action and it can't be inherited"
+        end
+
+        self.send(:private_class_method, :new)
+
+        self.class_eval(CALL_TMPL)
+
+        self.send(:alias_method, :[], :call)
+        self.send(:alias_method, :===, :call)
+        self.send(:alias_method, :yield, :call)
+      end
+    end
+
+    def self.included(base)
+      KIND.of!(::Class, base).extend(ClassMethods)
+
+      base.send(:include, ImmutableAttributes::Reader)
+    end
+
+    include ImmutableAttributes::Initializer
+
+    private
+
+      def Failure(arg1 = UNDEFINED, arg2 = UNDEFINED)
+        Result::Failure[arg1, arg2, value_must_be_a: ::Hash]
+      end
+
+      def Success(arg1 = UNDEFINED, arg2 = UNDEFINED)
+        Result::Success[arg1, arg2, value_must_be_a: ::Hash]
+      end
+  end
+end