kind 1.9.0 → 3.0.0

data/lib/kind/checker/protocol.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Kind
+  class Checker
+    module Protocol
+      def class?(value)
+        Kind::Is.__call__(__kind, value)
+      end
+
+      def instance(value, options = Empty::HASH)
+        default = options[:or]
+
+        return Kind::Of.(__kind, value) if ::Kind::Maybe::Value.none?(default)
+
+        Kind::Undefined != value && instance?(value) ? value : Kind::Of.(__kind, default)
+      end
+
+      def [](value, options = options = Empty::HASH)
+        instance(value, options)
+      end
+
+      def to_proc
+        @to_proc ||=
+          -> checker { -> value { checker.instance(value) } }.call(self)
+      end
+
+      def __is_instance__(value)
+        value.kind_of?(__kind)
+      end
+
+      def is_instance_to_proc
+        @is_instance_to_proc ||=
+          -> checker { -> value { checker.__is_instance__(value) } }.call(self)
+      end
+
+      def instance?(*args)
+        return is_instance_to_proc if args.empty?
+
+        return args.all? { |object| __is_instance__(object) } if args.size > 1
+
+        arg = args[0]
+        Kind::Undefined == arg ? is_instance_to_proc : __is_instance__(arg)
+      end
+
+      def or_nil(value)
+        return value if instance?(value)
+      end
+
+      def or_undefined(value)
+        or_nil(value) || Kind::Undefined
+      end
+
+      def __as_maybe__(value)
+        Kind::Maybe.new(or_nil(value))
+      end
+
+      def as_maybe_to_proc
+        @as_maybe_to_proc ||=
+          -> checker { -> value { checker.__as_maybe__(value) } }.call(self)
+      end
+
+      def as_maybe(value = Kind::Undefined)
+        return __as_maybe__(value) if Kind::Undefined != value
+
+        as_maybe_to_proc
+      end
+
+      def as_optional(value = Kind::Undefined)
+        as_maybe(value)
+      end
+    end
+  end
+end

data/lib/kind/error.rb

@@ -7,7 +7,7 @@ module Kind
     private_constant :UNDEFINED_OBJECT
 
     def initialize(arg, object = UNDEFINED_OBJECT)
-      if object == UNDEFINED_OBJECT
+      if UNDEFINED_OBJECT == object
         # Will be used when the exception was raised with a message. e.g:
         # raise Kind::Error, "some message"
         super(arg)

data/lib/kind/maybe.rb

@@ -2,9 +2,22 @@
 
 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 || value == Undefined
+        value.nil? || Undefined == value
       end
 
       def self.some?(value)
@@ -16,7 +29,7 @@ module Kind
       attr_reader :value
 
       def initialize(value)
-        @value = value
+        @value = value.kind_of?(Result) ? value.value : value
       end
 
       def value_or(method_name = Undefined, &block)
@@ -42,9 +55,9 @@ module Kind
       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 default == Undefined && !block
+        raise ArgumentError, INVALID_DEFAULT_ARG if Undefined == default && !block
 
-        Maybe::Value.some?(default) ? default : block.call
+        Undefined != default ? default : block.call
       end
 
       def none?; true; end
@@ -55,12 +68,14 @@ module Kind
 
       alias_method :then, :map
 
-      def try(method_name = Undefined, &block)
-        Kind.of.Symbol(method_name) if method_name != Undefined
+      def try!(method_name = Undefined, &block)
+        Kind.of.Symbol(method_name) if Undefined != method_name
 
-        nil
+        NONE_WITH_NIL_VALUE
       end
 
+      alias_method :try, :try!
+
       private_constant :INVALID_DEFAULT_ARG
     end
 
@@ -79,32 +94,90 @@ module Kind
       def map(&fn)
         result = fn.call(@value)
 
-        return NONE_WITH_NIL_VALUE if result == nil
-        return NONE_WITH_UNDEFINED_VALUE if result == Undefined
-
-        Some.new(result)
+        resolve(result)
       end
 
       alias_method :then, :map
 
-      def try(method_name = Undefined, *args, &block)
-        fn = method_name == Undefined ? block : Kind.of.Symbol(method_name).to_proc
+      def try!(method_name = Undefined, *args, &block)
+        Kind::Of::Symbol(method_name) if Undefined != method_name
 
-        result = args.empty? ? fn.call(value) : fn.call(*args.unshift(value))
+        __try__(method_name, args, block)
+      end
 
-        return result if Maybe::Value.some?(result)
+      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
+
+      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)
+        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.is_a?(Result) ? value.value : value)
+      result_type.new(value)
     end
 
-    def self.[](value);
+    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
   end
 
   Optional = Maybe
+
+  None = Maybe.none
+
+  def self.None
+    Kind::None
+  end
+
+  def self.Some(value)
+    Maybe.some(value)
+  end
+
+  def self.Maybe(kind)
+    Maybe::Typed.new(kind)
+  end
+
+  def self.Optional(kind)
+    Maybe::Typed.new(kind)
+  end
 end

data/lib/kind/types.rb

@@ -10,15 +10,25 @@ module Kind
       def self.%{method_name}(object = Undefined, options = Empty::HASH)
         default = options[:or]
 
-        return Kind::Of::%{kind_name} if object == Undefined && default.nil?
+        return Kind::Of::%{kind_name} if Undefined == object && default.nil?
 
-        Kind::Of.(::%{kind_name_to_check}, (object || default))
+        is_instance = Kind::Of::%{kind_name}.__is_instance__(object)
+
+        return object if is_instance
+
+        Kind::Of.(::%{kind_name_to_check}, object && default ? default : object || default)
+      end
+    RUBY
+
+    KIND_OF_IS = <<-RUBY
+      def self.%{method_name}?(*args)
+        Kind::Of::%{kind_name}.instance?(*args)
       end
     RUBY
 
     KIND_IS = <<-RUBY
       def self.%{method_name}(value = Undefined)
-        return Kind::Is::%{kind_name} if value == Undefined
+        return Kind::Is::%{kind_name} if Undefined == value
 
         Kind::Is.__call__(::%{kind_name_to_check}, value)
       end
@@ -88,11 +98,12 @@ module Kind
           kind_name = params[:kind_name]
           params[:kind_name_to_check] ||= kind_name
 
-          kind_checker = ::Module.new { extend Checkable }
+          kind_checker = ::Module.new { extend Checker::Protocol }
           kind_checker.module_eval("def self.__kind; #{params[:kind_name_to_check]}; end")
 
           kind_of_mod.instance_eval(KIND_OF % params)
           kind_of_mod.const_set(method_name, kind_checker)
+          kind_of_mod.instance_eval(KIND_OF_IS % params)
         end
 
         unless kind_is_mod.respond_to?(method_name)

data/lib/kind/undefined.rb

@@ -19,7 +19,7 @@ module Kind
     end
 
     def undefined.default(value, default)
-      return self if value != self
+      return self if self != value
 
       default.respond_to?(:call) ? default.call : default
     end

data/lib/kind/validator.rb

@@ -2,10 +2,10 @@
 
 module Kind
   module Validator
-    DEFAULT_STRATEGIES = Set.new(%w[instance_of kind_of is_a]).freeze
+    DEFAULT_STRATEGIES = Set.new(%w[instance_of kind_of]).freeze
 
     class InvalidDefinition < ArgumentError
-      OPTIONS = 'Options to define one: :of, :instance_of, :respond_to, :klass, :array_of or :array_with'.freeze
+      OPTIONS = 'Options to define one: :of, :is, :respond_to, :instance_of, :array_of or :array_with'.freeze
 
       def initialize(attribute)
         super "invalid type definition for :#{attribute} attribute. #{OPTIONS}"

data/lib/kind/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kind
-  VERSION = '1.9.0'
+  VERSION = '3.0.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kind
 version: !ruby/object:Gem::Version
-  version: 1.9.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-05-06 00:00:00.000000000 Z
+date: 2020-06-25 00:00:00.000000000 Z
 dependencies: []
 description: A simple type system (at runtime) for Ruby - free of dependencies.
 email:
@@ -32,6 +32,8 @@ files:
 - lib/kind/active_model/kind_validator.rb
 - lib/kind/active_model/validation.rb
 - lib/kind/checker.rb
+- lib/kind/checker/factory.rb
+- lib/kind/checker/protocol.rb
 - lib/kind/empty.rb
 - lib/kind/error.rb
 - lib/kind/is.rb