kind 3.1.0 → 5.2.0

data/lib/kind/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kind
-  VERSION = '3.1.0'
+  VERSION = '5.2.0'
 end

data/test.sh

@@ -1,11 +1,11 @@
 #!/bin/bash
 
-bundle
-
-rm Gemfile.lock
-
 source $(dirname $0)/.travis.sh
 
+echo ''
+echo 'Resetting Gemfile'
+echo ''
+
 rm Gemfile.lock
 
 bundle

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kind
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 5.2.0
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-07-08 00:00:00.000000000 Z
+date: 2021-03-18 00:00:00.000000000 Z
 dependencies: []
 description: A simple type system (at runtime) for Ruby - free of dependencies.
 email:
@@ -18,8 +18,10 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".tool-versions"
 - ".travis.sh"
 - ".travis.yml"
+- CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
 - LICENSE.txt
@@ -29,19 +31,85 @@ files:
 - bin/setup
 - kind.gemspec
 - lib/kind.rb
-- lib/kind/active_model/kind_validator.rb
+- lib/kind/__lib__/attributes.rb
+- lib/kind/__lib__/kind.rb
+- lib/kind/__lib__/undefined.rb
+- lib/kind/action.rb
 - lib/kind/active_model/validation.rb
-- lib/kind/checker.rb
-- lib/kind/checker/factory.rb
-- lib/kind/checker/protocol.rb
+- lib/kind/basic.rb
+- lib/kind/basic/error.rb
+- lib/kind/basic/undefined.rb
 - lib/kind/dig.rb
+- lib/kind/either.rb
+- lib/kind/either/left.rb
+- lib/kind/either/methods.rb
+- lib/kind/either/monad.rb
+- lib/kind/either/monad/wrapper.rb
+- lib/kind/either/right.rb
 - lib/kind/empty.rb
-- lib/kind/error.rb
-- lib/kind/is.rb
+- lib/kind/empty/constant.rb
+- lib/kind/enum.rb
+- lib/kind/enum/item.rb
+- lib/kind/enum/methods.rb
+- lib/kind/function.rb
+- lib/kind/functional.rb
+- lib/kind/functional/action.rb
+- lib/kind/immutable_attributes.rb
+- lib/kind/immutable_attributes/initializer.rb
+- lib/kind/immutable_attributes/reader.rb
 - lib/kind/maybe.rb
-- lib/kind/of.rb
-- lib/kind/types.rb
-- lib/kind/undefined.rb
+- lib/kind/maybe/methods.rb
+- lib/kind/maybe/monad.rb
+- lib/kind/maybe/monad/wrapper.rb
+- lib/kind/maybe/none.rb
+- lib/kind/maybe/some.rb
+- lib/kind/maybe/typed.rb
+- lib/kind/maybe/wrapper.rb
+- lib/kind/monad.rb
+- lib/kind/monads.rb
+- lib/kind/objects.rb
+- lib/kind/objects/basic_object.rb
+- lib/kind/objects/modules.rb
+- lib/kind/objects/modules/core/array.rb
+- lib/kind/objects/modules/core/class.rb
+- lib/kind/objects/modules/core/comparable.rb
+- lib/kind/objects/modules/core/enumerable.rb
+- lib/kind/objects/modules/core/enumerator.rb
+- lib/kind/objects/modules/core/file.rb
+- lib/kind/objects/modules/core/float.rb
+- lib/kind/objects/modules/core/hash.rb
+- lib/kind/objects/modules/core/integer.rb
+- lib/kind/objects/modules/core/io.rb
+- lib/kind/objects/modules/core/method.rb
+- lib/kind/objects/modules/core/module.rb
+- lib/kind/objects/modules/core/numeric.rb
+- lib/kind/objects/modules/core/proc.rb
+- lib/kind/objects/modules/core/queue.rb
+- lib/kind/objects/modules/core/range.rb
+- lib/kind/objects/modules/core/regexp.rb
+- lib/kind/objects/modules/core/string.rb
+- lib/kind/objects/modules/core/struct.rb
+- lib/kind/objects/modules/core/symbol.rb
+- lib/kind/objects/modules/core/time.rb
+- lib/kind/objects/modules/custom/boolean.rb
+- lib/kind/objects/modules/custom/callable.rb
+- lib/kind/objects/modules/custom/lambda.rb
+- lib/kind/objects/modules/stdlib/open_struct.rb
+- lib/kind/objects/modules/stdlib/set.rb
+- lib/kind/objects/nil.rb
+- lib/kind/objects/not_nil.rb
+- lib/kind/objects/object.rb
+- lib/kind/objects/respond_to.rb
+- lib/kind/objects/union_type.rb
+- lib/kind/presence.rb
+- lib/kind/result.rb
+- lib/kind/result/abstract.rb
+- lib/kind/result/failure.rb
+- lib/kind/result/methods.rb
+- lib/kind/result/monad.rb
+- lib/kind/result/monad/wrapper.rb
+- lib/kind/result/success.rb
+- lib/kind/try.rb
 - lib/kind/validator.rb
 - lib/kind/version.rb
 - test.sh
@@ -59,14 +127,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.2.0
+      version: 2.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.2.11
 signing_key: 
 specification_version: 4
 summary: A simple type system (at runtime) for Ruby.

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.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/checker.rb

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

data/lib/kind/checker/factory.rb

@@ -1,35 +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
-
-      MODULE_OR_CLASS = 'Module/Class'.freeze
-
-      private_constant :MODULE_OR_CLASS
-
-      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, kind, MODULE_OR_CLASS))
-          end
-        end
-      end
-    end
-  end
-end

data/lib/kind/checker/protocol.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-module Kind
-  class Checker
-    module Protocol
-      def class?(value)
-        Kind::Is.__call__(__kind, value)
-      end
-
-      def instance(value, options = Empty::HASH)
-        default = options[:or]
-
-        return Kind::Of.(__kind, value) if ::Kind::Maybe::Value.none?(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/error.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Kind
-  class Error < TypeError
-    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

data/lib/kind/is.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Kind
-  module Is
-    def self.call(expected, object)
-      __call__(Kind::Of.Module(expected), object)
-    end
-
-    def self.__call__(expected_kind, object)
-      kind = Kind::Of.Module(object)
-
-      if kind.is_a?(Class)
-        kind <= expected_kind || false
-      else
-        kind == expected_kind || kind.is_a?(expected_kind)
-      end
-    end
-  end
-end

data/lib/kind/of.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Kind
-  module Of
-    def self.call(kind, object, kind_name = nil)
-      return object if kind === object
-
-      raise Kind::Error.new(kind_name || kind.name, object)
-    end
-  end
-end

data/lib/kind/types.rb

@@ -1,115 +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)
-        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)
-        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
-
-        Kind::Is.__call__(::%{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
-
-      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