kind 1.8.0 → 1.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a0a88ddbce52eca41466b1c600f745b3c212e7833bbb178cabd86514e1011601
-  data.tar.gz: f96ab5843a3596a19863389dacda8e5865eff611163112f5092a3387ea6898a4
+  metadata.gz: 8d4f4be415e28c7f240a097a64626588e7b3c7bc8a70dbfd71bf2b5b426e016a
+  data.tar.gz: 7401efa30206d27d4f10608b5164d6c334d8da02e4652d8a7f156ee081f18ec5
 SHA512:
-  metadata.gz: 06af14f778ea084ae699a0c00e67d6808cbdace68a838cff42782fb7150f51e3524eba060784fd0cb540d08c2ecaa4b8135f75813e7d4223b87c9d1326831c05
-  data.tar.gz: 16e1e11bce9f67237a3f306b526f1b1f6564fe10eafcd22c2c90f2f18fa22077155a4372a9149d24dac02d266895e36c256a147a625f3592e8686bca974ab94b
+  metadata.gz: f672462c9e64afce93af792d179d1c6095003ade48329018f4e64eb0bae7fb825699f2350c643fa2a1f2a3ae2822b3cbb1e8444c3a423101a37beffadbd7a614
+  data.tar.gz: 890957443724fe3fdd7fec56d8b4a87c0e92f2793d26d298b8347b75e7091612e36a87d29bae70c7a789fe9e0750b366a4fe572104351e55b04903bbfcbffe03

data/.travis.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+
+bundle exec rake test
+
+ruby_v=$(ruby -v)
+
+ACTIVEMODEL_VERSION='3.2' bundle update && bundle exec rake test
+ACTIVEMODEL_VERSION='4.0' bundle update && bundle exec rake test
+ACTIVEMODEL_VERSION='4.1' bundle update && bundle exec rake test
+ACTIVEMODEL_VERSION='4.2' bundle update && bundle exec rake test
+ACTIVEMODEL_VERSION='5.0' bundle update && bundle exec rake test
+ACTIVEMODEL_VERSION='5.1' bundle update && bundle exec rake test
+
+if [[ ! $ruby_v =~ '2.2.0' ]]; then
+  ACTIVEMODEL_VERSION='5.2' bundle update && bundle exec rake test
+fi
+
+if [[ $ruby_v =~ '2.5.' ]] || [[ $ruby_v =~ '2.6.' ]] || [[ $ruby_v =~ '2.7.' ]]; then
+  ACTIVEMODEL_VERSION='6.0' bundle update && bundle exec rake test
+fi

data/.travis.yml

@@ -1,6 +1,8 @@
 ---
 language: ruby
 
+sudo: false
+
 cache: bundler
 
 rvm:
@@ -22,7 +24,7 @@ before_script:
   - chmod +x ./cc-test-reporter
   - "./cc-test-reporter before-build"
 
-script: bundle exec rake test
+script: "./.travis.sh"
 
 after_success:
   - "./cc-test-reporter after-build -t simplecov"

data/Gemfile

@@ -1,8 +1,33 @@
-source "https://rubygems.org"
+source 'https://rubygems.org'
 
-# Specify your gem's dependencies in kind.gemspec
-gemspec
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+activemodel_version = ENV['ACTIVEMODEL_VERSION']
+
+activemodel = case activemodel_version
+              when '3.2' then '3.2.22'
+              when '4.0' then '4.0.13'
+              when '4.1' then '4.1.16'
+              when '4.2' then '4.2.11'
+              when '5.0' then '5.0.7'
+              when '5.1' then '5.1.7'
+              when '5.2' then '5.2.4'
+              when '6.0' then '6.0.0'
+              end
+
+group :test do
+  if activemodel_version
+    gem 'activesupport', activemodel, require: false
+    gem 'activemodel', activemodel, require: false
+    gem 'minitest', activemodel_version < '4.1' ? '~> 4.2' : '~> 5.0'
+  else
+    gem 'minitest', '~> 5.0'
+  end
 
-gem "rake", "~> 12.0"
-gem "minitest", "~> 5.0"
-gem "simplecov", "~> 0.17.1"
+  gem 'simplecov', require: false
+end
+
+gem 'rake', '~> 13.0'
+
+# Specify your gem's dependencies in type_validator.gemspec
+gemspec

data/README.md

@@ -6,13 +6,13 @@
 
 # Kind <!-- omit in toc -->
 
-Basic type system for Ruby.
+A simple type system (at runtime) for Ruby - free of dependencies.
 
 **Motivation:**
 
 As a creator of Ruby gems, I have a common need that I have to handle in many of my projects: type checking of method arguments.
 
-One of the goals of this project is to do simple type checking like `"some string".is_a?(String)`, but, exposing useful abstractions to do it.
+One of the goals of this project is to do simple type checking like `"some string".is_a?(String)`, but, exposing useful abstractions to do it. e.g: [Kind.of.\<Type\> methods](#verifying-the-kind-of-some-object), [active model validations](#kindvalidator-activemodelvalidations), [maybe monad](#kindmaybe).
 
 ## Table of Contents <!-- omit in toc -->
 - [Required Ruby version](#required-ruby-version)
@@ -35,7 +35,11 @@ One of the goals of this project is to do simple type checking like `"some strin
   - [Kind::Maybe#try](#kindmaybetry)
   - [Kind.of.Maybe()](#kindofmaybe)
   - [Kind::Optional](#kindoptional)
-  - [Kind.of.<Type>.as_optional](#kindoftypeas_optional)
+  - [Kind.of.\<Type\>.as_optional](#kindoftypeas_optional)
+- [Kind::Validator (ActiveModel::Validations)](#kindvalidator-activemodelvalidations)
+  - [Usage](#usage-1)
+    - [Defining the default validation strategy](#defining-the-default-validation-strategy)
+    - [Using the `allow_nil` and `strict` options](#using-the-allow_nil-and-strict-options)
 - [Kind::Empty](#kindempty)
 - [Similar Projects](#similar-projects)
 - [Development](#development)
@@ -94,6 +98,17 @@ Kind.of.Boolean(true)  # true
 Kind.of.Boolean(false) # false
 ```
 
+> **Note:** `Kind.of.<Type>` supports the to_proc protocol.
+> But it won't perform a strict validation, instead, it will return true
+> when the value has the desired kind and false if it hasn't.
+
+```ruby
+collection = [ {number: 1}, 'number 2', {number: 3}, :number_4 ]
+
+collection
+  .select(&Kind.of.Hash) # [{number: 1}, {number: 3}]
+```
+
 When the verified value is nil, it is possible to define a default value with the same type to be returned.
 
 ```ruby
@@ -106,7 +121,7 @@ Kind.of.Hash(value, or: {})    # {}
 Kind.of.Boolean(nil, or: true) # true
 ```
 
-As an alternative syntax, you can use the `Kind::Of` instead of the `Kind.of` method. e.g: `Kind::Of::Hash('')`
+> **Note:** As an alternative syntax, you can use the `Kind::Of` instead of the `Kind.of` method. e.g: `Kind::Of::Hash('')`
 
 But if you don't need a strict type verification, use the `.or_nil` method.
 
@@ -133,19 +148,15 @@ Kind.of.Boolean.instance?(true)  # true
 Kind.of.Boolean.instance?(false) # true
 ```
 
-**Note:** When `.instance?` is called without an argument, it will return a lambda which will perform the kind verification.
+> **Note:** When `.instance?` is called without an argument,
+> it will return a lambda which will perform the kind verification.
 
 ```ruby
-collection = [
-  {number: 1},
-  'number 0',
-  {number: 2},
-  [0],
-]
+collection = [ {number: 1}, 'number 2', {number: 3}, :number_4 ]
 
 collection
   .select(&Kind.of.Hash.instance?)
-  .reduce(0) { |total, item| total + item.fetch(:number, 0) } # 3
+  .reduce(0) { |total, item| total + item.fetch(:number, 0) } # 4
 ```
 
 Also, there are aliases to perform the strict type verification. e.g:
@@ -548,7 +559,7 @@ puts result2 # 35
 
 [⬆️ Back to Top](#table-of-contents-)
 
-### Kind.of.<Type>.as_optional
+### Kind.of.\<Type\>.as_optional
 
 It is very common the need to avoid some computing when a method receives a wrong input.
 In these scenarios, you could check the given input type as optional and avoid unexpected behavior. e.g:
@@ -573,7 +584,7 @@ person_name(first_name: 'Rodrigo', last_name: 'Serradura') # "Rodrigo Serradura"
 # See below the previous implementation without using an optional.
 #
 def person_name(params)
-  if params.is_a?(Hash) && params.values_at(:first_name, :last_name).compact.size == 2
+  if params.kind_of?(Hash) && params.values_at(:first_name, :last_name).compact.size == 2
     "#{params[:first_name]} #{params[:last_name]}"
   else
     'John Doe'
@@ -586,12 +597,7 @@ end
 Let's see another example using a collection and how the method `.as_optional` works when it receives no argument.
 
 ```ruby
-collection = [
-  {number: 1},
-  'number 0',
-  {number: 2},
-  [0],
-]
+collection = [ {number: 1}, 'number 0', {number: 2}, [0] ]
 
 collection
   .select(&Kind.of.Hash.as_optional)
@@ -613,9 +619,9 @@ module PersonIntroduction
   extend self
 
   def call(params)
-    optional_params = Kind::Of::Hash.as_optional(params)
+    optional = Kind::Of::Hash.as_optional(params)
 
-    "Hi my name is #{full_name(optional_params)}, I'm #{age(optional_params)} years old."
+    "Hi my name is #{full_name(optional)}, I'm #{age(optional)} years old."
   end
 
   private
@@ -637,7 +643,7 @@ module PersonIntroduction
   extend self
 
   def call(params)
-    "Hi my name is #{full_name(params)}, I'm #{age(params)}"
+    "Hi my name is #{full_name(params)}, I'm #{age(params)} years old."
   end
 
   private
@@ -660,6 +666,139 @@ end
 
 [⬆️ Back to Top](#table-of-contents-)
 
+## Kind::Validator (ActiveModel::Validations)
+
+This module enables the capability to validate types via [active model validations](https://api.rubyonrails.org/classes/ActiveModel/Validations.html). e.g
+
+```ruby
+class Person
+  include ActiveModel::Validations
+
+  attr_accessor :first_name, :last_name
+
+  validates :first_name, :last_name, kind: String
+end
+```
+
+And to make use of it, you will need to do an explicitly require. e.g:
+
+```ruby
+# In some Gemfile
+gem 'kind', require: 'kind/active_model/validation'
+
+# In some .rb file
+require 'kind/active_model/validation'
+```
+
+### Usage
+
+**[Object#kind_of?](https://ruby-doc.org/core-2.6.4/Object.html#method-i-kind_of-3F)**
+
+```ruby
+validates :name, kind: { of: String }
+# or
+validates :name, kind: { is_a: String }
+
+# Use an array to verify if the attribute
+# is an instance of one of the classes/modules.
+
+validates :status, kind: { of: [String, Symbol]}
+# or
+validates :status, kind: { is_a: [String, Symbol]}
+```
+
+**[Object#instance_of?](https://ruby-doc.org/core-2.6.4/Object.html#method-i-instance_of-3F)**
+
+```ruby
+validates :name, kind: { instance_of: String }
+
+# or use an array to verify if the attribute
+# is an instance of one of the classes/modules.
+
+validates :name, kind: { instance_of: [String, Symbol] }
+```
+
+
+**[Object#respond_to?](https://ruby-doc.org/core-2.6.4/Object.html#method-i-respond_to-3F)**
+
+```ruby
+validates :handler, kind: { respond_to: :call }
+```
+
+**Class == Class || Class < Class**
+
+```ruby
+# Verifies if the attribute value is the class or a subclass.
+
+validates :handler, kind: { klass: Handler }
+
+# or use the :is option
+
+validates :handler, kind: { is: Handler }
+```
+
+**Array.new.all? { |item| item.kind_of?(Class) }**
+
+```ruby
+validates :account_types, kind: { array_of: String }
+
+# or use an array to verify if the attribute
+# is an instance of one of the classes
+
+validates :account_types, kind: { array_of: [String, Symbol] }
+```
+
+**Array.new.all? { |item| expected_values.include?(item) }**
+
+```ruby
+# Verifies if the attribute value
+# is an array with some or all the expected values.
+
+validates :account_types, kind: { array_with: ['foo', 'bar'] }
+```
+
+#### Defining the default validation strategy
+
+By default, you can define the attribute type directly (without a hash). e.g.
+
+```ruby
+validates :name, kind: String
+# or
+validates :name, kind: [String, Symbol]
+```
+
+To changes this behavior you can set another strategy to validates the attributes types:
+
+```ruby
+Kind::Validator.default_strategy = :instance_of
+
+# Tip: Create an initializer if you are in a Rails application.
+```
+
+And these are the available options to define the default strategy:
+-  `is_a`
+-  `kind_of` *(default)*
+-  `instance_of`
+
+#### Using the `allow_nil` and `strict` options
+
+You can use the `allow_nil` option with any of the kind validations. e.g.
+
+```ruby
+validates :name, kind: String, allow_nil: true
+```
+
+And as any active model validation, kind validations works with the `strict: true`
+option and with the `validates!` method. e.g.
+
+```ruby
+validates :first_name, kind: String, strict: true
+# or
+validates! :last_name, kind: String
+```
+
+[⬆️ Back to Top](#table-of-contents-)
+
 ## Kind::Empty
 
 When you define a method that has default arguments, for certain data types, you will always create a new object in memory. e.g:

data/kind.gemspec

@@ -6,8 +6,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ['Rodrigo Serradura']
   spec.email         = ['rodrigo.serradura@gmail.com']
 
-  spec.summary       = %q{Basic type system for Ruby.}
-  spec.description   = %q{Basic type system for Ruby (free of dependencies).}
+  spec.summary       = %q{A simple type system (at runtime) for Ruby.}
+  spec.description   = %q{A simple type system (at runtime) for Ruby - free of dependencies.}
   spec.homepage      = 'https://github.com/serradura/kind'
   spec.license       = 'MIT'
   spec.required_ruby_version = Gem::Requirement.new('>= 2.2.0')

data/lib/kind/active_model/kind_validator.rb

@@ -0,0 +1,76 @@
+# 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] || options[:is_a]
+      return is_class(expected, value) if expected = options[:is] || options[:klass]
+      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 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 kind_of(expected, value)
+      types = Array(expected)
+
+      return if types.any? { |type| value.is_a?(type) }
+
+      "must be a kind of: #{types.map { |klass| klass.name }.join(', ')}"
+    end
+
+    def is_class(klass, value)
+      return if Kind.of.Class(value) == Kind.of.Class(klass) || value < klass
+
+      "must be the class or a subclass of `#{klass.name}`"
+    end
+
+    def respond_to(method_name, value)
+      return if value.respond_to?(method_name)
+
+      "must respond to the method `#{method_name}`"
+    end
+
+    def array_of(expected, value)
+      types = Array(expected)
+
+      return if value.is_a?(Array) && !value.empty? && value.all? { |value| types.any? { |type| value.is_a?(type) } }
+
+      "must be an array of: #{types.map { |klass| klass.name }.join(', ')}"
+    end
+
+    def array_with(expected, value)
+      return if value.is_a?(Array) && !value.empty? && (value - Kind.of.Array(expected)).empty?
+
+      "must be an array with: #{expected.join(', ')}"
+    end
+end

data/lib/kind/active_model/validation.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'kind'
+require 'kind/validator'
+require 'active_model'
+require 'active_model/validations'
+require_relative 'kind_validator'

data/lib/kind/checker.rb

@@ -21,15 +21,15 @@ module Kind
     def instance?(value = Kind::Undefined)
       return __is_instance__(value) if value != Kind::Undefined
 
-      is_instance_to_proc
+      to_proc
     end
 
     def __is_instance__(value)
       value.is_a?(__kind)
     end
 
-    def is_instance_to_proc
-      @is_instance_to_proc ||=
+    def to_proc
+      @to_proc ||=
         -> checker { -> value { checker.__is_instance__(value) } }.call(self)
     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 object == UNDEFINED_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/validator.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Kind
+  module Validator
+    DEFAULT_STRATEGIES = Set.new(%w[instance_of kind_of is_a]).freeze
+
+    class InvalidDefinition < ArgumentError
+      OPTIONS = 'Options to define one: :of, :instance_of, :respond_to, :klass, :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 = '1.9.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: 1.9.0
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-05-04 00:00:00.000000000 Z
+date: 2020-05-06 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,6 +29,8 @@ 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/empty.rb
 - lib/kind/error.rb
@@ -36,7 +39,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 +66,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: []