kind 5.0.0 → 5.4.1

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(value)
+    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

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

data/lib/kind/enum/item.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Kind
+  module Enum
+    class Item
+      Underscore = ->(arg) do
+        str = String(arg).strip
+        str.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+        str.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+        str.tr!("-", "_")
+        str.downcase!
+        str
+      end
+
+      attr_reader :value, :to_s, :name, :to_sym, :inspect
+
+      alias_method :key, :to_s
+      alias_method :to_str, :to_s
+
+      def initialize(key, val)
+        @value = val.frozen? ? val : val.dup.freeze
+
+        @to_s = Kind.respond_to(key, :to_sym).to_s
+        @name = Underscore[key].upcase.freeze
+        @to_sym = key.to_sym
+        @inspect = ('#<Kind::Enum::Item name=%p to_s=%p value=%p>' % [@name, @to_s, @value]).freeze
+      end
+
+      def ==(arg)
+        arg == value || arg == to_s || arg == to_sym
+      end
+
+      def to_ary
+        [key, value]
+      end
+
+      alias_method :===, :==
+    end
+  end
+end

data/lib/kind/enum/methods.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Kind
+  module Enum
+    METHODS = \
+    <<-RUBY
+    def to_h
+      ENUM__HASH
+    end
+
+    def items
+      ENUM__ITEMS
+    end
+
+    def ===(arg)
+      ENUM__ITEMS.any? { |item| item === arg }
+    end
+
+    def refs
+      ENUM__REFS.to_a
+    end
+
+    def keys
+      ENUM__KEYS.to_a
+    end
+
+    def values
+      ENUM__VALS.to_a
+    end
+
+    def ref?(arg)
+      ENUM__REFS.include?(arg)
+    end
+
+    def key?(arg)
+      arg.respond_to?(:to_sym) ? ref?(arg) && !value?(arg) : false
+    end
+
+    def value?(arg)
+      ENUM__VALS.include?(arg)
+    end
+
+    def [](arg)
+      return arg if ref?(arg)
+
+      raise KeyError, "key or value not found: %p" % [arg]
+    end
+
+    def ref(arg)
+      arg if ref?(arg)
+    end
+
+    def item(arg)
+      ENUM__MAP[arg]
+    end
+
+    def key(arg)
+      item(arg).key if value?(arg)
+    end
+
+    def value_at(arg)
+      item(arg).value if key?(arg)
+    end
+
+    def self.included(base)
+      base.extend(base)
+    end
+    RUBY
+
+    private_constant :METHODS
+  end
+end

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