rtype-java 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d1db60aac3cff94cb673635875a2d5d8934a04b1
-  data.tar.gz: d44fdf33d45d9529c1fc03b623c1db7b77820c59
+  metadata.gz: f73ed6d853396aaf617ccca2503d24072a8157ff
+  data.tar.gz: 297450a94daa1c4b09f62a8d4ca5a5fdd6ce0c50
 SHA512:
-  metadata.gz: 828c8ab1a5d672c827328903960e33596b7d6ec39dac3307aa7aa1b33f03345eda025fad28d4f4683d2e1c7f80923b5295c8f61727e1d0690f1d29c25f308b92
-  data.tar.gz: 45a47173735f210b8c802e556aed6ac8393a294f0f0db6347dc4df0df908bdf9af34ffa156aeb0233f2dfc5cbe68f694a2ed172898e046bc94f61e591bc099a0
+  metadata.gz: a0c0a88a1228c732e986dfb071448ba3c96d5e2fb8406b0052e6521b9744dcda54cb1cc1eccf6d8b59cea211c17924a0dbc31894ee19cab3d7b50bf87323ec04
+  data.tar.gz: da199e102782202cdc1e06f4d0f94fc759b60d376d87f2bc2366d92be01613e7ab28a2ddf21273593edb9beebabf02f9fa6b14549a6a44bc6f34051f411b8e0c

data/README.md

@@ -8,22 +8,22 @@ You can do the type checking in Ruby with this gem!
 ```ruby
 require 'rtype'
 
-rtype :sum, [:to_i, Numeric] => Numeric
-def sum(a, b)
-  a.to_i + b
-end
-
-sum(123, "asd")
-# (Rtype::ArgumentTypeError) for 2nd argument:
-# Expected "asd" to be a Numeric
-
 class Test
-  rtype_self :invert, {state: Boolean} => Boolean
+  rtype [:to_i, Numeric] => Numeric
+  def sum(a, b)
+    a.to_i + b
+  end
+
+  rtype {state: Boolean} => Boolean
   def self.invert(state:)
     !state
   end
 end
 
+Test.new.sum(123, "asd")
+# (Rtype::ArgumentTypeError) for 2nd argument:
+# Expected "asd" to be a Numeric
+
 Test::invert(state: 0)
 # (Rtype::ArgumentTypeError) for 'state' argument:
 # Expected 0 to be a Boolean
@@ -102,7 +102,7 @@ then, Rtype use it. (Do not `require 'rtype-java'`)
   - 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
+  - vs Keyword arguments
     - `[{}]` 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)
@@ -158,15 +158,15 @@ then, Rtype use it. (Do not `require 'rtype-java'`)
 require 'rtype'
 
 class Example
-  rtype :test, [Integer] => nil
+  rtype [Integer] => nil
   def test(i)
   end
   
-  rtype :any_type_arg, [Any] => nil
+  rtype [Any] => nil
   def any_type_arg(arg)
   end
   
-  rtype :return_type_test, [] => Integer
+  rtype [] => Integer
   def return_type_test
     "not integer"
   end
@@ -189,13 +189,13 @@ e.return_type_test
 require 'rtype'
 
 class Example
-  rtype :say_your_name, {name: String} => Any
+  rtype {name: String} => Any
   def say_your_name(name:)
     puts "My name is #{name}"
   end
   
   # Mixing positional arguments and keyword arguments
-  rtype :name_and_age, [String, {age: Integer}] => Any
+  rtype [String, {age: Integer}] => Any
   def name_and_age(name, age:)
     puts "Name: #{name}, Age: #{age}"
   end
@@ -214,7 +214,7 @@ Example.new.say_your_name(name: 12345)
 require 'rtype'
 
 class Duck
-  rtype :says, [:to_i] => Any
+  rtype [:to_i] => Any
   def says(i)
     puts "duck:" + " quack"*i.to_i
   end
@@ -286,7 +286,7 @@ func({msg: "hello hash"}, {}) # hello hash
 ```
 
 #### rtype with attr_accessor
-`rtype_accessor`
+`rtype_accessor` : call attr_accessor and make it typed method
 
 You can use `rtype_accessor_self` for static accessor.
 
@@ -295,7 +295,7 @@ require 'rtype'
 
 class Example
   rtype_accessor :value, String
-  attr_accessor :value
+
   def initialize
     @value = 456
   end
@@ -316,9 +316,9 @@ Example.new.value
 require 'rtype'
 
 class Example
-  rtype :and_test, [String.and(:func)] => Any
+  rtype [String.and(:func)] => Any
   # also works:
-  # rtype :and_test, [Rtype::and(String, :func)] => Any
+  # rtype [Rtype::and(String, :func)] => Any
   def and_test(arg)
   end
 end
@@ -354,7 +354,7 @@ module Game
   class Player < Entity
     include Rtype::Behavior
 
-    rtype :attack, [And[*ENEMY]] => Any
+    rtype [And[*ENEMY]] => Any
     def attacks(enemy)
       "Player attacks '#{enemy.name}' (level #{enemy.level})!"
     end
@@ -375,12 +375,18 @@ Game::Player.new.attacks Game::Slime.new
 # Player attacks 'Powerful Slime' (level 123)!
 ```
 
-#### Position of `rtype` && (symbol || string)
+#### Position of `rtype` && (Specify method name || annotation mode) && (Symbol || String)
 ```ruby
 require 'rtype'
 
 class Example
-  # Works. Recommended
+  # Recommended. Annotation mode (no method name required)
+  rtype [Integer, String] => String
+  def hello_world(i, str)
+    puts "Hello? #{i} #{st
+  end
+
+  # Works (specifying method name)
   rtype :hello_world, [Integer, String] => String
   def hello_world(i, str)
     puts "Hello? #{i} #{st
@@ -397,11 +403,17 @@ class Example
   def hello_world_three(i, str)
     puts "Hello? #{i} #{str}"
   end
+
+  # Don't works. `rtype` works for next method
+  def hello_world_four(i, str)
+    puts "Hello? #{i} #{str}"
+  end
+  rtype [Integer, String] => String
 end
 ```
 
 #### Outside of module (root)
-Yes, it works
+Outside of module, annotation mode don't works. You must specify method name.
 
 ```ruby
 rtype :say, [String] => Any
@@ -409,11 +421,29 @@ def say(message)
   puts message
 end
 
-say "Hello" # Hello
+Test.new.say "Hello" # Hello
+
+rtype [String] => Any
+# (ArgumentError) Annotation mode not working out of module
 ```
 
 #### Static(singleton) method
-Use `rtype_self`
+rtype annotation mode works both instance and class method
+
+```ruby
+require 'rtype'
+
+class Example
+  rtype [:to_i] => Any
+  def self.say_ya(i)
+    puts "say" + " ya"*i.to_i
+  end
+end
+
+Example::say_ya(3) #say ya ya ya
+```
+
+however, if you specify method name, you must use `rtype_self` instead of `rtype`
 
 ```ruby
 require 'rtype'
@@ -437,7 +467,7 @@ Any change of this doesn't affect type checking
 require 'rtype'
 
 class Example
-  rtype :test, [:to_i] => Any
+  rtype [:to_i] => Any
   def test(i)
   end
 end

data/benchmark/benchmark.rb

@@ -34,17 +34,17 @@ end
 pure_obj = PureTest.new
 
 class RtypeTest
-	rtype :sum, [Numeric, Numeric] => Numeric
+	rtype [Numeric, Numeric] => Numeric
 	def sum(x, y)
 		x + y
 	end
 
-	rtype :mul, [:to_i, :to_i] => Numeric
+	rtype [:to_i, :to_i] => Numeric
 	def mul(x, y)
 		x * y
 	end
 
-	rtype :args, [Integer, Numeric, String, :to_i] => Any
+	rtype [Integer, Numeric, String, :to_i] => Any
 	def args(a, b, c, d)
 	end
 end

data/spec/rtype_spec.rb

@@ -62,6 +62,38 @@ describe Rtype do
 	end
 
 	describe 'Kernel#rtype' do
+		context "with annotation mode" do
+			it "works with instance method" do
+				class AnnotationTest
+					rtype [String] => Any
+					def test(str)
+					end
+				end
+				expect {
+					AnnotationTest.new.test(123)
+				}.to raise_error Rtype::ArgumentTypeError
+			end
+			it "works with class method" do
+				class AnnotationTest
+					rtype [String] => Any
+					def self.class_method_test(str)
+					end
+				end
+				expect {
+					AnnotationTest::class_method_test(123)
+				}.to raise_error Rtype::ArgumentTypeError
+			end
+			context "outside of module" do
+				it "doesn't works" do
+					expect {
+						rtype [String] => Any
+						def annotation_test(str)
+						end
+					}.to raise_error ArgumentError
+				end
+			end
+		end
+
 		it "outside of module" do
 			rtype :test_args, [String] => Any
 			def test_args(str)
@@ -119,7 +151,6 @@ describe Rtype do
 	it 'Kernel#rtype_accessor' do
 		class TestClass
 			rtype_accessor :value, String
-			attr_accessor :value
 
 			def initialize
 				@value = 123
@@ -134,12 +165,6 @@ describe Rtype do
 			@@val = 123
 
 			rtype_accessor_self :value, String
-			def self.value=(val)
-				@@val = val
-			end
-			def self.value
-				@@val
-			end
 		end
 		expect {TestClass::value = 123}.to raise_error Rtype::ArgumentTypeError
 		expect {TestClass::value}.to raise_error Rtype::ReturnTypeError
@@ -198,11 +223,15 @@ describe Rtype do
 			end
 			it "is wrong args" do
 				klass.send :rtype, :return_arg, [1..10] => Any
-				expect {instance.return_arg(1001)}.to raise_error Rtype::ArgumentTypeError
+				expect {
+					instance.return_arg(1001)
+				}.to raise_error Rtype::ArgumentTypeError
 			end
 			it "is wrong result" do
 				klass.send :rtype, :return_nil, [Any] => 1..10
-				expect {instance.return_nil(5)}.to raise_error Rtype::ReturnTypeError
+				expect {
+					instance.return_nil(5)
+				}.to raise_error Rtype::ReturnTypeError
 			end
 		end
 
@@ -549,13 +578,13 @@ describe Rtype do
 		end
 
 		describe 'wrong case' do
-			describe 'invalid signature form' do
-				it 'invalid argument signature' do
+			describe 'invalid type signature' do
+				it 'invalid arguments type signature' do
 					expect {
 						klass.send :rtype, :return_arg, Any => nil
 					}.to raise_error Rtype::TypeSignatureError
 				end
-				it 'invalid return signature' do
+				it 'invalid return type signature' do
 					expect {
 						klass.send :rtype, :return_arg, [] => 123
 					}.to raise_error Rtype::TypeSignatureError
@@ -590,6 +619,18 @@ describe Rtype do
 						klass.send :rtype, :return_arg, [] => "abc"
 					}.to raise_error Rtype::TypeSignatureError
 				end
+
+				context "with annotation mode" do
+					it 'works' do
+						expect {
+							class AnnotationTest
+								rtype [String, 123] => Any
+								def invalid_test(arg)
+								end
+							end
+						}.to raise_error Rtype::TypeSignatureError
+					end
+				end
 			end
 		end
 	end
@@ -672,6 +713,40 @@ describe Rtype do
 				}.to raise_error Rtype::ArgumentTypeError
 			end
 		end
+
+		it "One rtype annotation affect only one method" do
+			class AnnotationTest
+				rtype [String] => Any
+				def one(str)
+				end
+
+				def two(str)
+				end
+			end
+			expect {
+				AnnotationTest.new.one(123)
+			}.to raise_error Rtype::ArgumentTypeError
+			AnnotationTest.new.two(123)
+		end
+
+		it "One rtype annotation affect only one method, regardless of instance method or class method" do
+			class AnnotationTest2
+				rtype [String] => Any
+				def self.static_one(str)
+				end
+
+				def inst_one(str)
+				end
+
+				def self.static_two(str)
+				end
+			end
+			expect {
+				AnnotationTest2::static_one(123)
+			}.to raise_error Rtype::ArgumentTypeError
+			AnnotationTest2.new.inst_one(123)
+			AnnotationTest2::static_two(123)
+		end
 	end
 
 	describe "Call Rtype`s static method directly" do
@@ -687,6 +762,12 @@ describe Rtype do
 		end
 		
 		it 'Rtype::valid?' do
+			expect(
+				Rtype::valid?(String, "str")
+			).to be true
+			expect(
+				Rtype::valid?(Integer, "str")
+			).to be false
 			expect {
 				Rtype::valid?("Invalid type behavior", "Test Value")
 			}.to raise_error Rtype::TypeSignatureError
@@ -709,5 +790,33 @@ describe Rtype do
 				Rtype::assert_return_type nil, "No nil"
 			}.to raise_error Rtype::ReturnTypeError
 		end
+		
+		it 'Rtype::assert_valid_type_sig' do
+			Rtype::assert_valid_type_sig([Integer, String] => Any)
+			expect {
+				Rtype::assert_valid_type_sig([Integer, String])
+			}.to raise_error Rtype::TypeSignatureError
+		end
+		
+		it 'Rtype::assert_valid_arguments_type_sig' do
+			Rtype::assert_valid_arguments_type_sig([Integer, String])
+			expect {
+				Rtype::assert_valid_arguments_type_sig("[Integer, String]")
+			}.to raise_error Rtype::TypeSignatureError
+		end
+		
+		it 'Rtype::assert_valid_argument_type_sig_element' do
+			Rtype::assert_valid_argument_type_sig_element(Integer)
+			expect {
+				Rtype::assert_valid_argument_type_sig_element("Integer")
+			}.to raise_error Rtype::TypeSignatureError
+		end
+		
+		it 'Rtype::assert_valid_return_type_sig' do
+			Rtype::assert_valid_return_type_sig(Integer)
+			expect {
+				Rtype::assert_valid_return_type_sig("Integer")
+			}.to raise_error Rtype::TypeSignatureError
+		end
 	end
 end

metadata

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