kind 2.2.0 → 4.0.0

data/lib/kind/{types.rb → deprecations/types.rb}

@@ -8,6 +8,8 @@ module Kind
 
     KIND_OF = <<-RUBY
       def self.%{method_name}(object = Undefined, options = Empty::HASH)
+        DEPRECATION.warn_method_replacement('Kind::Of::%{method_name}', 'Kind::%{method_name}')
+
         default = options[:or]
 
         return Kind::Of::%{kind_name} if Undefined == object && default.nil?
@@ -16,29 +18,33 @@ module Kind
 
         return object if is_instance
 
-        Kind::Of.(::%{kind_name_to_check}, object && default ? default : object || default)
+        KIND.of!(::%{kind_name_to_check}, object && default ? default : object || default)
       end
     RUBY
 
     KIND_OF_IS = <<-RUBY
       def self.%{method_name}?(*args)
+        DEPRECATION.warn_method_replacement('Kind::Of::%{method_name}?', 'Kind::%{method_name}?')
+
         Kind::Of::%{kind_name}.instance?(*args)
       end
     RUBY
 
     KIND_IS = <<-RUBY
-      def self.%{method_name}(value = Undefined)
-        return Kind::Is::%{kind_name} if Undefined == value
+      def self.%{method_name}(value)
+        DEPRECATION.warn_removal('Kind::Is::%{method_name}')
 
-        Kind::Is.__call__(::%{kind_name_to_check}, value)
+        KIND.is!(::%{kind_name_to_check}, value)
       end
     RUBY
 
     private_constant :KIND_OF, :KIND_IS, :COLONS
 
     def add(kind, name: nil)
-      kind_name = Kind.of.Module(kind).name
-      checker = name ? Kind::Of.(String, name) : kind_name
+      DEPRECATION.warn_removal('Kind::Types')
+
+      kind_name = KIND.of_module_or_class!(kind).name
+      checker = name ? Kind::String[name] : kind_name
 
       if checker.include?(COLONS)
         add_kind_with_namespace(checker, method_name: name)
@@ -98,8 +104,8 @@ module Kind
           kind_name = params[:kind_name]
           params[:kind_name_to_check] ||= kind_name
 
-          kind_checker = ::Module.new { extend Checkable }
-          kind_checker.module_eval("def self.__kind; #{params[:kind_name_to_check]}; end")
+          kind_checker = ::Module.new { extend Checker::Protocol }
+          kind_checker.module_eval("def self.__kind; ::#{params[:kind_name_to_check]}; end")
 
           kind_of_mod.instance_eval(KIND_OF % params)
           kind_of_mod.const_set(method_name, kind_checker)
@@ -108,7 +114,7 @@ module Kind
 
         unless kind_is_mod.respond_to?(method_name)
           kind_is_mod.instance_eval(KIND_IS % params)
-          kind_is_mod.const_set(method_name, Module.new) if create_kind_is_mod
+          kind_is_mod.const_set(method_name, ::Module.new) if create_kind_is_mod
         end
       end
   end

data/lib/kind/dig.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Kind
+  module Dig
+    extend self
+
+    def call(data, keys)
+      return unless keys.is_a?(::Array)
+
+      keys.reduce(data) do |memo, key|
+        value = get(memo, key)
+
+        break if KIND.null?(value)
+
+        value
+      end
+    end
+
+    def [](*keys)
+      ->(data) { call(data, keys) }
+    end
+
+    private
+
+      def get(data, key)
+        return data[key] if ::Hash === data
+
+        case data
+        when ::Array
+          data[key] if key.respond_to?(:to_int)
+        when ::OpenStruct
+          data[key] if key.respond_to?(:to_sym)
+        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
+end

data/lib/kind/empty.rb

@@ -1,21 +1,15 @@
 # frozen_string_literal: true
 
-require 'set'
-
 module Kind
   module Empty
     SET = ::Set.new.freeze
-
     HASH = {}.freeze
+    ARRAY = [].freeze
+    STRING = ''.freeze
 
-    ARY = [].freeze
-    ARRAY = ARY
-
-    STR = ''.freeze
-    STRING = STR
+    ARY = ARRAY
+    STR = STRING
   end
 end
 
-unless defined?(Empty)
-  Empty = Kind::Empty
-end
+Empty = Kind::Empty unless defined?(Empty)

data/lib/kind/error.rb

@@ -2,12 +2,8 @@
 
 module Kind
   class Error < TypeError
-    UNDEFINED_OBJECT = Object.new
-
-    private_constant :UNDEFINED_OBJECT
-
-    def initialize(arg, object = UNDEFINED_OBJECT)
-      if UNDEFINED_OBJECT == object
+    def initialize(arg, object = UNDEFINED)
+      if UNDEFINED == object
         # Will be used when the exception was raised with a message. e.g:
         # raise Kind::Error, "some message"
         super(arg)

data/lib/kind/maybe.rb

@@ -1,124 +1,25 @@
 # frozen_string_literal: true
 
+require 'kind/dig'
+
 module Kind
   module Maybe
-    module Value
-      def self.none?(value)
-        value.nil? || Undefined == value
-      end
-
-      def self.some?(value)
-        !none?(value)
-      end
-    end
-
-    class Result
-      attr_reader :value
-
-      def initialize(value)
-        @value = value.kind_of?(Result) ? value.value : value
-      end
-
-      def value_or(method_name = Undefined, &block)
-        raise NotImplementedError
-      end
-
-      def none?
-        raise NotImplementedError
-      end
-
-      def some?; !none?; end
-
-      def map(&fn)
-        raise NotImplementedError
-      end
-
-      def try(method_name = Undefined, &block)
-        raise NotImplementedError
-      end
-    end
+    extend self
 
-    class None < Result
-      INVALID_DEFAULT_ARG = 'the default value must be defined as an argument or block'.freeze
+    require 'kind/maybe/result'
+    require 'kind/maybe/none'
+    require 'kind/maybe/some'
+    require 'kind/maybe/wrappable'
+    require 'kind/maybe/typed'
 
-      def value_or(default = Undefined, &block)
-        raise ArgumentError, INVALID_DEFAULT_ARG if Undefined == default && !block
-
-        Undefined != default ? default : block.call
-      end
-
-      def none?; true; end
-
-      def map(&fn)
-        self
-      end
-
-      alias_method :then, :map
-
-      def try(method_name = Undefined, &block)
-        Kind.of.Symbol(method_name) if Undefined != method_name
-
-        nil
-      end
-
-      private_constant :INVALID_DEFAULT_ARG
+    def new(value)
+      (KIND.null?(value) ? None : Some)
+        .new(value)
     end
 
-    NONE_WITH_NIL_VALUE = None.new(nil)
-    NONE_WITH_UNDEFINED_VALUE = None.new(Undefined)
-
-    private_constant :NONE_WITH_NIL_VALUE, :NONE_WITH_UNDEFINED_VALUE
-
-    class Some < Result
-      def value_or(default = Undefined, &block)
-        @value
-      end
-
-      def none?; false; end
-
-      def map(&fn)
-        result = fn.call(@value)
+    alias_method :[], :new
 
-        return result if Maybe::None === result
-        return NONE_WITH_NIL_VALUE if result.nil?
-        return NONE_WITH_UNDEFINED_VALUE if Undefined == result
-
-        Some.new(result)
-      end
-
-      alias_method :then, :map
-
-      def try(method_name = Undefined, *args, &block)
-        fn = Undefined == method_name ? block : Kind.of.Symbol(method_name).to_proc
-
-        result = args.empty? ? fn.call(value) : fn.call(*args.unshift(value))
-
-        return result if Maybe::Value.some?(result)
-      end
-    end
-
-    def self.new(value)
-      result_type = Maybe::Value.none?(value) ? None : Some
-      result_type.new(value)
-    end
-
-    def self.[](value);
-      new(value)
-    end
-
-    def self.none
-      NONE_WITH_NIL_VALUE
-    end
-
-    VALUE_CANT_BE_NONE = "value can't be nil or Kind::Undefined".freeze
-
-    private_constant :VALUE_CANT_BE_NONE
-
-    def self.some(value)
-      return Maybe::Some.new(value) if Value.some?(value)
-
-      raise ArgumentError, VALUE_CANT_BE_NONE
-    end
+    extend Wrappable
   end
 
   Optional = Maybe
@@ -126,10 +27,18 @@ module Kind
   None = Maybe.none
 
   def self.None
-    Kind::None
+    None
   end
 
   def self.Some(value)
     Maybe.some(value)
   end
+
+  def self.Maybe(kind)
+    Maybe::Typed.new(kind)
+  end
+
+  def self.Optional(kind)
+    Maybe::Typed.new(kind)
+  end
 end

data/lib/kind/maybe/none.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Kind
+  module Maybe
+    class None < Result
+      INVALID_DEFAULT_ARG = 'the default value must be defined as an argument or block'.freeze
+
+      def value_or(default = UNDEFINED, &block)
+        raise ArgumentError, INVALID_DEFAULT_ARG if UNDEFINED == default && !block
+
+        UNDEFINED != default ? default : block.call
+      end
+
+      def none?; true; end
+
+      def map(&fn)
+        self
+      end
+
+      alias_method :map!, :map
+      alias_method :then, :map
+      alias_method :then!, :map
+      alias_method :check, :map
+
+      def try!(method_name = UNDEFINED, *args, &block)
+        Kind::Symbol[method_name] if UNDEFINED != method_name
+
+        self
+      end
+
+      alias_method :try, :try!
+
+      def dig(*keys)
+        self
+      end
+
+      def presence
+        self
+      end
+
+      private_constant :INVALID_DEFAULT_ARG
+    end
+
+    NONE_WITH_NIL_VALUE = None.new(nil)
+    NONE_WITH_UNDEFINED_VALUE = None.new(Undefined)
+
+    def none
+      NONE_WITH_NIL_VALUE
+    end
+
+    def __none__(value) # :nodoc:
+      None.new(value)
+    end
+
+    private_constant :NONE_WITH_NIL_VALUE, :NONE_WITH_UNDEFINED_VALUE
+  end
+end

data/lib/kind/maybe/result.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Kind
+  module Maybe
+    class Result
+      attr_reader :value
+
+      Value = ->(arg) { arg.kind_of?(::Kind::Maybe::Result) ? arg.value : arg } # :nodoc:
+
+      def initialize(arg)
+        @value = Value.(arg)
+      end
+
+      def value_or(method_name = UNDEFINED, &block)
+        raise NotImplementedError
+      end
+
+      def none?
+        raise NotImplementedError
+      end
+
+      def some?; !none?; end
+
+      def map(&fn)
+        raise NotImplementedError
+      end
+
+      alias_method :map!, :map
+      alias_method :then, :map
+      alias_method :then!, :map
+
+      def check(&fn)
+        raise NotImplementedError
+      end
+
+      def try(method_name = UNDEFINED, &block)
+        raise NotImplementedError
+      end
+
+      alias_method :try!, :try
+
+      def dig(*keys)
+        raise NotImplementedError
+      end
+
+      def presence
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/kind/maybe/some.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Kind
+  module Maybe
+    class Some < Result
+      def value_or(default = UNDEFINED, &block)
+        @value
+      end
+
+      def none?; false; end
+
+      def map(&fn)
+        map!(&fn)
+      rescue StandardError => exception
+        None.new(exception)
+      end
+
+      alias_method :then, :map
+
+      def check(&fn)
+        result = fn.call(@value)
+
+        !result || KIND.null?(result) ? NONE_WITH_NIL_VALUE : self
+      end
+
+      def map!(&fn)
+        result = fn.call(@value)
+
+        resolve(result)
+      end
+
+      alias_method :then!, :map!
+
+      def try!(method_name = UNDEFINED, *args, &block)
+        return __try_block__(block, args) if block
+
+        return __try_method__(method_name, args) if UNDEFINED != method_name
+
+        raise ArgumentError, 'method name or a block must be present'
+      end
+
+      def try(method_name = UNDEFINED, *args, &block)
+        return __try_block__(block, args) if block
+
+        return __try_method__(method_name, args) if value.respond_to?(method_name)
+
+        NONE_WITH_NIL_VALUE
+      end
+
+      def dig(*keys)
+        resolve(Dig.(value, keys))
+      end
+
+      def presence
+        resolve(Presence.(value))
+      end
+
+      private
+
+        def __try_method__(method_name, args)
+          __try_block__(Kind::Symbol[method_name].to_proc, args)
+        end
+
+        def __try_block__(block, args)
+          result = args.empty? ? block.call(value) : block.call(*args.unshift(value))
+
+          resolve(result)
+        end
+
+        def resolve(result)
+          return result if Maybe::None === result
+          return None.new(result) if Exception === result
+          return NONE_WITH_NIL_VALUE if result.nil?
+          return NONE_WITH_UNDEFINED_VALUE if Undefined == result
+
+          Some.new(result)
+        end
+    end
+
+    VALUE_CANT_BE_NONE = "value can't be nil or Kind::Undefined".freeze
+
+    def some(value)
+      return Maybe::Some.new(value) if !KIND.null?(value)
+
+      raise ArgumentError, VALUE_CANT_BE_NONE
+    end
+
+    private_constant :VALUE_CANT_BE_NONE
+  end
+end