kind 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9b572e02668d3a89864333fad8605a280f3bb09f5de9c0db9800bdc956632b78
-  data.tar.gz: 643847caaa8791c0bb5f4304f9e14135e853fb9763c53f92d7c3760c5d384be5
+  metadata.gz: d0f8c5e797f181f52a5c27fec17d22c4569c6c9c7ada6bc0d374d64ec0d33142
+  data.tar.gz: 5fca4d34a15a049d57c1c9fb86b6de672309a581b21f3ace634063edcceadc5f
 SHA512:
-  metadata.gz: c8d9057024bb9c8dd10f69946e5fcf0027f07a848dd16772bcb81dd2d9eeff12f026fe3600808c24bcf60126274d27a170ee32ab37f73f7fdaa26377e2aa1704
-  data.tar.gz: d4872142369aadb04b2679bc1bf8bb6b690ea19b9a7208dc9b0cb3f25c32f275981479d7847e0fe884bbb3c43c1da748c40ecd47e8833ff4052848514f3fcf1c
+  metadata.gz: 37a4923bdde1c6cc3e5921c7090e69d50ed8405e9a3783e877e175aa853da8250c68bee76c851c8e1297e8704d1ce4a396cbc6ffea4f1a91a03c032f68fe3a87
+  data.tar.gz: 9bdbae7d4b146af928c944a7e935e612964c9c629101aaf72a163391cff62859d85c796b1612a6c2e9ab7544c411bcfcdc93e5ed616ec3dc6ac605eadbc53c5c

data/README.md

@@ -113,6 +113,7 @@ Kind.of.Hash.class?(Hash)
 # true
 
 Kind.of.Hash.class?(ActiveSupport::HashWithIndifferentAccess)
+# true
 ```
 
 ## Built-in type checkers

data/lib/kind.rb

@@ -9,141 +9,113 @@ module Kind
     end
   end
 
-  module Of
-    def self.call(klass, object)
-      return object if object.is_a?(klass)
+  module Is
+    def self.call(expected, value)
+      expected_mod = Kind::Of.Module(expected)
+      mod = Kind::Of.Module(value)
 
-      raise Kind::Error.new(klass, object)
+      mod <= expected_mod || false
     end
 
-    def self.Class(object)
-      self.call(::Class, object)
+    def self.Class(value)
+      value.is_a?(::Class)
     end
 
-    def self.Module(object)
-      self.call(::Module, object)
+    def self.Module(value)
+      value == ::Module || (value.is_a?(::Module) && !self.Class(value))
     end
+  end
 
-    def self.Boolean(object = nil)
-      return Kind::Of::Boolean if object.nil?
-
-      return object if object.is_a?(::TrueClass) || object.is_a?(::FalseClass)
+  class Checker
+    attr_reader :type
 
-      raise Kind::Error.new('Boolean'.freeze, object)
+    def initialize(type)
+      @type = type
     end
 
-    module Boolean
-      def self.class?(value)
-        Kind.is.Boolean(value)
-      end
-
-      def self.instance?(value)
-        value.is_a?(TrueClass) || value.is_a?(FalseClass)
-      end
+    def class?(value)
+      Kind::Is.call(@type, value)
+    end
 
-      def self.or_nil(value)
-        return value if instance?(value)
-      end
+    def instance?(value)
+      value.is_a?(@type)
     end
 
-    def self.Lambda(object = nil)
-      return Kind::Of::Lambda if object.nil?
+    def or_nil(value)
+      return value if instance?(value)
+    end
+  end
 
-      return object if object.is_a?(::Proc) && object.lambda?
+  module Of
+    def self.call(klass, object)
+      return object if object.is_a?(klass)
 
-      raise Kind::Error.new('Lambda'.freeze, object)
+      raise Kind::Error.new(klass, object)
     end
 
-    module Lambda
-      def self.class?(value)
-        Kind.is.Proc(value)
-      end
+    def self.Class(object = nil)
+      return Class if object.nil?
 
-      def self.instance?(value)
-        value.is_a?(::Proc) && value.lambda?
-      end
+      self.call(::Class, object)
+    end
 
-      def self.or_nil(value)
-        return value if instance?(value)
+    const_set(:Class, ::Class.new(Checker) do
+      def instance?(value)
+        Kind::Is.Class(value)
       end
-    end
-  end
 
-  module Is
-    def self.call(expected, value)
-      expected_klass, klass = Kind.of.Module(expected), Kind.of.Module(value)
+      alias class? instance?
+    end.new(::Class).freeze)
 
-      klass <= expected_klass || false
-    end
+    def self.Module(object = nil)
+      return Module if object.nil?
 
-    def self.Class(value)
-      value.is_a?(::Class)
+      self.call(::Module, object)
     end
 
-    def self.Module(value)
-      value == Module || (value.is_a?(::Module) && !self.Class(value))
-    end
+    const_set(:Module, ::Class.new(Checker) do
+      def instance?(value)
+        Kind::Is.Module(value)
+      end
 
-    def self.Boolean(value)
-      klass = Kind.of.Class(value)
-      klass <= TrueClass || klass <= FalseClass
-    end
+      alias class? instance?
+    end.new(::Module).freeze)
   end
 
-  def self.of; Of; end
-  def self.is; Is; end
-
   module Types
     extend self
 
     KIND_OF = <<-RUBY
-      def self.%{klass}(object = nil)
-        return Kind::Of::%{klass} if object.nil?
+      def self.%{name}(object = nil)
+        return Kind::Of::%{name} if object.nil?
 
-        Kind::Of.call(::%{klass}, object)
+        Kind::Of.call(::%{name}, object)
       end
     RUBY
 
     KIND_IS = <<-RUBY
-      def self.%{klass}(value)
-        Kind::Is.call(::%{klass}, value)
+      def self.%{name}(value)
+        Kind::Is.call(::%{name}, value)
       end
     RUBY
 
-    KIND_OF_MODULE = <<-RUBY
-      def self.class?(value)
-        Kind::Is.call(::%{klass}, value)
-      end
+    private_constant :KIND_OF, :KIND_IS
 
-      def self.instance?(value)
-        value.is_a?(::%{klass})
-      end
+    def add(mod)
+      name = Kind.of.Module(mod).name
 
-      def self.or_nil(value)
-        return value if instance?(value)
+      unless Of.respond_to?(name)
+        Of.instance_eval(KIND_OF % { name: name })
+        Of.const_set(name, Checker.new(mod).freeze)
       end
-    RUBY
-
-    private_constant :KIND_OF, :KIND_IS, :KIND_OF_MODULE
 
-    def add(klass)
-      klass_name = Kind.of.Module(klass).name
-
-      return if Of.respond_to?(klass_name)
-
-      Of.instance_eval(KIND_OF % { klass: klass_name })
-
-      type_module = Module.new
-      type_module.instance_eval(KIND_OF_MODULE % { klass: klass_name })
-
-      Of.const_set(klass_name, type_module)
-
-      return if Is.respond_to?(klass_name)
-
-      Is.instance_eval(KIND_IS % { klass: klass_name })
+      Is.instance_eval(KIND_IS % { name: name }) unless Is.respond_to?(name)
     end
   end
 
+  def self.is; Is; end
+  def self.of; Of; end
+
   # Classes
   [
     String, Symbol, Numeric, Integer, Float, Regexp, Time,
@@ -156,4 +128,55 @@ module Kind
   [
     Enumerable, Comparable
   ].each { |klass| Types.add(klass) }
+
+  # --------------------- #
+  # Special type checkers #
+  # --------------------- #
+
+  module Is
+    def self.Boolean(value)
+      klass = Kind.of.Class(value)
+      klass <= TrueClass || klass <= FalseClass
+    end
+  end
+
+  module Of
+    # -- Boolean
+
+    def self.Boolean(object = nil)
+      return Kind::Of::Boolean if object.nil?
+
+      return object if object.is_a?(::TrueClass) || object.is_a?(::FalseClass)
+
+      raise Kind::Error.new('Boolean'.freeze, object)
+    end
+
+    const_set(:Boolean, ::Class.new(Checker) do
+      def class?(value)
+        Kind.is.Boolean(value)
+      end
+
+      def instance?(value)
+        value.is_a?(TrueClass) || value.is_a?(FalseClass)
+      end
+    end.new([TrueClass, FalseClass].freeze).freeze)
+
+    # -- Lambda
+
+    def self.Lambda(object = nil)
+      return Kind::Of::Lambda if object.nil?
+
+      return object if object.is_a?(::Proc) && object.lambda?
+
+      raise Kind::Error.new('Lambda'.freeze, object)
+    end
+
+    const_set(:Lambda, ::Class.new(Checker) do
+      def instance?(value)
+        value.is_a?(::Proc) && value.lambda?
+      end
+    end.new(::Proc).freeze)
+  end
+
+  private_constant :Checker
 end

data/lib/kind/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kind
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-01-02 00:00:00.000000000 Z
+date: 2020-01-03 00:00:00.000000000 Z
 dependencies: []
 description: Basic type system for Ruby.
 email: