kind 4.1.0 → 5.4.0

data/lib/kind/function.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'kind/basic'
+
+module Kind
+  module Function
+    module Behavior
+      def self.extended(base)
+        base.send(:alias_method, :[], :call)
+        base.send(:alias_method, :===, :call)
+        base.send(:alias_method, :yield, :call)
+      end
+    end
+
+    def self.included(_)
+      raise RuntimeError, "The Kind::Function can't be included, it can be only extended."
+    end
+
+    def self.extended(base)
+      base.extend(Kind.of_module(base))
+    end
+
+    def kind_function!
+      return self if Kind.is?(Behavior, self)
+
+      KIND.respond_to!(:call, self).extend(Behavior)
+
+      if method(:call).parameters.empty?
+        raise ArgumentError, "#{self.name}.call must receive at least one argument"
+      end
+
+      self.instance_eval(
+        'def to_proc; @to_proc ||= method(:call).to_proc; end' \
+        "\n" \
+        'def curry; @curry ||= to_proc.curry; end'
+      )
+
+      self.to_proc
+      self.curry
+      self
+    end
+
+    private_constant :Behavior
+  end
+end

data/lib/kind/functional.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'kind/basic'
+require 'kind/empty'
+require 'kind/__lib__/attributes'
+
+module Kind
+  module Functional
+    def self.extended(_)
+      raise RuntimeError, "The Kind::Functional can't be extended, it can be only included."
+    end
+
+    def self.included(base)
+      Kind.of_class(base).send(:extend, ClassMethods)
+    end
+
+    module Behavior
+      def self.included(base)
+        base.send(:alias_method, :[], :call)
+        base.send(:alias_method, :===, :call)
+        base.send(:alias_method, :yield, :call)
+      end
+
+      def initialize(arg = Empty::HASH)
+        hash = STRICT.kind_of(::Hash, arg)
+
+        self.class.__dependencies__.each do |name, (kind, default, _visibility)|
+          value_to_assign = ATTRIBUTES.value_to_assign!(kind, default, hash, name)
+
+          instance_variable_set("@#{name}", value_to_assign)
+        end
+      end
+    end
+
+    module DependencyInjection
+      def __dependencies__ # :nodoc:
+        @__dependencies__ ||= {}
+      end
+
+      def dependency(name, kind, default: UNDEFINED)
+        __dependencies__[ATTRIBUTES.name!(name)] = ATTRIBUTES.value!(kind, default)
+
+        attr_reader(name)
+
+        private(name)
+
+        name
+      end
+    end
+
+    module ClassMethods
+      include DependencyInjection
+
+      def kind_functional!
+        return self if Kind.is?(Behavior, self)
+
+        public_methods = self.public_instance_methods - ::Object.new.methods
+
+        unless public_methods.include?(:call)
+          raise Kind::Error.new("expected #{self} to implement `#call`")
+        end
+
+        if public_methods.size > 1
+          raise Kind::Error.new("#{self} can only have `#call` as its public method")
+        end
+
+        if public_instance_method(:call).parameters.empty?
+          raise ArgumentError, "#{self.name}#call must receive at least one argument"
+        end
+
+        self.send(:include, Behavior)
+
+        def self.inherited(_)
+          raise RuntimeError, "#{self.name} is a Kind::Functional and it can't be inherited by anyone"
+        end
+
+        self.class_eval(
+          'def to_proc; @to_proc ||= method(:call).to_proc; end' \
+          "\n" \
+          'def curry; @curry ||= to_proc.curry; end'
+        )
+
+        __dependencies__.freeze
+
+        self
+      end
+    end
+  end
+end

data/lib/kind/functional/action.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'kind/functional'
+require 'kind/functional/steps'
+
+module Kind
+  module Functional::Action
+    CALL_TMPL = [
+      'def call(%s)',
+      '  result = call!(%s)',
+      '',
+      '  return result if Kind::Result::Monad === result',
+      '',
+      '  raise Kind::Error, "#{self.class.name}#call! must return a Kind::Success or Kind::Failure"',
+      'end'
+    ].join("\n").freeze
+
+    module Macros
+      def kind_functional_action!
+        return self if Kind.is?(Result::Methods, self)
+
+        public_methods = self.public_instance_methods - ::Object.new.methods
+
+        unless public_methods.include?(:call!)
+          raise Kind::Error.new("expected #{self} to implement `#call!`")
+        end
+
+        if public_methods.size > 1
+          raise Kind::Error.new("#{self} can only have `#call!` as its public method")
+        end
+
+        call_parameters = public_instance_method(:call!).parameters
+
+        if call_parameters.empty?
+          raise ArgumentError, "#{self.name}#call! must receive at least one argument"
+        end
+
+        def self.inherited(_)
+          raise RuntimeError, "#{self.name} is a Kind::Functional::Action and it can't be inherited"
+        end
+
+        call_parameters.flatten!
+
+        call_with_args = call_parameters.include?(:req) || call_parameters.include?(:rest)
+        call_with_kargs = call_parameters.include?(:keyreq) || call_parameters.include?(:keyrest)
+
+        call_tmpl_args = '*args, **kargs' if call_with_args && call_with_kargs
+        call_tmpl_args = '*args'          if call_with_args && !call_with_kargs
+        call_tmpl_args = '**kargs'        if !call_with_args && call_with_kargs
+
+        self.class_eval(
+          "def to_proc; @to_proc ||= method(:call!).to_proc; end" \
+          "\n" \
+          "def curry; @curry ||= to_proc.curry; end" \
+          "\n" \
+          "#{CALL_TMPL % [call_tmpl_args, call_tmpl_args]}"
+        )
+
+        if Kind.of_module?(self)
+          self.send(:extend, Functional::Steps)
+        else
+          self.send(:include, Functional::Steps)
+          self.send(:include, Functional::Behavior)
+
+          __dependencies__.freeze
+        end
+
+        self.send(:protected, :call!)
+
+        self
+      end
+    end
+
+    def self.included(base)
+      Kind.of_class(base).send(:extend, Functional::DependencyInjection)
+
+      base.send(:extend, Macros)
+    end
+
+    def self.extended(base)
+      base.send(:extend, Kind.of_module(base))
+      base.send(:extend, Macros)
+    end
+
+    private_constant :Macros, :CALL_TMPL
+  end
+end

data/lib/kind/functional/steps.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'kind/basic'
+require 'kind/empty'
+require 'kind/result'
+require 'kind/__lib__/action_steps'
+
+module Kind
+  module Functional
+    module Steps
+      def self.extended(base)
+        base.extend(Result::Methods)
+        base.extend(ACTION_STEPS)
+      end
+
+      def self.included(base)
+        base.send(:include, Result::Methods)
+        base.send(:include, ACTION_STEPS)
+      end
+    end
+  end
+end

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 = STRICT.kind_of(::Hash, arg)
+
+        self.class.new(@_____attrs.merge(hash))
+      end
+    end
+
+  end
+end

data/lib/kind/maybe.rb

@@ -1,44 +1,69 @@
 # frozen_string_literal: true
 
-require 'kind/dig'
+require 'kind/basic'
 
 module Kind
   module Maybe
-    extend self
-
-    require 'kind/maybe/result'
+    require 'kind/maybe/monad'
     require 'kind/maybe/none'
     require 'kind/maybe/some'
-    require 'kind/maybe/wrappable'
+    require 'kind/maybe/wrapper'
     require 'kind/maybe/typed'
+    require 'kind/maybe/methods'
+
+    extend self
 
     def new(value)
-      (KIND.null?(value) ? None : Some)
+      (::Exception === value || KIND.nil_or_undefined?(value) ? None : Some)
         .new(value)
     end
 
     alias_method :[], :new
 
-    extend Wrappable
+    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
+
+        __maybe
+      end
+
+      alias_method :optional, :maybe
+
+      private
+
+        def __maybe
+          @__maybe ||= Maybe::Typed[self]
+        end
+    end
+
+    extend Wrapper
   end
 
   Optional = Maybe
 
-  None = Maybe.none
+  None = Maybe::NONE_INSTANCE
 
   def self.None
-    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