kind 3.0.0 → 5.0.0

data/lib/kind/core/undefined.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Kind
+  UNDEFINED = Object.new.freeze
+
+  private_constant :UNDEFINED
+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.kind_of?(::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,13 @@
 # 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

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/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,164 +1,25 @@
 # frozen_string_literal: true
 
+require 'kind/dig'
+
 module Kind
   module Maybe
-    class Typed
-      def initialize(kind)
-        @kind_checker = Kind::Checker::Factory.create(kind)
-      end
-
-      def wrap(value)
-        @kind_checker.as_maybe(value)
-      end
-
-      alias_method :new, :wrap
-      alias_method :[], :wrap
-    end
-
-    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
+    extend self
 
-      def try(method_name = Undefined, &block)
-        raise NotImplementedError
-      end
-    end
-
-    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 :then, :map
+    require 'kind/maybe/result'
+    require 'kind/maybe/none'
+    require 'kind/maybe/some'
+    require 'kind/maybe/wrappable'
+    require 'kind/maybe/typed'
 
-      def try!(method_name = Undefined, &block)
-        Kind.of.Symbol(method_name) if Undefined != method_name
-
-        NONE_WITH_NIL_VALUE
-      end
-
-      alias_method :try, :try!
-
-      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
+    alias_method :[], :new
 
-      def map(&fn)
-        result = fn.call(@value)
-
-        resolve(result)
-      end
-
-      alias_method :then, :map
-
-      def try!(method_name = Undefined, *args, &block)
-        Kind::Of::Symbol(method_name) if Undefined != method_name
-
-        __try__(method_name, args, block)
-      end
-
-      def try(method_name = Undefined, *args, &block)
-        if (Undefined != method_name && value.respond_to?(Kind::Of::Symbol(method_name))) ||
-           (Undefined == method_name && block)
-          __try__(method_name, args, block)
-        else
-          NONE_WITH_NIL_VALUE
-        end
-      end
-
-      private
-
-        def __try__(method_name = Undefined, args, block)
-          fn = Undefined == method_name ? block : method_name.to_proc
-
-          result = args.empty? ? fn.call(value) : fn.call(*args.unshift(value))
-
-          resolve(result)
-        end
-
-        def resolve(result)
-          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
-    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.wrap(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
@@ -166,7 +27,7 @@ module Kind
   None = Maybe.none
 
   def self.None
-    Kind::None
+    None
   end
 
   def self.Some(value)

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