kind 1.8.0 → 2.3.0

data/lib/kind/checker/factory.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+module Kind
+  class Checker
+    class Factory
+      include Singleton
+
+      def self.create(kind)
+        instance.create(kind)
+      end
+
+      def initialize
+        @__checkers__ = {}
+      end
+
+      MODULE_OR_CLASS = 'Module/Class'.freeze
+
+      private_constant :MODULE_OR_CLASS
+
+      def create(kind)
+        @__checkers__[kind] ||= begin
+          kind_name = kind.name
+
+          if Kind::Of.const_defined?(kind_name, false)
+            Kind::Of.const_get(kind_name)
+          else
+            Kind::Checker.new(Kind::Of.(Module, kind, MODULE_OR_CLASS))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -2,8 +2,18 @@
 
 module Kind
   class Error < TypeError
-    def initialize(kind_name, object)
-      super("#{object.inspect} expected to be a kind of #{kind_name}")
+    UNDEFINED_OBJECT = Object.new
+
+    private_constant :UNDEFINED_OBJECT
+
+    def initialize(arg, 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)
+      else
+        super("#{object.inspect} expected to be a kind of #{arg}")
+      end
     end
   end
 end

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
@@ -56,7 +69,7 @@ module Kind
       alias_method :then, :map
 
       def try(method_name = Undefined, &block)
-        Kind.of.Symbol(method_name) if method_name != Undefined
+        Kind.of.Symbol(method_name) if Undefined != method_name
 
         nil
       end
@@ -79,8 +92,9 @@ 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
+        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
@@ -88,7 +102,7 @@ module Kind
       alias_method :then, :map
 
       def try(method_name = Undefined, *args, &block)
-        fn = method_name == Undefined ? block : Kind.of.Symbol(method_name).to_proc
+        fn = Undefined == method_name ? block : Kind.of.Symbol(method_name).to_proc
 
         result = args.empty? ? fn.call(value) : fn.call(*args.unshift(value))
 
@@ -98,13 +112,49 @@ module Kind
 
     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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Kind
+  module Validator
+    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
+
+      def initialize(attribute)
+        super "invalid type definition for :#{attribute} attribute. #{OPTIONS}"
+      end
+
+      private_constant :OPTIONS
+    end
+
+    class InvalidDefaultStrategy < ArgumentError
+      OPTIONS =
+        DEFAULT_STRATEGIES.map { |option| ":#{option}" }.join(', ')
+
+      def initialize(option)
+        super "#{option.inspect} is an invalid option. Please use one of these: #{OPTIONS}"
+      end
+
+      private_constant :OPTIONS
+    end
+
+    def self.default_strategy
+      @default_strategy ||= :kind_of
+    end
+
+    def self.default_strategy=(option)
+      if DEFAULT_STRATEGIES.member?(String(option))
+        @default_strategy = option.to_sym
+      else
+        raise InvalidDefaultStrategy.new(option)
+      end
+    end
+  end
+end

data/lib/kind/version.rb

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

data/test.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+
+bundle
+
+rm Gemfile.lock
+
+source $(dirname $0)/.travis.sh
+
+rm Gemfile.lock
+
+bundle

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: kind
 version: !ruby/object:Gem::Version
-  version: 1.8.0
+  version: 2.3.0
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-05-04 00:00:00.000000000 Z
+date: 2020-06-25 00:00:00.000000000 Z
 dependencies: []
-description: Basic type system for Ruby (free of dependencies).
+description: A simple type system (at runtime) for Ruby - free of dependencies.
 email:
 - rodrigo.serradura@gmail.com
 executables: []
@@ -18,6 +18,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".travis.sh"
 - ".travis.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
@@ -28,7 +29,11 @@ files:
 - bin/setup
 - kind.gemspec
 - lib/kind.rb
+- 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
@@ -36,7 +41,9 @@ files:
 - lib/kind/of.rb
 - lib/kind/types.rb
 - lib/kind/undefined.rb
+- lib/kind/validator.rb
 - lib/kind/version.rb
+- test.sh
 homepage: https://github.com/serradura/kind
 licenses:
 - MIT
@@ -61,5 +68,5 @@ requirements: []
 rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
-summary: Basic type system for Ruby.
+summary: A simple type system (at runtime) for Ruby.
 test_files: []