kind 4.0.0 → 5.3.0

data/lib/kind/active_model/kind_validator.rb

@@ -1,96 +0,0 @@
-# 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::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_or_class(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::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/core.rb

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

data/lib/kind/core/deprecation.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module Kind
-  module DEPRECATION # :nodoc: all
-    WARN_IS_DISABLED = String(ENV['DISABLE_KIND_DEPRECATION']).strip == 't'
-
-    module DevNull
-      def self.warn(_)
-      end
-    end
-
-    OUTPUT = WARN_IS_DISABLED ? DevNull : ::Kernel
-
-    def self.warn(message)
-      OUTPUT.warn("[DEPRECATION] #{message}" % { version: 'version 5.0' })
-    end
-
-    def self.warn_method_replacement(old_method, new_method)
-      self.warn "`#{old_method}` is deprecated, it will be removed in %{version}. " \
-        "Please use `#{new_method}` instead."
-    end
-
-    def self.warn_removal(name)
-      self.warn "`#{name}` is deprecated, it will be removed in %{version}."
-    end
-
-    private_constant :DevNull, :OUTPUT
-  end
-end

data/lib/kind/core/kind.rb

@@ -1,61 +0,0 @@
-# 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

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

data/lib/kind/deprecations/built_in_type_checkers.rb

@@ -1,23 +0,0 @@
-# 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/deprecations/checker.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require 'kind/deprecations/checker/factory'
-require 'kind/deprecations/checker/protocol'
-
-module Kind
-  class Checker
-    include Protocol
-
-    attr_reader :__kind
-
-    def initialize(kind)
-      @__kind = kind
-    end
-  end
-end

data/lib/kind/deprecations/checker/factory.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require 'singleton'
-
-module Kind
-  class Checker
-    class Factory
-      include Singleton
-
-      def self.create(kind)
-        instance.create(kind)
-      end
-
-      def initialize
-        @__checkers__ = {}
-      end
-
-      def create(kind)
-        @__checkers__[kind] ||= begin
-          kind_name = kind.name
-
-          if Kind::Of.const_defined?(kind_name, false)
-            Kind::Of.const_get(kind_name)
-          else
-            Kind::Checker.new(Kind.of_module_or_class(kind))
-          end
-        end
-      end
-    end
-  end
-end

data/lib/kind/deprecations/checker/protocol.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-module Kind
-  class Checker
-    module Protocol
-      def class?(value)
-        KIND.is?(__kind, value)
-      end
-
-      def instance(value, options = Empty::HASH)
-        default = options[:or]
-
-        return KIND.of!(__kind, value) if ::Kind::KIND.null?(default)
-
-        Kind::Undefined != value && instance?(value) ? value : KIND.of!(__kind, default)
-      end
-
-      def [](value, options = options = Empty::HASH)
-        instance(value, options)
-      end
-
-      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)
-        return value if instance?(value)
-      end
-
-      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
-  end
-end

data/lib/kind/deprecations/is.rb

@@ -1,35 +0,0 @@
-# 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

@@ -1,258 +0,0 @@
-# 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