kind 4.1.0 → 5.4.0

data/lib/kind/deprecations/types.rb

@@ -1,121 +0,0 @@
-# frozen_string_literal: true
-
-module Kind
-  module Types
-    extend self
-
-    COLONS = '::'.freeze
-
-    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?
-
-        is_instance = Kind::Of::%{kind_name}.__is_instance__(object)
-
-        return object if is_instance
-
-        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)
-        DEPRECATION.warn_removal('Kind::Is::%{method_name}')
-
-        KIND.is!(::%{kind_name_to_check}, value)
-      end
-    RUBY
-
-    private_constant :KIND_OF, :KIND_IS, :COLONS
-
-    def add(kind, name: nil)
-      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)
-      else
-        add_root(checker, kind_name, method_name: name,
-                                     kind_name_to_check: kind_name,
-                                     create_kind_is_mod: false)
-      end
-    end
-
-    private
-
-      def add_root(checker, kind_name, method_name:, create_kind_is_mod:, kind_name_to_check: nil)
-        root_kind_name = method_name ? method_name : kind_name
-
-        params = {
-          method_name: method_name ? method_name : checker,
-          kind_name: method_name ? method_name : kind_name,
-          kind_name_to_check: kind_name_to_check || root_kind_name
-        }
-
-        add_kind(params, 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)
-
-        params = { method_name: checker, kind_name: kind_name }
-
-        add_kind(params, kind_of_mod, kind_is_mod, true)
-      end
-
-      def add_kind(params, kind_of_mod, kind_is_mod, create_kind_is_mod)
-        method_name = params[:method_name]
-
-        unless kind_of_mod.respond_to?(method_name)
-          kind_name = params[:kind_name]
-          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_of_mod.instance_eval(KIND_OF % params)
-          kind_of_mod.const_set(method_name, kind_checker)
-          kind_of_mod.instance_eval(KIND_OF_IS % params)
-        end
-
-        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
-        end
-      end
-  end
-end

data/lib/kind/error.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Kind
-  class Error < TypeError
-    def initialize(arg, object = UNDEFINED)
-      if UNDEFINED == 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

data/lib/kind/maybe/result.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module Kind
-  module Maybe
-    class Result
-      attr_reader :value
-
-      Value = ->(arg) { arg.kind_of?(Maybe::Result) ? arg.value : arg } # :nodoc:
-
-      def initialize(arg)
-        @value = Value.(arg)
-      end
-
-      def value_or(method_name = UNDEFINED, &block)
-        raise NotImplementedError
-      end
-
-      def none?
-        raise NotImplementedError
-      end
-
-      def some?; !none?; end
-
-      def map(&fn)
-        raise NotImplementedError
-      end
-
-      alias_method :map!, :map
-      alias_method :then, :map
-      alias_method :then!, :map
-
-      def check(&fn)
-        raise NotImplementedError
-      end
-
-      def try(method_name = UNDEFINED, &block)
-        raise NotImplementedError
-      end
-
-      alias_method :try!, :try
-
-      def dig(*keys)
-        raise NotImplementedError
-      end
-
-      def presence
-        raise NotImplementedError
-      end
-    end
-  end
-end

data/lib/kind/type_checker.rb

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-module Kind
-  module TypeChecker
-    def name
-      kind.name
-    end
-
-    def ===(value)
-      kind === value
-    end
-
-    def [](value)
-      return value if self === value
-
-      KIND.error!(name, value)
-    end
-
-    def or_nil(value)
-      return value if self === value
-    end
-
-    def or_undefined(value)
-      or_nil(value) || Undefined
-    end
-
-    def or(fallback, value = UNDEFINED)
-      return __or_func.(fallback) if UNDEFINED === value
-
-      self === value ? value : fallback
-    end
-
-    def value?(value = UNDEFINED)
-      return self === value if UNDEFINED != value
-
-      @__is_value ||= ->(ck) { ->(value) { ck === value } }.(self)
-    end
-
-    def value(arg, default:)
-      KIND.value(self, arg, self[default])
-    end
-
-    def or_null(value) # :nodoc:
-      KIND.null?(value) ? value : self[value]
-    end
-
-    def maybe(value = UNDEFINED, &block)
-      return __maybe[value] if UNDEFINED != value && !block
-      return __maybe.wrap(&block) if UNDEFINED == value && block
-      return __maybe.wrap(value, &block) if UNDEFINED != value && block
-
-      __maybe
-    end
-
-    alias optional maybe
-
-    private
-
-      def __maybe
-        @__maybe ||= Maybe::Typed.new(self)
-      end
-
-      def __or_func
-        @__or_func ||= ->(tc, fb, value) { tc === value ? value : tc.or_null(fb) }.curry[self]
-      end
-  end
-
-  class TypeChecker::Object # :nodoc: all
-    include TypeChecker
-
-    ResolveKindName = ->(kind, opt) do
-      name = Try.(opt, :[], :name)
-      name || Try.(kind, :name)
-    end
-
-    attr_reader :kind, :name
-
-    def initialize(kind, opt)
-      name = ResolveKindName.(kind, opt)
-
-      @name = KIND.of!(::String, name)
-      @kind = KIND.respond_to!(:===, kind)
-    end
-
-    private_constant :ResolveKindName
-  end
-end

data/lib/kind/type_checkers.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require 'kind/type_checkers/core/array'
-require 'kind/type_checkers/core/class'
-require 'kind/type_checkers/core/comparable'
-require 'kind/type_checkers/core/enumerable'
-require 'kind/type_checkers/core/enumerator'
-require 'kind/type_checkers/core/file'
-require 'kind/type_checkers/core/float'
-require 'kind/type_checkers/core/hash'
-require 'kind/type_checkers/core/integer'
-require 'kind/type_checkers/core/io'
-require 'kind/type_checkers/core/module'
-require 'kind/type_checkers/core/method'
-require 'kind/type_checkers/core/numeric'
-require 'kind/type_checkers/core/proc'
-require 'kind/type_checkers/core/queue'
-require 'kind/type_checkers/core/range'
-require 'kind/type_checkers/core/regexp'
-require 'kind/type_checkers/core/string'
-require 'kind/type_checkers/core/struct'
-require 'kind/type_checkers/core/symbol'
-require 'kind/type_checkers/core/time'
-
-require 'kind/type_checkers/stdlib/open_struct'
-require 'kind/type_checkers/stdlib/set'
-
-require 'kind/type_checkers/custom/boolean'
-require 'kind/type_checkers/custom/callable'
-require 'kind/type_checkers/custom/lambda'