rtype 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 580a93433f2e77fc81b6a9abd7b14d390952f05d
-  data.tar.gz: 78f18ddfed8634652bc9c0da161dec708db99293
+  metadata.gz: c4bad8e7cdc12a3c4a598e806553fd89c184c212
+  data.tar.gz: 67576b9e8839a9f1988ee4f561cb0474824ecb84
 SHA512:
-  metadata.gz: e6df637fa65774fcf9addcf06dc4b8fc526587e1cfe448229644b8756f17129f603086a90a68d16422900f5b20020927bd67e403f8550ffb1823b4484d365d39
-  data.tar.gz: 653c366459022762cf1e5ded44eac4452365b6549f23efad8c1f875eb785ed14d56788d72efe222d6a76906367f908b7594f22c6372707c931079d2af104a5bb
+  metadata.gz: 4b82873431c88b2811b9ee34bdd84a3f23e683cbf4baaba9c57da29954b34869a3739db623496f0e07af92b8eab5750d10d523b3e93c3cf91080a5a36c5dd5fb
+  data.tar.gz: 29a5f2356be7ed7637841a0a240689cd11f7d19f73ce5b5447c8ec99bb497ee931e2c48706048efacffe4d15c7a73619b184b49e53bbb9c920dfd328905e4954

data/README.md

@@ -31,15 +31,16 @@ Test::invert(state: 0)
 
 ## Requirements
 - Ruby >= 2.1
-- MRI or RBX
+- MRI
   - If C native extension is used, otherwise it is not required
 - JRuby
   - If Java extension is used, otherwise it is not required
 
 ## Features
-- Provide type checking for argument and return
+- Provide type checking for arguments and return
 - Support type checking for [keyword argument](#keyword-argument)
 - [Type checking for array elements](#array)
+- [Type checking for hash elements](#hash)
 - [Duck typing](#duck-typing)
 - Custom type behavior
 
@@ -54,7 +55,7 @@ require 'rtype'
 ### Native extension
 Rtype itself is pure-ruby gem. but you can make it more faster by using native extension.
 
-#### Native extension for MRI, RBX
+#### Native extension for MRI
 Just run
 ```ruby
 gem install rtype-native
@@ -96,6 +97,18 @@ then, Rtype use it. (Do not `require 'rtype-java'`)
   - Of course, nested array works
   - Example: [Array](#array)
   - This can be used as a tuple
+- `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
+  - The type signature could not be positioned at last index
+    - `[{}]` 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 keyword argument. non-keyword arguments must be in array.
+  - Of course, nested hash works
+  - Example: [Hash](#hash)
 - `Proc`
   - Value must return a truthy value for this proc
 - `true`
@@ -106,15 +119,36 @@ then, Rtype use it. (Do not `require 'rtype-java'`)
   - Only available for **return type**. void return type in other languages
 - Special Behaviors
   - `Rtype::and(*types)` : Ensure value is valid for all the types
-    - It also can be used as `Rtype::Behavior::And[*types]` or `include Rtype::Behavior; And[...]`
+    - `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
-    - It also can be used as `Rtype::Behavior::Or[*types]` or `include Rtype::Behavior; Or[...]`
+    - `Rtype::or(*types)`
+    - `Rtype::Behavior::Or[*types]`
+    - `include Rtype::Behavior; Or[...]`
+    - `obj.or(*others)` (core extension)
+
   - `Rtype::xor(*types)` : Ensure value is valid for only one of the types
-    - It also can be used as `Rtype::Behavior::Xor[*types]` or `include Rtype::Behavior; Xor[...]`
+    - `Rtype::xor(*types)`
+    - `Rtype::Behavior::Xor[*types]`
+    - `include Rtype::Behavior; Xor[...]`
+    - `obj.xor(*others)` (core extension)
+
   - `Rtype::not(*types)` : Ensure value is not valid for all the types
-    - It also can be used as `Rtype::Behavior::Not[*types]` or `include Rtype::Behavior; Not[...]`
+    - `Rtype::not(*types)`
+    - `Rtype::Behavior::Not[*types]`
+    - `include Rtype::Behavior; Not[...]`
+    - `obj.not` (core extension)
+
   - `Rtype::nilable(type)` : Ensure value can be nil
-    - It also can be used as `Rtype::Behavior::Nilable[type]` or `include Rtype::Behavior; Nilable[...]`
+    - `Rtype::nilable(type)`
+    - `Rtype::Behavior::Nilable[type]`
+    - `include Rtype::Behavior; Nilable[...]`
+    - `obj.nilable` (core extension)
+    - `obj.or_nil` (core extension)
+
   - You can create custom behavior by extending `Rtype::Behavior::Base`
 
 ### Examples
@@ -219,6 +253,38 @@ func [1]
 func [1, 2] # Your location is (1, 2). I will look for you. I will find you
 ```
 
+#### Hash
+```ruby
+# last hash element is keyword arguments
+rtype :func, [{msg: String}, {}] => Any
+def func(hash)
+  puts hash[:msg]
+end
+
+# last hash is keyword arguments
+func({}, {})
+# (Rtype::ArgumentTypeError) for 1st argument:
+# Expected {} to be an hash with 1 elements:
+# - msg : Expected nil to be a String
+
+func({msg: 123}, {})
+# (Rtype::ArgumentTypeError) for 1st argument:
+# Expected {:msg=>123} to be an hash with 1 elements:
+# - msg : Expected 123 to be a String
+
+func({msg: "hello", key: 'value'}, {})
+# (Rtype::ArgumentTypeError) for 1st argument:
+# Expected {:msg=>"hello", :key=>"value"} to be an hash with 1 elements:
+# - msg : Expected "hello" to be a String
+
+func({"msg" => "hello hash"}, {})
+# (Rtype::ArgumentTypeError) for 1st argument:
+# Expected {"msg"=>"hello hash"} to be an hash with 1 elements:
+# - msg : Expected nil to be a String
+
+func({msg: "hello hash"}, {}) # hello hash
+```
+
 #### rtype with attr_accessor
 `rtype_accessor`
 
@@ -250,7 +316,9 @@ Example.new.value
 require 'rtype'
 
 class Example
-  rtype :and_test, [Rtype::and(String, :func)] => Any
+  rtype :and_test, [String.and(:func)] => Any
+  # also works:
+  # rtype :and_test, [Rtype::and(String, :func)] => Any
   def and_test(arg)
   end
 end
@@ -344,7 +412,7 @@ end
 say "Hello" # Hello
 ```
 
-#### Static method
+#### Static(singleton) method
 Use `rtype_self`
 
 ```ruby

data/lib/rtype/behavior/core_ext.rb

@@ -0,0 +1,22 @@
+class Object
+	def and(*others)
+		::Rtype::and(self, *others)
+	end
+
+	def nilable
+		::Rtype::nilable(self)
+	end
+	alias_method :or_nil, :nilable
+
+	def not
+		::Rtype::not(self)
+	end
+
+	def or(*others)
+		::Rtype::or(self, *others)
+	end
+
+	def xor(*others)
+		::Rtype::xor(self, *others)
+	end
+end

data/lib/rtype/behavior/nilable.rb

@@ -15,7 +15,7 @@ module Rtype
 		end
 	end
 
-	def self.nilable(*args)
+	def nilable(*args)
 		Behavior::Nilable[*args]
 	end
 end

data/lib/rtype/behavior/not.rb

@@ -18,7 +18,7 @@ module Rtype
 		end
 	end
 
-	def self.not(*args)
+	def not(*args)
 		Behavior::Not[*args]
 	end
 end

data/lib/rtype/behavior/or.rb

@@ -18,7 +18,7 @@ module Rtype
 		end
 	end
 
-	def self.or(*args)
+	def or(*args)
 		Behavior::Or[*args]
 	end
 end

data/lib/rtype/behavior/xor.rb

@@ -19,7 +19,7 @@ module Rtype
 		end
 	end
 
-	def self.xor(*args)
+	def xor(*args)
 		Behavior::Xor[*args]
 	end
 end

data/lib/rtype/behavior.rb

@@ -8,4 +8,5 @@ require_relative 'behavior/or'
 require_relative 'behavior/and'
 require_relative 'behavior/xor'
 require_relative 'behavior/not'
-require_relative 'behavior/nilable'
+require_relative 'behavior/nilable'
+require_relative 'behavior/core_ext'

data/lib/rtype/version.rb

@@ -1,3 +1,3 @@
 module Rtype
-	VERSION = "0.3.0".freeze
+	VERSION = "0.4.0".freeze
 end

data/lib/rtype.rb

@@ -40,7 +40,7 @@ module Rtype
 		return_sig = el[1]
 
 		if arg_sig.is_a?(Array)
-			expected_args = arg_sig
+			expected_args = arg_sig.dup
 			if expected_args.last.is_a?(Hash)
 				expected_kwargs = expected_args.pop
 			else
@@ -51,12 +51,12 @@ module Rtype
 			expected_kwargs = arg_sig
 		end
 
-		expected_args.each { |e| valid?(e, nil) }
+		expected_args.each { |e| check_valid_argument_type_sig(e) }
 		if expected_kwargs.keys.any? { |e| !e.is_a?(Symbol) }
 			raise TypeSignatureError, "Invalid type signature: keyword arguments contain non-symbol key"
 		end
-		expected_kwargs.each_value { |e| valid?(e, nil) }
-		valid?(return_sig, nil) unless return_sig.nil?
+		expected_kwargs.each_value { |e| check_valid_argument_type_sig(e) }
+		check_valid_return_type_sig(return_sig)
 
 		sig = TypeSignature.new
 		sig.argument_type = arg_sig
@@ -123,7 +123,7 @@ module Rtype
 		when Array
 			if value.is_a?(Array)
 				arr = expected.map.with_index do |e, idx|
-					if e.is_a?(Array)
+					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])
@@ -133,6 +133,20 @@ module Rtype
 			else
 				"Expected #{value.inspect} to be an array"
 			end
+		when Hash
+			if value.is_a?(Hash)
+				arr = []
+				expected.each do |k, v|
+					if v.is_a?(Array) || v.is_a?(Hash)
+						arr << "- #{k} : {\n" + type_error_message(v, value[k]) + "\n}"
+					else
+						arr << "- #{k} : " + type_error_message(v, value[k])
+					end
+				end
+				"Expected #{value.inspect} to be an hash with #{expected.length} elements:\n" + arr.join("\n")
+			else
+				"Expected #{value.inspect} to be an hash"
+			end
 		when Proc
 			"Expected #{value.inspect} to return a truthy value for proc #{expected}"
 		when true
@@ -166,7 +180,34 @@ private
 		end
 		nil
 	end
-	
+
+	def check_valid_argument_type_sig(sig)
+		case sig
+		when Rtype::Behavior::Base
+		when Module
+		when Symbol
+		when Regexp
+		when Range
+		when Array
+			sig.each do |e|
+				check_valid_argument_type_sig(e)
+			end
+		when Hash
+			sig.each_value do |e|
+				check_valid_argument_type_sig(e)
+			end
+		when Proc
+		when true
+		when false
+		else
+			raise TypeSignatureError, "Invalid type signature: Unknown type behavior #{sig}"
+		end
+	end
+
+	def check_valid_return_type_sig(sig)
+		check_valid_argument_type_sig(sig) unless sig.nil?
+	end
+
 public
 	unless respond_to?(:valid?)
 	# validate argument type
@@ -180,6 +221,10 @@ public
 			!!(expected =~ value.to_s)
 		when Range
 			expected.include?(value)
+		when Hash
+			return false unless value.is_a?(Hash)
+			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
@@ -207,7 +252,7 @@ public
 			value = args[i]
 			unless expected.nil?
 				unless valid?(expected, value)
-					raise ArgumentTypeError, "for #{(i+1).ordinalize} argument:\n" + type_error_message(expected, value)
+					raise ArgumentTypeError, "#{arg_message(i)}\n" + type_error_message(expected, value)
 				end
 			end
 		end
@@ -222,7 +267,7 @@ public
 			value = args[i]
 			unless expected.nil?
 				unless valid?(expected, value)
-					raise ArgumentTypeError, "#{arg_message(idx)}\n" + type_error_message(expected, value)
+					raise ArgumentTypeError, "#{arg_message(i)}\n" + type_error_message(expected, value)
 				end
 			end
 		end

data/spec/rtype_spec.rb

@@ -13,6 +13,9 @@ describe Rtype do
 				obj
 			end
 
+			def two_args(a, b)
+			end
+
 			def three_args(a, b, c)
 			end
 
@@ -207,10 +210,26 @@ describe Rtype do
 			it "is right" do
 				klass.send :rtype, :return_arg, [[:to_i, :to_i]] => Any
 				instance.return_arg([123, 456])
+
+				klass.send :rtype, :two_args, [[:to_i], [:to_i]] => Any
+				instance.two_args([123], [456])
 			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
+				expect {
+					instance.return_arg([123, [true]])
+				}.to raise_error Rtype::ArgumentTypeError
+				expect {
+					instance.return_arg([123, true])
+				}.to raise_error Rtype::ArgumentTypeError
+
+				klass.send :rtype, :two_args, [[:to_i], [:to_i]] => Any
+				expect {
+					instance.two_args([123, 123], [123])
+				}.to raise_error Rtype::ArgumentTypeError
+				expect {
+					instance.two_args([123], 123)
+				}.to raise_error Rtype::ArgumentTypeError
 			end
 			it "is wrong result" do
 				klass.send :rtype, :return_arg, [Any] => [:to_i, :to_i]
@@ -218,6 +237,23 @@ describe Rtype do
 			end
 		end
 
+		describe 'Hash' do
+			it "is right" do
+				klass.send :rtype, :return_arg, [{k: Integer}, {}] => Any
+				instance.return_arg({k: 123}, {})
+			end
+			it "is wrong args" do
+				klass.send :rtype, :return_arg, [{k: Integer}, {}] => Any
+				expect {
+					instance.return_arg({k: "str"}, {})
+				}.to raise_error Rtype::ArgumentTypeError
+			end
+			it "is wrong result" do
+				klass.send :rtype, :return_arg, [Any] => {k: Integer}
+				expect { instance.return_arg({k: "str"}) }.to raise_error Rtype::ReturnTypeError
+			end
+		end
+
 		describe 'Proc' do
 			it "is right" do
 				klass.send :rtype, :return_arg, [->(arg){!arg.nil?}] => Any
@@ -285,36 +321,117 @@ describe Rtype do
 		end
 
 		describe 'Special type behaviors' do
-			it 'Rtype::Behavior::And' do
-				klass.send :rtype, :return_nil, [Rtype.and(:to_i, :chars)] => nil
-				instance.return_nil("Hello")
-				expect {instance.return_nil(123)}.to raise_error Rtype::ArgumentTypeError
+			describe 'Rtype::Behavior::And' do
+				it 'module singleton method' do
+					klass.send :rtype, :return_nil, [Rtype::and(:to_i, :chars)] => nil
+					instance.return_nil("Hello")
+					expect {instance.return_nil(123)}.to raise_error Rtype::ArgumentTypeError
+				end
+
+				it 'class singleton [] method' do
+					klass.send :rtype, :return_nil, [ Rtype::Behavior::And[:to_i, :chars] ] => nil
+					instance.return_nil("Hello")
+					expect {instance.return_nil(123)}.to raise_error Rtype::ArgumentTypeError
+				end
+
+				it 'core extension method' do
+					klass.send :rtype, :return_nil, [ :to_i.and(:chars) ] => nil
+					instance.return_nil("Hello")
+					expect {instance.return_nil(123)}.to raise_error Rtype::ArgumentTypeError
+				end
 			end
 
-			it 'Rtype::Behavior::Or' 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
+			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
 
-			it 'Rtype::Behavior::Nilable' do
-				klass.send :rtype, :return_nil, [Rtype.nilable(Integer)] => nil
-				instance.return_nil(nil)
-				instance.return_nil(123)
-				expect {instance.return_nil("abc")}.to raise_error Rtype::ArgumentTypeError
+			describe 'Rtype::Behavior::Nilable' do
+				it 'module singleton method' do
+					klass.send :rtype, :return_nil, [Rtype::nilable(Integer)] => nil
+					instance.return_nil(nil)
+					instance.return_nil(123)
+					expect {instance.return_nil("abc")}.to raise_error Rtype::ArgumentTypeError
+				end
+
+				it 'class singleton [] method' do
+					klass.send :rtype, :return_nil, [ Rtype::Behavior::Nilable[Integer] ] => nil
+					instance.return_nil(nil)
+					instance.return_nil(123)
+					expect {instance.return_nil("abc")}.to raise_error Rtype::ArgumentTypeError
+				end
+
+				it 'core extension method :nilable' do
+					klass.send :rtype, :return_nil, [Integer.nilable] => nil
+					instance.return_nil(nil)
+					instance.return_nil(123)
+					expect {instance.return_nil("abc")}.to raise_error Rtype::ArgumentTypeError
+				end
+
+				it 'core extension method :or_nil' do
+					klass.send :rtype, :return_nil, [Integer.or_nil] => nil
+					instance.return_nil(nil)
+					instance.return_nil(123)
+					expect {instance.return_nil("abc")}.to raise_error Rtype::ArgumentTypeError
+				end
 			end
 
-			it 'Rtype::Behavior::Not' do
-				klass.send :rtype, :return_nil, [Rtype.not(String)] => nil
-				instance.return_nil(123)
-				expect {instance.return_nil("abc")}.to raise_error Rtype::ArgumentTypeError
+			describe 'Rtype::Behavior::Not' do
+				it 'module singleton method' do
+					klass.send :rtype, :return_nil, [Rtype::not(String)] => nil
+					instance.return_nil(123)
+					expect {instance.return_nil("abc")}.to raise_error Rtype::ArgumentTypeError
+				end
+
+				it 'class singleton [] method' do
+					klass.send :rtype, :return_nil, [ Rtype::Behavior::Not[String] ] => nil
+					instance.return_nil(123)
+					expect {instance.return_nil("abc")}.to raise_error Rtype::ArgumentTypeError
+				end
+
+				it 'core extension method' do
+					klass.send :rtype, :return_nil, [ String.not ] => nil
+					instance.return_nil(123)
+					expect {instance.return_nil("abc")}.to raise_error Rtype::ArgumentTypeError
+				end
 			end
 
-			it 'Rtype::Behavior::Xor' do
-				klass.send :rtype, :return_nil, [Rtype.xor(:to_i, String)] => nil
-				instance.return_nil(123)
-				expect {instance.return_nil("abc")}.to raise_error Rtype::ArgumentTypeError
+			describe 'Rtype::Behavior::Xor' do
+				it 'module singleton method' do
+					klass.send :rtype, :return_nil, [Rtype::xor(:to_i, String)] => nil
+					instance.return_nil(123)
+					expect {instance.return_nil("abc")}.to raise_error Rtype::ArgumentTypeError
+				end
+
+				it 'class singleton [] method' do
+					klass.send :rtype, :return_nil, [ Rtype::Behavior::Xor[:to_i, String] ] => nil
+					instance.return_nil(123)
+					expect {instance.return_nil("abc")}.to raise_error Rtype::ArgumentTypeError
+				end
+
+				it 'core extension method' do
+					klass.send :rtype, :return_nil, [ :to_i.xor(String) ] => nil
+					instance.return_nil(123)
+					expect {instance.return_nil("abc")}.to raise_error Rtype::ArgumentTypeError
+				end
 			end
 		end
 	end
@@ -334,6 +451,27 @@ 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}, {})
+				expect {
+					instance.two_args({k: 123}, {}, {})
+				}.to raise_error Rtype::ArgumentTypeError
+				expect {
+					instance.two_args({k: 123}, 456, {})
+				}.to raise_error Rtype::ArgumentTypeError
+				expect {
+					instance.two_args({k: 123}, {k: "str"}, {})
+				}.to raise_error Rtype::ArgumentTypeError
+			end
+
 			it 'one keyword argument' do
 				klass.send :rtype, :kwarg, {a: Float} => Any
 				expect {instance.kwarg(a: 1)}.to raise_error Rtype::ArgumentTypeError
@@ -370,6 +508,25 @@ describe Rtype do
 				expect {instance.kwarg(a: 1)}.to raise_error Rtype::ArgumentTypeError
 				expect {instance.kwarg(:a => 1)}.to raise_error Rtype::ArgumentTypeError
 			end
+
+			context 'when hash is not last element' do
+				it 'is hash-type argument, not keyword argument' do
+					klass.send :rtype, :return_arg, [{a: String}, {}] => Any
+					expect {
+						instance.return_arg({a: 123}, {})
+					}.to raise_error Rtype::ArgumentTypeError
+				end
+			end
+
+			it 'hash-type argument and keyword argument' do
+				klass.send :rtype, :arg_and_kwarg, [{a: String}, {b: String}] => Any
+				expect {
+					instance.arg_and_kwarg({a: 123}, b: "str")
+				}.to raise_error Rtype::ArgumentTypeError
+				expect {
+					instance.arg_and_kwarg({a: "str"}, b: 123)
+				}.to raise_error Rtype::ArgumentTypeError
+			end
 		end
 
 		describe 'check return' do
@@ -400,13 +557,13 @@ describe Rtype do
 				end
 				it 'invalid return signature' do
 					expect {
-						klass.send :rtype, :return_arg, [] => {}
+						klass.send :rtype, :return_arg, [] => 123
 					}.to raise_error Rtype::TypeSignatureError
 				end
 
 				it 'invalid type behavior in arguments' do
 					expect {
-						klass.send :rtype, :sum_kwargs, [{a: Integer}, {b: Integer}] => Any
+						klass.send :rtype, :sum_kwargs, [{a: 123}, {b: Integer}] => Any
 					}.to raise_error Rtype::TypeSignatureError
 					expect {
 						klass.send :rtype, :return_arg, [123] => Any
@@ -418,7 +575,7 @@ describe Rtype do
 						klass.send :rtype, :kwarg, {a: 123} => Any
 					}.to raise_error Rtype::TypeSignatureError
 					expect {
-						klass.send :rtype, :kwarg, {a: {b: Integer}} => Any
+						klass.send :rtype, :kwarg, {a: {b: 123}} => Any
 					}.to raise_error Rtype::TypeSignatureError
 					expect {
 						klass.send :rtype, :kwarg, {Object.new => Integer} => Any
@@ -506,6 +663,15 @@ describe Rtype do
 				instance.three_kwargs(a: "abc", b: 123, c: 456)
 			end
 		end
+
+		context 'when hash type argument contain a key not configured to rtype' do
+			it 'raises error' do
+				klass.send :rtype, :return_arg, [{a: String}, {}] => Any
+				expect {
+					instance.return_arg({a: "str", b: "str"}, {})
+				}.to raise_error Rtype::ArgumentTypeError
+			end
+		end
 	end
 
 	describe "Call Rtype`s static method directly" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rtype
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Sputnik Gugja
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-27 00:00:00.000000000 Z
+date: 2016-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -52,7 +52,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Ruby with type
+description: The fastest type checking gem
 email:
 - sputnikgugja@gmail.com
 executables: []
@@ -69,6 +69,7 @@ files:
 - lib/rtype/behavior.rb
 - lib/rtype/behavior/and.rb
 - lib/rtype/behavior/base.rb
+- lib/rtype/behavior/core_ext.rb
 - lib/rtype/behavior/nilable.rb
 - lib/rtype/behavior/not.rb
 - lib/rtype/behavior/or.rb