rtype-java 0.6.0 → 0.6.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c8580ec5d359d6dcd395a437bc94ed40b25b486c
-  data.tar.gz: 5289c039445424a7e0281df85005fca8cebba108
+  metadata.gz: 737fa70842fcb7a501d1ebf85ee6e0768c460b9a
+  data.tar.gz: 911f20fd87e9d944cf8012e3fa54b4bcd51c2f71
 SHA512:
-  metadata.gz: ecf925fec3898c4ff928e570877ec5c5ad5ba54c87ec14c28711a7e6eaacfdd5384d0d4444f1a2f5602a2cd52c3476955f42e4590552d527f21ac38a20675618
-  data.tar.gz: e1a0e23fcfe6b918103cd2df0ebea7847aeb370c2b395dd35f153e06928700c4f2b9360abad766a8839319a9128dd8475b0953fb4c8ac395bf080a1aacd960c6
+  metadata.gz: 2e99777a95f7eb0aaafe871f0f31b3bae1f10da171061a980c5b1c5b15f6507d3f111aac6971300cc503a78f17ad2dd29f312b9863c3a289551318d59b8d8df7
+  data.tar.gz: 2d3a1b3fb7a2349f1d5c0f6c8b2c30bf89f0839fa58b15b543e8e89515d7a1c90732547def82792e49dcaa3fb536ebb2bdb5030d962de5cb667cf609c9ffbeda

data/README.md

@@ -32,9 +32,9 @@ Test::invert(state: 0)
 ## Requirements
 - Ruby >= 2.1
 - MRI
-  - If C native extension is used, otherwise it is not required
-- JRuby
-  - If Java extension is used, otherwise it is not required
+  - If C native extension is used. otherwise it is not required
+- JRuby (JRuby 9000+)
+  - If Java extension is used. otherwise it is not required
 
 ## Features
 - Provides type checking for arguments and return
@@ -80,52 +80,58 @@ then, Rtype use it. (Do not `require 'rtype-java'`)
 
 ### Supported Type Behaviors
 - `Module`
-  - Value must be an instance of the module/class or one of its superclasses
+  - A value must be an instance of the module/class or one of its superclasses (`is_a?`)
   - `Any` : An alias for `BasicObject` (means Any Object)
   - `Boolean` : `true` or `false`
 - `Symbol`
-  - Value must have(respond to) a method with the name
+  - A value must have(respond to) a method with the name
 - `Regexp`
-  - Value must match the regexp pattern
+  - A value must match the regexp pattern
 - `Range`
-  - Value must be included in the range
+  - A value must be included in the range
 - `Array`
-  - Value can be any type in the array
+  - A 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
+  - A value must be a hash
+  - Each of the value’s elements must be valid
+  - The value's key list must be equal to the hash's key list
   - **String** key is **different** from **symbol** key
-  - 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)
+  - 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)
     - `{}` 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 the proc
+  - A value must return a truthy value for the proc
 - `true`
-  - Value must be **truthy**
+  - A value must be **truthy**
 - `false`
-  - Value must be **falsy**
+  - A value must be **falsy**
 - `nil`
-  - Value must be nil
+  - A value must be nil
+  
 - Special Behaviors
-  - `Rtype::and(*types)` : Ensure value is valid for all the types
+  - `Rtype::TypedArray` : Ensures a value is an array with the type (type signature)
+    - `Array::of(type)` (recommended)
+    - `Rtype::Behavior::TypedArray[type]`
+    - Example: [TypedArray](#typed-array)
+    
+  - `Rtype::and(*types)` : Ensures a value is valid for all the types
     - `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)` : Ensures a value is valid for only one of the types
     - `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)` : Ensures a value is not valid for all the types
     - `Rtype::not(*types)`, `Rtype::Behavior::Not[*types]`, `include Rtype::Behavior; Not[...]`
     - `Object#not`
 
-  - `Rtype::nilable(type)` : Ensure value can be nil
+  - `Rtype::nilable(type)` : Ensures a value can be nil
     - `Rtype::nilable(type)`, `Rtype::Behavior::Nilable[type]`, `include Rtype::Behavior; Nilable[...]`
     - `Object#nilable`
     - `Object#or_nil`
@@ -231,29 +237,29 @@ end
 # last hash is keyword arguments
 func({}, {})
 # (Rtype::ArgumentTypeError) for 1st argument:
-# Expected {} to be an hash with 1 elements:
+# Expected {} to be a 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:
+# Expected {:msg=>123} to be a 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:
+# Expected {:msg=>"hello", :key=>"value"} to be a 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:
+# Expected {"msg"=>"hello hash"} to be a hash with 1 elements:
 # - msg : Expected nil to be a String
 
 func({msg: "hello hash"}, {}) # hello hash
 ```
 
 #### rtype with attr_accessor
-`rtype_accessor` : calls `attr_accessor` if the accessor method(getter/setter) is not defined, and makes it typed method
+`rtype_accessor` : calls `attr_accessor` if the accessor method(getter/setter) is not defined. and makes it typed
 
 You can use `rtype_accessor_self` for static accessor.
 
@@ -277,6 +283,38 @@ Example.new.value
 # Expected 456 to be a String
 ```
 
+#### Typed Array
+```ruby
+### TEST 1 ###
+class Test
+	rtype [Array.of(Integer)] => Any
+	def sum(args)
+		num = 0
+		args.each { |e| num += e }
+	end
+end
+
+sum([1, 2, 3]) # => 6
+
+sum([1.0, 2, 3])
+# (Rtype::ArgumentTypeError) for 1st argument:
+# Expected [1.0, 2, 3] to be an array with type Integer"
+```
+
+```ruby
+### TEST 2 ###
+class Test
+	rtype [ Array.of([Integer, Float]) ] => Any
+	def sum(args)
+		num = 0
+		args.each { |e| num += e }
+	end
+end
+
+sum([1, 2, 3]) # => 6
+sum([1.0, 2, 3]) # => 6.0
+```
+
 #### Combined type
 ```ruby
 ### TEST 1 ###
@@ -342,7 +380,7 @@ Game::Player.new.attacks Game::Slime.new
 # Player attacks 'Powerful Slime' (level 123)!
 ```
 
-#### Position of `rtype` && (Specify method name || annotation mode) && (Symbol || String)
+#### Position of `rtype` && (specifying method name || annotation mode) && (symbol || string)
 ```ruby
 require 'rtype'
 
@@ -371,7 +409,7 @@ class Example
     puts "Hello? #{i} #{str}"
   end
 
-  # Don't works. `rtype` works for next method
+  # Doesn't work. `rtype` works for following (next) method
   def hello_world_four(i, str)
     puts "Hello? #{i} #{str}"
   end
@@ -380,7 +418,7 @@ end
 ```
 
 #### Outside of module (root)
-Outside of module, annotation mode don't works. You must specify method name.
+In the outside of module, annotation mode don't works. You must specify method name.
 
 ```ruby
 rtype :say, [String] => Any
@@ -394,7 +432,7 @@ rtype [String] => Any
 # (ArgumentError) Annotation mode not working out of module
 ```
 
-#### Static(singleton) method
+#### Class method
 rtype annotation mode works both instance and class method
 
 ```ruby
@@ -410,7 +448,7 @@ end
 Example::say_ya(3) #say ya ya ya
 ```
 
-however, if you specify method name, you must use `rtype_self` instead of `rtype`
+if you specify method name, however, you must use `rtype_self` instead of `rtype`
 
 ```ruby
 require 'rtype'
@@ -425,7 +463,7 @@ end
 Example::say_ya(3) #say ya ya ya
 ```
 
-#### Check type information
+#### Checking type information
 This is just the 'information'
 
 Any change of this doesn't affect type checking
@@ -524,7 +562,7 @@ Comparison:
 ## Rubype, Sig
 Rtype is influenced by [Rubype](https://github.com/gogotanaka/Rubype) and [Sig](https://github.com/janlelis/sig).
 
-If you don't like Rtype, You can use other type checking gem such as Contracts, Rubype, Rtc, Typecheck, Sig.
+If you don't like Rtype, You can use other library such as Contracts, Rubype, Rtc, Typecheck, Sig.
 
 ## Author
 Sputnik Gugja (sputnikgugja@gmail.com)

data/spec/rtype_spec.rb

@@ -150,24 +150,30 @@ describe Rtype do
 
 	it 'Kernel#rtype_accessor' do
 		class TestClass
-			rtype_accessor :value, String
+			rtype_accessor :value, :value2, String
 
 			def initialize
 				@value = 123
+				@value2 = 123
 			end
 		end
 		expect {TestClass.new.value = 123}.to raise_error Rtype::ArgumentTypeError
 		expect {TestClass.new.value}.to raise_error Rtype::ReturnTypeError
+		expect {TestClass.new.value2 = 123}.to raise_error Rtype::ArgumentTypeError
+		expect {TestClass.new.value2}.to raise_error Rtype::ReturnTypeError
 	end
 
 	it 'Kernel#rtype_accessor_self' do
 		class TestClass
-			@@val = 123
+			@@value = 123
+			@@value2 = 123
 
-			rtype_accessor_self :value, String
+			rtype_accessor_self :value, :value2, String
 		end
 		expect {TestClass::value = 123}.to raise_error Rtype::ArgumentTypeError
 		expect {TestClass::value}.to raise_error Rtype::ReturnTypeError
+		expect {TestClass::value2 = 123}.to raise_error Rtype::ArgumentTypeError
+		expect {TestClass::value2}.to raise_error Rtype::ReturnTypeError
 	end
 
 	describe 'Test type behaviors' do
@@ -440,6 +446,34 @@ describe Rtype do
 					expect {instance.return_nil("abc")}.to raise_error Rtype::ArgumentTypeError
 				end
 			end
+			
+			describe 'Rtype::Behavior::TypedArray' do
+				it 'class singleton [] method' do
+					klass.send :rtype, :return_nil, [ Rtype::Behavior::TypedArray[Integer] ] => nil
+					instance.return_nil([123])
+					expect {instance.return_nil(123)}.to raise_error Rtype::ArgumentTypeError
+					expect {instance.return_nil([1.0])}.to raise_error Rtype::ArgumentTypeError
+				end
+
+				it 'core extension method (Array::of)' do
+					klass.send :rtype, :return_nil, [ Array.of(Integer) ] => nil
+					instance.return_nil([123])
+					expect {instance.return_nil(123)}.to raise_error Rtype::ArgumentTypeError
+					expect {instance.return_nil([1.0])}.to raise_error Rtype::ArgumentTypeError
+				end
+				
+				it 'complicated type sig' do
+					klass.send :rtype, :return_nil, [ Array.of(:to_i.and(:chars)) ] => nil
+					instance.return_nil(["hello"])
+					expect {instance.return_nil("hello")}.to raise_error Rtype::ArgumentTypeError
+					expect {instance.return_nil([123])}.to raise_error Rtype::ArgumentTypeError
+				end
+				
+				it 'allows empty array' do
+					klass.send :rtype, :return_nil, [ Array.of(Integer) ] => nil
+					instance.return_nil([])
+				end
+			end
 		end
 	end
 

data/spec/spec_helper.rb

@@ -2,4 +2,12 @@ require 'coveralls'
 Coveralls.wear!
 
 require 'rtype'
-require 'rspec'
+require 'rspec'
+
+if !Rtype::NATIVE_EXT_VERSION.nil?
+	puts "Rtype with native extension"
+elsif !Rtype::JAVA_EXT_VERSION.nil?
+	puts "Rtype with java extension"
+else
+	puts "Rtype without native extension"
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rtype-java
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.3
 platform: ruby
 authors:
 - Sputnik Gugja
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-05 00:00:00.000000000 Z
+date: 2016-07-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rtype
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.6.0
+        version: 0.6.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.6.0
+        version: 0.6.3
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement