rtype-native 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7628a99152b791414bf7a6651d3fec5229718c2c
-  data.tar.gz: 1fe92f38dc1995a88342ce8d9a80c7dca9de5a6d
+  metadata.gz: 7da1eeceea62ee24758dd2af72476310ba28b645
+  data.tar.gz: 4b5902e8d4a5f83939893a7d9bcee7b2d215ee5a
 SHA512:
-  metadata.gz: 9ecde7d0cebc9796d8e29845f341fe8f913d1e1cd3a424741c7b8c35ab16083a305a5b7c695e3a70d5da9606f552825e7a6cc110bed4553f6c20746a6d958e74
-  data.tar.gz: c06b26503bd67776e2592d2bc956ae9a83879b04d81bee393312433f7c66d7219f2c469cc9230cb572053e744f086fb06a63dbf43516a12095da734d4829595c
+  metadata.gz: e6c32b52f0d3c39da572c560007d09de8aef01ff1ca8165b5254c0814a18b7fe9eaf58f6db789034b3ece1c3120e984f4db760d80b9804c9a385f35eb6e7f3c7
+  data.tar.gz: 9e32a39033098b5ac96290f6c6533ef16eaf683c713034f3c969a97b4466f685d41a0c2177d931b4cecde97622168cf98a749af523c353c2f37f30cf58cee59d

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/ext/rtype/c/rtype.c

@@ -12,6 +12,25 @@ rb_rtype_valid(VALUE self, VALUE expected, VALUE value) {
 			return rb_respond_to(value, rb_to_id(expected)) ? Qtrue : Qfalse;
 		case T_REGEXP:
 			return rb_reg_match( expected, rb_funcall(value, rb_intern("to_s"), 0) ) != Qnil ? Qtrue : Qfalse;
+		case T_HASH:
+			if( !RB_TYPE_P(value, T_HASH) ) {
+				return Qfalse;
+			}
+			VALUE e_keys = rb_funcall(expected, rb_intern("keys"), 0);
+			VALUE v_keys = rb_funcall(value, rb_intern("keys"), 0);
+			if( !RTEST(rb_funcall(e_keys, rb_intern("=="), 1, v_keys)) ) {
+				return Qfalse;
+			}
+
+			long i;
+			for(i = 0; i < RARRAY_LEN(e_keys); i++) {
+				VALUE e_k = rb_ary_entry(e_keys, i);
+				VALUE e_v = rb_hash_aref(expected, e_k);
+				if(rb_rtype_valid(self, e_v, rb_hash_aref(value, e_k)) == Qfalse) {
+					return Qfalse;
+				}
+			}
+			return Qtrue;
 		case T_ARRAY:
 			if( !RB_TYPE_P(value, T_ARRAY) ) {
 				return Qfalse;

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-native
 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: rtype
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: 0.4.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: 0.4.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement