kind 5.0.0 → 5.4.1

data/lib/kind/presence.rb

@@ -1,13 +1,15 @@
 # frozen_string_literal: true
 
+require 'kind/basic'
+
 module Kind
   module Presence
     extend self
 
     def call(object)
-      return object.blank? ? nil : object if object.respond_to?(:blank?)
+      return if KIND.nil_or_undefined?(object)
 
-      return object if TrueClass === object
+      return object.blank? ? nil : object if object.respond_to?(:blank?)
 
       return blank_str?(object) ? nil : object if String === object
 

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,33 @@
+# 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(value)
+    end
+
+    def map(_ = UNDEFINED, &_fn)
+      self
+    end
+
+    alias_method :|, :map
+    alias_method :>>, :map
+    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,74 @@
+# frozen_string_literal: true
+
+module Kind
+  class Result::Monad
+    include Result::Abstract
+
+    require 'kind/empty'
+    require 'kind/result/monad/wrapper'
+
+    attr_reader :type, :value
+
+    def self.[](arg1 = UNDEFINED, arg2 = UNDEFINED, opt = Empty::HASH) # :nodoc:
+      value_must_be_a = opt[:value_must_be_a]
+
+      type = UNDEFINED == arg2 ? self::DEFAULT_TYPE : STRICT.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 ? STRICT.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(_ = UNDEFINED, &_fn)
+      raise NotImplementedError
+    end
+
+    alias_method :|, :map
+    alias_method :>>, :map
+    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,53 @@
+# 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(callable = UNDEFINED, &fn)
+      _resolve_map(callable, fn)
+    rescue Kind::Monad::Error => e
+      raise e
+    rescue StandardError => e
+      Result::Failure[:exception, e]
+    end
+
+    alias_method :then, :map
+    alias_method :and_then, :map
+
+    def map!(callable = UNDEFINED, &fn)
+      _resolve_map(callable, fn)
+    end
+
+    alias_method :|, :map!
+    alias_method :>>, :map!
+    alias_method :then!, :map!
+    alias_method :and_then!, :map!
+
+    def inspect
+      '#<%s type=%p value=%p>' % ['Kind::Success', type, value]
+    end
+
+    private
+
+      def _resolve_map(callable, fn)
+        callable.respond_to?(:call) ? _map(callable) : _map(fn)
+      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
+  end
+end

data/lib/kind/strict/disabled.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Kind
+  module STRICT
+    [
+      :object_is_a, :class!, :kind_of,
+      :module_or_class, :module!, :not_nil
+    ].each { |method_name| remove_method(method_name) }
+
+    def object_is_a(_kind, value, _label = nil) # :nodoc:
+      value
+    end
+
+    def class!(value) # :nodoc:
+      value
+    end
+
+    def kind_of(_kind, value, _kind_name = nil) # :nodoc:
+      value
+    end
+
+    def module_or_class(value) # :nodoc:
+      value
+    end
+
+    def module!(value) # :nodoc:
+      value
+    end
+
+    def not_nil(value, label) # :nodoc:
+      value
+    end
+  end
+end

data/lib/kind/try.rb

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

data/lib/kind/validator.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'kind/basic'
+
 module Kind
   module Validator
     DEFAULT_STRATEGIES = ::Set.new(%w[instance_of kind_of]).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