kind 5.1.0 → 5.5.0

data/lib/kind/result/abstract.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Kind
+  module Result::Abstract
+    def failure?
+      false
+    end
+
+    def failed?
+      failure?
+    end
+
+    def success?
+      false
+    end
+
+    def succeeded?
+      success?
+    end
+
+    def on(&block)
+      raise NotImplementedError
+    end
+
+    def on_success(types = Undefined, matcher = Undefined)
+      raise NotImplementedError
+    end
+
+    def on_failure(types = Undefined, matcher = Undefined)
+      raise NotImplementedError
+    end
+
+    def result?(types, matcher)
+      undef_t = Undefined == (t = types)
+      undef_m = Undefined == (m = matcher)
+
+      return true if undef_t && undef_m
+
+      if !undef_t && undef_m && !(Array === types || Symbol === types)
+        m, t = types, matcher
+
+        undef_m, undef_t = false, true
+      end
+
+      is_type = undef_t || (::Array === t ? t.empty? || t.include?(type) : t == type)
+      is_type && (undef_m || m === value)
+    end
+
+    def to_ary
+      [type, value]
+    end
+  end
+end

data/lib/kind/result/failure.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Kind
+  class Result::Failure < Result::Monad
+    DEFAULT_TYPE = :error
+
+    def failure?
+      true
+    end
+
+    def value_or(default = UNDEFINED, &block)
+      Error.invalid_default_arg! if UNDEFINED == default && !block
+
+      UNDEFINED != default ? default : block.call(value)
+    end
+
+    def map(_ = UNDEFINED, &_fn)
+      self
+    end
+
+    alias_method :|, :map
+    alias_method :>>, :map
+    alias_method :map!, :map
+    alias_method :then, :map
+    alias_method :then!, :map
+    alias_method :and_then, :map
+    alias_method :and_then!, :map
+
+    def inspect
+      '#<%s type=%p value=%p>' % ['Kind::Failure', type, value]
+    end
+  end
+end

data/lib/kind/result/methods.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Kind
+  module Result::Methods
+    def Failure(arg1 = UNDEFINED, arg2 = UNDEFINED)
+      Result::Failure[arg1, arg2]
+    end
+
+    def Success(arg1 = UNDEFINED, arg2 = UNDEFINED)
+      Result::Success[arg1, arg2]
+    end
+
+    def self.included(base)
+      base.send(:private, :Success, :Failure)
+    end
+  end
+end

data/lib/kind/result/monad.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Kind
+  class Result::Monad
+    include Result::Abstract
+
+    require 'kind/empty'
+    require 'kind/result/monad/wrapper'
+
+    attr_reader :type, :value
+
+    def self.[](arg1 = UNDEFINED, arg2 = UNDEFINED, opt = Empty::HASH) # :nodoc:
+      value_must_be_a = opt[:value_must_be_a]
+
+      type = UNDEFINED == arg2 ? self::DEFAULT_TYPE : STRICT.kind_of(::Symbol, arg1)
+
+      Error.wrong_number_of_args!(given: 0, expected: '1 or 2') if UNDEFINED == arg1
+
+      value = UNDEFINED == arg2 ? arg1 : arg2
+
+      new(type, (value_must_be_a ? STRICT.kind_of(value_must_be_a, value) : value))
+    end
+
+    private_class_method :new
+
+    def initialize(type, value)
+      @type = type
+      @value = value
+    end
+
+    def value_or(_method_name = UNDEFINED, &block)
+      raise NotImplementedError
+    end
+
+    def map(_ = UNDEFINED, &_fn)
+      raise NotImplementedError
+    end
+
+    alias_method :|, :map
+    alias_method :>>, :map
+    alias_method :map!, :map
+    alias_method :then, :map
+    alias_method :then!, :map
+    alias_method :and_then, :map
+    alias_method :and_then!, :map
+
+    def on
+      monad = Wrapper.new(self)
+
+      yield(monad)
+
+      monad.output
+    end
+
+    def on_success(types = Undefined, matcher = Undefined)
+      yield(value) if success? && result?(types, matcher)
+
+      self
+    end
+
+    def on_failure(types = Undefined, matcher = Undefined)
+      yield(value) if failure? && result?(types, matcher)
+
+      self
+    end
+
+    def ===(m)
+      return false unless Result::Abstract === m
+      return false unless (self.success? && m.success?) || (self.failure? && m.failure?)
+
+      self.type == m.type && self.value === m.value
+    end
+  end
+end

data/lib/kind/result/monad/wrapper.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Kind
+  require 'kind/monad'
+
+  class Result::Monad::Wrapper < Kind::Monad::Wrapper
+    def failure(types = Undefined, matcher = Undefined)
+      return if @monad.success? || output?
+
+      @output = yield(@monad.value) if @monad.result?(types, matcher)
+    end
+
+    def success(types = Undefined, matcher = Undefined)
+      return if @monad.failure? || output?
+
+      @output = yield(@monad.value) if @monad.result?(types, matcher)
+    end
+  end
+end

data/lib/kind/result/success.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Kind
+  class Result::Success < Result::Monad
+    DEFAULT_TYPE = :ok
+
+    def success?
+      true
+    end
+
+    def value_or(_default = UNDEFINED, &block)
+      @value
+    end
+
+    def map(callable = UNDEFINED, &fn)
+      _resolve_map(callable, fn)
+    rescue Kind::Monad::Error => e
+      raise e
+    rescue StandardError => e
+      Result::Failure[:exception, e]
+    end
+
+    alias_method :then, :map
+    alias_method :and_then, :map
+
+    def map!(callable = UNDEFINED, &fn)
+      _resolve_map(callable, fn)
+    end
+
+    alias_method :|, :map!
+    alias_method :>>, :map!
+    alias_method :then!, :map!
+    alias_method :and_then!, :map!
+
+    def inspect
+      '#<%s type=%p value=%p>' % ['Kind::Success', type, value]
+    end
+
+    private
+
+      def _resolve_map(callable, fn)
+        callable.respond_to?(:call) ? _map(callable) : _map(fn)
+      end
+
+      def _map(fn)
+        monad = fn.call(@value)
+
+        return monad if Result::Monad === monad
+
+        raise Kind::Monad::Error.new('Kind::Success | Kind::Failure', monad)
+      end
+  end
+end

data/lib/kind/strict/disabled.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Kind
+  module STRICT
+    [
+      :object_is_a, :class!, :kind_of,
+      :module_or_class, :module!, :not_nil
+    ].each { |method_name| remove_method(method_name) }
+
+    def object_is_a(_kind, value, _label = nil) # :nodoc:
+      value
+    end
+
+    def class!(value) # :nodoc:
+      value
+    end
+
+    def kind_of(_kind, value, _kind_name = nil) # :nodoc:
+      value
+    end
+
+    def module_or_class(value) # :nodoc:
+      value
+    end
+
+    def module!(value) # :nodoc:
+      value
+    end
+
+    def not_nil(value, label) # :nodoc:
+      value
+    end
+  end
+end

data/lib/kind/try.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'kind/basic'
+require 'kind/empty'
+require 'kind/presence'
+
+module Kind
+  module Try
+    extend self
+
+    def call!(object, method_name, args = Empty::ARRAY) # :nodoc
+      return if KIND.nil_or_undefined?(object)
+
+      resolve(object, method_name, args)
+    end
+
+    def call(object, *input)
+      args = input.size == 1 && input[0].kind_of?(::Array) ? input[0] : input
+
+      result = call!(object, args.shift, args)
+
+      return result unless block_given?
+
+      yield(result) unless KIND.nil_or_undefined?(result)
+    end
+
+    def presence(*args, &block)
+      Presence.(call(*args, &block))
+    end
+
+    def self.[](*args)
+      method_name = args.shift
+
+      ->(object) { call!(object, method_name, args) }
+    end
+
+    private
+
+      def resolve(object, method_name, args)
+        return unless object.respond_to?(method_name)
+        return object.public_send(method_name) if args.empty?
+
+        object.public_send(method_name, *args)
+      end
+  end
+end

data/lib/kind/validator.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'kind'
+require 'kind/basic'
 
 module Kind
   module Validator
@@ -77,11 +77,15 @@ class KindValidator < ActiveModel::EachValidator
     end
 
     def kind_of(expected, value)
-      types = Array(expected)
+      if ::Array === expected
+        return if expected.any? { |type| type === value }
 
-      return if types.any? { |type| type === value }
+        "must be a kind of #{expected.map { |type| type.name }.join(', ')}"
+      else
+        return if expected === value
 
-      "must be a kind of: #{types.map { |type| type.name }.join(', ')}"
+        expected.respond_to?(:name) ? "must be a kind of #{expected.name}" : 'invalid kind'
+      end
     end
 
     CLASS_OR_MODULE = 'Class/Module'.freeze
@@ -97,11 +101,11 @@ class KindValidator < ActiveModel::EachValidator
     def kind_is_not(expected, value)
       case expected
       when ::Class
-        return if expected == Kind::Class[value] || value < expected
+        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 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"
@@ -128,13 +132,13 @@ class KindValidator < ActiveModel::EachValidator
 
       return if types.any? { |type| value.instance_of?(type) }
 
-      "must be an instance of: #{types.map { |klass| klass.name }.join(', ')}"
+      "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?
+      return if value.kind_of?(::Array) && !value.empty? && (value - Kind.of!(::Array, expected)).empty?
 
-      "must be an array with: #{expected.join(', ')}"
+      "must be an array with #{expected.join(', ')}"
     end
 
     def array_of(expected, value)
@@ -142,6 +146,6 @@ class KindValidator < ActiveModel::EachValidator
 
       return if value.kind_of?(::Array) && !value.empty? && value.all? { |val| types.any? { |type| type === val } }
 
-      "must be an array of: #{types.map { |klass| klass.name }.join(', ')}"
+      "must be an array of #{types.map { |klass| klass.name }.join(', ')}"
     end
 end

data/lib/kind/version.rb

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

metadata

@@ -1,16 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: kind
 version: !ruby/object:Gem::Version
-  version: 5.1.0
+  version: 5.5.0
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-02-24 00:00:00.000000000 Z
+date: 2021-04-06 00:00:00.000000000 Z
 dependencies: []
-description: A simple type system (at runtime) for Ruby - free of dependencies.
+description: A development toolkit for Ruby with several small/cohesive abstractions
+  (monads, enums, business logic, data validation...) to empower your development
+  workflow - It's totally free of dependencies.
 email:
 - rodrigo.serradura@gmail.com
 executables: []
@@ -31,51 +33,90 @@ files:
 - bin/setup
 - kind.gemspec
 - lib/kind.rb
+- lib/kind/__lib__/action_steps.rb
+- lib/kind/__lib__/attributes.rb
+- lib/kind/__lib__/kind.rb
+- lib/kind/__lib__/of.rb
+- lib/kind/__lib__/strict.rb
+- lib/kind/__lib__/undefined.rb
+- lib/kind/action.rb
 - lib/kind/active_model/validation.rb
-- lib/kind/core.rb
-- lib/kind/core/dig.rb
-- lib/kind/core/empty.rb
-- lib/kind/core/empty/constant.rb
-- lib/kind/core/error.rb
-- lib/kind/core/maybe.rb
-- lib/kind/core/maybe/none.rb
-- lib/kind/core/maybe/result.rb
-- lib/kind/core/maybe/some.rb
-- lib/kind/core/maybe/typed.rb
-- lib/kind/core/maybe/wrappable.rb
-- lib/kind/core/presence.rb
-- lib/kind/core/try.rb
-- lib/kind/core/type_checker.rb
-- lib/kind/core/type_checkers.rb
-- lib/kind/core/type_checkers/custom/boolean.rb
-- lib/kind/core/type_checkers/custom/callable.rb
-- lib/kind/core/type_checkers/custom/lambda.rb
-- lib/kind/core/type_checkers/ruby/array.rb
-- lib/kind/core/type_checkers/ruby/class.rb
-- lib/kind/core/type_checkers/ruby/comparable.rb
-- lib/kind/core/type_checkers/ruby/enumerable.rb
-- lib/kind/core/type_checkers/ruby/enumerator.rb
-- lib/kind/core/type_checkers/ruby/file.rb
-- lib/kind/core/type_checkers/ruby/float.rb
-- lib/kind/core/type_checkers/ruby/hash.rb
-- lib/kind/core/type_checkers/ruby/integer.rb
-- lib/kind/core/type_checkers/ruby/io.rb
-- lib/kind/core/type_checkers/ruby/method.rb
-- lib/kind/core/type_checkers/ruby/module.rb
-- lib/kind/core/type_checkers/ruby/numeric.rb
-- lib/kind/core/type_checkers/ruby/proc.rb
-- lib/kind/core/type_checkers/ruby/queue.rb
-- lib/kind/core/type_checkers/ruby/range.rb
-- lib/kind/core/type_checkers/ruby/regexp.rb
-- lib/kind/core/type_checkers/ruby/string.rb
-- lib/kind/core/type_checkers/ruby/struct.rb
-- lib/kind/core/type_checkers/ruby/symbol.rb
-- lib/kind/core/type_checkers/ruby/time.rb
-- lib/kind/core/type_checkers/stdlib/open_struct.rb
-- lib/kind/core/type_checkers/stdlib/set.rb
-- lib/kind/core/undefined.rb
-- lib/kind/core/utils/kind.rb
-- lib/kind/core/utils/undefined.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/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/functional/steps.rb
+- lib/kind/immutable_attributes.rb
+- lib/kind/immutable_attributes/initializer.rb
+- lib/kind/immutable_attributes/reader.rb
+- lib/kind/maybe.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/strict/disabled.rb
+- lib/kind/try.rb
 - lib/kind/validator.rb
 - lib/kind/version.rb
 - test.sh
@@ -100,8 +141,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.2.11
 signing_key: 
 specification_version: 4
-summary: A simple type system (at runtime) for Ruby.
+summary: A development toolkit for Ruby with several small/cohesive abstractions to
+  empower your development workflow.
 test_files: []