rtype-native 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7da1eeceea62ee24758dd2af72476310ba28b645
-  data.tar.gz: 4b5902e8d4a5f83939893a7d9bcee7b2d215ee5a
+  metadata.gz: 28069650cae37a261b249dc6a17e02fff057366a
+  data.tar.gz: 9aec95155efd5ce7bbde4ca1485b758b2cdce470
 SHA512:
-  metadata.gz: e6c32b52f0d3c39da572c560007d09de8aef01ff1ca8165b5254c0814a18b7fe9eaf58f6db789034b3ece1c3120e984f4db760d80b9804c9a385f35eb6e7f3c7
-  data.tar.gz: 9e32a39033098b5ac96290f6c6533ef16eaf683c713034f3c969a97b4466f685d41a0c2177d931b4cecde97622168cf98a749af523c353c2f37f30cf58cee59d
+  metadata.gz: e25171477b08e51f113596422ad0d895e183e0ded024b28029581b14eaaede365fa87947f001db53e94dc3d5b951959f9ac70913bfab794f2486eae2ea6874cd
+  data.tar.gz: 8ac147a3f4a894d8f53e160c95a516b1cea118e40bb59b8b1fdc20a8ff4e48d2a4d10c785cf481ad4b129664ffc13f86b972f5447512bd6da94a25071055ec32

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

@@ -1,6 +1,7 @@
 #include "rtype.h"
 
 VALUE rb_mRtype, rb_mRtypeBehavior, rb_cRtypeBehaviorBase, rb_eRtypeArgumentTypeError, rb_eRtypeTypeSignatureError, rb_eRtypeReturnTypeError;
+static ID id_to_s, id_keys, id_eqeq, id_include, id_valid, id_call;
 
 VALUE
 rb_rtype_valid(VALUE self, VALUE expected, VALUE value) {
@@ -11,14 +12,14 @@ rb_rtype_valid(VALUE self, VALUE expected, VALUE value) {
 		case T_SYMBOL:
 			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;
+			return rb_reg_match( expected, rb_funcall(value, id_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)) ) {
+			VALUE e_keys = rb_funcall(expected, id_keys, 0);
+			VALUE v_keys = rb_funcall(value, id_keys, 0);
+			if( !RTEST(rb_funcall(e_keys, id_eqeq, 1, v_keys)) ) {
 				return Qfalse;
 			}
 
@@ -57,13 +58,13 @@ rb_rtype_valid(VALUE self, VALUE expected, VALUE value) {
 			return !RTEST(value) ? Qtrue : Qfalse;
 		default:
 			if(rb_obj_is_kind_of(expected, rb_cRange)) {
-				return rb_funcall(expected, rb_intern("include?"), 1, value);
+				return rb_funcall(expected, id_include, 1, value);
 			}
 			else if(rb_obj_is_kind_of(expected, rb_cProc)) {
-				return RTEST(rb_funcall(expected, rb_intern("call"), 1, value)) ? Qtrue : Qfalse;
+				return RTEST(rb_funcall(expected, id_call, 1, value)) ? Qtrue : Qfalse;
 			}
 			else if( RTEST(rb_obj_is_kind_of(expected, rb_cRtypeBehaviorBase)) ) {
-				return rb_funcall(expected, rb_intern("valid?"), 1, value);
+				return rb_funcall(expected, id_valid, 1, value);
 			}
 			else {
 				VALUE str = rb_any_to_s(expected);
@@ -134,6 +135,13 @@ void Init_rtype_native(void) {
 	rb_eRtypeTypeSignatureError = rb_define_class_under(rb_mRtype, "TypeSignatureError", rb_eArgError);
 	rb_eRtypeReturnTypeError = rb_define_class_under(rb_mRtype, "ReturnTypeError", rb_eStandardError);
 
+	id_to_s = rb_intern("to_s");
+	id_keys = rb_intern("keys");
+	id_eqeq = rb_intern("==");
+	id_include = rb_intern("include?");
+	id_valid = rb_intern("valid?");
+	id_call = rb_intern("call");
+
 	rb_define_method(rb_mRtype, "valid?", rb_rtype_valid, 2);
 	rb_define_method(rb_mRtype, "assert_arguments_type", rb_rtype_assert_arguments_type, 2);
 	rb_define_method(rb_mRtype, "assert_arguments_type_with_keywords", rb_rtype_assert_arguments_type_with_keywords, 4);

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-native
 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