kind 3.0.1 → 5.1.0

data/lib/kind/{undefined.rb → core/undefined.rb}

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-
 module Kind
   Undefined = Object.new.tap do |undefined|
     def undefined.inspect
@@ -19,9 +18,12 @@ module Kind
     end
 
     def undefined.default(value, default)
-      return self if self != value
+      return value if self != value
 
       default.respond_to?(:call) ? default.call : default
     end
+
+    undefined.inspect
+    undefined.freeze
   end
 end

data/lib/kind/core/utils/kind.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Kind
+  module KIND
+    def self.null?(value) # :nodoc:
+      value.nil? || Undefined == value
+    end
+
+    def self.of?(kind, values) # :nodoc:
+      of_kind = -> value { kind === value }
+
+      values.empty? ? of_kind : values.all?(&of_kind)
+    end
+
+    def self.of!(kind, value, kind_name = nil) # :nodoc:
+      return value if kind === value
+
+      error!(kind_name || kind.name, value)
+    end
+
+    def self.error!(kind_name, value) # :nodoc:
+      raise Error.new(kind_name, value)
+    end
+
+    def self.of_class?(value) # :nodoc:
+      value.kind_of?(::Class)
+    end
+
+    def self.of_module?(value) # :nodoc:
+      ::Module == value || (value.kind_of?(::Module) && !of_class?(value))
+    end
+
+    def self.of_module_or_class!(value) # :nodoc:
+      of!(::Module, value, 'Module/Class')
+    end
+
+    def self.respond_to!(method_name, value) # :nodoc:
+      return value if value.respond_to?(method_name)
+
+      raise Error.new("expected #{value} to respond to :#{method_name}")
+    end
+
+    def self.is?(expected, value) # :nodoc:
+      is!(of_module_or_class!(expected), value)
+    end
+
+    def self.is!(expected_kind, value) # :nodoc:
+      kind = of_module_or_class!(value)
+
+      if of_class?(kind)
+        kind <= expected_kind || expected_kind == ::Class
+      else
+        kind == expected_kind || kind.kind_of?(expected_kind)
+      end
+    end
+
+    def self.value(kind, arg, default) # :nodoc:
+      kind === arg ? arg : default
+    end
+  end
+end

data/lib/kind/core/utils/undefined.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Kind
+  UNDEFINED = Object.new.freeze
+
+  private_constant :UNDEFINED
+end

data/lib/kind/validator.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
+require 'kind'
+
 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,108 @@ 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)
+      types = Array(expected)
+
+      return if types.any? { |type| type === value }
+
+      "must be a kind of: #{types.map { |type| type.name }.join(', ')}"
+    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::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::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

data/lib/kind/version.rb

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

data/test.sh

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kind
 version: !ruby/object:Gem::Version
-  version: 3.0.1
+  version: 5.1.0
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-06-25 00:00:00.000000000 Z
+date: 2021-02-24 00:00:00.000000000 Z
 dependencies: []
 description: A simple type system (at runtime) for Ruby - free of dependencies.
 email:
@@ -18,8 +18,10 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".tool-versions"
 - ".travis.sh"
 - ".travis.yml"
+- CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
 - LICENSE.txt
@@ -29,18 +31,51 @@ 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
-- lib/kind/maybe.rb
-- lib/kind/of.rb
-- lib/kind/types.rb
-- lib/kind/undefined.rb
+- lib/kind/core.rb
+- lib/kind/core/dig.rb
+- lib/kind/core/empty.rb
+- lib/kind/core/empty/constant.rb
+- lib/kind/core/error.rb
+- lib/kind/core/maybe.rb
+- lib/kind/core/maybe/none.rb
+- lib/kind/core/maybe/result.rb
+- lib/kind/core/maybe/some.rb
+- lib/kind/core/maybe/typed.rb
+- lib/kind/core/maybe/wrappable.rb
+- lib/kind/core/presence.rb
+- lib/kind/core/try.rb
+- lib/kind/core/type_checker.rb
+- lib/kind/core/type_checkers.rb
+- lib/kind/core/type_checkers/custom/boolean.rb
+- lib/kind/core/type_checkers/custom/callable.rb
+- lib/kind/core/type_checkers/custom/lambda.rb
+- lib/kind/core/type_checkers/ruby/array.rb
+- lib/kind/core/type_checkers/ruby/class.rb
+- lib/kind/core/type_checkers/ruby/comparable.rb
+- lib/kind/core/type_checkers/ruby/enumerable.rb
+- lib/kind/core/type_checkers/ruby/enumerator.rb
+- lib/kind/core/type_checkers/ruby/file.rb
+- lib/kind/core/type_checkers/ruby/float.rb
+- lib/kind/core/type_checkers/ruby/hash.rb
+- lib/kind/core/type_checkers/ruby/integer.rb
+- lib/kind/core/type_checkers/ruby/io.rb
+- lib/kind/core/type_checkers/ruby/method.rb
+- lib/kind/core/type_checkers/ruby/module.rb
+- lib/kind/core/type_checkers/ruby/numeric.rb
+- lib/kind/core/type_checkers/ruby/proc.rb
+- lib/kind/core/type_checkers/ruby/queue.rb
+- lib/kind/core/type_checkers/ruby/range.rb
+- lib/kind/core/type_checkers/ruby/regexp.rb
+- lib/kind/core/type_checkers/ruby/string.rb
+- lib/kind/core/type_checkers/ruby/struct.rb
+- lib/kind/core/type_checkers/ruby/symbol.rb
+- lib/kind/core/type_checkers/ruby/time.rb
+- lib/kind/core/type_checkers/stdlib/open_struct.rb
+- lib/kind/core/type_checkers/stdlib/set.rb
+- lib/kind/core/undefined.rb
+- lib/kind/core/utils/kind.rb
+- lib/kind/core/utils/undefined.rb
 - lib/kind/validator.rb
 - lib/kind/version.rb
 - test.sh
@@ -58,14 +93,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.2.0
+      version: 2.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: A simple type system (at runtime) for Ruby.

data/lib/kind/active_model/kind_validator.rb

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-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)
-      types = Array(expected)
-
-      return if types.any? { |type| value.kind_of?(type) }
-
-      "must be a kind of: #{types.map { |klass| klass.name }.join(', ')}"
-    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) }.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(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(method_name, value)
-      return if value.respond_to?(method_name)
-
-      "must respond to the method `#{method_name}`"
-    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? { |value| types.any? { |type| value.kind_of?(type) } }
-
-      "must be an array of: #{types.map { |klass| klass.name }.join(', ')}"
-    end
-end

data/lib/kind/checker.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require 'kind/checker/factory'
-require 'kind/checker/protocol'
-module Kind
-  class Checker
-    include Protocol
-
-    attr_reader :__kind
-
-    def initialize(kind)
-      @__kind = kind
-    end
-  end
-end