kind 3.1.0 → 4.0.0

data/lib/kind/core/kind.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Kind
+  module KIND
+    def self.null?(value) # :nodoc:
+      value.nil? || Undefined == value
+    end
+
+    def self.of?(kind, values) # :nodoc:
+      of_kind = -> value { kind === value }
+
+      values.empty? ? of_kind : values.all?(&of_kind)
+    end
+
+    def self.of!(kind, value, kind_name = nil) # :nodoc:
+      return value if kind === value
+
+      error!(kind_name || kind.name, value)
+    end
+
+    def self.error!(kind_name, value) # :nodoc:
+      raise Error.new(kind_name, value)
+    end
+
+    def self.of_class?(value) # :nodoc:
+      value.kind_of?(::Class)
+    end
+
+    def self.of_module?(value) # :nodoc:
+      ::Module == value || (value.is_a?(::Module) && !of_class?(value))
+    end
+
+    def self.of_module_or_class!(value) # :nodoc:
+      of!(::Module, value, 'Module/Class')
+    end
+
+    def self.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 self.is?(expected, value) # :nodoc:
+      is!(of_module_or_class!(expected), value)
+    end
+
+    def self.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
+
+    def self.value(kind, arg, default) # :nodoc:
+      kind === arg ? arg : default
+    end
+  end
+end

data/lib/kind/core/undefined.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Kind
+  UNDEFINED = Object.new.freeze
+
+  private_constant :UNDEFINED
+end

data/lib/kind/deprecations/built_in_type_checkers.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Kind
+  # -- Classes
+  [
+    ::String, ::Symbol, ::Numeric, ::Integer, ::Float, ::Regexp, ::Time,
+    ::Array, ::Range, ::Hash, ::Struct, ::Enumerator, ::Set, ::OpenStruct,
+    ::Method, ::Proc,
+    ::IO, ::File
+  ].each { |klass| Types.add(klass) }
+
+  Types.add(::Queue, name: 'Queue'.freeze)
+
+  # -- Modules
+  [
+    ::Enumerable, ::Comparable
+  ].each { |klass| Types.add(klass) }
+
+  # -- Kind::Of::Maybe
+
+  Types.add(Kind::Maybe::Result, name: 'Maybe'.freeze)
+  Types.add(Kind::Maybe::Result, name: 'Optional'.freeze)
+end

data/lib/kind/{checker.rb → deprecations/checker.rb}

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-require 'kind/checker/factory'
-require 'kind/checker/protocol'
+require 'kind/deprecations/checker/factory'
+require 'kind/deprecations/checker/protocol'
+
 module Kind
   class Checker
     include Protocol

data/lib/kind/{checker → deprecations/checker}/factory.rb

@@ -15,10 +15,6 @@ module Kind
         @__checkers__ = {}
       end
 
-      MODULE_OR_CLASS = 'Module/Class'.freeze
-
-      private_constant :MODULE_OR_CLASS
-
       def create(kind)
         @__checkers__[kind] ||= begin
           kind_name = kind.name
@@ -26,7 +22,7 @@ module Kind
           if Kind::Of.const_defined?(kind_name, false)
             Kind::Of.const_get(kind_name)
           else
-            Kind::Checker.new(Kind::Of.(Module, kind, MODULE_OR_CLASS))
+            Kind::Checker.new(Kind.of_module_or_class(kind))
           end
         end
       end

data/lib/kind/{checker → deprecations/checker}/protocol.rb

@@ -4,15 +4,15 @@ module Kind
   class Checker
     module Protocol
       def class?(value)
-        Kind::Is.__call__(__kind, value)
+        KIND.is?(__kind, value)
       end
 
       def instance(value, options = Empty::HASH)
         default = options[:or]
 
-        return Kind::Of.(__kind, value) if ::Kind::Maybe::Value.none?(default)
+        return KIND.of!(__kind, value) if ::Kind::KIND.null?(default)
 
-        Kind::Undefined != value && instance?(value) ? value : Kind::Of.(__kind, default)
+        Kind::Undefined != value && instance?(value) ? value : KIND.of!(__kind, default)
       end
 
       def [](value, options = options = Empty::HASH)

data/lib/kind/deprecations/is.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Kind
+  module Is
+    def self.call(expected, object)
+      DEPRECATION.warn_method_replacement('Kind::Is.call', 'Kind::KIND.is?')
+
+      KIND.is?(expected, object)
+    end
+
+    def self.Class(value)
+      DEPRECATION.warn_method_replacement('Kind::Is.Class', 'Kind.of_class?')
+
+      Kind.of_class?(value)
+    end
+
+    def self.Module(value)
+      DEPRECATION.warn_method_replacement('Kind::Is.Module', 'Kind.of_module?')
+
+      Kind.of_module?(value)
+    end
+
+    def self.Boolean(value)
+      DEPRECATION.warn_removal('Kind::Is.Boolean')
+
+      Kind::Class[value] <= TrueClass || value <= FalseClass
+    end
+
+    def self.Callable(value)
+      DEPRECATION.warn_method_replacement('Kind::Is.Callable', 'Kind::Callable?')
+
+      value.respond_to?(:call)
+    end
+  end
+end

data/lib/kind/deprecations/of.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+module Kind
+  module Of
+    def self.call(kind, object, kind_name = nil)
+      DEPRECATION.warn_method_replacement('Kind::Of.call', 'Kind::KIND.of!')
+
+      KIND.of!(kind, object, kind_name)
+    end
+
+    # -- Class
+
+    def self.Class(object = Undefined)
+      DEPRECATION.warn_method_replacement('Kind::Of::Class', 'Kind::Class')
+
+      return Class if Undefined == object
+
+      self.call(::Class, object)
+    end
+
+    const_set(:Class, ::Module.new do
+      extend Checker::Protocol
+
+      def self.__kind; ::Class; end
+
+      def self.class?(value); Kind.of_class?(value); end
+
+      def self.__is_instance__(value); class?(value); end
+    end)
+
+    def self.Class?(*args)
+      DEPRECATION.warn_method_replacement('Kind::Of::Class?', 'Kind::Class?')
+
+      Kind::Class?(*args)
+    end
+
+    # -- Module
+
+    def self.Module(object = Undefined)
+      DEPRECATION.warn_method_replacement('Kind::Of::Module', 'Kind::Module')
+
+      return Module if Undefined == object
+
+      self.call(::Module, object)
+    end
+
+    const_set(:Module, ::Module.new do
+      extend Checker::Protocol
+
+      def self.__kind_undefined(value)
+        __kind_error(Kind::Undefined) if Kind::Undefined == value
+
+        yield
+      end
+
+      def self.__kind_error(value)
+        raise Kind::Error.new('Module'.freeze, value)
+      end
+
+      def self.__kind_of(value)
+        return value if Kind.of_module?(value)
+
+        __kind_error(value)
+      end
+
+      def self.__kind; ::Module; end
+
+      def self.class?(value); Kind.of_module?(value); end
+
+      def self.instance(value, options = Empty::HASH)
+        default = options[:or]
+
+        if ::Kind::KIND.null?(default)
+          __kind_undefined(value) { __kind_of(value) }
+        else
+          return value if Kind::Undefined != value && instance?(value)
+
+          __kind_undefined(default) { __kind_of(default) }
+        end
+      end
+
+      def self.__is_instance__(value); class?(value); end
+    end)
+
+    def self.Module?(*args)
+      DEPRECATION.warn_method_replacement('Kind::Of::Module?', 'Kind::Module?')
+
+      Kind::Module?(*args)
+    end
+
+    # -- Boolean
+
+    def self.Boolean(object = Undefined, options = Empty::HASH)
+      DEPRECATION.warn_method_replacement('Kind::Of::Boolean', 'Kind::Boolean')
+
+      default = options[:or]
+
+      return Kind::Of::Boolean if Undefined == object && default.nil?
+
+      bool = object.nil? ? default : object
+
+      return bool if bool.is_a?(::TrueClass) || bool.is_a?(::FalseClass)
+
+      raise Kind::Error.new('Boolean'.freeze, bool)
+    end
+
+    const_set(:Boolean, ::Module.new do
+      extend Checker::Protocol
+
+      def self.__kind; [TrueClass, FalseClass].freeze; end
+
+      def self.class?(value); Kind.is.Boolean(value); end
+
+      def self.instance(value, options= Empty::HASH)
+        default = options[:or]
+
+        if ::Kind::KIND.null?(default)
+          __kind_undefined(value) { Kind::Of::Boolean(value) }
+        else
+          return value if Kind::Undefined != value && instance?(value)
+
+          __kind_undefined(default) { Kind::Of::Boolean(default) }
+        end
+      end
+
+      def self.__kind_undefined(value)
+        if Kind::Undefined == value
+          raise Kind::Error.new('Boolean'.freeze, Kind::Undefined)
+        else
+          yield
+        end
+      end
+
+      def self.__is_instance__(value);
+        value.is_a?(TrueClass) || value.is_a?(FalseClass)
+      end
+
+      def self.or_undefined(value)
+        result = or_nil(value)
+        result.nil? ? Kind::Undefined : result
+      end
+    end)
+
+    def self.Boolean?(*args)
+      DEPRECATION.warn_method_replacement('Kind::Of::Boolean?', 'Kind::Boolean?')
+
+      Kind::Boolean?(*args)
+    end
+
+    # -- Lambda
+
+    def self.Lambda(object = Undefined, options = Empty::HASH)
+      DEPRECATION.warn_method_replacement('Kind::Of::Lambda', 'Kind::Lambda')
+
+      default = options[:or]
+
+      return Kind::Of::Lambda if Undefined == object && default.nil?
+
+      func = object || default
+
+      return func if func.is_a?(::Proc) && func.lambda?
+
+      raise Kind::Error.new('Lambda'.freeze, func)
+    end
+
+    const_set(:Lambda, ::Module.new do
+      extend Checker::Protocol
+
+      def self.__kind; ::Proc; end
+
+      def self.instance(value, options = Empty::HASH)
+        default = options[:or]
+
+        if ::Kind::KIND.null?(default)
+          __kind_undefined(value) { Kind::Of::Lambda(value) }
+        else
+          return value if Kind::Undefined != value && instance?(value)
+
+          __kind_undefined(default) { Kind::Of::Lambda(default) }
+        end
+      end
+
+      def self.__kind_undefined(value)
+        if Kind::Undefined == value
+          raise Kind::Error.new('Lambda'.freeze, Kind::Undefined)
+        else
+          yield
+        end
+      end
+
+      def self.__is_instance__(value)
+        value.is_a?(__kind) && value.lambda?
+      end
+    end)
+
+    def self.Lambda?(*args)
+      DEPRECATION.warn_method_replacement('Kind::Of::Lambda?', 'Kind::Lambda?')
+
+      Kind::Lambda?(*args)
+    end
+
+    # -- Callable
+
+    def self.Callable(object = Undefined, options = Empty::HASH)
+      DEPRECATION.warn_method_replacement('Kind::Of::Callable', 'Kind::Callable')
+
+      default = options[:or]
+
+      return Kind::Of::Callable if Undefined == object && default.nil?
+
+      callable = object || default
+
+      return callable if callable.respond_to?(:call)
+
+      raise Kind::Error.new('Callable'.freeze, callable)
+    end
+
+    const_set(:Callable, ::Module.new do
+      extend Checker::Protocol
+
+      def self.__kind; Object; end
+
+      def self.class?(value)
+        Kind::Is::Callable(value)
+      end
+
+      def self.instance(value, options = Empty::HASH)
+        default = options[:or]
+
+        if ::Kind::KIND.null?(default)
+          __kind_undefined(value) { Kind::Of::Callable(value) }
+        else
+          return value if Kind::Undefined != value && instance?(value)
+
+          __kind_undefined(default) { Kind::Of::Callable(default) }
+        end
+      end
+
+      def self.__kind_undefined(value)
+        if Kind::Undefined == value
+          raise Kind::Error.new('Callable'.freeze, Kind::Undefined)
+        else
+          yield
+        end
+      end
+
+      def self.__is_instance__(value);
+        value.respond_to?(:call)
+      end
+    end)
+
+    def self.Callable?(*args)
+      DEPRECATION.warn_method_replacement('Kind::Of::Callable?', 'Kind::Callable?')
+
+      Kind::Callable?(*args)
+    end
+  end
+end

data/lib/kind/{types.rb → deprecations/types.rb}

@@ -8,6 +8,8 @@ module Kind
 
     KIND_OF = <<-RUBY
       def self.%{method_name}(object = Undefined, options = Empty::HASH)
+        DEPRECATION.warn_method_replacement('Kind::Of::%{method_name}', 'Kind::%{method_name}')
+
         default = options[:or]
 
         return Kind::Of::%{kind_name} if Undefined == object && default.nil?
@@ -16,29 +18,33 @@ module Kind
 
         return object if is_instance
 
-        Kind::Of.(::%{kind_name_to_check}, object && default ? default : object || default)
+        KIND.of!(::%{kind_name_to_check}, object && default ? default : object || default)
       end
     RUBY
 
     KIND_OF_IS = <<-RUBY
       def self.%{method_name}?(*args)
+        DEPRECATION.warn_method_replacement('Kind::Of::%{method_name}?', 'Kind::%{method_name}?')
+
         Kind::Of::%{kind_name}.instance?(*args)
       end
     RUBY
 
     KIND_IS = <<-RUBY
-      def self.%{method_name}(value = Undefined)
-        return Kind::Is::%{kind_name} if Undefined == value
+      def self.%{method_name}(value)
+        DEPRECATION.warn_removal('Kind::Is::%{method_name}')
 
-        Kind::Is.__call__(::%{kind_name_to_check}, value)
+        KIND.is!(::%{kind_name_to_check}, value)
       end
     RUBY
 
     private_constant :KIND_OF, :KIND_IS, :COLONS
 
     def add(kind, name: nil)
-      kind_name = Kind.of.Module(kind).name
-      checker = name ? Kind::Of.(String, name) : kind_name
+      DEPRECATION.warn_removal('Kind::Types')
+
+      kind_name = KIND.of_module_or_class!(kind).name
+      checker = name ? Kind::String[name] : kind_name
 
       if checker.include?(COLONS)
         add_kind_with_namespace(checker, method_name: name)
@@ -99,7 +105,7 @@ module Kind
           params[:kind_name_to_check] ||= kind_name
 
           kind_checker = ::Module.new { extend Checker::Protocol }
-          kind_checker.module_eval("def self.__kind; #{params[:kind_name_to_check]}; end")
+          kind_checker.module_eval("def self.__kind; ::#{params[:kind_name_to_check]}; end")
 
           kind_of_mod.instance_eval(KIND_OF % params)
           kind_of_mod.const_set(method_name, kind_checker)
@@ -108,7 +114,7 @@ module Kind
 
         unless kind_is_mod.respond_to?(method_name)
           kind_is_mod.instance_eval(KIND_IS % params)
-          kind_is_mod.const_set(method_name, Module.new) if create_kind_is_mod
+          kind_is_mod.const_set(method_name, ::Module.new) if create_kind_is_mod
         end
       end
   end