kind 3.1.0 → 5.2.0

data/lib/kind/immutable_attributes.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'kind/basic'
+require 'kind/__lib__/attributes'
+
+module Kind
+  module ImmutableAttributes
+    require 'kind/immutable_attributes/initializer'
+    require 'kind/immutable_attributes/reader'
+
+    module ClassMethods
+      def __attributes__ # :nodoc:
+        @__attributes__ ||= {}
+      end
+
+      def attribute(name, kind = nil, default: UNDEFINED, visibility: :public)
+        __attributes__[ATTRIBUTES.name!(name)] = ATTRIBUTES.value(kind, default, visibility)
+
+        attr_reader(name)
+
+        private(name) if visibility == :private
+        protected(name) if visibility == :protected
+
+        name
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.send(:include, Reader)
+      base.send(:include, Initializer)
+    end
+  end
+end

data/lib/kind/immutable_attributes/initializer.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'kind/__lib__/attributes'
+require 'kind/basic'
+require 'kind/empty'
+
+module Kind
+  module ImmutableAttributes
+    module Initializer
+      def initialize(arg)
+        input = __resolve_attribute_input(arg)
+
+        hash = call_before_initialize_to_prepare_the_input(input)
+
+        @_nil_attrs = ::Set.new
+        @_____attrs = {}
+        @attributes = {}
+
+        self.class.__attributes__.each do |name, (kind, default, visibility)|
+          value_to_assign = __resolve_attribute_value_to_assign(kind, default, hash, name)
+
+          @_nil_attrs << name if value_to_assign.nil?
+          @_____attrs[name] = value_to_assign
+          @attributes[name] = value_to_assign if visibility == :public
+
+          instance_variable_set("@#{name}", value_to_assign)
+        end
+
+        @_nil_attrs.freeze
+        @attributes.freeze
+
+        call_after_initialize_and_assign_the_attributes
+      end
+
+      def nil_attributes
+        @_nil_attrs.to_a
+      end
+
+      def nil_attributes?(*names)
+        names.empty? ? !@_nil_attrs.empty? : names.all? { |name| @_nil_attrs.include?(name) }
+      end
+
+      private
+
+        def call_before_initialize_to_prepare_the_input(input)
+          input
+        end
+
+        def call_after_initialize_and_assign_the_attributes
+        end
+
+        def __resolve_attribute_input(arg)
+          return arg.attributes if arg.kind_of?(ImmutableAttributes)
+
+          arg.kind_of?(::Hash) ? arg : Empty::HASH
+        end
+
+        def __resolve_attribute_value_to_assign(kind, default, hash, name)
+          if kind.kind_of?(::Class) && kind < ImmutableAttributes
+            kind.new(hash[name])
+          elsif kind.kind_of?(::Array) && (nkind = kind[0]).kind_of?(::Class) && nkind < ImmutableAttributes
+            Array(hash[name]).map { |item| nkind.new(item) }
+          else
+            ATTRIBUTES.value_to_assign(kind, default, hash, name)
+          end
+        end
+    end
+
+  end
+end

data/lib/kind/immutable_attributes/reader.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'kind/basic'
+require 'kind/__lib__/attributes'
+
+module Kind
+  module ImmutableAttributes
+
+    module Reader
+      def self.included(base)
+        base.send(:attr_reader, :attributes)
+      end
+
+      def attribute?(name)
+        self.class.__attributes__.key?(name.to_sym)
+      end
+
+      def attribute(name)
+        @attributes[name.to_sym]
+      end
+
+      def attribute!(name)
+        @attributes.fetch(name.to_sym)
+      end
+
+      def with_attribute(name, value)
+        self.class.new(@_____attrs.merge(name.to_sym => value))
+      end
+
+      def with_attributes(arg)
+        hash = KIND.of!(::Hash, arg)
+
+        self.class.new(@_____attrs.merge(hash))
+      end
+    end
+
+  end
+end

data/lib/kind/maybe.rb

@@ -1,193 +1,69 @@
 # frozen_string_literal: true
 
-require 'kind/dig'
+require 'kind/basic'
 
 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
+    require 'kind/maybe/monad'
+    require 'kind/maybe/none'
+    require 'kind/maybe/some'
+    require 'kind/maybe/wrapper'
+    require 'kind/maybe/typed'
+    require 'kind/maybe/methods'
+
+    extend self
+
+    def new(value)
+      (::Exception === value || KIND.null?(value) ? None : Some)
+        .new(value)
     end
 
-    class Result
-      attr_reader :value
+    alias_method :[], :new
 
-      def initialize(value)
-        @value = value.kind_of?(Result) ? value.value : value
-      end
-
-      def value_or(method_name = Undefined, &block)
-        raise NotImplementedError
-      end
+    module Buildable
+      def maybe(value = UNDEFINED, &block)
+        return __maybe[value] if UNDEFINED != value && !block
+        return __maybe.wrap(&block) if UNDEFINED == value && block
+        return __maybe.wrap(value, &block) if UNDEFINED != value && block
 
-      def none?
-        raise NotImplementedError
+        __maybe
       end
 
-      def some?; !none?; end
-
-      def map(&fn)
-        raise NotImplementedError
-      end
-
-      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
-
-      def try!(method_name = Undefined, *args, &block)
-        Kind.of.Symbol(method_name) if Undefined != method_name
-
-        NONE_WITH_NIL_VALUE
-      end
-
-      alias_method :try, :try!
-
-      def dig(*keys)
-        NONE_WITH_NIL_VALUE
-      end
-
-      private_constant :INVALID_DEFAULT_ARG
-    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)
-
-        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
-
-      def dig(*keys)
-        resolve(Kind::Dig.call(value, keys))
-      end
+      alias_method :optional, :maybe
 
       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)
+        def __maybe
+          @__maybe ||= Maybe::Typed[self]
         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 Wrapper
   end
 
   Optional = Maybe
 
-  None = Maybe.none
+  None = Maybe::NONE_INSTANCE
 
   def self.None
-    Kind::None
+    Maybe::NONE_INSTANCE
   end
 
   def self.Some(value)
-    Maybe.some(value)
+    Maybe::Some[value]
   end
 
   def self.Maybe(kind)
-    Maybe::Typed.new(kind)
+    warn '[DEPRECATION] Kind::Maybe() is deprecated; use Kind::Maybe::Typed[] instead. ' \
+        'It will be removed on next major release.'
+
+    Maybe::Typed[kind]
   end
 
   def self.Optional(kind)
-    Maybe::Typed.new(kind)
+    warn '[DEPRECATION] Kind::Optional() is deprecated; use Kind::Optional::Typed[] instead. ' \
+        'It will be removed on next major release.'
+
+    Optional::Typed[kind]
   end
 end

data/lib/kind/maybe/methods.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Kind
+  module Maybe::Methods
+    def Maybe(&block)
+      Kind::Maybe.from(&block)
+    end
+
+    def None
+      Kind::Maybe::NONE_INSTANCE
+    end
+
+    def Some(value = UNDEFINED, &block)
+      UNDEFINED == value && block ? Maybe(&block) : Kind::Maybe[value]
+    end
+
+    def self.included(base)
+      base.send(:private, :Some, :None)
+    end
+  end
+end

data/lib/kind/maybe/monad.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Kind
+  module Maybe
+    class Monad
+      require 'kind/maybe/monad/wrapper'
+
+      attr_reader :value
+
+      Value = ->(arg) { arg.kind_of?(Maybe::Monad) ? arg.value : arg } # :nodoc:
+
+      def initialize(value)
+        @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
+
+      alias_method :map!, :map
+      alias_method :then, :map
+      alias_method :then!, :map
+      alias_method :and_then, :map
+      alias_method :and_then!, :map!
+
+      def check(&fn)
+        raise NotImplementedError
+      end
+
+      alias_method :accept, :check
+      alias_method :reject, :check
+
+      def try(_method_name = UNDEFINED, &block)
+        raise NotImplementedError
+      end
+
+      alias_method :try!, :try
+
+      def dig(*keys)
+        raise NotImplementedError
+      end
+
+      def presence
+        raise NotImplementedError
+      end
+
+      def on
+        monad = Wrapper.new(self)
+
+        yield(monad)
+
+        monad.output
+      end
+
+      def on_some(matcher = UNDEFINED)
+        yield(value) if some? && maybe?(matcher)
+
+        self
+      end
+
+      def on_none(matcher = UNDEFINED)
+        yield(value) if none? && maybe?(matcher)
+
+        self
+      end
+
+      def maybe?(matcher)
+        UNDEFINED == matcher || matcher === value
+      end
+    end
+  end
+end