rtype 0.6.3 → 0.6.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4edbfe36753db1a9d6a413bf31ccbed37c499df5
-  data.tar.gz: bfa734ba5689e7fca457b247e0f03dbcde507f8e
+  metadata.gz: 272dbec168fe9d7b24c0b73b7ba9096b4567cf40
+  data.tar.gz: 7a3323d9bf39563681e79f058f5f35cf595a8b1f
 SHA512:
-  metadata.gz: 60031209128806548c02edc8944e18a103c3f34a2ddca144dd53716050e939d9f7e4baf9ec7d33a3cf70da28ef156b5fcafd8177cddba6f11be6029cf0a4357a
-  data.tar.gz: 5f40a360733043804e02478347ec2a8a3c187b3d7ea943e31d470a7b4727fa4d89770ad93d1e08bb349550ea1a733fc4f2908d0776db4df777567dcc6083b8e1
+  metadata.gz: 6f10da6933a0dec59ff8b60d026b19fa365594721a7ff1e97b0729c93e3d2f5329c085056b72d172500e13345be26b897b945951998174c2c79b596cd726d132
+  data.tar.gz: 75e312d85ac8f8f7a8b84b780eb1eb8f2925fef496fbf5d299959fbb8414b74d14a5dcd1a5f87ae71680b2cca68d41b32fa4e02cebcc1d2811a23ffc887d8fe6

data/README.md

@@ -3,8 +3,6 @@
 [![Build Status](https://travis-ci.org/sputnikgugja/rtype.svg?branch=master)](https://travis-ci.org/sputnikgugja/rtype)
 [![Coverage Status](https://coveralls.io/repos/github/sputnikgugja/rtype/badge.svg?branch=master)](https://coveralls.io/github/sputnikgugja/rtype?branch=master)
 
-You can do the type checking in Ruby with this gem!
-
 ```ruby
 require 'rtype'
 
@@ -38,10 +36,12 @@ Test::invert(state: 0)
 
 ## Features
 - Provides type checking for arguments and return
-- Supports type checking for [keyword argument](#keyword-argument)
+- Provides type checking for [Keyword Argument](#keyword-argument)
 - [Type checking for hash elements](#hash)
-- [Duck typing](#duck-typing)
+- [Duck Typing](#duck-typing)
+- [Typed Array](#typed-array)
 - Custom type behavior
+- ...
 
 ## Installation
 Run `gem install rtype` or add `gem 'rtype'` to your `Gemfile`
@@ -55,7 +55,7 @@ require 'rtype'
 Rtype itself is pure-ruby gem. but you can make it more faster by using native extension.
 
 #### Native extension for MRI
-Just run
+Run
 ```ruby
 gem install rtype-native
 ```
@@ -63,10 +63,10 @@ or add to your `Gemfile`:
 ```ruby
 gem 'rtype-native'
 ```
-then, Rtype use it. (Do not `require 'rtype-native'`)
+then, Rtype uses it. (**Do not** `require 'rtype-native'`)
 
 #### Java extension for JRuby
-Just run
+Run
 ```ruby
 gem install rtype-java
 ```
@@ -74,67 +74,71 @@ or add to your `Gemfile`:
 ```ruby
 gem 'rtype-java'
 ```
-then, Rtype use it. (Do not `require 'rtype-java'`)
+then, Rtype uses it. (**Do not** `require 'rtype-java'`)
 
 ## Usage
 
 ### Supported Type Behaviors
 - `Module`
-  - A value must be an instance of the module/class or one of its superclasses (`is_a?`)
-  - `Any` : An alias for `BasicObject` (means Any Object)
+  - Value must be of this module (`is_a?`)
+  - `Any` : Alias for `BasicObject` (means Any Object)
   - `Boolean` : `true` or `false`
 - `Symbol`
-  - A value must have(respond to) a method with the name
+  - Value must respond to a method with this name
 - `Regexp`
-  - A value must match the regexp pattern
+  - Value must match this regexp pattern
 - `Range`
-  - A value must be included in the range
+  - Value must be included in this range
 - `Array`
-  - A value can be any type in the array
+  - Value can be any type in this array
 - `Hash`
-  - A value must be a hash
-  - Each of the value’s elements must be valid
-  - The value's key list must be equal to the hash's key list
+  - Value must be a hash
+  - Each of elements must be valid
+  - Value's keys must be equal to this hash's keys
   - **String** key is **different** from **symbol** key
   - vs. Keyword arguments (e.g.)
-    - `[{}]` is **not** hash type argument. it is keyword argument, because its position is last
-    - `[{}, {}]` is empty hash type argument (first), and one empty keyword argument (second)
-    - `[{}, {}, {}]` is two empty hash type argument (first, second), and empty keyword argument (last)
+    - `[{}]` is **not** hash argument. it is keyword argument, because its position is last
+    - `[{}, {}]` is hash argument (first) and keyword argument (second)
+    - `[{}, {}, {}]` is two hash argument (first, second) and keyword argument (last)
     - `{}` is keyword argument. non-keyword arguments must be in array.
   - Of course, nested hash works
   - Example: [Hash](#hash)
 - `Proc`
-  - A value must return a truthy value for the proc
+  - Value must return a truthy value for this proc
 - `true`
-  - A value must be **truthy**
+  - Value must be truthy
 - `false`
-  - A value must be **falsy**
+  - Value must be falsy
 - `nil`
-  - A value must be nil
+  - Value must be nil
   
 - Special Behaviors
-  - `Rtype::TypedArray` : Ensures a value is an array with the type (type signature)
+  - `TypedArray` : Ensures value is an array with the type (type signature)
     - `Array::of(type)` (recommended)
-    - `Rtype::Behavior::TypedArray[type]`
+    - or `Rtype::Behavior::TypedArray[type]`
     - Example: [TypedArray](#typed-array)
+  
+  - `Num, Int, Flo` : Numeric check
+    - `Num/Int/Flo >/>=/</<=/== x`
+    - e.g. `Num >= 2` means value must be a `Numeric` and >= 2
+    - e.g. `Int >= 2` means value must be a `Integer` and >= 2
+    - e.g. `Flo >= 2` means value must be a `Float` and >= 2
+  
+  - `And` : Ensures value is valid for all given types
+    - `Rtype::and(*types)`, `Rtype::Behavior::And[*types]`
+    - or `Array#comb`, `Object#and(*others)`
     
-  - `Rtype::and(*types)` : Ensures a value is valid for all the types
-    - `Rtype::and(*types)`, `Rtype::Behavior::And[*types]`, `include Rtype::Behavior; And[...]`
-    - `Array#comb`
-    - `Object#and(*others)`
-    
-  - `Rtype::xor(*types)` : Ensures a value is valid for only one of the types
-    - `Rtype::xor(*types)`, `Rtype::Behavior::Xor[*types]`, `include Rtype::Behavior; Xor[...]`
-    - `Object#xor(*others)`
+  - `Xor` : Ensures value is valid for only one of given types
+    - `Rtype::xor(*types)`, `Rtype::Behavior::Xor[*types]`
+    - or `Object#xor(*others)`
 
-  - `Rtype::not(*types)` : Ensures a value is not valid for all the types
-    - `Rtype::not(*types)`, `Rtype::Behavior::Not[*types]`, `include Rtype::Behavior; Not[...]`
-    - `Object#not`
+  - `Not` : Ensures value is not valid for all given types
+    - `Rtype::not(*types)`, `Rtype::Behavior::Not[*types]`
+    - or `Object#not`
 
-  - `Rtype::nilable(type)` : Ensures a value can be nil
-    - `Rtype::nilable(type)`, `Rtype::Behavior::Nilable[type]`, `include Rtype::Behavior; Nilable[...]`
-    - `Object#nilable`
-    - `Object#or_nil`
+  - `Nilable` : Value can be nil
+    - `Rtype::nilable(type)`, `Rtype::Behavior::Nilable[type]`
+    - or `Object#nilable`, `Object#or_nil`
 
   - You can create custom behavior by extending `Rtype::Behavior::Base`
 
@@ -234,7 +238,7 @@ def func(hash)
   puts hash[:msg]
 end
 
-# last hash is keyword arguments
+# last hash is not hash argument but keyword arguments
 func({}, {})
 # (Rtype::ArgumentTypeError) for 1st argument:
 # Expected {} to be a hash with 1 elements:
@@ -315,83 +319,18 @@ sum([1, 2, 3]) # => 6
 sum([1.0, 2, 3]) # => 6.0
 ```
 
-#### Combined type
-```ruby
-### TEST 1 ###
-require 'rtype'
-
-class Example
-  rtype [[String, :func].comb] => Any
-  # also works:
-  # rtype [Rtype::and(String, :func)] => Any
-  def and_test(arg)
-  end
-end
-
-Example.new.and_test("A string")
-# (Rtype::ArgumentTypeError) for 1st argument:
-# Expected "A string" to be a String
-# AND Expected "A string" to respond to :func
-```
-```ruby
-### TEST 2 ###
-# ... require rtype and define Example the same as above ...
-
-class String
-  def func; end
-end
-
-Example.new.and_test("A string") # Works!
-```
-
-#### Combined duck type
-Application of duck typing and combined type
-
-```ruby
-require 'rtype'
-
-module Game
-  ENEMY = [
-    :name,
-    :level
-  ].comb
-  
-  class Player < Entity
-    include Rtype::Behavior
-
-    rtype [ENEMY] => Any
-    def attacks(enemy)
-      "Player attacks '#{enemy.name}' (level #{enemy.level})!"
-    end
-  end
-  
-  class Slime < Entity
-    def name
-      "Powerful Slime"
-    end
-    
-    def level
-      123
-    end
-  end
-end
-
-Game::Player.new.attacks Game::Slime.new
-# Player attacks 'Powerful Slime' (level 123)!
-```
-
-#### Position of `rtype` && (specifying method name || annotation mode) && (symbol || string)
+#### `rtype`
 ```ruby
 require 'rtype'
 
 class Example
-  # Recommended. Annotation mode (no method name required)
+  # Recommended. With annotation mode (no method name required)
   rtype [Integer, String] => String
   def hello_world(i, str)
     puts "Hello? #{i} #{st
   end
 
-  # Works (specifying method name)
+  # Works (with specifying method name)
   rtype :hello_world, [Integer, String] => String
   def hello_world(i, str)
     puts "Hello? #{i} #{st
@@ -409,7 +348,7 @@ class Example
     puts "Hello? #{i} #{str}"
   end
 
-  # Doesn't work. `rtype` works for following (next) method
+  # Doesn't work. annotation mode works for following (next) method
   def hello_world_four(i, str)
     puts "Hello? #{i} #{str}"
   end
@@ -417,8 +356,8 @@ class Example
 end
 ```
 
-#### Outside of module (root)
-In the outside of module, annotation mode don't works. You must specify method name.
+#### In the outside of module (root)
+In the outside of module, annotation mode doesn't work. You must specify method name.
 
 ```ruby
 rtype :say, [String] => Any
@@ -429,11 +368,11 @@ end
 Test.new.say "Hello" # Hello
 
 rtype [String] => Any
-# (ArgumentError) Annotation mode not working out of module
+# (ArgumentError) Annotation mode not working in the outside of module
 ```
 
 #### Class method
-rtype annotation mode works both instance and class method
+Annotation mode works for both instance method and class method
 
 ```ruby
 require 'rtype'
@@ -463,8 +402,8 @@ end
 Example::say_ya(3) #say ya ya ya
 ```
 
-#### Checking type information
-This is just the 'information'
+#### Type information
+This is just 'information'
 
 Any change of this doesn't affect type checking
 

data/Rakefile

@@ -3,10 +3,10 @@ require "rspec/core/rake_task"
 # Default pattern is 'spec/**{,/*/**}/*_spec.rb'
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
+task :default => [:spec]
 
 # Benchmark
 desc "Compare with pure ruby and other gems"
 task :benchmark do
   ruby "benchmark/benchmark.rb"
-end
+end

data/lib/rtype/behavior/core_ext.rb

@@ -1,28 +1,160 @@
 class Object
+	# @return [Rtype::Behavior::And]
 	def and(*others)
 		::Rtype::and(self, *others)
 	end
 
+	# @return [Rtype::Behavior::Nilable]
 	def nilable
 		::Rtype::nilable(self)
 	end
 	alias_method :or_nil, :nilable
 
+	# @return [Rtype::Behavior::Not]
 	def not
 		::Rtype::not(self)
 	end
 
+	# @return [Rtype::Behavior::Xor]
 	def xor(*others)
 		::Rtype::xor(self, *others)
 	end
 end
 
 class Array
+	# @return [Rtype::Behavior::TypedArray]
 	def self.of(type_sig)
 		::Rtype::Behavior::TypedArray.new(type_sig)
 	end
 	
+	# @return [Rtype::Behavior::And]
 	def comb
 		::Rtype::Behavior::And[*self]
 	end
 end
+
+class Num
+	# @param [Numeric] x
+	# @return [Proc]
+	# @example Value must be a Numeric and > 2
+	#   rtype [Num > 2] => Any
+	def self.>(x)
+		lambda { |obj| obj.is_a?(Numeric) && obj > x }
+	end
+
+	# @param [Numeric] x
+	# @return [Proc]
+	# @example Value must be a Numeric and > 2
+	#   rtype [Num > 2] => Any
+	def self.>=(x)
+		lambda { |obj| obj.is_a?(Numeric) && obj >= x }
+	end
+
+	# @param [Numeric] x
+	# @return [Proc]
+	# @example Value must be a Numeric and > 2
+	#   rtype [Num > 2] => Any
+	def self.<(x)
+		lambda { |obj| obj.is_a?(Numeric) && obj < x }
+	end
+
+	# @param [Numeric] x
+	# @return [Proc]
+	# @example Value must be a Numeric and > 2
+	#   rtype [Num > 2] => Any
+	def self.<=(x)
+		lambda { |obj| obj.is_a?(Numeric) && obj <= x }
+	end
+	
+	# @param [Numeric] x
+	# @return [Proc]
+	# @example Value must be a Numeric and > 2
+	#   rtype [Num > 2] => Any
+	def self.==(x)
+		lambda { |obj| obj.is_a?(Numeric) && obj == x }
+	end
+end
+
+class Int
+	# @param [Numeric] x
+	# @return [Proc]
+	# @example Value must be a Integer and > 2
+	#   rtype [Int > 2] => Any
+	def self.>(x)
+		lambda { |obj| obj.is_a?(Integer) && obj > x }
+	end
+
+	# @param [Numeric] x
+	# @return [Proc]
+	# @example Value must be a Integer and > 2
+	#   rtype [Int > 2] => Any
+	def self.>=(x)
+		lambda { |obj| obj.is_a?(Integer) && obj >= x }
+	end
+
+	# @param [Numeric] x
+	# @return [Proc]
+	# @example Value must be a Integer and > 2
+	#   rtype [Int > 2] => Any
+	def self.<(x)
+		lambda { |obj| obj.is_a?(Integer) && obj < x }
+	end
+
+	# @param [Numeric] x
+	# @return [Proc]
+	# @example Value must be a Integer and > 2
+	#   rtype [Int > 2] => Any
+	def self.<=(x)
+		lambda { |obj| obj.is_a?(Integer) && obj <= x }
+	end
+	
+	# @param [Numeric] x
+	# @return [Proc]
+	# @example Value must be a Integer and > 2
+	#   rtype [Int > 2] => Any
+	def self.==(x)
+		lambda { |obj| obj.is_a?(Integer) && obj == x }
+	end
+end
+
+class Flo
+	# @param [Numeric] x
+	# @return [Proc]
+	# @example Value must be a Float and > 2
+	#   rtype [Flo > 2] => Any
+	def self.>(x)
+		lambda { |obj| obj.is_a?(Float) && obj > x }
+	end
+
+	# @param [Numeric] x
+	# @return [Proc]
+	# @example Value must be a Float and > 2
+	#   rtype [Flo > 2] => Any
+	def self.>=(x)
+		lambda { |obj| obj.is_a?(Float) && obj >= x }
+	end
+
+	# @param [Numeric] x
+	# @return [Proc]
+	# @example Value must be a Float and > 2
+	#   rtype [Flo > 2] => Any
+	def self.<(x)
+		lambda { |obj| obj.is_a?(Float) && obj < x }
+	end
+
+	# @param [Numeric] x
+	# @return [Proc]
+	# @example Value must be a Float and > 2
+	#   rtype [Flo > 2] => Any
+	def self.<=(x)
+		lambda { |obj| obj.is_a?(Float) && obj <= x }
+	end
+	
+	# @param [Numeric] x
+	# @return [Proc]
+	# @example Value must be a Float and > 2
+	#   rtype [Flo > 2] => Any
+	def self.==(x)
+		lambda { |obj| obj.is_a?(Float) && obj == x }
+	end
+end

data/lib/rtype/version.rb

@@ -1,5 +1,5 @@
 module Rtype
-	VERSION = "0.6.3".freeze
+	VERSION = "0.6.4".freeze
 	# rtype java extension version. nil If the extension is not used
 	JAVA_EXT_VERSION = nil unless defined?(JAVA_EXT_VERSION)
 	# rtype c extension version. nil If the extension is not used

data/lib/rtype.rb

@@ -1,17 +1,20 @@
-if defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
-	begin
-		require 'java'
-		require 'rtype/rtype_java'
-		# puts "Rtype with Java extension"
-	rescue LoadError
-		# puts "Rtype without native extension"
-	end
-else
-	begin
-		require "rtype/rtype_native"
-		# puts "Rtype with C native extension"
-	rescue LoadError
-		# puts "Rtype without native extension"
+if defined?(RUBY_ENGINE)
+	case RUBY_ENGINE
+	when "jruby"
+		begin
+			require 'java'
+			require 'rtype/rtype_java'
+			# puts "Rtype with Java extension"
+		rescue LoadError
+			# puts "Rtype without native extension"
+		end
+	when "ruby"
+		begin
+			require "rtype/rtype_native"
+			# puts "Rtype with C native extension"
+		rescue LoadError
+			# puts "Rtype without native extension"
+		end
 	end
 end
 
@@ -322,7 +325,7 @@ module Rtype
 	# Validates arguments
 	# 
 	# @param [Array] expected_args A type signature for non-keyword arguments
-	# @param args
+	# @param [Array] args
 	# @return [void]
 	# 
 	# @raise [TypeSignatureError] If expected_args is invalid
@@ -346,9 +349,9 @@ module Rtype
 	# Validates arguments and keyword arguments
 	# 
 	# @param [Array] expected_args A type signature for non-keyword arguments
-	# @param args Arguments
+	# @param [Array] args Arguments
 	# @param [Hash] expected_kwargs A type signature for keyword arguments
-	# @param kwargs Keword arguments
+	# @param [Hash] kwargs Keword arguments
 	# @return [void]
 	# 
 	# @raise [TypeSignatureError] If expected_args or expected_kwargs are invalid

data/spec/rtype_spec.rb

@@ -474,6 +474,68 @@ describe Rtype do
 					instance.return_nil([])
 				end
 			end
+			
+			describe 'Numeric check' do
+				it 'Num (Numeric)' do
+					klass.send :rtype, :return_nil, [Num >= 0] => Any
+					expect { instance.return_nil("hello") }.to raise_error Rtype::ArgumentTypeError
+					expect { instance.return_nil(-1) }.to raise_error Rtype::ArgumentTypeError
+					instance.return_nil(2)
+					instance.return_nil(2.0)
+					
+					klass.send :rtype, :return_nil, [Num > 0] => Any
+					expect { instance.return_nil("non numeric") }.to raise_error Rtype::ArgumentTypeError
+					expect { instance.return_nil(0) }.to raise_error Rtype::ArgumentTypeError
+					
+					klass.send :rtype, :return_nil, [Num < 0] => Any
+					expect { instance.return_nil("non numeric") }.to raise_error Rtype::ArgumentTypeError
+					expect { instance.return_nil(0) }.to raise_error Rtype::ArgumentTypeError
+					
+					klass.send :rtype, :return_nil, [Num <= 0] => Any
+					expect { instance.return_nil("non numeric") }.to raise_error Rtype::ArgumentTypeError
+					expect { instance.return_nil(1) }.to raise_error Rtype::ArgumentTypeError
+				end
+				
+				it 'Int (Integer)' do
+					klass.send :rtype, :return_nil, [Int >= 0] => Any
+					expect { instance.return_nil("hello") }.to raise_error Rtype::ArgumentTypeError
+					expect { instance.return_nil(1.0) }.to raise_error Rtype::ArgumentTypeError
+					expect { instance.return_nil(-1) }.to raise_error Rtype::ArgumentTypeError
+					instance.return_nil(2)
+					
+					klass.send :rtype, :return_nil, [Int > 0] => Any
+					expect { instance.return_nil(1.0) }.to raise_error Rtype::ArgumentTypeError
+					expect { instance.return_nil(0) }.to raise_error Rtype::ArgumentTypeError
+					
+					klass.send :rtype, :return_nil, [Int < 0] => Any
+					expect { instance.return_nil(-1.0) }.to raise_error Rtype::ArgumentTypeError
+					expect { instance.return_nil(0) }.to raise_error Rtype::ArgumentTypeError
+					
+					klass.send :rtype, :return_nil, [Int <= 0] => Any
+					expect { instance.return_nil(0.0) }.to raise_error Rtype::ArgumentTypeError
+					expect { instance.return_nil(1) }.to raise_error Rtype::ArgumentTypeError
+				end
+				
+				it 'Flo (Float)' do
+					klass.send :rtype, :return_nil, [Flo >= 0] => Any
+					expect { instance.return_nil("hello") }.to raise_error Rtype::ArgumentTypeError
+					expect { instance.return_nil(1) }.to raise_error Rtype::ArgumentTypeError
+					expect { instance.return_nil(-1.0) }.to raise_error Rtype::ArgumentTypeError
+					instance.return_nil(2.0)
+					
+					klass.send :rtype, :return_nil, [Flo > 0] => Any
+					expect { instance.return_nil(1) }.to raise_error Rtype::ArgumentTypeError
+					expect { instance.return_nil(0.0) }.to raise_error Rtype::ArgumentTypeError
+					
+					klass.send :rtype, :return_nil, [Flo < 0] => Any
+					expect { instance.return_nil(-1) }.to raise_error Rtype::ArgumentTypeError
+					expect { instance.return_nil(0.0) }.to raise_error Rtype::ArgumentTypeError
+					
+					klass.send :rtype, :return_nil, [Flo <= 0] => Any
+					expect { instance.return_nil(0) }.to raise_error Rtype::ArgumentTypeError
+					expect { instance.return_nil(1.0) }.to raise_error Rtype::ArgumentTypeError
+				end
+			end
 		end
 	end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rtype
 version: !ruby/object:Gem::Version
-  version: 0.6.3
+  version: 0.6.4
 platform: ruby
 authors:
 - Sputnik Gugja
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-21 00:00:00.000000000 Z
+date: 2016-07-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '11.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '11.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement