kind 3.1.0 → 5.2.0

data/lib/kind/objects/respond_to.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Kind
+  class RespondTo
+    include Kind::BasicObject
+
+    def self.[](*args)
+      args.each { |arg| KIND.of!(::Symbol, arg) }
+
+      new(args)
+    end
+
+    private_class_method :new
+
+    attr_reader :inspect
+
+    def initialize(method_names)
+      @method_names = method_names
+      @inspect = "Kind::RespondTo#{@method_names}"
+    end
+
+    def ===(value)
+      KIND.interface?(@method_names, value)
+    end
+
+    alias_method :call, :===
+
+    alias_method :name, :inspect
+  end
+end

data/lib/kind/objects/union_type.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Kind
+  class UnionType
+    include Kind::BasicObject
+
+    Interface = Kind::RespondTo[:name, :===]
+
+    singleton_class.send(:alias_method, :[], :new)
+
+    attr_reader :inspect
+
+    def initialize(kind)
+      @kinds = Array(kind)
+      @inspect = "(#{@kinds.map(&:name).join(' | ')})"
+    end
+
+    def |(kind)
+      self.class.new(@kinds + [Interface[kind]])
+    end
+
+    def ===(value)
+      @kinds.any? { |kind| kind === value }
+    end
+
+    alias_method :name, :inspect
+
+    module Buildable
+      def |(another_kind)
+        __union_type | another_kind
+      end
+
+      private
+
+        def __union_type
+          @__union_type ||= UnionType[self]
+        end
+    end
+
+    private_constant :Interface
+  end
+
+  RespondTo.send(:include, UnionType::Buildable)
+end

data/lib/kind/presence.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'kind/basic'
+
+module Kind
+  module Presence
+    extend self
+
+    def call(object)
+      return if KIND.null?(object)
+
+      return object.blank? ? nil : object if object.respond_to?(:blank?)
+
+      return blank_str?(object) ? nil : object if String === object
+
+      return object.empty? ? nil : object if object.respond_to?(:empty?)
+
+      return object if object
+    end
+
+    def to_proc
+      -> object { call(object) }
+    end
+
+    private
+
+      BLANK_RE = /\A[[:space:]]*\z/
+
+      def blank_str?(object)
+        object.empty? || BLANK_RE === object
+      end
+
+      private_constant :BLANK_RE
+  end
+end

data/lib/kind/result.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'kind/basic'
+
+module Kind
+  module Result
+    require 'kind/result/abstract'
+    require 'kind/result/monad'
+    require 'kind/result/failure'
+    require 'kind/result/success'
+    require 'kind/result/methods'
+
+    extend self
+
+    def new(value)
+      Success[value]
+    end
+
+    alias_method :[], :new
+
+    def self.from
+      result = yield
+
+      Result::Monad === result ? result : Result::Success[result]
+    rescue StandardError => e
+      Result::Failure[:exception, e]
+    end
+  end
+
+  extend Result::Methods
+end

data/lib/kind/result/abstract.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Kind
+  module Result::Abstract
+    def failure?
+      false
+    end
+
+    def failed?
+      failure?
+    end
+
+    def success?
+      false
+    end
+
+    def succeeded?
+      success?
+    end
+
+    def on(&block)
+      raise NotImplementedError
+    end
+
+    def on_success(types = Undefined, matcher = Undefined)
+      raise NotImplementedError
+    end
+
+    def on_failure(types = Undefined, matcher = Undefined)
+      raise NotImplementedError
+    end
+
+    def result?(types, matcher)
+      undef_t = Undefined == (t = types)
+      undef_m = Undefined == (m = matcher)
+
+      return true if undef_t && undef_m
+
+      if !undef_t && undef_m && !(Array === types || Symbol === types)
+        m, t = types, matcher
+
+        undef_m, undef_t = false, true
+      end
+
+      is_type = undef_t || (::Array === t ? t.empty? || t.include?(type) : t == type)
+      is_type && (undef_m || m === value)
+    end
+
+    def to_ary
+      [type, value]
+    end
+  end
+end

data/lib/kind/result/failure.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Kind
+  class Result::Failure < Result::Monad
+    DEFAULT_TYPE = :error
+
+    def failure?
+      true
+    end
+
+    def value_or(default = UNDEFINED, &block)
+      Error.invalid_default_arg! if UNDEFINED == default && !block
+
+      UNDEFINED != default ? default : block.call
+    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 type=%p value=%p>' % ['Kind::Failure', type, value]
+    end
+  end
+end

data/lib/kind/result/methods.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Kind
+  module Result::Methods
+    def Failure(arg1 = UNDEFINED, arg2 = UNDEFINED)
+      Result::Failure[arg1, arg2]
+    end
+
+    def Success(arg1 = UNDEFINED, arg2 = UNDEFINED)
+      Result::Success[arg1, arg2]
+    end
+
+    def self.included(base)
+      base.send(:private, :Success, :Failure)
+    end
+  end
+end

data/lib/kind/result/monad.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Kind
+  class Result::Monad
+    include Result::Abstract
+
+    require 'kind/result/monad/wrapper'
+
+    attr_reader :type, :value
+
+    def self.[](arg1 = UNDEFINED, arg2 = UNDEFINED, value_must_be_a: nil) # :nodoc:
+      type = UNDEFINED == arg2 ? self::DEFAULT_TYPE : KIND.of!(::Symbol, arg1)
+
+      Error.wrong_number_of_args!(given: 0, expected: '1 or 2') if UNDEFINED == arg1
+
+      value = UNDEFINED == arg2 ? arg1 : arg2
+
+      new(type, (value_must_be_a ? KIND.of!(value_must_be_a, value) : value))
+    end
+
+    private_class_method :new
+
+    def initialize(type, value)
+      @type = type
+      @value = value
+    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_success(types = Undefined, matcher = Undefined)
+      yield(value) if success? && result?(types, matcher)
+
+      self
+    end
+
+    def on_failure(types = Undefined, matcher = Undefined)
+      yield(value) if failure? && result?(types, matcher)
+
+      self
+    end
+
+    def ===(m)
+      return false unless Result::Abstract === m
+      return false unless (self.success? && m.success?) || (self.failure? && m.failure?)
+
+      self.type == m.type && self.value === m.value
+    end
+  end
+end

data/lib/kind/result/monad/wrapper.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Kind
+  require 'kind/monad'
+
+  class Result::Monad::Wrapper < Kind::Monad::Wrapper
+    def failure(types = Undefined, matcher = Undefined)
+      return if @monad.success? || output?
+
+      @output = yield(@monad.value) if @monad.result?(types, matcher)
+    end
+
+    def success(types = Undefined, matcher = Undefined)
+      return if @monad.failure? || output?
+
+      @output = yield(@monad.value) if @monad.result?(types, matcher)
+    end
+  end
+end

data/lib/kind/result/success.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Kind
+  class Result::Success < Result::Monad
+    DEFAULT_TYPE = :ok
+
+    def success?
+      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
+      Result::Failure[:exception, e]
+    end
+
+    def map!(&fn)
+      monad = fn.call(@value)
+
+      return monad if Result::Monad === monad
+
+      raise Kind::Monad::Error.new('Kind::Success | Kind::Failure', monad)
+    end
+
+    alias_method :then, :map
+    alias_method :then!, :map!
+    alias_method :and_then, :map
+    alias_method :and_then!, :map!
+
+    def inspect
+      '#<%s type=%p value=%p>' % ['Kind::Success', type, value]
+    end
+  end
+end

data/lib/kind/try.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'kind/basic'
+require 'kind/empty'
+require 'kind/presence'
+
+module Kind
+  module Try
+    extend self
+
+    def call!(object, method_name, args = Empty::ARRAY) # :nodoc
+      return if KIND.null?(object)
+
+      resolve(object, method_name, args)
+    end
+
+    def call(object, *input)
+      args = input.size == 1 && input[0].kind_of?(::Array) ? input[0] : input
+
+      result = call!(object, args.shift, args)
+
+      return result unless block_given?
+
+      yield(result) unless KIND.null?(result)
+    end
+
+    def presence(*args, &block)
+      Presence.(call(*args, &block))
+    end
+
+    def self.[](*args)
+      method_name = args.shift
+
+      ->(object) { call!(object, method_name, args) }
+    end
+
+    private
+
+      def resolve(object, method_name, args)
+        return unless object.respond_to?(method_name)
+        return object.public_send(method_name) if args.empty?
+
+        object.public_send(method_name, *args)
+      end
+  end
+end

data/lib/kind/validator.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
+require 'kind/basic'
+
 module Kind
   module Validator
-    DEFAULT_STRATEGIES = Set.new(%w[instance_of kind_of]).freeze
+    DEFAULT_STRATEGIES = ::Set.new(%w[instance_of kind_of]).freeze
 
     class InvalidDefinition < ArgumentError
       OPTIONS = 'Options to define one: :of, :is, :respond_to, :instance_of, :array_of or :array_with'.freeze
@@ -38,3 +40,112 @@ module Kind
     end
   end
 end
+
+require 'active_model'
+require 'active_model/validations'
+
+class KindValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    return if options[:allow_nil] && value.nil?
+
+    return unless error = call_validation_for(attribute, value)
+
+    raise Kind::Error.new("#{attribute} #{error}") if options[:strict]
+
+    record.errors.add(attribute, error)
+  end
+
+  private
+
+    def call_validation_for(attribute, value)
+      expected = options[:with] || options[:in]
+
+      return validate_with_default_strategy(expected, value) if expected
+
+      return kind_of(expected, value) if expected = options[:of]
+      return kind_is(expected, value) if expected = options[:is]
+      return respond_to(expected, value) if expected = options[:respond_to]
+      return instance_of(expected, value) if expected = options[:instance_of]
+      return array_with(expected, value) if expected = options[:array_with]
+      return array_of(expected, value) if expected = options[:array_of]
+
+      raise Kind::Validator::InvalidDefinition.new(attribute)
+    end
+
+    def validate_with_default_strategy(expected, value)
+      send(Kind::Validator.default_strategy, expected, value)
+    end
+
+    def kind_of(expected, value)
+      if ::Array === expected
+        return if expected.any? { |type| type === value }
+
+        "must be a kind of #{expected.map { |type| type.name }.join(', ')}"
+      else
+        return if expected === value
+
+        expected.respond_to?(:name) ? "must be a kind of #{expected.name}" : 'invalid kind'
+      end
+    end
+
+    CLASS_OR_MODULE = 'Class/Module'.freeze
+
+    def kind_is(expected, value)
+      return kind_is_not(expected, value) unless expected.kind_of?(::Array)
+
+      result = expected.map { |kind| kind_is_not(kind, value) }.tap(&:compact!)
+
+      result.empty? || result.size < expected.size ? nil : result.join(', ')
+    end
+
+    def kind_is_not(expected, value)
+      case expected
+      when ::Class
+        return if expected == Kind.of!(::Class, value) || value < expected
+
+        "must be the class or a subclass of `#{expected.name}`"
+      when ::Module
+        return if value.kind_of?(::Class) && value <= expected
+        return if expected == Kind.of_module_or_class(value) || value.kind_of?(expected)
+
+        "must include the `#{expected.name}` module"
+      else
+        raise Kind::Error.new(CLASS_OR_MODULE, expected)
+      end
+    end
+
+    def respond_to(expected, value)
+      method_names = Array(expected)
+
+      expected_methods = method_names.select { |method_name| !value.respond_to?(method_name) }
+      expected_methods.map! { |method_name| "`#{method_name}`" }
+
+      return if expected_methods.empty?
+
+      methods = expected_methods.size == 1 ? 'method' : 'methods'
+
+      "must respond to the #{methods}: #{expected_methods.join(', ')}"
+    end
+
+    def instance_of(expected, value)
+      types = Array(expected)
+
+      return if types.any? { |type| value.instance_of?(type) }
+
+      "must be an instance of #{types.map { |klass| klass.name }.join(', ')}"
+    end
+
+    def array_with(expected, value)
+      return if value.kind_of?(::Array) && !value.empty? && (value - Kind.of!(::Array, expected)).empty?
+
+      "must be an array with #{expected.join(', ')}"
+    end
+
+    def array_of(expected, value)
+      types = Array(expected)
+
+      return if value.kind_of?(::Array) && !value.empty? && value.all? { |val| types.any? { |type| type === val } }
+
+      "must be an array of #{types.map { |klass| klass.name }.join(', ')}"
+    end
+end