kind 4.0.0 → 5.3.0

data/kind.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   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')
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.1.0')
 
   spec.metadata['homepage_uri'] = spec.homepage
   spec.metadata['source_code_uri'] = 'https://github.com/serradura/kind'

data/lib/kind.rb

@@ -1,86 +1,4 @@
 # frozen_string_literal: true
 
-require 'set'
-require 'ostruct'
-
-require 'kind/version'
-require 'kind/core'
-
-require 'kind/error'
-require 'kind/empty'
-require 'kind/dig'
-require 'kind/try'
-require 'kind/presence'
-require 'kind/undefined'
-require 'kind/type_checker'
-
-require 'kind/type_checkers'
-require 'kind/maybe'
-
-require 'kind/deprecations/checker'
-require 'kind/deprecations/of'
-require 'kind/deprecations/is'
-require 'kind/deprecations/types'
-require 'kind/deprecations/built_in_type_checkers'
-
-module Kind
-  def self.is?(kind, arg)
-    KIND.is?(kind, arg)
-  end
-
-  def self.of?(kind, *args)
-    KIND.of?(kind, args)
-  end
-
-  def self.of_class?(value)
-    KIND.of_class?(value)
-  end
-
-  def self.of_module?(value)
-    KIND.of_module?(value)
-  end
-
-  def self.respond_to(value, *method_names)
-    method_names.each { |method_name| KIND.respond_to!(method_name, value) }
-
-    value
-  end
-
-  def self.of_module_or_class(value)
-    KIND.of_module_or_class!(value)
-  end
-
-  def self.is(expected = UNDEFINED, object = UNDEFINED)
-    if UNDEFINED == expected && UNDEFINED == object
-      DEPRECATION.warn('`Kind.is` without args is deprecated. This behavior will be removed in %{version}')
-
-      return Is
-    end
-
-    return is?(expected, object) if UNDEFINED != object
-
-    raise ArgumentError, 'wrong number of arguments (given 1, expected 2)'
-  end
-
-  def self.of(kind = UNDEFINED, object = UNDEFINED)
-    if UNDEFINED == kind && UNDEFINED == object
-      DEPRECATION.warn('`Kind.of` without args is deprecated. This behavior will be removed in %{version}')
-
-      Of
-    elsif UNDEFINED != object
-      KIND.of!(kind, object)
-    else
-      DEPRECATION.warn_method_replacement('Kind.of(<Kind>)', 'Kind::Of(<Kind>)')
-
-      Checker::Factory.create(kind)
-    end
-  end
-
-  def self.value(kind, value, default:)
-    KIND.value(kind, value, of(kind, default))
-  end
-
-  def self.Of(kind, opt = Empty::HASH)
-    TypeChecker::Object.new(kind, opt)
-  end
-end
+require 'kind/basic'
+require 'kind/objects'

data/lib/kind/__lib__/action_steps.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Kind
+  module ACTION_STEPS
+    private
+
+      def Check(mthod); ->(value) { __Check(thod, value) }; end
+      def Step(mthod); ->(value) { __Step(mthod, value) }; end
+      def Map(mthod); ->(value) { __Map(mthod, value) }; end
+      def Tee(mthod); ->(value) { __Tee(mthod, value) }; end
+      def Try(mthod, opt = Empty::HASH)
+        ->(value) { __Try(mthod, value, opt) }
+      end
+
+      def Check!(mthod, value); __Check(mthod, value); end
+      def Step!(mthod, value); __Step(mthod, value); end
+      def Map!(mthod, value); __Map(mthod, value); end
+      def Tee!(mthod, value); __Tee(mthod, value); end
+      def Try!(mthod, value, opt = Empty::HASH); __Try(mthod, value, opt); end
+
+      def __Check(mthod, value) # :nodoc:
+        __resolve_step(mthod, value) ? Success(mthod, value) : Failure(mthod, value)
+      end
+
+      def __Step(mthod, value) # :nodoc:
+        __resolve_step(mthod, value)
+      end
+
+      def __Map(mthod, value) # :nodoc:
+        Success(mthod, __resolve_step(mthod, value))
+      end
+
+      def __Tee(mthod, value) # :nodoc:
+        __resolve_step(mthod, value)
+
+        Success(mthod, value)
+      end
+
+      def __Try(mthod, value, opt = Empty::HASH) # :nodoc:
+        begin
+          Success(mthod, __resolve_step(mthod, value))
+        rescue opt.fetch(:catch, StandardError) => e
+          Failure(mthod, __map_step_exception(e))
+        end
+      end
+
+      def __resolve_step(mthod, value) # :nodoc:
+        send(mthod, value)
+      end
+
+      def __map_step_exception(value) # :nodoc:
+        value
+      end
+  end
+
+  private_constant :ACTION_STEPS
+end

data/lib/kind/__lib__/attributes.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'kind/__lib__/kind'
+require 'kind/__lib__/undefined'
+
+module Kind
+  module ATTRIBUTES
+    extend self
+
+    def name!(name)
+      STRICT.kind_of(::Symbol, name)
+    end
+
+    def value(kind, default, visibility = :private)
+      [kind, default, visibility]
+    end
+
+    def value_to_assign(kind, default, hash, name)
+      raw_value = hash[name]
+
+      return raw_value if kind.nil? && UNDEFINED == default
+
+      value = resolve_value_to_assign(kind, default, raw_value)
+
+      (kind.nil? || kind === value) ? value : nil
+    end
+
+    def value!(kind, default)
+      return value(kind, default) unless kind.nil?
+
+      raise Error.new("kind expected to not be nil")
+    end
+
+    def value_to_assign!(kind, default, hash, name)
+      value = resolve_value_to_assign(kind, default, hash[name])
+
+      Kind.of(kind, value, label: name)
+    end
+
+    private
+
+      def resolve_value_to_assign(kind, default, value)
+        if kind == ::Proc
+          UNDEFINED == default ? value : KIND.value(kind, value, default)
+        else
+          default_is_a_callable = default.respond_to?(:call)
+
+          default_value =
+            if default_is_a_callable
+              default_fn = Proc === default ? default : default.method(:call)
+
+              default_fn.arity != 0 ? default_fn.call(value) : default_fn.call
+            else
+              default
+            end
+
+          return value if UNDEFINED == default_value
+          return default_value || value if kind.nil?
+
+          default_is_a_callable ? KIND.value(kind, default_value, value) : KIND.value(kind, value, default_value)
+        end
+      end
+  end
+
+  private_constant :ATTRIBUTES
+end

data/lib/kind/__lib__/kind.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'kind/__lib__/strict'
+
+module Kind
+  module KIND
+    extend self
+
+    def nil_or_undefined?(value) # :nodoc:
+      value.nil? || Undefined == value
+    end
+
+    def of?(kind, values) # :nodoc:
+      of_kind = -> value { kind === value }
+
+      values.empty? ? of_kind : values.all?(&of_kind)
+    end
+
+    def 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 interface?(method_names, value) # :nodoc:
+      method_names.all? { |method_name| value.respond_to?(method_name) }
+    end
+
+    def value(kind, arg, default) # :nodoc:
+      kind === arg ? arg : default
+    end
+
+    def is?(expected, value) # :nodoc:
+      is(STRICT.module_or_class(expected), value)
+    end
+
+    private
+
+      def is(expected_kind, value) # :nodoc:
+        kind = STRICT.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
+  end
+
+  private_constant :KIND
+end

data/lib/kind/__lib__/of.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Kind
+  module OF
+    extend self
+
+    def class?(value) # :nodoc:
+      value.kind_of?(::Class)
+    end
+
+    def module?(value) # :nodoc:
+      ::Module == value || (value.kind_of?(::Module) && !class?(value))
+    end
+  end
+
+  private_constant :OF
+end

data/lib/kind/__lib__/strict.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'kind/__lib__/of'
+
+module Kind
+  module STRICT
+    extend self
+
+    def error(kind_name, value, label = nil) # :nodoc:
+      raise Error.new(kind_name, value, label: label)
+    end
+
+    def object_is_a(kind, value, label = nil) # :nodoc:
+      return value if kind === value
+
+      error(kind.name, value, label)
+    end
+
+    def kind_of(kind, value, kind_name = nil) # :nodoc:
+      return value if kind === value
+
+      error(kind_name || kind.name, value)
+    end
+
+    def module_or_class(value) # :nodoc:
+      kind_of(::Module, value, 'Module/Class')
+    end
+
+    def class!(value) # :nodoc:
+      kind_of(::Class, value)
+    end
+
+    def module!(value) # :nodoc:
+      return value if OF.module?(value)
+
+      error('Module', value)
+    end
+
+    def not_nil(value, label) # :nodoc:
+      return value unless value.nil?
+
+      label_text = label ? "#{label}: " : ''
+
+      raise Error.new("#{label_text}expected to not be nil")
+    end
+  end
+
+  private_constant :STRICT
+end

data/lib/kind/__lib__/undefined.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Kind
+  UNDEFINED = Object.new.tap do |undefined|
+    def undefined.inspect
+      @inspect ||= 'UNDEFINED'.freeze
+    end
+
+    undefined.inspect
+    undefined.freeze
+  end
+
+  private_constant :UNDEFINED
+end

data/lib/kind/action.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require 'kind/basic'
+require 'kind/empty'
+require 'kind/result'
+require 'kind/immutable_attributes'
+require 'kind/__lib__/action_steps'
+
+module Kind
+  module Action
+    CALL_TMPL = [
+      'def self.call(arg)',
+      '  new(Kind.of!(::Hash, arg)).call',
+      'end',
+      '',
+      'def call',
+      '  result = call!',
+      '',
+      '  return result if Kind::Result::Monad === result',
+      '',
+      '  raise Kind::Error, "#{self.class.name}#call! must return a Success() or Failure()"',
+      'end'
+    ].join("\n").freeze
+
+    private_constant :CALL_TMPL
+
+    module ClassMethods
+      include ImmutableAttributes::ClassMethods
+
+      def to_proc
+        @to_proc ||= ->(arg) { call(arg) }
+      end
+
+      ATTRIBUTE_METHODS = [
+        :attributes, :attribute,
+        :attribute?, :attribute!,
+        :with_attribute, :with_attributes,
+        :nil_attributes, :nil_attributes?
+      ]
+
+      private_constant :ATTRIBUTE_METHODS
+
+      def kind_action!
+        return self if respond_to?(:call)
+
+        public_methods = self.public_instance_methods - ::Object.new.methods
+
+        remaining_methods = public_methods - (__attributes__.keys + ATTRIBUTE_METHODS)
+
+        unless remaining_methods.include?(:call!)
+          raise Kind::Error.new("expected #{self} to implement `#call!`")
+        end
+
+        if remaining_methods.size > 1
+          raise Kind::Error.new("#{self} can only have `#call!` as its public method")
+        end
+
+        call_parameters = public_instance_method(:call!).parameters
+
+        unless call_parameters.empty?
+          raise ArgumentError, "#{self.name}#call! must receive no arguments"
+        end
+
+        def self.inherited(_)
+          raise RuntimeError, "#{self.name} is a Kind::Action and it can't be inherited"
+        end
+
+        self.send(:private_class_method, :new)
+
+        self.class_eval(CALL_TMPL)
+
+        self.send(:alias_method, :[], :call)
+        self.send(:alias_method, :===, :call)
+        self.send(:alias_method, :yield, :call)
+      end
+    end
+
+    module StepAdapters
+      private
+
+        def Check!(mthod); __Check(mthod, Empty::HASH); end
+        def Step!(mthod); __Step(mthod, Empty::HASH); end
+        def Map!(mthod); __Map(mthod, Empty::HASH); end
+        def Tee!(_mthod); raise NotImplementedError; end
+        def Try!(mthod, opt = Empty::HASH); __Try(mthod, Empty::HASH, opt); end
+
+        def __resolve_step(method_name, value)
+          m = method(method_name)
+          m.arity > 0 ? m.call(value) : m.call
+        end
+
+        def __map_step_exception(value)
+          { exception: value }
+        end
+    end
+
+    private_constant :StepAdapters
+
+    def self.included(base)
+      Kind.of_class(base).extend(ClassMethods)
+
+      base.send(:include, ACTION_STEPS)
+      base.send(:include, StepAdapters)
+      base.send(:include, ImmutableAttributes::Reader)
+    end
+
+    include ImmutableAttributes::Initializer
+
+    def inspect
+      '#<%s attributes=%p nil_attributes=%p>' % [self.class.name, attributes, nil_attributes]
+    end
+
+    private
+
+      def Failure(arg1 = UNDEFINED, arg2 = UNDEFINED)
+        arg1 = Empty::HASH if UNDEFINED == arg1 && UNDEFINED == arg2
+
+        Result::Failure[arg1, arg2, value_must_be_a: ::Hash]
+      end
+
+      def Success(arg1 = UNDEFINED, arg2 = UNDEFINED)
+        arg1 = Empty::HASH if UNDEFINED == arg1 && UNDEFINED == arg2
+
+        Result::Success[arg1, arg2, value_must_be_a: ::Hash]
+      end
+  end
+end