rtype 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 573badbc833de876d782b2e6c3fb21a0ca10cd49
-  data.tar.gz: ebd29e696a8752c8f79ac4867d24ac63cedbd72b
+  metadata.gz: c238c2b45a71c23c3d5c3a4f442d7c71f512b05b
+  data.tar.gz: a4068b256226cc7b8b16e1dbb31c1c086e892fb1
 SHA512:
-  metadata.gz: ddda1bff5a6d6f2af36d738fecd36b74f148c912de27d2f4b7c85f8f95d235eade4000746e0ab418075b9817671f734faa0a0882dc96d75f3fff995aa9b977fc
-  data.tar.gz: 74da35dc41d1b3c4380a9a405ef3ee68a87ded82eaf99269ea35fc1d504e7bfde5fa96495eeffe7fe9e218c1c03d902b7781894b2ca5472104944543d832f0e3
+  metadata.gz: a71adbd7caa172f8aeda43b017f9e8a28ff57851c96e21a4461177b24fa0e242624db8193482e07bfda8999b687179507648693eac8fd9eedcd8bbbedee84f4a
+  data.tar.gz: 0d308aeadfa63866b391c219c2d3e162722221aed6c8e6480ebc72b7fb0f934f32d173a12cef40c23a6d909425efea898dbe56129f5877c1f1ff848cd402395f

data/Gemfile

@@ -1,3 +1,3 @@
 source 'https://rubygems.org'
 
-gemspec
+gemspec :name => 'rtype'

data/README.md

@@ -31,9 +31,9 @@ Test::invert(state: 0)
 
 ## Requirements
 - Ruby >= 2.1
+- MRI or RBX if native extension is used. Rtype itself without it is pure-ruby gem, therefore you can use Rtype in JRuby, etc.
 
 ## Features
-- Very simple
 - Provide type checking for argument and return
 - Support type checking for [keyword argument](#keyword-argument)
 - [Type checking for array elements](#array)
@@ -48,6 +48,14 @@ And add to your `.rb` source file:
 require 'rtype'
 ```
 
+### Native extension
+Rtype itself is pure-ruby gem. but you can make it more faster by native extension.
+
+Just run `gem install rtype-native` or add `gem 'rtype-native'` to your `Gemfile`, then Rtype use it.
+(Do not `require 'rtype-native'`)
+
+It is only for MRI or RBX. JRuby extension not supported yet.
+
 ## Usage
 
 ### Supported Type Behaviors
@@ -360,100 +368,70 @@ Example.new.method(:test).return_type
 ## Benchmarks
 Result of `rake benchmark` ([source](https://github.com/sputnikgugja/rtype/tree/master/benchmark/benchmark.rb))
 
-The benchmark doesn't include `Rubype` gem because I can't install Rubype on my environment.
-
 ### MRI
-Rtype is 1.56x faster than Sig and 2.85x faster than Contracts
-
 ```
 Ruby version: 2.1.7
 Ruby engine: ruby
 Ruby description: ruby 2.1.7p400 (2015-08-18 revision 51632) [x64-mingw32]
-Rtype version: 0.1.1
+Rtype version: 0.2.0
+Rubype version: 0.3.1
 Sig version: 1.0.1
 Contracts version: 0.13.0
 Typecheck version: 0.1.2
 Warming up --------------------------------------
-                pure    52.239k i/100ms
-               rtype     7.861k i/100ms
-                 sig     5.680k i/100ms
-           contracts     3.514k i/100ms
-           typecheck   813.000  i/100ms
+                pure    85.600k i/100ms
+               rtype    25.735k i/100ms
+              rubype    20.922k i/100ms
+                 sig     8.960k i/100ms
+           contracts     4.659k i/100ms
+           typecheck     1.102k i/100ms
 Calculating -------------------------------------
-                pure      2.125M (±25.5%) i/s -     10.030M
-               rtype    106.900k (±13.8%) i/s -    526.687k
-                 sig     68.405k (±17.0%) i/s -    335.120k
-           contracts     37.494k (±12.1%) i/s -    186.242k
-           typecheck      9.165k (±11.7%) i/s -     45.528k
+                pure      3.273M (± 2.4%) i/s -     16.435M
+               rtype    340.376k (± 1.9%) i/s -      1.724M
+              rubype    268.253k (± 4.2%) i/s -      1.339M
+                 sig    100.050k (± 1.9%) i/s -    501.760k
+           contracts     50.027k (± 2.0%) i/s -    251.586k
+           typecheck     11.317k (± 1.4%) i/s -     57.304k
 
 Comparison:
-                pure:  2124989.5 i/s
-               rtype:   106899.8 i/s - 19.88x slower
-                 sig:    68405.0 i/s - 31.06x slower
-           contracts:    37493.9 i/s - 56.68x slower
-           typecheck:     9164.5 i/s - 231.87x slower
+                pure:  3272978.0 i/s
+               rtype:   340375.8 i/s - 9.62x slower
+              rubype:   268252.5 i/s - 12.20x slower
+                 sig:   100050.1 i/s - 32.71x slower
+           contracts:    50026.9 i/s - 65.42x slower
+           typecheck:    11317.1 i/s - 289.21x slower
 ```
 
 ### JRuby
-Rtype is 1.23x ~ 1.90x faster than Sig and 3.26x ~ 4.57x faster than Contracts
+Without Rubype that doesn't support JRuby
 
 ```
-# Test 1
-Ruby version: 2.2.3
-Ruby engine: jruby
-Ruby description: jruby 9.0.5.0 (2.2.3) 2016-01-26 7bee00d Java HotSpot(TM) 64-Bit Server VM 25.60-b23 on 1.8.0_60-b27 +jit [Windows 10-amd64]
-Rtype version: 0.1.1
-Sig version: 1.0.1
-Contracts version: 0.13.0
-Typecheck version: 0.1.2
-Warming up --------------------------------------
-                pure     7.415k i/100ms
-               rtype   883.000  i/100ms
-                 sig   922.000  i/100ms
-           contracts   408.000  i/100ms
-           typecheck   404.000  i/100ms
-Calculating -------------------------------------
-                pure      4.242M (±46.3%) i/s -     16.795M
-               rtype     55.772k (±29.1%) i/s -    249.006k
-                 sig     29.344k (±23.5%) i/s -    134.612k
-           contracts     12.192k (±29.4%) i/s -     51.816k
-           typecheck      7.503k (±23.5%) i/s -     35.148k
-
-Comparison:
-                pure:  4241753.6 i/s
-               rtype:    55771.7 i/s - 76.06x slower
-                 sig:    29344.3 i/s - 144.55x slower
-           contracts:    12192.0 i/s - 347.91x slower
-           typecheck:     7502.8 i/s - 565.36x slower
-```
-```
-# Test 2
 Ruby version: 2.2.3
 Ruby engine: jruby
 Ruby description: jruby 9.0.5.0 (2.2.3) 2016-01-26 7bee00d Java HotSpot(TM) 64-Bit Server VM 25.60-b23 on 1.8.0_60-b27 +jit [Windows 10-amd64]
-Rtype version: 0.1.1
+Rtype version: 0.2.0
 Sig version: 1.0.1
 Contracts version: 0.13.0
 Typecheck version: 0.1.2
 Warming up --------------------------------------
-                pure     7.943k i/100ms
-               rtype     1.060k i/100ms
-                 sig     1.565k i/100ms
-           contracts   365.000  i/100ms
-           typecheck   545.000  i/100ms
+                pure    29.127k i/100ms
+               rtype     4.566k i/100ms
+                 sig     4.162k i/100ms
+           contracts   776.000  i/100ms
+           typecheck   981.000  i/100ms
 Calculating -------------------------------------
-                pure      4.321M (±48.9%) i/s -     17.220M
-               rtype     56.584k (±22.5%) i/s -    266.060k
-                 sig     45.925k (±17.8%) i/s -    223.795k
-           contracts     17.338k (±20.8%) i/s -     82.490k
-           typecheck      8.449k (±16.5%) i/s -     41.420k
+                pure      6.705M (±12.0%) i/s -     32.826M
+               rtype     89.262k (± 3.3%) i/s -    447.468k
+                 sig     74.070k (± 2.0%) i/s -    370.418k
+           contracts     25.399k (± 2.9%) i/s -    127.264k
+           typecheck     12.461k (± 9.0%) i/s -     61.803k
 
 Comparison:
-                pure:  4320949.8 i/s
-               rtype:    56584.5 i/s - 76.36x slower
-                 sig:    45925.4 i/s - 94.09x slower
-           contracts:    17337.9 i/s - 249.22x slower
-           typecheck:     8449.4 i/s - 511.39x slower
+                pure:  6705166.5 i/s
+               rtype:    89262.5 i/s - 75.12x slower
+                 sig:    74070.1 i/s - 90.52x slower
+           contracts:    25398.9 i/s - 263.99x slower
+           typecheck:    12460.7 i/s - 538.10x slower
 ```
 
 ## Rubype, Sig

data/benchmark/benchmark.rb

@@ -1,6 +1,9 @@
 require 'benchmark/ips'
 
-require_relative '../lib/rtype'
+is_mri = RUBY_ENGINE == 'ruby'
+
+require "rtype"
+require "rubype" if is_mri
 require "sig"
 require "contracts"
 require "contracts/version"
@@ -11,6 +14,7 @@ puts "Ruby engine: #{RUBY_ENGINE}"
 puts "Ruby description: #{RUBY_DESCRIPTION}"
 
 puts "Rtype version: #{Rtype::VERSION}"
+puts "Rubype version: #{Rubype::VERSION}" if is_mri
 puts "Sig version: #{Sig::VERSION}"
 puts "Contracts version: #{Contracts::VERSION}"
 puts "Typecheck version: #{Typecheck::VERSION}"
@@ -46,6 +50,25 @@ class RtypeTest
 end
 rtype_obj = RtypeTest.new
 
+if is_mri
+	class RubypeTest
+		def sum(x, y)
+			x + y
+		end
+		typesig :sum, [Numeric, Numeric] => Numeric
+
+		def mul(x, y)
+			x * y
+		end
+		typesig :mul, [:to_i, :to_i] => Numeric
+
+		def args(a, b, c, d)
+		end
+		typesig :args, [Integer, Numeric, String, :to_i] => Any
+	end
+	rubype_obj = RubypeTest.new
+end
+
 class SigTest
 	sig [Numeric, Numeric], Numeric,
 	def sum(x, y)
@@ -123,6 +146,18 @@ Benchmark.ips do |x|
 		end
 	end
 
+	if is_mri
+		x.report("rubype") do |times|
+			i = 0
+			while i < times
+				rubype_obj.sum(1, 2)
+				rubype_obj.mul(1, 2)
+				rubype_obj.args(1, 2, "c", 4)
+				i += 1
+			end
+		end
+	end
+	
 	x.report("sig") do |times|
 		i = 0
 		while i < times

data/lib/rtype/behavior/nilable.rb

@@ -6,7 +6,7 @@ module Rtype
 			end
 
 			def valid?(value)
-				value.nil? || Rtype::valid?(e, value)
+				value.nil? || Rtype::valid?(@type, value)
 			end
 
 			def error_message(value)

data/lib/rtype/version.rb

@@ -1,3 +1,3 @@
 module Rtype
-	VERSION = "0.1.1".freeze
+	VERSION = "0.2.0".freeze
 end

data/lib/rtype.rb

@@ -1,3 +1,10 @@
+begin
+	require "rtype/rtype_native"
+	puts "Rtype with native extension"
+rescue LoadError
+	puts "Rtype without native extension"
+end
+
 require_relative 'rtype/core_ext'
 require_relative 'rtype/version'
 require_relative 'rtype/type_signature_error'
@@ -45,18 +52,7 @@ module Rtype
 			sig.return_type = return_sig
 			@@type_signatures[owner][method_name] = 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
+			define_typed_method_to_proxy(owner, method_name, expected_args, expected_kwargs, return_sig)
 		end
 
 		def define_typed_accessor(owner, accessor_name, type_behavior)
@@ -67,51 +63,10 @@ module Rtype
 			define_typed_method owner, setter, [type_behavior] => Any
 		end
 
-		# validate argument type
-		def valid?(expected, value)
-			case expected
-			when Module
-				value.is_a? expected
-			when Symbol
-				value.respond_to? expected
-			when Regexp
-				!!(expected =~ value.to_s)
-			when Range
-				expected.include?(value)
-			when Array
-				return false unless value.is_a?(Array)
-				return false unless expected.length == value.length
-				idx = -1
-				expected.all? { |e| idx += 1; valid?(e, value[idx]) }
-			when Proc
-				!!expected.call(value)
-			when true
-				!!value
-			when false
-				!value
-			when Rtype::Behavior::Base
-				expected.valid? value
-			else
-				raise TypeSignatureError, "Invalid type signature: Unknown type behavior #{expected}"
-			end
-		end
-
 		def type_signatures
 			@@type_signatures
 		end
 
-		def assert_arguments_type(expected_args, args)
-			# `length.times` is faster than `each_with_index`
-			args.length.times do |i|
-				expected = expected_args[i]
-				value = args[i]
-				unless expected.nil?
-					unless valid?(expected, value)
-						raise ArgumentTypeError, "for #{(i+1).ordinalize} argument:\n" + type_error_message(expected, value)
-					end
-				end
-			end
-		end
 =begin
 		def assert_keyword_arguments_type(expected_kwargs, kwargs)
 			kwargs.each do |key, value|
@@ -124,39 +79,24 @@ module Rtype
 			end
 		end
 =end
-		def assert_arguments_type_with_keywords(expected_args, args, expected_kwargs, kwargs)
-			# `length.times` is faster than `each_with_index`
-			args.length.times do |i|
-				expected = expected_args[i]
-				value = args[i]
-				unless expected.nil?
-					unless valid?(expected, value)
-						raise ArgumentTypeError, "for #{(i+1).ordinalize} argument:\n" + type_error_message(expected, value)
-					end
-				end
-			end
-			kwargs.each do |key, value|
-				expected = expected_kwargs[key]
-				unless expected.nil?
-					unless valid?(expected, value)
-						raise ArgumentTypeError, "for '#{key}' argument:\n" + type_error_message(expected, value)
-					end
-				end
-			end
+
+		def arg_type_error_message(idx, expected, value)
+			"#{arg_message(idx)}\n" + type_error_message(expected, value)
 		end
 
-		def assert_return_type(expected, result)
-			if expected.nil?
-				unless result.nil?
-					raise ReturnTypeError, "for return:\n" + type_error_message(expected, result)
-				end
-			else
-				unless valid?(expected, result)
-					raise ReturnTypeError, "for return:\n" + type_error_message(expected, result)
-				end
-			end
+		def kwarg_type_error_message(key, expected, value)
+			"#{kwarg_message(key)}\n" + type_error_message(expected, value)
+		end
+
+		def arg_message(idx)
+			"for #{(idx+1).ordinalize} argument:"
+		end
+
+		def kwarg_message(key)
+			"for '#{key}' argument:"
 		end
 
+
 		def type_error_message(expected, value)
 			case expected
 			when Rtype::Behavior::Base
@@ -199,5 +139,104 @@ module Rtype
 			arg_sig = hash.first[0]
 			arg_sig.is_a?(Array) || arg_sig.is_a?(Hash)
 		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)
+				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
+	end
+
+	unless self.respond_to?(:valid?)
+	# validate argument type
+	def self.valid?(expected, value)
+		case expected
+		when Module
+			value.is_a? expected
+		when Symbol
+			value.respond_to? expected
+		when Regexp
+			!!(expected =~ value.to_s)
+		when Range
+			expected.include?(value)
+		when Array
+			return false unless value.is_a?(Array)
+			return false unless expected.length == value.length
+			idx = -1
+			expected.all? { |e| idx += 1; valid?(e, value[idx]) }
+		when Proc
+			!!expected.call(value)
+		when true
+			!!value
+		when false
+			!value
+		when Rtype::Behavior::Base
+			expected.valid? value
+		else
+			raise TypeSignatureError, "Invalid type signature: Unknown type behavior #{expected}"
+		end
+	end
+	end
+
+	unless self.respond_to?(:assert_arguments_type)
+	def self.assert_arguments_type(expected_args, args)
+		# `length.times` is faster than `each_with_index`
+		args.length.times do |i|
+			expected = expected_args[i]
+			value = args[i]
+			unless expected.nil?
+				unless valid?(expected, value)
+					raise ArgumentTypeError, "for #{(i+1).ordinalize} argument:\n" + type_error_message(expected, value)
+				end
+			end
+		end
+	end
+	end
+
+	unless self.respond_to?(:assert_arguments_type_with_keywords)
+	def self.assert_arguments_type_with_keywords(expected_args, args, expected_kwargs, kwargs)
+		# `length.times` is faster than `each_with_index`
+		args.length.times do |i|
+			expected = expected_args[i]
+			value = args[i]
+			unless expected.nil?
+				unless valid?(expected, value)
+					raise ArgumentTypeError, "#{arg_message(idx)}\n" + type_error_message(expected, value)
+				end
+			end
+		end
+		kwargs.each do |key, value|
+			expected = expected_kwargs[key]
+			unless expected.nil?
+				unless valid?(expected, value)
+					raise ArgumentTypeError, "#{kwarg_message(key)}\n" + type_error_message(expected, value)
+				end
+			end
+		end
+	end
+	end
+
+	unless self.respond_to?(:assert_return_type)
+	def self.assert_return_type(expected, result)
+		if expected.nil?
+			unless result.nil?
+				raise ReturnTypeError, "for return:\n" + type_error_message(expected, result)
+			end
+		else
+			unless valid?(expected, result)
+				raise ReturnTypeError, "for return:\n" + type_error_message(expected, result)
+			end
+		end
+	end
 	end
 end

data/spec/rtype_spec.rb

@@ -3,10 +3,22 @@ require_relative 'spec_helper'
 describe Rtype do
 	let(:klass) do
 		Class.new do
+			attr_accessor :value
+
+			def initialize
+				@value = 123
+			end
+
 			def return_arg(obj)
 				obj
 			end
 
+			def three_args(a, b, c)
+			end
+
+			def three_kwargs(a:, b:, c:)
+			end
+
 			def return_nil(obj)
 				nil
 			end
@@ -265,6 +277,40 @@ describe Rtype do
 				}.to raise_error Rtype::TypeSignatureError
 			end
 		end
+
+		describe 'Special type behaviors' do
+			it 'Rtype::Behavior::And' do
+				klass.send :rtype, :return_nil, [Rtype.and(:to_i, :chars)] => nil
+				instance.return_nil("Hello")
+				expect {instance.return_nil(123)}.to raise_error Rtype::ArgumentTypeError
+			end
+
+			it 'Rtype::Behavior::Or' 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 'Rtype::Behavior::Nilable' do
+				klass.send :rtype, :return_nil, [Rtype.nilable(Integer)] => nil
+				instance.return_nil(nil)
+				instance.return_nil(123)
+				expect {instance.return_nil("abc")}.to raise_error Rtype::ArgumentTypeError
+			end
+
+			it 'Rtype::Behavior::Not' do
+				klass.send :rtype, :return_nil, [Rtype.not(String)] => nil
+				instance.return_nil(123)
+				expect {instance.return_nil("abc")}.to raise_error Rtype::ArgumentTypeError
+			end
+
+			it 'Rtype::Behavior::Xor' do
+				klass.send :rtype, :return_nil, [Rtype.xor(:to_i, String)] => nil
+				instance.return_nil(123)
+				expect {instance.return_nil("abc")}.to raise_error Rtype::ArgumentTypeError
+			end
+		end
 	end
 
 	describe 'Signature' do
@@ -433,5 +479,63 @@ describe Rtype do
 				expect {instance.private_func}.to raise_error NoMethodError
 			end
 		end
+
+		context 'with empty argument signature' do
+			it 'accept any arguments' do
+				klass.send :rtype, :three_args, [] => Any
+				instance.three_args("abc", 123, 456)
+			end
+		end
+
+		context 'when args length is more than arg signature length' do
+			it 'type checking ignore rest args' do
+				klass.send :rtype, :three_args, [String] => Any
+				instance.three_args("abc", 123, 456)
+			end
+		end
+
+		context 'when keyword args contain a key not configured to rtype' do
+			it 'type checking ignore the key' do
+				klass.send :rtype, :three_kwargs, {a: String} => Any
+				instance.three_kwargs(a: "abc", b: 123, c: 456)
+			end
+		end
+	end
+
+	describe "Call Rtype`s static method directly" do
+		it 'Rtype::define_typed_method' do
+			Rtype::define_typed_method klass, :return_arg, [String] => Any
+			expect {instance.return_arg(123)}.to raise_error Rtype::ArgumentTypeError
+		end
+
+		it 'Rtype::define_typed_accessor' do
+			Rtype::define_typed_accessor klass, :value, String
+			expect { instance.value = 123 }.to raise_error Rtype::ArgumentTypeError
+			expect { instance.value }.to raise_error Rtype::ReturnTypeError
+		end
+		
+		it 'Rtype::valid?' do
+			expect {
+				Rtype::valid?("Invalid type behavior", "Test Value")
+			}.to raise_error Rtype::TypeSignatureError
+		end
+		
+		it 'Rtype::assert_arguments_type' do
+			expect {
+				Rtype::assert_arguments_type([Integer, String], [123, 123])
+			}.to raise_error Rtype::ArgumentTypeError
+		end
+		
+		it 'Rtype::assert_arguments_type_with_keywords' do
+			expect {
+				Rtype::assert_arguments_type_with_keywords([Integer, String], [123, "abc"], {arg: String}, {arg: 123})
+			}.to raise_error Rtype::ArgumentTypeError
+		end
+		
+		it 'Rtype::assert_return_type' do
+			expect {
+				Rtype::assert_return_type nil, "No nil"
+			}.to raise_error Rtype::ReturnTypeError
+		end
 	end
 end

data/spec/spec_helper.rb

@@ -1,6 +1,5 @@
-require 'coveralls'
-Coveralls.wear!
-
-# $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
-require_relative '../lib/rtype'
+require 'coveralls'
+Coveralls.wear!
+
+require 'rtype'
 require 'rspec'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rtype
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Sputnik Gugja
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-13 00:00:00.000000000 Z
+date: 2016-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -90,7 +90,7 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - "~>"
     - !ruby/object:Gem::Version
       version: '2.1'
 required_rubygems_version: !ruby/object:Gem::Requirement