rtype-java 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2c76537dff4a7ccee1fa77da9c10e7097919dfeb
-  data.tar.gz: 6f67d948e8827f5f656affbeb09a8e8bdec40777
+  metadata.gz: c8580ec5d359d6dcd395a437bc94ed40b25b486c
+  data.tar.gz: 5289c039445424a7e0281df85005fca8cebba108
 SHA512:
-  metadata.gz: 9b5801ef42df2010d681e96bc8409cbf1eb70999ce5b888bba6921138c6b549b4d8458fdfd4ee6b5d98783c84cfa424471875090b43b3f60235c77702afdfbf1
-  data.tar.gz: e1ebae61666ebfa0305c5992772e3fe8bcb0db11c96fb25b5eda491bca8d1d84c4295a6782f07230f6a5bf86e18dffd357ee72a47397b8267b144a5f2156dcd5
+  metadata.gz: ecf925fec3898c4ff928e570877ec5c5ad5ba54c87ec14c28711a7e6eaacfdd5384d0d4444f1a2f5602a2cd52c3476955f42e4590552d527f21ac38a20675618
+  data.tar.gz: e1a0e23fcfe6b918103cd2df0ebea7847aeb370c2b395dd35f153e06928700c4f2b9360abad766a8839319a9128dd8475b0953fb4c8ac395bf080a1aacd960c6

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