kind 1.7.0 → 2.2.0

data/kind.gemspec

@@ -6,8 +6,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ['Rodrigo Serradura']
   spec.email         = ['rodrigo.serradura@gmail.com']
 
-  spec.summary       = %q{Basic type system for Ruby.}
-  spec.description   = %q{Basic type system for Ruby (free of dependencies).}
+  spec.summary       = %q{A simple type system (at runtime) for Ruby.}
+  spec.description   = %q{A simple type system (at runtime) for Ruby - free of dependencies.}
   spec.homepage      = 'https://github.com/serradura/kind'
   spec.license       = 'MIT'
   spec.required_ruby_version = Gem::Requirement.new('>= 2.2.0')

data/lib/kind.rb

@@ -18,9 +18,9 @@ module Kind
   private_constant :WRONG_NUMBER_OF_ARGUMENTS
 
   def self.is(expected = Undefined, object = Undefined)
-    return Is if expected == Undefined && object == Undefined
+    return Is if Undefined == expected && Undefined == object
 
-    return Kind::Is.(expected, object) if object != Undefined
+    return Kind::Is.(expected, object) if Undefined != object
 
     raise ArgumentError, WRONG_NUMBER_OF_ARGUMENTS
   end
@@ -29,10 +29,16 @@ module Kind
 
   private_constant :MODULE_OR_CLASS
 
+  private_class_method def self.__checkers__
+    @__checkers__ ||= {}
+  end
+
+  __checkers__
+
   def self.of(kind = Undefined, object = Undefined)
-    return Of if kind == Undefined && object == Undefined
+    return Of if Undefined == kind && Undefined == object
 
-    return Kind::Of.(kind, object) if object != Undefined
+    return Kind::Of.(kind, object) if Undefined != object
 
     __checkers__[kind] ||= begin
       kind_name = kind.name
@@ -45,8 +51,8 @@ module Kind
     end
   end
 
-  private_class_method def self.__checkers__
-    @__checkers__ ||= {}
+  def self.of?(kind, *args)
+    Kind.of(kind).instance?(*args)
   end
 
   # --------------------- #
@@ -55,20 +61,19 @@ module Kind
 
   module Is
     def self.Class(value)
-      value.is_a?(::Class)
+      value.kind_of?(::Class)
     end
 
     def self.Module(value)
-      value == ::Module || (value.is_a?(::Module) && !self.Class(value))
+      ::Module == value || (value.is_a?(::Module) && !self.Class(value))
     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
 
@@ -76,7 +81,7 @@ module Kind
     # -- Class
 
     def self.Class(object = Undefined)
-      return Class if object == Undefined
+      return Class if Undefined == object
 
       self.call(::Class, object)
     end
@@ -88,13 +93,17 @@ module Kind
 
       def self.class?(value); Kind::Is.Class(value); end
 
-      def self.instance?(value); 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 object == Undefined
+      return Module if Undefined == object
 
       self.call(::Module, object)
     end
@@ -102,7 +111,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 Kind::Undefined == value
+
+        yield
+      end
 
       def self.__kind_error(value)
         raise Kind::Error.new('Module'.freeze, value)
@@ -114,11 +127,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
 
@@ -128,21 +137,25 @@ module Kind
         if ::Kind::Maybe::Value.none?(default)
           __kind_undefined(value) { __kind_of(value) }
         else
-          return value if instance?(value)
+          return value if Kind::Undefined != value && instance?(value)
 
           __kind_undefined(default) { __kind_of(default) }
         end
       end
 
-      def self.instance?(value); class?(value); 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 object == Undefined && default.nil?
+      return Kind::Of::Boolean if Undefined == object && default.nil?
 
       bool = object.nil? ? default : object
 
@@ -164,21 +177,21 @@ module Kind
         if ::Kind::Maybe::Value.none?(default)
           __kind_undefined(value) { Kind::Of::Boolean(value) }
         else
-          return value if instance?(value)
+          return value if Kind::Undefined != value && instance?(value)
 
           __kind_undefined(default) { Kind::Of::Boolean(default) }
         end
       end
 
       def self.__kind_undefined(value)
-        if value == Kind::Undefined
+        if Kind::Undefined == value
           raise Kind::Error.new('Boolean'.freeze, Kind::Undefined)
         else
           yield
         end
       end
 
-      def self.instance?(value);
+      def self.__is_instance__(value);
         value.is_a?(TrueClass) || value.is_a?(FalseClass)
       end
 
@@ -188,12 +201,16 @@ module Kind
       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 object == Undefined && default.nil?
+      return Kind::Of::Lambda if Undefined == object && default.nil?
 
       func = object || default
 
@@ -213,31 +230,35 @@ module Kind
         if ::Kind::Maybe::Value.none?(default)
           __kind_undefined(value) { Kind::Of::Lambda(value) }
         else
-          return value if instance?(value)
+          return value if Kind::Undefined != value && instance?(value)
 
           __kind_undefined(default) { Kind::Of::Lambda(default) }
         end
       end
 
       def self.__kind_undefined(value)
-        if value == Kind::Undefined
+        if Kind::Undefined == value
           raise Kind::Error.new('Lambda'.freeze, Kind::Undefined)
         else
           yield
         end
       end
 
-      def self.instance?(value)
+      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 object == Undefined && default.nil?
+      return Kind::Of::Callable if Undefined == object && default.nil?
 
       callable = object || default
 
@@ -261,25 +282,29 @@ module Kind
         if ::Kind::Maybe::Value.none?(default)
           __kind_undefined(value) { Kind::Of::Callable(value) }
         else
-          return value if instance?(value)
+          return value if Kind::Undefined != value && instance?(value)
 
           __kind_undefined(default) { Kind::Of::Callable(default) }
         end
       end
 
       def self.__kind_undefined(value)
-        if value == Kind::Undefined
+        if Kind::Undefined == value
           raise Kind::Error.new('Callable'.freeze, Kind::Undefined)
         else
           yield
         end
       end
 
-      def self.instance?(value);
+      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 #
     # ---------------------- #

data/lib/kind/active_model/kind_validator.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+class KindValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    return if options[:allow_nil] && value.nil?
+
+    return unless error = call_validation_for(attribute, value)
+
+    raise Kind::Error.new("#{attribute} #{error}") if options[:strict]
+
+    record.errors.add(attribute, error)
+  end
+
+  private
+
+    def call_validation_for(attribute, value)
+      expected = options[:with] || options[:in]
+
+      return validate_with_default_strategy(expected, value) if expected
+
+      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]
+      return array_of(expected, value) if expected = options[:array_of]
+
+      raise Kind::Validator::InvalidDefinition.new(attribute)
+    end
+
+    def validate_with_default_strategy(expected, value)
+      send(Kind::Validator.default_strategy, expected, value)
+    end
+
+    def kind_of(expected, value)
+      types = Array(expected)
+
+      return if types.any? { |type| value.kind_of?(type) }
+
+      "must be a kind of: #{types.map { |klass| klass.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)
+
+      result = expected.map { |kind| kind_is_not(kind, value) }.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
+
+        "must be the class or a subclass of `#{expected.name}`"
+      when Module
+        return if value.kind_of?(Class) && value <= expected
+        return if expected == Kind.of.Module(value) || 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)
+      return if value.respond_to?(method_name)
+
+      "must respond to the method `#{method_name}`"
+    end
+
+    def instance_of(expected, value)
+      types = Array(expected)
+
+      return if types.any? { |type| value.instance_of?(type) }
+
+      "must be an instance of: #{types.map { |klass| klass.name }.join(', ')}"
+    end
+
+    def array_with(expected, value)
+      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/active_model/validation.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'kind'
+require 'kind/validator'
+require 'active_model'
+require 'active_model/validations'
+require_relative 'kind_validator'

data/lib/kind/checker.rb

@@ -11,15 +11,34 @@ module Kind
 
       return Kind::Of.(__kind, value) if ::Kind::Maybe::Value.none?(default)
 
-      instance?(value) ? value : Kind::Of.(__kind, default)
+      Kind::Undefined != value && instance?(value) ? value : Kind::Of.(__kind, default)
     end
 
     def [](value, options = options = Empty::HASH)
       instance(value, options)
     end
 
-    def instance?(value)
-      value.is_a?(__kind)
+    def to_proc
+      @to_proc ||=
+        -> checker { -> value { checker.instance(value) } }.call(self)
+    end
+
+    def __is_instance__(value)
+      value.kind_of?(__kind)
+    end
+
+    def is_instance_to_proc
+      @is_instance_to_proc ||=
+        -> checker { -> value { checker.__is_instance__(value) } }.call(self)
+    end
+
+    def instance?(*args)
+      return is_instance_to_proc if args.empty?
+
+      return args.all? { |object| __is_instance__(object) } if args.size > 1
+
+      arg = args[0]
+      Kind::Undefined == arg ? is_instance_to_proc : __is_instance__(arg)
     end
 
     def or_nil(value)
@@ -29,6 +48,25 @@ module Kind
     def or_undefined(value)
       or_nil(value) || Kind::Undefined
     end
+
+    def __as_maybe__(value)
+      Kind::Maybe.new(or_nil(value))
+    end
+
+    def as_maybe_to_proc
+      @as_maybe_to_proc ||=
+        -> checker { -> value { checker.__as_maybe__(value) } }.call(self)
+    end
+
+    def as_maybe(value = Kind::Undefined)
+      return __as_maybe__(value) if Kind::Undefined != value
+
+      as_maybe_to_proc
+    end
+
+    def as_optional(value = Kind::Undefined)
+      as_maybe(value)
+    end
   end
 
   private_constant :Checkable

data/lib/kind/error.rb

@@ -2,8 +2,18 @@
 
 module Kind
   class Error < TypeError
-    def initialize(kind_name, object)
-      super("#{object.inspect} expected to be a kind of #{kind_name}")
+    UNDEFINED_OBJECT = Object.new
+
+    private_constant :UNDEFINED_OBJECT
+
+    def initialize(arg, object = UNDEFINED_OBJECT)
+      if UNDEFINED_OBJECT == object
+        # Will be used when the exception was raised with a message. e.g:
+        # raise Kind::Error, "some message"
+        super(arg)
+      else
+        super("#{object.inspect} expected to be a kind of #{arg}")
+      end
     end
   end
 end