kind 3.1.0 → 5.2.0

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,92 @@
+# frozen_string_literal: true
+
+require 'kind/basic'
+require 'kind/result'
+require 'kind/immutable_attributes'
+
+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
+
+    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
+
+    def self.included(base)
+      KIND.of!(::Class, base).extend(ClassMethods)
+
+      base.send(:include, ImmutableAttributes::Reader)
+    end
+
+    include ImmutableAttributes::Initializer
+
+    private
+
+      def Failure(arg1 = UNDEFINED, arg2 = UNDEFINED)
+        Result::Failure[arg1, arg2, value_must_be_a: ::Hash]
+      end
+
+      def Success(arg1 = UNDEFINED, arg2 = UNDEFINED)
+        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,73 @@
+# 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)
+    KIND.of_class?(value)
+  end
+
+  def of_module?(value)
+    KIND.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)
+    return value if kind === value
+
+    KIND.error!(kind.name, value, label)
+  end
+
+  alias_method :of!, :of
+
+  def of_module_or_class(value)
+    KIND.of_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}

@@ -5,6 +5,11 @@ module Kind
     def undefined.inspect
       @inspect ||= 'Kind::Undefined'.freeze
     end
+    undefined.inspect
+
+    def undefined.empty?
+      true
+    end
 
     def undefined.to_s
       inspect
@@ -19,9 +24,11 @@ module Kind
     end
 
     def undefined.default(value, default)
-      return self if self != value
+      return value if self != value
 
       default.respond_to?(:call) ? default.call : default
     end
+
+    undefined.freeze
   end
 end

data/lib/kind/dig.rb

@@ -1,35 +1,55 @@
 # 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.is_a?(Array)
-
+    def call!(data, keys = Empty::ARRAY) # :nodoc
       keys.reduce(data) do |memo, key|
         value = get(memo, key)
 
-        break if value.nil?
+        break if KIND.null?(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.null?(result)
+    end
+
+    def presence(*args, &block)
+      Presence.(call(*args, &block))
+    end
+
+    def [](*keys)
+      ->(data) { call!(data, keys) }
+    end
+
     private
 
       def get(data, key)
-        return data[key] if Hash === data
+        return data[key] if ::Hash === data
 
         case data
-        when Array
+        when ::Array
           data[key] if key.respond_to?(:to_int)
-        when OpenStruct
+        when ::OpenStruct
           data[key] if key.respond_to?(:to_sym)
-        when Struct
-          if key.respond_to?(:to_int) || key.respond_to?(:to_sym)
-            data[key] rescue nil
-          end
+        when ::Struct
+          data[key] rescue nil if key.respond_to?(:to_int) || key.respond_to?(:to_sym)
+        else
+          data.public_send(key) if key.respond_to?(:to_sym) && data.respond_to?(key)
         end
       end
   end

data/lib/kind/either.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'kind/basic'
+
+module Kind
+  module Either
+    require 'kind/either/monad'
+    require 'kind/either/left'
+    require 'kind/either/right'
+    require 'kind/either/methods'
+
+    extend self
+
+    def new(value)
+      Right[value]
+    end
+
+    alias_method :[], :new
+
+    def self.from
+      result = yield
+
+      Either::Monad === result ? result : Either::Right[result]
+    rescue StandardError => e
+      Either::Left[e]
+    end
+  end
+
+  extend Either::Methods
+end

data/lib/kind/either/left.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Kind
+  class Either::Left < Either::Monad
+    def left?
+      true
+    end
+
+    def value_or(default = UNDEFINED, &block)
+      Error.invalid_default_arg! if UNDEFINED == default && !block
+
+      UNDEFINED != default ? default : block.call
+    end
+
+    def map(&_)
+      self
+    end
+
+    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 value=%p>' % ['Kind::Left', value]
+    end
+  end
+end

data/lib/kind/either/methods.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Kind
+  module Either::Methods
+    def Left(value)
+      Either::Left[value]
+    end
+
+    def Right(value)
+      Either::Right[value]
+    end
+
+    def self.included(base)
+      base.send(:private, :Left, :Right)
+    end
+  end
+end

data/lib/kind/either/monad.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Kind
+  class Either::Monad
+    require 'kind/either/monad/wrapper'
+
+    attr_reader :value
+
+    singleton_class.send(:alias_method, :[], :new)
+
+    def initialize(value)
+      @value = value
+    end
+
+    def left?
+      false
+    end
+
+    def right?
+      false
+    end
+
+    def value_or(_method_name = UNDEFINED, &block)
+      raise NotImplementedError
+    end
+
+    def map(&_)
+      raise NotImplementedError
+    end
+
+    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_right(matcher = UNDEFINED)
+      yield(value) if right? && either?(matcher)
+
+      self
+    end
+
+    def on_left(matcher = UNDEFINED)
+      yield(value) if left? && either?(matcher)
+
+      self
+    end
+
+    def either?(matcher)
+      UNDEFINED == matcher || matcher === value
+    end
+
+    def ===(monad)
+      self.class === monad && self.value === monad.value
+    end
+  end
+end