kind 1.9.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8d4f4be415e28c7f240a097a64626588e7b3c7bc8a70dbfd71bf2b5b426e016a
-  data.tar.gz: 7401efa30206d27d4f10608b5164d6c334d8da02e4652d8a7f156ee081f18ec5
+  metadata.gz: ebd68f3e676f6b030fa85da36b57a47a7f866e52373aed2b0e41315c63b0fdd0
+  data.tar.gz: 5800122e2ed54025450eabe06bee5f9df3474c45b6ffa396c3b80dc4ad8ca566
 SHA512:
-  metadata.gz: f672462c9e64afce93af792d179d1c6095003ade48329018f4e64eb0bae7fb825699f2350c643fa2a1f2a3ae2822b3cbb1e8444c3a423101a37beffadbd7a614
-  data.tar.gz: 890957443724fe3fdd7fec56d8b4a87c0e92f2793d26d298b8347b75e7091612e36a87d29bae70c7a789fe9e0750b366a4fe572104351e55b04903bbfcbffe03
+  metadata.gz: d3769fbbe39073a41961af28fde90412f30f1caab3b2129b4a91a39afb1e482310e209b1a5eea4249f09c667760f862c06cc98dc56ab7bb40854561ef75ea435
+  data.tar.gz: 8356c7a49afe6370ecced9485acd2a663d1f17729cbbccd89dec2c1f839ad0f754778502e447c89b8a129697a891bed07af30c20df0b52a9e4d338cb4df593ed

data/README.md

@@ -195,6 +195,49 @@ Kind.of.Hash.class?(Hash) # true
 Kind.of.Hash.class?(ActiveSupport::HashWithIndifferentAccess) # true
 ```
 
+> **Note:** The `Kind.is` could check the inheritance of Classes/Modules.
+
+```ruby
+#
+# Verifying if the attribute value is the class or a subclass.
+#
+class Human; end
+class Person < Human; end
+class User < Human; end
+
+Kind.is(Human, User)   # true
+Kind.is(Human, Human)  # true
+Kind.is(Human, Person) # true
+
+Kind.is(Human, Struct) # false
+
+#
+# Verifying if the attribute value is the module or if it is a class that includes the module
+#
+module Human; end
+class Person; include Human; end
+class User; include Human; end
+
+Kind.is(Human, User)   # true
+Kind.is(Human, Human)  # true
+Kind.is(Human, Person) # true
+
+Kind.is(Human, Struct) # false
+
+#
+# Verifying if the attribute value is the module or if it is a module that extends the module
+#
+module Human; end
+module Person; extend Human; end
+module User; extend Human; end
+
+Kind.is(Human, User)   # true
+Kind.is(Human, Human)  # true
+Kind.is(Human, Person) # true
+
+Kind.is(Human, Struct) # false
+```
+
 [⬆️ Back to Top](#table-of-contents-)
 
 ### How to create a new type checker?
@@ -377,7 +420,7 @@ The list of types (classes and modules) available to use with `Kind.of.*` or `Ki
 - `Kind.of.Module()`
 - `Kind.of.Lambda()`
 - `Kind.of.Boolean()`
-- `Kind.of.Callable()`: verifies if the given value `respond_to?(:call)` or if it's a class/module and if its `public_instance_methods.include?(:call)`.
+- `Kind.of.Callable()`: verifies if the given value `respond_to?(:call)`.
 - `Kind.of.Maybe()` or its alias `Kind.of.Optional()`
 
 **Note:** Remember, you can use the `Kind.is.*` method to check if some given value is a class/module with all type checkers above.
@@ -668,7 +711,7 @@ end
 
 ## Kind::Validator (ActiveModel::Validations)
 
-This module enables the capability to validate types via [active model validations](https://api.rubyonrails.org/classes/ActiveModel/Validations.html). e.g
+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
 
 ```ruby
 class Person
@@ -696,15 +739,47 @@ require 'kind/active_model/validation'
 
 ```ruby
 validates :name, kind: { of: String }
-# or
-validates :name, kind: { is_a: String }
 
 # Use an array to verify if the attribute
 # is an instance of one of the classes/modules.
 
 validates :status, kind: { of: [String, Symbol]}
-# or
-validates :status, kind: { is_a: [String, Symbol]}
+```
+
+**[Kind.is](#verifying-the-kind-of-some-classmodule)**
+
+```ruby
+#
+# Verifying if the attribute value is the class or a subclass.
+#
+class Human; end
+class Person < Human; end
+class User < Human; end
+
+validates :human_kind, kind: { is: Human }
+
+#
+# Verifying if the attribute value is the module or if it is a class that includes the module
+#
+module Human; end
+class Person; include Human; end
+class User; include Human; end
+
+validates :human_kind, kind: { is: Human }
+
+#
+# Verifying if the attribute value is the module or if it is a module that extends the module
+#
+module Human; end
+module Person; extend Human; end
+module User; extend Human; end
+
+validates :human_kind, kind: { is: Human }
+
+# or use an array to verify if the attribute
+# is a kind of one those classes/modules.
+
+validates :human_kind, kind: { is: [Person, User] }
 ```
 
 **[Object#instance_of?](https://ruby-doc.org/core-2.6.4/Object.html#method-i-instance_of-3F)**
@@ -725,18 +800,6 @@ validates :name, kind: { instance_of: [String, Symbol] }
 validates :handler, kind: { respond_to: :call }
 ```
 
-**Class == Class || Class < Class**
-
-```ruby
-# Verifies if the attribute value is the class or a subclass.
-
-validates :handler, kind: { klass: Handler }
-
-# or use the :is option
-
-validates :handler, kind: { is: Handler }
-```
-
 **Array.new.all? { |item| item.kind_of?(Class) }**
 
 ```ruby

data/lib/kind/active_model/kind_validator.rb

@@ -18,8 +18,8 @@ class KindValidator < ActiveModel::EachValidator
 
       return validate_with_default_strategy(expected, value) if expected
 
-      return kind_of(expected, value) if expected = options[:of] || options[:is_a]
-      return is_class(expected, value) if expected = options[:is] || options[:klass]
+      return kind_of(expected, value) if expected = options[:of]
+      return kind_is(expected, value) if expected = options[:is]
       return respond_to(expected, value) if expected = options[:respond_to]
       return instance_of(expected, value) if expected = options[:instance_of]
       return array_with(expected, value) if expected = options[:array_with]
@@ -32,26 +32,38 @@ class KindValidator < ActiveModel::EachValidator
       send(Kind::Validator.default_strategy, expected, value)
     end
 
-    def instance_of(expected, value)
+    def kind_of(expected, value)
       types = Array(expected)
 
-      return if types.any? { |type| value.instance_of?(type) }
+      return if types.any? { |type| value.kind_of?(type) }
 
-      "must be an instance of: #{types.map { |klass| klass.name }.join(', ')}"
+      "must be a kind of: #{types.map { |klass| klass.name }.join(', ')}"
     end
 
-    def kind_of(expected, value)
-      types = Array(expected)
+    CLASS_OR_MODULE = 'Class/Module'.freeze
 
-      return if types.any? { |type| value.is_a?(type) }
+    def kind_is(expected, value)
+      return kind_is_not(expected, value) unless expected.kind_of?(Array)
 
-      "must be a kind of: #{types.map { |klass| klass.name }.join(', ')}"
+      result = expected.map { |kind| kind_is_not(kind, value) }.compact
+
+      result.empty? || result.size < expected.size ? nil : result.join(', ')
     end
 
-    def is_class(klass, value)
-      return if Kind.of.Class(value) == Kind.of.Class(klass) || value < klass
+    def kind_is_not(expected, value)
+      case expected
+      when Class
+        return if Kind.of.Class(value) == expected || value < expected
 
-      "must be the class or a subclass of `#{klass.name}`"
+        "must be the class or a subclass of `#{expected.name}`"
+      when Module
+        return if value.kind_of?(Class) && value <= expected
+        return if Kind.of.Module(value) == expected || value.kind_of?(expected)
+
+        "must include the `#{expected.name}` module"
+      else
+        raise Kind::Error.new(CLASS_OR_MODULE, expected)
+      end
     end
 
     def respond_to(method_name, value)
@@ -60,17 +72,25 @@ class KindValidator < ActiveModel::EachValidator
       "must respond to the method `#{method_name}`"
     end
 
-    def array_of(expected, value)
+    def instance_of(expected, value)
       types = Array(expected)
 
-      return if value.is_a?(Array) && !value.empty? && value.all? { |value| types.any? { |type| value.is_a?(type) } }
+      return if types.any? { |type| value.instance_of?(type) }
 
-      "must be an array of: #{types.map { |klass| klass.name }.join(', ')}"
+      "must be an instance of: #{types.map { |klass| klass.name }.join(', ')}"
     end
 
     def array_with(expected, value)
-      return if value.is_a?(Array) && !value.empty? && (value - Kind.of.Array(expected)).empty?
+      return if value.kind_of?(Array) && !value.empty? && (value - Kind.of.Array(expected)).empty?
 
       "must be an array with: #{expected.join(', ')}"
     end
+
+    def array_of(expected, value)
+      types = Array(expected)
+
+      return if value.kind_of?(Array) && !value.empty? && value.all? { |value| types.any? { |type| value.kind_of?(type) } }
+
+      "must be an array of: #{types.map { |klass| klass.name }.join(', ')}"
+    end
 end

data/lib/kind/validator.rb

@@ -2,10 +2,10 @@
 
 module Kind
   module Validator
-    DEFAULT_STRATEGIES = Set.new(%w[instance_of kind_of is_a]).freeze
+    DEFAULT_STRATEGIES = Set.new(%w[instance_of kind_of]).freeze
 
     class InvalidDefinition < ArgumentError
-      OPTIONS = 'Options to define one: :of, :instance_of, :respond_to, :klass, :array_of or :array_with'.freeze
+      OPTIONS = 'Options to define one: :of, :is, :respond_to, :instance_of, :array_of or :array_with'.freeze
 
       def initialize(attribute)
         super "invalid type definition for :#{attribute} attribute. #{OPTIONS}"

data/lib/kind/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kind
-  VERSION = '1.9.0'
+  VERSION = '2.0.0'
 end

data/lib/kind.rb

@@ -55,7 +55,7 @@ module Kind
 
   module Is
     def self.Class(value)
-      value.is_a?(::Class)
+      value.kind_of?(::Class)
     end
 
     def self.Module(value)
@@ -63,12 +63,11 @@ module Kind
     end
 
     def self.Boolean(value)
-      klass = Kind.of.Class(value)
-      klass <= TrueClass || klass <= FalseClass
+      Kind.of.Class(value) <= TrueClass || value <= FalseClass
     end
 
     def self.Callable(value)
-      value.respond_to?(:call) || (value.is_a?(Module) && value.public_instance_methods.include?(:call))
+      value.respond_to?(:call)
     end
   end
 
@@ -102,7 +101,11 @@ module Kind
     const_set(:Module, ::Module.new do
       extend Checkable
 
-      def self.__kind; ::Module; end
+      def self.__kind_undefined(value)
+        __kind_error(Kind::Undefined) if value == Kind::Undefined
+
+        yield
+      end
 
       def self.__kind_error(value)
         raise Kind::Error.new('Module'.freeze, value)
@@ -114,11 +117,7 @@ module Kind
         __kind_error(value)
       end
 
-      def self.__kind_undefined(value)
-        __kind_error(Kind::Undefined) if value == Kind::Undefined
-
-        yield
-      end
+      def self.__kind; ::Module; end
 
       def self.class?(value); Kind::Is.Module(value); end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kind
 version: !ruby/object:Gem::Version
-  version: 1.9.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-05-06 00:00:00.000000000 Z
+date: 2020-05-07 00:00:00.000000000 Z
 dependencies: []
 description: A simple type system (at runtime) for Ruby - free of dependencies.
 email: