kind 4.0.0 → 5.3.0

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.is_a?(::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

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

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Kind
+  require 'kind/monad'
+
+  class Either::Monad::Wrapper < Kind::Monad::Wrapper
+    def left(matcher = UNDEFINED)
+      return if @monad.right? || output?
+
+      @output = yield(@monad.value) if @monad.either?(matcher)
+    end
+
+    def right(matcher = UNDEFINED)
+      return if @monad.left? || output?
+
+      @output = yield(@monad.value) if @monad.either?(matcher)
+    end
+  end
+end

data/lib/kind/either/right.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Kind
+  class Either::Right < Either::Monad
+    def right?
+      true
+    end
+
+    def value_or(_default = UNDEFINED, &block)
+      @value
+    end
+
+    def map(&fn)
+      map!(&fn)
+    rescue Kind::Monad::Error => e
+      raise e
+    rescue StandardError => e
+      Either::Left[e]
+    end
+
+    def map!(&fn)
+      monad = fn.call(@value)
+
+      return monad if Either::Monad === monad
+
+      raise Kind::Monad::Error.new('Kind::Right | Kind::Left', monad)
+    end
+
+    alias_method :then, :map
+    alias_method :then!, :map!
+    alias_method :and_then, :map
+    alias_method :and_then!, :map!
+
+    def inspect
+      '#<%s value=%p>' % ['Kind::Right', value]
+    end
+  end
+end

data/lib/kind/empty.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'set'
+
 module Kind
   module Empty
     SET = ::Set.new.freeze
@@ -11,5 +13,3 @@ module Kind
     STR = STRING
   end
 end
-
-Empty = Kind::Empty unless defined?(Empty)

data/lib/kind/empty/constant.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+if defined?(Empty)
+  raise LoadError, "already initialized constant Empty"
+else
+  Empty = Kind::Empty
+end

data/lib/kind/enum.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'set'
+require 'kind/basic'
+
+module Kind
+  module Enum
+    require 'kind/enum/item'
+    require 'kind/enum/methods'
+
+    extend self
+
+    def values(input)
+      enum_module = ::Module.new
+
+      enum_items =
+        case input
+        when ::Hash then create_from_hash(input)
+        when ::Array then create_from_array(input)
+        else raise ArgumentError, 'use an array or hash to define a Kind::Enum'
+        end
+
+      enum_items.each { |item| enum_module.const_set(item.name, item) }
+
+      enum_map = enum_items.each_with_object({}) do |item, memo|
+        memo[item.to_s] = item
+        memo[item.value] = item
+        memo[item.to_sym] = item
+      end
+
+      enum_module.const_set(:ENUM__MAP, enum_map)
+      enum_module.const_set(:ENUM__HASH, enum_items.map(&:to_ary).to_h.freeze)
+      enum_module.const_set(:ENUM__KEYS, ::Set.new(enum_items.map(&:key)).freeze)
+      enum_module.const_set(:ENUM__VALS, ::Set.new(enum_items.map(&:value)).freeze)
+      enum_module.const_set(:ENUM__REFS, ::Set.new(enum_map.keys))
+      enum_module.const_set(:ENUM__ITEMS, enum_items.freeze)
+
+      enum_module.send(:private_constant, :ENUM__MAP, :ENUM__HASH, :ENUM__KEYS,
+                                          :ENUM__VALS, :ENUM__REFS, :ENUM__ITEMS)
+
+      enum_module.module_eval(METHODS)
+
+      enum_module.extend(enum_module)
+      enum_module
+    end
+
+    private
+
+      def create_from_hash(input)
+        input.map { |key, value| build_item(key, value) }
+      end
+
+      def create_from_array(input)
+        input.map.with_index { |key, index| build_item(key, index) }
+      end
+
+      def build_item(key, value)
+        return Item.new(key, value) if key.respond_to?(:to_sym)
+
+        raise ArgumentError, 'use a string or symbol to define a Kind::Enum item'
+      end
+  end
+end