kind 5.0.0 → 5.4.1

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

data/lib/kind/active_model/validation.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
-require 'kind'
+warn '[DEPRECATION] "kind/active_model/validation" is deprecated; use "kind/validator" instead. ' \
+    'It will be removed on next major release.'
+
 require 'kind/validator'
-require 'active_model'
-require 'active_model/validations'
-require_relative 'kind_validator'

data/lib/kind/basic.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'kind/version'
+
+require 'kind/__lib__/kind'
+require 'kind/__lib__/undefined'
+
+require 'kind/basic/undefined'
+require 'kind/basic/error'
+
+module Kind
+  extend self
+
+  def is?(kind, arg)
+    KIND.is?(kind, arg)
+  end
+
+  def is(*args)
+    warn '[DEPRECATION] Kind.is will behave like Kind.is! in the next major release; ' \
+        'use Kind.is? instead.'
+
+    is?(*args)
+  end
+
+  def is!(kind, arg, label: nil)
+    return arg if KIND.is?(kind, arg)
+
+    label_text = label ? "#{label}: " : ''
+
+    raise Kind::Error.new("#{label_text}#{arg} expected to be a #{kind}")
+  end
+
+  def of?(kind, *args)
+    KIND.of?(kind, args)
+  end
+
+  def of_class?(value)
+    OF.class?(value)
+  end
+
+  def of_module?(value)
+    OF.module?(value)
+  end
+
+  def respond_to?(value, *method_names)
+    return super(value) if method_names.empty?
+
+    KIND.interface?(method_names, value)
+  end
+
+  def of(kind, value, label: nil)
+    STRICT.object_is_a(kind, value, label)
+  end
+
+  alias_method :of!, :of
+
+  def of_class(value)
+    STRICT.class!(value)
+  end
+
+  def of_module(value)
+    STRICT.module!(value)
+  end
+
+  def of_module_or_class(value)
+    STRICT.module_or_class(value)
+  end
+
+  def respond_to(value, *method_names)
+    method_names.each { |method_name| KIND.respond_to!(method_name, value) }
+
+    value
+  end
+  alias_method :respond_to!, :respond_to
+
+  def value(kind, value, default:)
+    KIND.value(kind, value, of(kind, default))
+  end
+end

data/lib/kind/basic/error.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Kind
+  class Error < StandardError
+    INVALID_DEFAULT_ARG = 'the default value must be defined as an argument or block'.freeze
+
+    def self.wrong_number_of_args!(given:, expected:)
+      raise ArgumentError, "wrong number of arguments (given #{given}, expected #{expected})"
+    end
+
+    def self.invalid_default_arg!
+      raise ArgumentError, INVALID_DEFAULT_ARG
+    end
+
+    def initialize(arg, object = UNDEFINED, label: nil)
+      if UNDEFINED == object
+        # Will be used when the exception was raised with a message. e.g:
+        # raise Kind::Error, "some message"
+        super(arg)
+      else
+        label_text = label ? "#{label}: " : ''
+
+        super("#{label_text}#{object.inspect} expected to be a kind of #{arg}")
+      end
+    end
+
+    private_constant :INVALID_DEFAULT_ARG
+  end
+end

data/lib/kind/{undefined.rb → basic/undefined.rb}

@@ -1,9 +1,15 @@
 # frozen_string_literal: true
+
 module Kind
   Undefined = Object.new.tap do |undefined|
     def undefined.inspect
       @inspect ||= 'Kind::Undefined'.freeze
     end
+    undefined.inspect
+
+    def undefined.empty?
+      true
+    end
 
     def undefined.to_s
       inspect
@@ -23,7 +29,6 @@ module Kind
       default.respond_to?(:call) ? default.call : default
     end
 
-    undefined.inspect
     undefined.freeze
   end
 end

data/lib/kind/dig.rb

@@ -1,23 +1,39 @@
 # frozen_string_literal: true
 
+require 'kind/basic'
+require 'kind/empty'
+require 'kind/presence'
+
 module Kind
   module Dig
     extend self
 
-    def call(data, keys)
-      return unless keys.kind_of?(::Array)
-
+    def call!(data, keys = Empty::ARRAY) # :nodoc
       keys.reduce(data) do |memo, key|
         value = get(memo, key)
 
-        break if KIND.null?(value)
+        break if KIND.nil_or_undefined?(value)
 
         value
       end
     end
 
+    def call(data, *input)
+      args = input.size == 1 && input[0].kind_of?(::Array) ? input[0] : input
+
+      result = call!(data, 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 [](*keys)
-      ->(data) { call(data, keys) }
+      ->(data) { call!(data, keys) }
     end
 
     private