rtype 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c4bad8e7cdc12a3c4a598e806553fd89c184c212
-  data.tar.gz: 67576b9e8839a9f1988ee4f561cb0474824ecb84
+  metadata.gz: 3e11e54455d379c4d6317ad318c97065c003f4de
+  data.tar.gz: 5111741978b57a0ed2741dcc936329bb8590a63b
 SHA512:
-  metadata.gz: 4b82873431c88b2811b9ee34bdd84a3f23e683cbf4baaba9c57da29954b34869a3739db623496f0e07af92b8eab5750d10d523b3e93c3cf91080a5a36c5dd5fb
-  data.tar.gz: 29a5f2356be7ed7637841a0a240689cd11f7d19f73ce5b5447c8ec99bb497ee931e2c48706048efacffe4d15c7a73619b184b49e53bbb9c920dfd328905e4954
+  metadata.gz: 16573abd845d6ce88f84014bbc7be4ad39a7b5a78dba4613729b00451983ba697d1b7ee2679f76c95bce06b4ae952254ccf1676c739289215f95e04c7418ca6b
+  data.tar.gz: d784a35084da9e02ff50cfd80a8c18867b8a0ca7133a2e4697d15f3e754db56f24ea55037afa398f6203962e93c27ba649036cd41736eefe700f00adc04797db

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/lib/rtype/core_ext.rb

@@ -3,21 +3,35 @@ class TrueClass; include Boolean; end
 class FalseClass; include Boolean; end
 Any = BasicObject
 
+class Object
+	include ::Rtype::MethodAnnotator
+end
+
 module Kernel
 private
 	def _rtype_proxy
 		unless @_rtype_proxy
-			@_rtype_proxy = Module.new
+			@_rtype_proxy = ::Rtype::RtypeProxy.new
 			prepend @_rtype_proxy
 		end
 		@_rtype_proxy
 	end
 
-	def rtype(method_name, type_sig_info)
+	def rtype(method_name=nil, type_sig_info)
 		if is_a?(Module)
-			::Rtype::define_typed_method(self, method_name, type_sig_info)
+			if method_name.nil?
+				::Rtype::assert_valid_type_sig(type_sig_info)
+				_rtype_proxy.annotation_mode = true
+				_rtype_proxy.annotation_type_sig = type_sig_info
+			else
+				::Rtype::define_typed_method(self, method_name, type_sig_info)
+			end
 		else
-			rtype_self(method_name, type_sig_info)
+			if method_name.nil?
+				raise ArgumentError, "Annotation mode not working out of module"
+			else
+				rtype_self(method_name, type_sig_info)
+			end
 		end
 	end
 
@@ -26,6 +40,11 @@ private
 	end
 
 	def rtype_accessor(accessor_name, type_behavior)
+		accessor_name = accessor_name.to_sym
+		if !respond_to?(accessor_name) || !respond_to?(:"#{accessor_name}=")
+			attr_accessor accessor_name
+		end
+
 		if is_a?(Module)
 			::Rtype::define_typed_accessor(self, accessor_name, type_behavior)
 		else
@@ -34,6 +53,10 @@ private
 	end
 
 	def rtype_accessor_self(accessor_name, type_behavior)
+		accessor_name = accessor_name.to_sym
+		if !respond_to?(accessor_name) || !respond_to?(:"#{accessor_name}=")
+			singleton_class.send(:attr_accessor, accessor_name)
+		end
 		::Rtype::define_typed_accessor(singleton_class, accessor_name, type_behavior)
 	end
 end

data/lib/rtype/method_annotator.rb

@@ -0,0 +1,31 @@
+module Rtype
+	module MethodAnnotator
+		def self.included(base)
+			base.extend ClassMethods
+		end
+
+		module ClassMethods
+			def method_added(name)
+				if @_rtype_proxy
+					proxy = _rtype_proxy
+					if proxy.annotation_mode
+						::Rtype::define_typed_method(self, name, proxy.annotation_type_sig)
+						proxy.annotation_mode = false
+						proxy.annotation_type_sig = nil
+					end
+				end
+			end
+
+			def singleton_method_added(name)
+				if @_rtype_proxy
+					proxy = _rtype_proxy
+					if proxy.annotation_mode
+						::Rtype::define_typed_method(singleton_class, name, proxy.annotation_type_sig)
+						proxy.annotation_mode = false
+						proxy.annotation_type_sig = nil
+					end
+				end
+			end
+		end
+	end
+end

data/lib/rtype/rtype_proxy.rb

@@ -0,0 +1,10 @@
+module Rtype
+	class RtypeProxy < Module
+		attr_accessor :annotation_mode
+		attr_accessor :annotation_type_sig
+		def initialize
+			@annotation_mode = false
+			@annotation_type_sig = nil
+		end
+	end
+end

data/lib/rtype/version.rb

@@ -1,3 +1,3 @@
 module Rtype
-	VERSION = "0.4.0".freeze
+	VERSION = "0.5.0".freeze
 end

data/lib/rtype.rb

@@ -15,6 +15,8 @@ else
 	end
 end
 
+require_relative 'rtype/rtype_proxy'
+require_relative 'rtype/method_annotator'
 require_relative 'rtype/core_ext'
 require_relative 'rtype/version'
 require_relative 'rtype/type_signature_error'
@@ -31,9 +33,9 @@ module Rtype
 	@@type_signatures = Hash.new({})
 
 	def define_typed_method(owner, method_name, type_sig_info)
-		raise TypeSignatureError, "Invalid type signature" unless valid_type_sig_info_form?(type_sig_info)
 		method_name = method_name.to_sym
 		raise ArgumentError, "method_name is nil" if method_name.nil?
+		assert_valid_type_sig(type_sig_info)
 
 		el = type_sig_info.first
 		arg_sig = el[0]
@@ -51,13 +53,6 @@ module Rtype
 			expected_kwargs = arg_sig
 		end
 
-		expected_args.each { |e| check_valid_argument_type_sig(e) }
-		if expected_kwargs.keys.any? { |e| !e.is_a?(Symbol) }
-			raise TypeSignatureError, "Invalid type signature: keyword arguments contain non-symbol key"
-		end
-		expected_kwargs.each_value { |e| check_valid_argument_type_sig(e) }
-		check_valid_return_type_sig(return_sig)
-
 		sig = TypeSignature.new
 		sig.argument_type = arg_sig
 		sig.return_type = return_sig
@@ -158,30 +153,41 @@ module Rtype
 		end
 	end
 
-private
-	def valid_type_sig_info_form?(hash)
-		return false unless hash.is_a?(Hash)
-		arg_sig = hash.first[0]
-		arg_sig.is_a?(Array) || arg_sig.is_a?(Hash)
+	def assert_valid_type_sig(sig)
+		unless sig.is_a?(Hash)
+			raise TypeSignatureError, "Invalid type signature: type signature is not hash"
+		end
+		if sig.empty?
+			raise TypeSignatureError, "Invalid type signature: type signature is empty hash"
+		end
+		assert_valid_arguments_type_sig(sig.first[0])
+		assert_valid_return_type_sig(sig.first[1])
 	end
 
-	def define_typed_method_to_proxy(owner, method_name, expected_args, expected_kwargs, return_sig)
-		# `send` is faster than `method(...).call`
-		owner.send(:_rtype_proxy).send :define_method, method_name do |*args, **kwargs, &block|
-			if kwargs.empty?
-				::Rtype.assert_arguments_type(expected_args, args)
-				result = super(*args, &block)
+	def assert_valid_arguments_type_sig(sig)
+		if sig.is_a?(Array)
+			sig = sig.dup
+			if sig.last.is_a?(Hash)
+				kwargs = sig.pop
 			else
-				::Rtype.assert_arguments_type_with_keywords(expected_args, args, expected_kwargs, kwargs)
-				result = super(*args, **kwargs, &block)
+				kwargs = {}
 			end
-			::Rtype.assert_return_type(return_sig, result)
-			result
+			sig.each { |e| assert_valid_argument_type_sig_element(e) }
+			if kwargs.keys.any? { |e| !e.is_a?(Symbol) }
+				raise TypeSignatureError, "Invalid type signature: keyword arguments contain non-symbol key"
+			end
+			kwargs.each_value { |e| assert_valid_argument_type_sig_element(e) }
+		elsif sig.is_a?(Hash)
+			if sig.keys.any? { |e| !e.is_a?(Symbol) }
+				raise TypeSignatureError, "Invalid type signature: keyword arguments contain non-symbol key"
+			end
+			sig.each_value { |e| assert_valid_argument_type_sig_element(e) }
+		else
+			raise TypeSignatureError, "Invalid type signature: arguments type signature is neither array nor hash"
 		end
-		nil
 	end
 
-	def check_valid_argument_type_sig(sig)
+	def assert_valid_argument_type_sig_element(sig)
 		case sig
 		when Rtype::Behavior::Base
 		when Module
@@ -190,11 +196,11 @@ private
 		when Range
 		when Array
 			sig.each do |e|
-				check_valid_argument_type_sig(e)
+				assert_valid_argument_type_sig_element(e)
 			end
 		when Hash
 			sig.each_value do |e|
-				check_valid_argument_type_sig(e)
+				assert_valid_argument_type_sig_element(e)
 			end
 		when Proc
 		when true
@@ -204,8 +210,25 @@ private
 		end
 	end
 
-	def check_valid_return_type_sig(sig)
-		check_valid_argument_type_sig(sig) unless sig.nil?
+	def assert_valid_return_type_sig(sig)
+		assert_valid_argument_type_sig_element(sig) unless sig.nil?
+	end
+
+private
+	def define_typed_method_to_proxy(owner, method_name, expected_args, expected_kwargs, return_sig)
+		# `send` is faster than `method(...).call`
+		owner.send(:_rtype_proxy).send :define_method, method_name do |*args, **kwargs, &block|
+			if kwargs.empty?
+				::Rtype::assert_arguments_type(expected_args, args)
+				result = super(*args, &block)
+			else
+				::Rtype::assert_arguments_type_with_keywords(expected_args, args, expected_kwargs, kwargs)
+				result = super(*args, **kwargs, &block)
+			end
+			::Rtype::assert_return_type(return_sig, result)
+			result
+		end
+		nil
 	end
 
 public

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
 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: rake
@@ -75,7 +75,9 @@ files:
 - lib/rtype/behavior/or.rb
 - lib/rtype/behavior/xor.rb
 - lib/rtype/core_ext.rb
+- lib/rtype/method_annotator.rb
 - lib/rtype/return_type_error.rb
+- lib/rtype/rtype_proxy.rb
 - lib/rtype/type_signature.rb
 - lib/rtype/type_signature_error.rb
 - lib/rtype/version.rb