rtype 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 705c8cfc434a65a0d0be00560f97a75380443e5b
-  data.tar.gz: 8cb8cf5be58792d7b434f650abeb2c6022f2b1c5
+  metadata.gz: 545e8dc3a8ac3c44aa68d87126c6dbf8d57302bb
+  data.tar.gz: f3d34bb1fb2ecd9cb7f4b0a9315d14fa5a726940
 SHA512:
-  metadata.gz: 0ed1a39880ce0949e075747d0fcd92c793add8fe09dbf227a5a188474ac8fa14f0da93c34391b350b26af451717de9b9a058a66d6d92890c24bbe4b7b1e7e46e
-  data.tar.gz: 56bcb6c32091b30d918966f018c662595f699b4c87aee01a2291536d9b7c59111892deb52578c09958ae59f1fb7758454ca02a20d0b79c9790ddf9f47e0fd075
+  metadata.gz: e39262cd99fdf372ed953a2e4c09cafcc09b7d236946d66d3d37acd03f432e72a0de4f7aaf3cd7d74e0d8997ef0178846ba35c040e209acc08a4a60b4e43f7b5
+  data.tar.gz: e31ad200c1d08bb0077ef429cfa4d813bff2732f04f705eafc0ce4166c9dbbf0f82581a9e4655500fdb35ec09721cc22c3d29104fccf40c789fd2cdc7bd3f8b2

data/README.md

@@ -37,9 +37,8 @@ Test::invert(state: 0)
   - If Java extension is used, otherwise it is not required
 
 ## Features
-- Provide type checking for arguments and return
-- Support type checking for [keyword argument](#keyword-argument)
-- [Type checking for array elements](#array)
+- Provides type checking for arguments and return
+- Supports type checking for [keyword argument](#keyword-argument)
 - [Type checking for hash elements](#hash)
 - [Duck typing](#duck-typing)
 - Custom type behavior
@@ -81,28 +80,23 @@ then, Rtype use it. (Do not `require 'rtype-java'`)
 
 ### Supported Type Behaviors
 - `Module`
-  - Value must be an instance of this module/class or one of its superclasses
+  - Value must be an instance of the module/class or one of its superclasses
   - `Any` : An alias for `BasicObject` (means Any Object)
   - `Boolean` : `true` or `false`
 - `Symbol`
-  - Value must have(respond to) a method with this name
+  - Value must have(respond to) a method with the name
 - `Regexp`
-  - Value must match this regexp pattern
+  - Value must match the regexp pattern
 - `Range`
-  - Value must be included in this range
-- `Array` (tuple)
-  - Value must be an array
-  - Each of value's elements must be valid
-  - Value's length must be equal to the array's length
-  - Of course, nested array works
-  - Example: [Array](#array)
-  - This can be used as a tuple
+  - Value must be included in the range
+- `Array`
+  - Value can be any type in the array
 - `Hash`
   - Value must be an hash
   - Each of value’s elements must be valid
   - Value's key list must be equal to the hash's key list
   - **String** key is **different** from **symbol** key
-  - vs Keyword arguments
+  - 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)
@@ -110,44 +104,31 @@ then, Rtype use it. (Do not `require 'rtype-java'`)
   - Of course, nested hash works
   - Example: [Hash](#hash)
 - `Proc`
-  - Value must return a truthy value for this proc
+  - Value must return a truthy value for the proc
 - `true`
   - Value must be **truthy**
 - `false`
   - Value must be **falsy**
 - `nil`
-  - Only available for **return type**. void return type in other languages
+  - Value must be nil
 - Special Behaviors
   - `Rtype::and(*types)` : Ensure value is valid for all the types
-    - `Rtype::and(*types)`
-    - `Rtype::Behavior::And[*types]`
-    - `include Rtype::Behavior; And[...]`
-    - `obj.and(*others)` (core extension)
-
-  - `Rtype::or(*types)` : Ensure value is valid for at least one of the types
-    - `Rtype::or(*types)`
-    - `Rtype::Behavior::Or[*types]`
-    - `include Rtype::Behavior; Or[...]`
-    - `obj.or(*others)` (core extension)
-
+    - `Rtype::and(*types)`, `Rtype::Behavior::And[*types]`, `include Rtype::Behavior; And[...]`
+    - `Array#comb`
+    - `Object#and(*others)`
+    
   - `Rtype::xor(*types)` : Ensure value is valid for only one of the types
-    - `Rtype::xor(*types)`
-    - `Rtype::Behavior::Xor[*types]`
-    - `include Rtype::Behavior; Xor[...]`
-    - `obj.xor(*others)` (core extension)
+    - `Rtype::xor(*types)`, `Rtype::Behavior::Xor[*types]`, `include Rtype::Behavior; Xor[...]`
+    - `Object#xor(*others)`
 
   - `Rtype::not(*types)` : Ensure value is not valid for all the types
-    - `Rtype::not(*types)`
-    - `Rtype::Behavior::Not[*types]`
-    - `include Rtype::Behavior; Not[...]`
-    - `obj.not` (core extension)
+    - `Rtype::not(*types)`, `Rtype::Behavior::Not[*types]`, `include Rtype::Behavior; Not[...]`
+    - `Object#not`
 
   - `Rtype::nilable(type)` : Ensure value can be nil
-    - `Rtype::nilable(type)`
-    - `Rtype::Behavior::Nilable[type]`
-    - `include Rtype::Behavior; Nilable[...]`
-    - `obj.nilable` (core extension)
-    - `obj.or_nil` (core extension)
+    - `Rtype::nilable(type)`, `Rtype::Behavior::Nilable[type]`, `include Rtype::Behavior; Nilable[...]`
+    - `Object#nilable`
+    - `Object#or_nil`
 
   - You can create custom behavior by extending `Rtype::Behavior::Base`
 
@@ -224,33 +205,19 @@ Duck.new.says("2") # duck: quack quack
 ```
 
 #### Array
-This can be used as a tuple.
-
 ```ruby
-rtype :func, [[Numeric, Numeric]] => Any
-def func(arr)
-  puts "Your location is (#{arr[0]}, #{arr[1]}). I will look for you. I will find you"
+rtype :ruby!, [[String, Integer]] => Any
+def ruby!(arg)
+	puts "ruby!"
 end
 
-func [1, "str"]
-# (Rtype::ArgumentTypeError) for 1st argument:
-# Expected [1, "str"] to be an array with 2 elements:
-# - [0] index : Expected 1 to be a Numeric
-# - [1] index : Expected "str" to be a Numeric
-
-func [1, 2, 3]
-# (Rtype::ArgumentTypeError) for 1st argument:
-# Expected [1, 2, 3] to be an array with 2 elements:
-# - [0] index : Expected 1 to be a Numeric
-# - [1] index : Expected 2 to be a Numeric
+func("str") # ruby!
+func(123) # ruby!
 
-func [1]
+func(nil)
 # (Rtype::ArgumentTypeError) for 1st argument:
-# Expected [1] to be an array with 2 elements:
-# - [0] index : Expected 1 to be a Numeric
-# - [1] index : Expected nil to be a Numeric
-
-func [1, 2] # Your location is (1, 2). I will look for you. I will find you
+# Expected nil to be a String
+# OR Expected nil to be a Integer
 ```
 
 #### Hash
@@ -316,7 +283,7 @@ Example.new.value
 require 'rtype'
 
 class Example
-  rtype [String.and(:func)] => Any
+  rtype [[String, :func].comb] => Any
   # also works:
   # rtype [Rtype::and(String, :func)] => Any
   def and_test(arg)
@@ -349,12 +316,12 @@ module Game
   ENEMY = [
     :name,
     :level
-  ]
+  ].comb
   
   class Player < Entity
     include Rtype::Behavior
 
-    rtype [And[*ENEMY]] => Any
+    rtype [ENEMY] => Any
     def attacks(enemy)
       "Player attacks '#{enemy.name}' (level #{enemy.level})!"
     end
@@ -565,4 +532,4 @@ Sputnik Gugja (sputnikgugja@gmail.com)
 ## License
 MIT license (@ Sputnik Gugja)
 
-See `LICENSE` file.
+See `LICENSE` file.

data/lib/rtype/behavior/core_ext.rb

@@ -12,11 +12,7 @@ class Object
 		::Rtype::not(self)
 	end
 
-	def or(*others)
-		::Rtype::or(self, *others)
-	end
-
 	def xor(*others)
 		::Rtype::xor(self, *others)
 	end
-end
+end

data/lib/rtype/behavior.rb

@@ -4,9 +4,8 @@ module Rtype
 end
 
 require_relative 'behavior/base'
-require_relative 'behavior/or'
 require_relative 'behavior/and'
 require_relative 'behavior/xor'
 require_relative 'behavior/not'
 require_relative 'behavior/nilable'
-require_relative 'behavior/core_ext'
+require_relative 'behavior/core_ext'

data/lib/rtype/core_ext.rb

@@ -83,17 +83,8 @@ class Method
 	end
 end
 
-class Fixnum
-	def ordinalize
-	    if (11..13).include?(self % 100)
-			"#{self}th"
-	    else
-			case self % 10
-			when 1; "#{self}st"
-			when 2; "#{self}nd"
-			when 3; "#{self}rd"
-			else "#{self}th"
-			end
-	    end
+class Array
+	def comb
+		::Rtype::Behavior::And[*self]
 	end
-end
+end

data/lib/rtype/version.rb

@@ -1,3 +1,7 @@
 module Rtype
-	VERSION = "0.5.1".freeze
+	VERSION = "0.6.0".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
+	NATIVE_EXT_VERSION = nil unless defined?(NATIVE_EXT_VERSION)
 end

data/lib/rtype.rb

@@ -98,14 +98,13 @@ module Rtype
 	end
 
 	def arg_message(idx)
-		"for #{(idx+1).ordinalize} argument:"
+		"for #{ordinalize_number(idx+1)} argument:"
 	end
 
 	def kwarg_message(key)
 		"for '#{key}' argument:"
 	end
 
-
 	def type_error_message(expected, value)
 		case expected
 		when Rtype::Behavior::Base
@@ -119,18 +118,8 @@ module Rtype
 		when Range
 			"Expected #{value.inspect} to be included in range #{expected.inspect}"
 		when Array
-			if value.is_a?(Array)
-				arr = expected.map.with_index do |e, idx|
-					if e.is_a?(Array) || e.is_a?(Hash)
-						"- [#{idx}] index : {\n" + type_error_message(e, value[idx]) + "\n}"
-					else
-						"- [#{idx}] index : " + type_error_message(e, value[idx])
-					end
-				end
-				"Expected #{value.inspect} to be an array with #{expected.length} elements:\n" + arr.join("\n")
-			else
-				"Expected #{value.inspect} to be an array"
-			end
+			arr = expected.map { |e| type_error_message(e, value) }
+			arr.join("\nOR ")
 		when Hash
 			if value.is_a?(Hash)
 				arr = []
@@ -208,13 +197,14 @@ module Rtype
 		when Proc
 		when true
 		when false
+		when nil
 		else
 			raise TypeSignatureError, "Invalid type signature: Unknown type behavior #{sig}"
 		end
 	end
 
 	def assert_valid_return_type_sig(sig)
-		assert_valid_argument_type_sig_element(sig) unless sig.nil?
+		assert_valid_argument_type_sig_element(sig)
 	end
 
 private
@@ -233,7 +223,19 @@ private
 		end
 		nil
 	end
-
+	
+	def ordinalize_number(num)
+	    if (11..13).include?(num % 100)
+			"#{num}th"
+	    else
+			case num % 10
+			when 1; "#{num}st"
+			when 2; "#{num}nd"
+			when 3; "#{num}rd"
+			else "#{num}th"
+			end
+	    end
+	end
 public
 	unless respond_to?(:valid?)
 	# validate argument type
@@ -252,10 +254,7 @@ public
 			return false unless expected.keys == value.keys
 			expected.all? { |k, v| valid?(v, value[k]) }
 		when Array
-			return false unless value.is_a?(Array)
-			return false unless expected.length == value.length
-			idx = -1
-			expected.all? { |e| idx += 1; valid?(e, value[idx]) }
+			expected.any? { |e| valid?(e, value) }
 		when Proc
 			!!expected.call(value)
 		when true
@@ -264,6 +263,8 @@ public
 			!value
 		when Rtype::Behavior::Base
 			expected.valid? value
+		when nil
+			value.nil?
 		else
 			raise TypeSignatureError, "Invalid type signature: Unknown type behavior #{expected}"
 		end
@@ -272,14 +273,14 @@ public
 
 	unless respond_to?(:assert_arguments_type)
 	def assert_arguments_type(expected_args, args)
+		e_len = expected_args.length
 		# `length.times` is faster than `each_with_index`
 		args.length.times do |i|
+			break if i >= e_len
 			expected = expected_args[i]
 			value = args[i]
-			unless expected.nil?
-				unless valid?(expected, value)
-					raise ArgumentTypeError, "#{arg_message(i)}\n" + type_error_message(expected, value)
-				end
+			unless valid?(expected, value)
+				raise ArgumentTypeError, "#{arg_message(i)}\n" + type_error_message(expected, value)
 			end
 		end
 	end
@@ -287,19 +288,20 @@ public
 
 	unless respond_to?(:assert_arguments_type_with_keywords)
 	def assert_arguments_type_with_keywords(expected_args, args, expected_kwargs, kwargs)
+		e_len = expected_args.length
 		# `length.times` is faster than `each_with_index`
 		args.length.times do |i|
+			break if i >= e_len
 			expected = expected_args[i]
 			value = args[i]
-			unless expected.nil?
-				unless valid?(expected, value)
-					raise ArgumentTypeError, "#{arg_message(i)}\n" + type_error_message(expected, value)
-				end
+			unless valid?(expected, value)
+				raise ArgumentTypeError, "#{arg_message(i)}\n" + type_error_message(expected, value)
 			end
 		end
+		
 		kwargs.each do |key, value|
-			expected = expected_kwargs[key]
-			unless expected.nil?
+			if expected_kwargs.key?(key)
+				expected = expected_kwargs[key]
 				unless valid?(expected, value)
 					raise ArgumentTypeError, "#{kwarg_message(key)}\n" + type_error_message(expected, value)
 				end
@@ -310,14 +312,8 @@ public
 
 	unless respond_to?(:assert_return_type)
 	def assert_return_type(expected, result)
-		if expected.nil?
-			unless result.nil?
-				raise ReturnTypeError, "for return:\n" + type_error_message(expected, result)
-			end
-		else
-			unless valid?(expected, result)
-				raise ReturnTypeError, "for return:\n" + type_error_message(expected, result)
-			end
+		unless valid?(expected, result)
+			raise ReturnTypeError, "for return:\n" + type_error_message(expected, result)
 		end
 	end
 	end

data/spec/rtype_spec.rb

@@ -237,31 +237,30 @@ describe Rtype do
 
 		describe 'Array' do
 			it "is right" do
-				klass.send :rtype, :return_arg, [[:to_i, :to_i]] => Any
-				instance.return_arg([123, 456])
+				klass.send :rtype, :return_arg, [[:to_i]] => Any
+				instance.return_arg(123)
 
-				klass.send :rtype, :two_args, [[:to_i], [:to_i]] => Any
-				instance.two_args([123], [456])
+				klass.send :rtype, :return_arg, [[String, Integer]] => Any
+				instance.return_arg("str")
+				instance.return_arg(123)
+				
+				klass.send :rtype, :return_arg, [] => [String, Integer]
+				instance.return_arg("str")
+				instance.return_arg(123)
 			end
 			it "is wrong args" do
-				klass.send :rtype, :return_arg, [[:to_i, :to_i]] => Any
-				expect {
-					instance.return_arg([123, [true]])
-				}.to raise_error Rtype::ArgumentTypeError
+				klass.send :rtype, :return_arg, [[String, Integer]] => Any
 				expect {
-					instance.return_arg([123, true])
+					instance.return_arg(nil)
 				}.to raise_error Rtype::ArgumentTypeError
 
-				klass.send :rtype, :two_args, [[:to_i], [:to_i]] => Any
+				klass.send :rtype, :return_arg, [[String]] => Any
 				expect {
-					instance.two_args([123, 123], [123])
-				}.to raise_error Rtype::ArgumentTypeError
-				expect {
-					instance.two_args([123], 123)
+					instance.return_arg(123)
 				}.to raise_error Rtype::ArgumentTypeError
 			end
 			it "is wrong result" do
-				klass.send :rtype, :return_arg, [Any] => [:to_i, :to_i]
+				klass.send :rtype, :return_arg, [Any] => [String, Integer]
 				expect {instance.return_arg(true)}.to raise_error Rtype::ReturnTypeError
 			end
 		end
@@ -335,17 +334,19 @@ describe Rtype do
 		end
 
 		describe 'nil' do
-			it "is only for return" do
+			it "for return" do
 				klass.send :rtype, :return_nil, [] => nil
 				instance.return_nil(123)
 
 				klass.send :rtype, :return_arg, [] => nil
 				expect {instance.return_arg(123)}.to raise_error Rtype::ReturnTypeError
 			end
-			it "could not be used for args" do
+			it "for args" do
+				klass.send :rtype, :return_arg, [nil] => Any
+				instance.return_arg(nil)
 				expect {
-					klass.send :rtype, :return_arg, [nil] => Any
-				}.to raise_error Rtype::TypeSignatureError
+					instance.return_arg(123)
+				}.to raise_error Rtype::ArgumentTypeError
 			end
 		end
 
@@ -370,29 +371,6 @@ describe Rtype do
 				end
 			end
 
-			describe 'Rtype::Behavior::Or' do
-				it 'module singleton method' do
-					klass.send :rtype, :return_nil, [Rtype::or(Integer, String)] => nil
-					instance.return_nil(123)
-					instance.return_nil("abc")
-					expect {instance.return_nil(nil)}.to raise_error Rtype::ArgumentTypeError
-				end
-
-				it 'class singleton [] method' do
-					klass.send :rtype, :return_nil, [ Rtype::Behavior::Or[Integer, String] ] => nil
-					instance.return_nil(123)
-					instance.return_nil("abc")
-					expect {instance.return_nil(nil)}.to raise_error Rtype::ArgumentTypeError
-				end
-
-				it 'core extension method' do
-					klass.send :rtype, :return_nil, [ Integer.or(String) ] => nil
-					instance.return_nil(123)
-					instance.return_nil("abc")
-					expect {instance.return_nil(nil)}.to raise_error Rtype::ArgumentTypeError
-				end
-			end
-
 			describe 'Rtype::Behavior::Nilable' do
 				it 'module singleton method' do
 					klass.send :rtype, :return_nil, [Rtype::nilable(Integer)] => nil
@@ -480,13 +458,6 @@ describe Rtype do
 				expect {instance.sum(1, 2.0)}.to raise_error Rtype::ArgumentTypeError
 			end
 
-			it 'two array' do
-				klass.send :rtype, :sum, [[Integer], [Integer]] => Any
-				instance.sum([1], [2])
-				expect {instance.sum([1], 2)}.to raise_error Rtype::ArgumentTypeError
-				expect {instance.sum([1], ["str"])}.to raise_error Rtype::ArgumentTypeError
-			end
-
 			it 'two hash' do
 				klass.send :rtype, :two_args, [{k: Integer}, {k: Integer}, {}] => Any
 				instance.two_args({k: 123}, {k: 456}, {})
@@ -564,9 +535,9 @@ describe Rtype do
 				instance.return_arg("str")
 			end
 
-			it 'Array (tuple)' do
+			it 'Array' do
 				klass.send :rtype, :return_arg, [] => [Integer, Float]
-				expect {instance.return_arg([1, 2])}.to raise_error Rtype::ReturnTypeError
+				expect {instance.return_arg("str")}.to raise_error Rtype::ReturnTypeError
 			end
 		end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rtype
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Sputnik Gugja
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-25 00:00:00.000000000 Z
+date: 2016-05-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -72,7 +72,6 @@ files:
 - lib/rtype/behavior/core_ext.rb
 - lib/rtype/behavior/nilable.rb
 - lib/rtype/behavior/not.rb
-- lib/rtype/behavior/or.rb
 - lib/rtype/behavior/xor.rb
 - lib/rtype/core_ext.rb
 - lib/rtype/method_annotator.rb

data/lib/rtype/behavior/or.rb

@@ -1,24 +0,0 @@
-module Rtype
-	module Behavior
-		class Or < Base
-			def initialize(*types)
-				@types = types
-			end
-
-			def valid?(value)
-				@types.any? do |e|
-					Rtype::valid? e, value
-				end
-			end
-
-			def error_message(value)
-				arr = @types.map { |e| Rtype::type_error_message(e, value) }
-				arr.join "\nOR "
-			end
-		end
-	end
-
-	def or(*args)
-		Behavior::Or[*args]
-	end
-end