kind 0.6.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 33889c9e4fc1ad94b529e15711ae7d8a36271710367769d3d675301977e1e83c
-  data.tar.gz: 39ed9dfb4b99ca346ebc82561592f4d867479576c6d749aa41f8d86b4e2bf2df
+  metadata.gz: c1ca16c1feac58c7a1303c0ee1cda8cd5831a2270039ed8301912afc7a3a9f55
+  data.tar.gz: 61dba4fdf5c8c94118f93ca5d16ab55364601fc5846f9d574cf44df05f6dff2a
 SHA512:
-  metadata.gz: 1b4093ba9909ea58cd319e0cafda608dc78f259da971685c1a9d778a012d17c5f5ab027739aed74c0eb354b7f7572e01749d3ce7822b9be4a15d7cb26be5f254
-  data.tar.gz: 881b88913a5172e3cb3bcfd73b466bd26422d0213e9088600c3c611bb20b3c326dfb8f6bdfcac0556b2aa5f2462a197522e59f94f147eaa9beb85102ee4dc0f5
+  metadata.gz: 8397153bb070e3e27d4f2dfd0557a5f050a7ec292f4e2e779ffb7cdda26c125c29c64c283d8adc8ea09dce5ad4b23ed18575f35c711353a2184fbdff4effe34a
+  data.tar.gz: 7fee91750a8b24697e023a4be435b8c8db78cdd3f365dd70f5b9b0fda6daf549b3235528e94f6d9f985b5850ee031cbdd84475f8aabe4b549392c2304b7d8fa0

data/README.md

@@ -23,6 +23,7 @@ One of the goals of this project is to do simple type checking like `"some strin
     - [Kind.of](#kindof)
     - [Kind.is](#kindis)
 - [How to create a new type checker?](#how-to-create-a-new-type-checker)
+- [What happens if a custom type checker has a namespace?](#what-happens-if-a-custom-type-checker-has-a-namespace)
 - [Development](#development)
 - [Contributing](#contributing)
 - [License](#license)
@@ -58,11 +59,9 @@ def sum(a, b)
   Kind.of.Numeric(a) + Kind.of.Numeric(b)
 end
 
-sum(1, 1)
-# 2
+sum(1, 1)  # 2
 
-sum('1', 1)
-# Kind::Error ("\"1\" expected to be a kind of Numeric")
+sum('1', 1 # Kind::Error ("\"1\" expected to be a kind of Numeric")
 ```
 
 ### Verifying the kind of some object
@@ -70,16 +69,13 @@ sum('1', 1)
 By default, basic verifications are strict. So, when you perform `Kind.of.Hash(value)`, if the given value was a Hash, the value itself will be returned, but if it isn't the right type, an error will be raised.
 
 ```ruby
-Kind.of.Hash('')
-# raise Kind::Error, "'' expected to be a kind of Hash"
+Kind.of.Hash('')     # raise Kind::Error, "'' expected to be a kind of Hash"
 
-Kind.of.Hash({a: 1})
-# {a: 1}
+Kind.of.Hash({a: 1}) # {a: 1}
 
 # ---
 
-Kind.of.Boolean(nil)
-# raise Kind::Error, "nil expected to be a kind of Boolean"
+Kind.of.Boolean(nil)   # raise Kind::Error, "nil expected to be a kind of Boolean"
 
 Kind.of.Boolean(true)  # true
 Kind.of.Boolean(false) # false
@@ -90,13 +86,11 @@ When the verified value is nil, it is possible to define a default value with th
 ```ruby
 value = nil
 
-Kind.of.Hash(value, or: {})
-# {}
+Kind.of.Hash(value, or: {})    # {}
 
 # ---
 
-Kind.of.Boolean(nil, or: true)
-# true
+Kind.of.Boolean(nil, or: true) # true
 ```
 
 As an alternative syntax, you can use the `Kind::Of` instead of the method. e.g: `Kind::Of::Hash('')`
@@ -134,24 +128,19 @@ Kind.of.Boolean.instance?(false) # true
 You can use `Kind.is` to verify if some class has the expected type as its ancestor.
 
 ```ruby
-Kind.is.Hash(String)
-# false
+Kind.is.Hash(String) # false
 
-Kind.is.Hash(Hash)
-# true
+Kind.is.Hash(Hash)   # true
 
-Kind.is.Hash(ActiveSupport::HashWithIndifferentAccess)
-# true
+Kind.is.Hash(ActiveSupport::HashWithIndifferentAccess) # true
 ```
 
 And just for convenience, you can use the method `Kind.of.*.class?` to verify if the given class has the expected type as its ancestor.
 
 ```ruby
-Kind.of.Hash.class?(Hash)
-# true
+Kind.of.Hash.class?(Hash) # true
 
-Kind.of.Hash.class?(ActiveSupport::HashWithIndifferentAccess)
-# true
+Kind.of.Hash.class?(ActiveSupport::HashWithIndifferentAccess) # true
 ```
 
 [⬆️ Back to Top](#table-of-contents-)
@@ -218,24 +207,67 @@ end
 # Usage examples: #
 # --------------- #
 
-Kind.of.User(User.new)
-# #<User:0x0000...>
+Kind.of.User(User.new)  # #<User:0x0000...>
 
-Kind.of.User({})
-# Kind::Error ({} expected to be a kind of User)
+Kind.of.User({})        # Kind::Error ({} expected to be a kind of User)
 
-Kind.of.User.or_nil({})
-# nil
-
-Kind.of.User.instance?({}) # false
-Kind.of.User.class?(Hash)  # false
+Kind.of.User.or_nil({}) # nil
 
+Kind.of.User.instance?({})   # false
 Kind.of.User.instance?(User) # true
-Kind.of.User.class?(User)    # true
+
+Kind.of.User.class?(Hash)  # false
+Kind.of.User.class?(User)  # true
 ```
 
 [⬆️ Back to Top](#table-of-contents-)
 
+## What happens if a custom type checker has a namespace?
+
+The type checker will preserve the namespace. ;)
+
+```ruby
+module Account
+  class User
+    Kind::Types.add(self)
+  end
+end
+
+module Account
+  class User
+    class Membership
+      Kind::Types.add(self)
+    end
+  end
+end
+
+Kind.of.Account::User(Account::User.new)  # #<Account::User:0x0000...>
+
+Kind.of.Account::User({})        # Kind::Error ({} expected to be a kind of Account::User)
+
+Kind.of.Account::User.or_nil({}) # nil
+
+Kind.of.Account::User.instance?({})   # false
+Kind.of.Account::User.instance?(User) # true
+
+Kind.of.Account::User.class?(Hash)  # false
+Kind.of.Account::User.class?(User)  # true
+
+# ---
+
+Kind.of.Account::User::Membership(Account::User::Membership.new)  # #<Account::User::Membership:0x0000...>
+
+Kind.of.Account::User::Membership({})        # Kind::Error ({} expected to be a kind of Account::User::Membership)
+
+Kind.of.Account::User::Membership.or_nil({}) # nil
+
+Kind.of.Account::User::Membership.instance?({})   # false
+Kind.of.Account::User::Membership.instance?(User) # true
+
+Kind.of.Account::User::Membership.class?(Hash)  # false
+Kind.of.Account::User::Membership.class?(User)  # true
+```
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/kind.rb

@@ -26,19 +26,13 @@ module Kind
     end
   end
 
-  class Checker
-    attr_reader :type
-
-    def initialize(type)
-      @type = type
-    end
-
+  module Checker
     def class?(value)
-      Kind::Is.call(@type, value)
+      Kind::Is.(__kind, value)
     end
 
     def instance?(value)
-      value.is_a?(@type)
+      value.is_a?(__kind)
     end
 
     def or_nil(value)
@@ -59,13 +53,15 @@ module Kind
       self.call(::Class, object)
     end
 
-    const_set(:Class, ::Class.new(Checker) do
-      def instance?(value)
-        Kind::Is.Class(value)
-      end
+    const_set(:Class, ::Module.new do
+      extend Checker
 
-      alias class? instance?
-    end.new(::Class).freeze)
+      def self.__kind; ::Class; end
+
+      def self.class?(value); Kind::Is.Class(value); end
+
+      def self.instance?(value); class?(value); end
+    end)
 
     def self.Module(object = nil)
       return Module if object.nil?
@@ -73,49 +69,105 @@ module Kind
       self.call(::Module, object)
     end
 
-    const_set(:Module, ::Class.new(Checker) do
-      def instance?(value)
-        Kind::Is.Module(value)
-      end
+    const_set(:Module, ::Module.new do
+      extend Checker
+
+      def self.__kind; ::Module; end
 
-      alias class? instance?
-    end.new(::Module).freeze)
+      def self.class?(value); Kind::Is.Module(value); end
+
+      def self.instance?(value); class?(value); end
+    end)
   end
 
   module Types
     extend self
 
+    COLONS = '::'.freeze
+
     KIND_OF = <<-RUBY
-      def self.%{name}(object = nil, options = {})
+      def self.%{method_name}(object = nil, options = {})
         default = options[:or]
 
-        return Kind::Of::%{name} if object.nil? && default.nil?
+        return Kind::Of::%{kind_name} if object.nil? && default.nil?
 
-        Kind::Of.call(::%{name}, (object || default), name: "%{name}".freeze)
+        Kind::Of.(::%{kind_name}, (object || default), name: "%{kind_name}".freeze)
       end
     RUBY
 
     KIND_IS = <<-RUBY
-      def self.%{name}(value)
-        Kind::Is.call(::%{name}, value)
+      def self.%{method_name}(value = nil)
+        return Kind::Is::%{kind_name} if value.nil?
+
+        Kind::Is.(::%{kind_name}, value)
       end
     RUBY
 
-    private_constant :KIND_OF, :KIND_IS
+    private_constant :KIND_OF, :KIND_IS, :COLONS
 
-    def add(mod, name: nil)
-      mod_name = Kind.of.Module(mod).name
-      chk_name = name ? Kind::Of.(String, name) : mod_name
+    def add(kind, name: nil)
+      kind_name = Kind.of.Module(kind).name
+      checker = name ? Kind::Of.(String, name) : kind_name
 
-      unless Of.respond_to?(chk_name)
-        Of.instance_eval(KIND_OF % { name: chk_name })
-        Of.const_set(chk_name, Checker.new(mod).freeze)
+      case
+      when checker.include?(COLONS)
+        add_kind_with_namespace(checker, method_name: name)
+      else
+        add_root(checker, kind_name, method_name: name, create_kind_is_mod: false)
       end
+    end
 
-      unless Is.respond_to?(chk_name)
-        Is.instance_eval(KIND_IS % { name: chk_name })
+    private
+
+      def add_root(checker, kind_name, method_name:, create_kind_is_mod:)
+        root_checker = method_name ? method_name : checker
+        root_kind_name = method_name ? method_name : kind_name
+
+        add_kind(root_checker, root_kind_name, Kind::Of, Kind::Is, create_kind_is_mod)
+      end
+
+      def add_kind_with_namespace(checker, method_name:)
+        raise NotImplementedError if method_name
+
+        const_names = checker.split(COLONS)
+        const_names.each_with_index do |const_name, index|
+          if index == 0
+            add_root(const_name, const_name, method_name: nil, create_kind_is_mod: true)
+          else
+            add_node(const_names, index)
+          end
+        end
+      end
+
+      def add_node(const_names, index)
+        namespace = const_names[0..(index-1)]
+        namespace_name = namespace.join(COLONS)
+
+        kind_of_mod = Kind::Of.const_get(namespace_name)
+        kind_is_mod = Kind::Is.const_get(namespace_name)
+
+        checker = const_names[index]
+        kind_name = const_names[0..index].join(COLONS)
+
+        add_kind(checker, kind_name, kind_of_mod, kind_is_mod, true)
+      end
+
+      def add_kind(checker, kind_name, kind_of_mod, kind_is_mod, create_kind_is_mod)
+        params = { method_name: checker, kind_name: kind_name }
+
+        unless kind_of_mod.respond_to?(checker)
+          kind_checker = ::Module.new { extend Checker }
+          kind_checker.module_eval("def self.__kind; #{kind_name}; end")
+
+          kind_of_mod.instance_eval(KIND_OF % params)
+          kind_of_mod.const_set(checker, kind_checker)
+        end
+
+        unless kind_is_mod.respond_to?(checker)
+          kind_is_mod.instance_eval(KIND_IS % params)
+          kind_is_mod.const_set(checker, Module.new) if create_kind_is_mod
+        end
       end
-    end
   end
 
   def self.is; Is; end
@@ -162,15 +214,17 @@ module Kind
       raise Kind::Error.new('Boolean'.freeze, bool)
     end
 
-    const_set(:Boolean, ::Class.new(Checker) do
-      def class?(value)
-        Kind.is.Boolean(value)
-      end
+    const_set(:Boolean, ::Module.new do
+      extend Checker
 
-      def instance?(value)
+      def self.__kind; [TrueClass, FalseClass].freeze; end
+
+      def self.class?(value); Kind.is.Boolean(value); end
+
+      def self.instance?(value);
         value.is_a?(TrueClass) || value.is_a?(FalseClass)
       end
-    end.new([TrueClass, FalseClass].freeze).freeze)
+    end)
 
     # -- Lambda
 
@@ -186,11 +240,15 @@ module Kind
       raise Kind::Error.new('Lambda'.freeze, func)
     end
 
-    const_set(:Lambda, ::Class.new(Checker) do
-      def instance?(value)
-        value.is_a?(@type) && value.lambda?
+    const_set(:Lambda, ::Module.new do
+      extend Checker
+
+      def self.__kind; ::Proc; end
+
+      def self.instance?(value)
+        value.is_a?(__kind) && value.lambda?
       end
-    end.new(::Proc).freeze)
+    end)
   end
 
   private_constant :Checker

data/lib/kind/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kind
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-01-07 00:00:00.000000000 Z
+date: 2020-03-17 00:00:00.000000000 Z
 dependencies: []
 description: Basic type system for Ruby (free of dependencies).
 email: