rtype-java 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 507e4b1a4282df7820b412b246c6686a9b934fea
-  data.tar.gz: 1cc94f2f7401f544cc10c81b7cd9ef27fe8911e1
+  metadata.gz: d1db60aac3cff94cb673635875a2d5d8934a04b1
+  data.tar.gz: d44fdf33d45d9529c1fc03b623c1db7b77820c59
 SHA512:
-  metadata.gz: e8aa68a2002d14d410d161616a32dd8ced5c6bd4e8069b3053dbdde838fd0130a9e39d20f81d0e473cf7e269e5433bbfb8266abcd81c5ddee3d60ae2cf717020
-  data.tar.gz: fbf54ee612438f1eaff516deb3439732c3cd8ab88810184f0abb9dc1bd71c82d0f0e359192d706360b7ee98ffdf46938c669c1b1b6bc80723a37013314ef8c1c
+  metadata.gz: 828c8ab1a5d672c827328903960e33596b7d6ec39dac3307aa7aa1b33f03345eda025fad28d4f4683d2e1c7f80923b5295c8f61727e1d0690f1d29c25f308b92
+  data.tar.gz: 45a47173735f210b8c802e556aed6ac8393a294f0f0db6347dc4df0df908bdf9af34ffa156aeb0233f2dfc5cbe68f694a2ed172898e046bc94f61e591bc099a0

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/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-java
 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