kind 3.0.0 → 5.0.0

data/lib/kind.rb

@@ -1,314 +1,62 @@
 # frozen_string_literal: true
 
+require 'set'
+require 'ostruct'
+
 require 'kind/version'
+require 'kind/core'
 
+require 'kind/error'
 require 'kind/empty'
+require 'kind/dig'
+require 'kind/try'
+require 'kind/presence'
 require 'kind/undefined'
-require 'kind/checker'
 require 'kind/maybe'
 
-require 'kind/error'
-require 'kind/of'
-require 'kind/is'
-require 'kind/types'
+require 'kind/type_checker'
+require 'kind/type_checkers'
 
 module Kind
-  WRONG_NUMBER_OF_ARGUMENTS = 'wrong number of arguments (given 1, expected 2)'.freeze
-
-  private_constant :WRONG_NUMBER_OF_ARGUMENTS
-
-  def self.is(expected = Undefined, object = Undefined)
-    return Is if Undefined == expected && Undefined == object
-
-    return Kind::Is.(expected, object) if Undefined != object
+  extend self
 
-    raise ArgumentError, WRONG_NUMBER_OF_ARGUMENTS
+  def is?(kind, arg)
+    KIND.is?(kind, arg)
   end
 
-  def self.of(kind = Undefined, object = Undefined)
-    return Of if Undefined == kind && Undefined == object
+  alias is is?
 
-    return Kind::Of.(kind, object) if Undefined != object
-
-    Kind::Checker::Factory.create(kind)
+  def of?(kind, *args)
+    KIND.of?(kind, args)
   end
 
-  def self.of?(kind, *args)
-    Kind.of(kind).instance?(*args)
+  def of_class?(value)
+    KIND.of_class?(value)
   end
 
-  # --------------------- #
-  # Special type checkers #
-  # --------------------- #
-
-  module Is
-    def self.Class(value)
-      value.kind_of?(::Class)
-    end
-
-    def self.Module(value)
-      ::Module == value || (value.is_a?(::Module) && !self.Class(value))
-    end
-
-    def self.Boolean(value)
-      Kind.of.Class(value) <= TrueClass || value <= FalseClass
-    end
-
-    def self.Callable(value)
-      value.respond_to?(:call)
-    end
+  def of_module?(value)
+    KIND.of_module?(value)
   end
 
-  module Of
-    # -- Class
-
-    def self.Class(object = Undefined)
-      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::Is.Class(value); end
-
-      def self.__is_instance__(value); class?(value); end
-    end)
-
-    def self.Class?(*args)
-      Kind::Of::Class.instance?(*args)
-    end
-
-    # -- Module
-
-    def self.Module(object = Undefined)
-      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::Is.Module(value)
-
-        __kind_error(value)
-      end
-
-      def self.__kind; ::Module; end
-
-      def self.class?(value); Kind::Is.Module(value); end
-
-      def self.instance(value, options = Empty::HASH)
-        default = options[:or]
-
-        if ::Kind::Maybe::Value.none?(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)
-      Kind::Of::Module.instance?(*args)
-    end
-
-    # -- Boolean
-
-    def self.Boolean(object = Undefined, options = Empty::HASH)
-      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 respond_to(value, *method_names)
+    method_names.each { |method_name| KIND.respond_to!(method_name, value) }
 
-      def self.class?(value); Kind.is.Boolean(value); end
-
-      def self.instance(value, options= Empty::HASH)
-        default = options[:or]
-
-        if ::Kind::Maybe::Value.none?(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)
-      Kind::Of::Boolean.instance?(*args)
-    end
-
-    # -- Lambda
-
-    def self.Lambda(object = Undefined, options = Empty::HASH)
-      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::Maybe::Value.none?(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)
-      Kind::Of::Lambda.instance?(*args)
-    end
-
-    # -- Callable
-
-    def self.Callable(object = Undefined, options = Empty::HASH)
-      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::Maybe::Value.none?(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)
-      Kind::Of::Callable.instance?(*args)
-    end
-
-    # ---------------------- #
-    # Built-in type checkers #
-    # ---------------------- #
-
-    # -- Classes
-    [
-      String, Symbol, Numeric, Integer, Float, Regexp, Time,
-      Array, Range, Hash, Struct, Enumerator, Set,
-      Method, Proc,
-      IO, File
-    ].each { |klass| Types.add(klass) }
+    value
+  end
 
-    Types.add(Queue, name: 'Queue'.freeze)
+  def of_module_or_class(value)
+    KIND.of_module_or_class!(value)
+  end
 
-    # -- Modules
-    [
-      Enumerable, Comparable
-    ].each { |klass| Types.add(klass) }
+  def of(kind, object)
+    KIND.of!(kind, object)
+  end
 
-    # -- Kind::Of::Maybe
+  def value(kind, value, default:)
+    KIND.value(kind, value, of(kind, default))
+  end
 
-    Types.add(Kind::Maybe::Result, name: 'Maybe'.freeze)
-    Types.add(Kind::Maybe::Result, name: 'Optional'.freeze)
+  def Of(kind, opt = Empty::HASH)
+    TypeChecker::Object.new(kind, opt)
   end
 end

data/lib/kind/active_model/kind_validator.rb

@@ -35,30 +35,30 @@ class KindValidator < ActiveModel::EachValidator
     def kind_of(expected, value)
       types = Array(expected)
 
-      return if types.any? { |type| value.kind_of?(type) }
+      return if types.any? { |type| type === value }
 
-      "must be a kind of: #{types.map { |klass| klass.name }.join(', ')}"
+      "must be a kind of: #{types.map { |type| type.name }.join(', ')}"
     end
 
     CLASS_OR_MODULE = 'Class/Module'.freeze
 
     def kind_is(expected, value)
-      return kind_is_not(expected, value) unless expected.kind_of?(Array)
+      return kind_is_not(expected, value) unless expected.kind_of?(::Array)
 
-      result = expected.map { |kind| kind_is_not(kind, value) }.compact
+      result = expected.map { |kind| kind_is_not(kind, value) }.tap(&:compact!)
 
       result.empty? || result.size < expected.size ? nil : result.join(', ')
     end
 
     def kind_is_not(expected, value)
       case expected
-      when Class
-        return if expected == Kind.of.Class(value) || value < expected
+      when ::Class
+        return if expected == Kind::Class[value] || value < expected
 
         "must be the class or a subclass of `#{expected.name}`"
-      when Module
+      when ::Module
         return if value.kind_of?(Class) && value <= expected
-        return if expected == Kind.of.Module(value) || value.kind_of?(expected)
+        return if expected == Kind.of_module_or_class(value) || value.kind_of?(expected)
 
         "must include the `#{expected.name}` module"
       else
@@ -66,10 +66,17 @@ class KindValidator < ActiveModel::EachValidator
       end
     end
 
-    def respond_to(method_name, value)
-      return if value.respond_to?(method_name)
+    def respond_to(expected, value)
+      method_names = Array(expected)
 
-      "must respond to the method `#{method_name}`"
+      expected_methods = method_names.select { |method_name| !value.respond_to?(method_name) }
+      expected_methods.map! { |method_name| "`#{method_name}`" }
+
+      return if expected_methods.empty?
+
+      methods = expected_methods.size == 1 ? 'method' : 'methods'
+
+      "must respond to the #{methods}: #{expected_methods.join(', ')}"
     end
 
     def instance_of(expected, value)
@@ -81,7 +88,7 @@ class KindValidator < ActiveModel::EachValidator
     end
 
     def array_with(expected, value)
-      return if value.kind_of?(Array) && !value.empty? && (value - Kind.of.Array(expected)).empty?
+      return if value.kind_of?(::Array) && !value.empty? && (value - Kind::Array[expected]).empty?
 
       "must be an array with: #{expected.join(', ')}"
     end
@@ -89,7 +96,7 @@ class KindValidator < ActiveModel::EachValidator
     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) } }
+      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

data/lib/kind/core.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Kind
+  module Core
+    require 'kind/core/kind'
+    require 'kind/core/undefined'
+  end
+end

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.kind_of?(::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