rtype 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c238c2b45a71c23c3d5c3a4f442d7c71f512b05b
-  data.tar.gz: a4068b256226cc7b8b16e1dbb31c1c086e892fb1
+  metadata.gz: 580a93433f2e77fc81b6a9abd7b14d390952f05d
+  data.tar.gz: 78f18ddfed8634652bc9c0da161dec708db99293
 SHA512:
-  metadata.gz: a71adbd7caa172f8aeda43b017f9e8a28ff57851c96e21a4461177b24fa0e242624db8193482e07bfda8999b687179507648693eac8fd9eedcd8bbbedee84f4a
-  data.tar.gz: 0d308aeadfa63866b391c219c2d3e162722221aed6c8e6480ebc72b7fb0f934f32d173a12cef40c23a6d909425efea898dbe56129f5877c1f1ff848cd402395f
+  metadata.gz: e6df637fa65774fcf9addcf06dc4b8fc526587e1cfe448229644b8756f17129f603086a90a68d16422900f5b20020927bd67e403f8550ffb1823b4484d365d39
+  data.tar.gz: 653c366459022762cf1e5ded44eac4452365b6549f23efad8c1f875eb785ed14d56788d72efe222d6a76906367f908b7594f22c6372707c931079d2af104a5bb

data/README.md

@@ -31,7 +31,10 @@ 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.
+- MRI or RBX
+  - If C native extension is used, otherwise it is not required
+- JRuby
+  - If Java extension is used, otherwise it is not required
 
 ## Features
 - Provide type checking for argument and return
@@ -49,12 +52,29 @@ require 'rtype'
 ```
 
 ### Native extension
-Rtype itself is pure-ruby gem. but you can make it more faster by native extension.
+Rtype itself is pure-ruby gem. but you can make it more faster by using 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'`)
+#### Native extension for MRI, RBX
+Just run
+```ruby
+gem install rtype-native
+```
+or add to your `Gemfile`:
+```ruby
+gem 'rtype-native'
+```
+then, Rtype use it. (Do not `require 'rtype-native'`)
 
-It is only for MRI or RBX. JRuby extension not supported yet.
+#### Java extension for JRuby
+Just run
+```ruby
+gem install rtype-java
+```
+or add to your `Gemfile`:
+```ruby
+gem 'rtype-java'
+```
+then, Rtype use it. (Do not `require 'rtype-java'`)
 
 ## Usage
 
@@ -370,68 +390,70 @@ Result of `rake benchmark` ([source](https://github.com/sputnikgugja/rtype/tree/
 
 ### MRI
 ```
+Rtype with C native extension
 Ruby version: 2.1.7
 Ruby engine: ruby
 Ruby description: ruby 2.1.7p400 (2015-08-18 revision 51632) [x64-mingw32]
-Rtype version: 0.2.0
+Rtype version: 0.3.0
 Rubype version: 0.3.1
 Sig version: 1.0.1
 Contracts version: 0.13.0
 Typecheck version: 0.1.2
 Warming up --------------------------------------
-                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
+                pure    85.328k i/100ms
+               rtype    25.665k i/100ms
+              rubype    21.414k i/100ms
+                 sig     8.921k i/100ms
+           contracts     4.638k i/100ms
+           typecheck     1.110k i/100ms
 Calculating -------------------------------------
-                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
+                pure      3.282M (± 2.7%) i/s -     16.468M
+               rtype    339.065k (± 2.6%) i/s -      1.720M
+              rubype    266.893k (± 5.9%) i/s -      1.349M
+                 sig     99.952k (± 2.1%) i/s -    499.576k
+           contracts     49.693k (± 1.5%) i/s -    250.452k
+           typecheck     11.356k (± 1.6%) i/s -     57.720k
 
 Comparison:
-                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
+                pure:  3282431.9 i/s
+               rtype:   339064.9 i/s - 9.68x slower
+              rubype:   266892.9 i/s - 12.30x slower
+                 sig:    99952.2 i/s - 32.84x slower
+           contracts:    49693.0 i/s - 66.05x slower
+           typecheck:    11355.9 i/s - 289.05x slower
 ```
 
 ### JRuby
 Without Rubype that doesn't support JRuby
 
 ```
+Rtype with Java extension
 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.2.0
+Rtype version: 0.3.0
 Sig version: 1.0.1
 Contracts version: 0.13.0
 Typecheck version: 0.1.2
 Warming up --------------------------------------
-                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
+                pure     9.994k i/100ms
+               rtype     6.181k i/100ms
+                 sig     4.041k i/100ms
+           contracts   951.000  i/100ms
+           typecheck   970.000  i/100ms
 Calculating -------------------------------------
-                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
+                pure      7.128M (?±35.6%) i/s -     30.831M
+               rtype    121.556k (?± 6.2%) i/s -    605.738k
+                 sig     72.187k (?± 6.4%) i/s -    359.649k
+           contracts     24.984k (?± 3.9%) i/s -    125.532k
+           typecheck     12.041k (?± 9.5%) i/s -     60.140k
 
 Comparison:
-                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
+                pure:  7128373.0 i/s
+               rtype:   121555.8 i/s - 58.64x slower
+                 sig:    72186.8 i/s - 98.75x slower
+           contracts:    24984.5 i/s - 285.31x slower
+           typecheck:    12041.0 i/s - 592.01x slower
 ```
 
 ## Rubype, Sig

data/lib/rtype/version.rb

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

data/lib/rtype.rb

@@ -1,8 +1,18 @@
-begin
-	require "rtype/rtype_native"
-	puts "Rtype with native extension"
-rescue LoadError
-	puts "Rtype without native extension"
+if defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
+	begin
+		require 'java'
+		require 'rtype/rtype_java'
+		puts "Rtype with Java extension"
+	rescue LoadError
+		puts "Rtype without native extension"
+	end
+else
+	begin
+		require "rtype/rtype_native"
+		puts "Rtype with C native extension"
+	rescue LoadError
+		puts "Rtype without native extension"
+	end
 end
 
 require_relative 'rtype/core_ext'
@@ -14,152 +24,153 @@ require_relative 'rtype/type_signature'
 require_relative 'rtype/behavior'
 
 module Rtype
+	extend self
+
 	# This is just the 'information'
 	# Any change of this doesn't affect type checking
 	@@type_signatures = Hash.new({})
 
-	class << self
-		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?
-
-			el = type_sig_info.first
-			arg_sig = el[0]
-			return_sig = el[1]
-
-			if arg_sig.is_a?(Array)
-				expected_args = arg_sig
-				if expected_args.last.is_a?(Hash)
-					expected_kwargs = expected_args.pop
-				else
-					expected_kwargs = {}
-				end
-			elsif arg_sig.is_a?(Hash)
-				expected_args = []
-				expected_kwargs = arg_sig
+	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?
+
+		el = type_sig_info.first
+		arg_sig = el[0]
+		return_sig = el[1]
+
+		if arg_sig.is_a?(Array)
+			expected_args = arg_sig
+			if expected_args.last.is_a?(Hash)
+				expected_kwargs = expected_args.pop
+			else
+				expected_kwargs = {}
 			end
+		elsif arg_sig.is_a?(Hash)
+			expected_args = []
+			expected_kwargs = arg_sig
+		end
 
-			expected_args.each { |e| valid?(e, nil) }
-			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| valid?(e, nil) }
-			valid?(return_sig, nil) unless return_sig.nil?
+		expected_args.each { |e| valid?(e, nil) }
+		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| valid?(e, nil) }
+		valid?(return_sig, nil) unless return_sig.nil?
 
-			sig = TypeSignature.new
-			sig.argument_type = arg_sig
-			sig.return_type = return_sig
-			@@type_signatures[owner][method_name] = sig
+		sig = TypeSignature.new
+		sig.argument_type = arg_sig
+		sig.return_type = return_sig
+		@@type_signatures[owner][method_name] = sig
 
-			define_typed_method_to_proxy(owner, method_name, expected_args, expected_kwargs, return_sig)
-		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)
-			getter = accessor_name.to_sym
-			setter = :"#{accessor_name}="
-			valid?(type_behavior, nil)
-			define_typed_method owner, getter, [] => type_behavior
-			define_typed_method owner, setter, [type_behavior] => Any
-		end
+	def define_typed_accessor(owner, accessor_name, type_behavior)
+		getter = accessor_name.to_sym
+		setter = :"#{accessor_name}="
+		valid?(type_behavior, nil)
+		define_typed_method owner, getter, [] => type_behavior
+		define_typed_method owner, setter, [type_behavior] => Any
+	end
 
-		def type_signatures
-			@@type_signatures
-		end
+	def type_signatures
+		@@type_signatures
+	end
 
 =begin
-		def assert_keyword_arguments_type(expected_kwargs, kwargs)
-			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
+	def assert_keyword_arguments_type(expected_kwargs, kwargs)
+		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
+	end
 =end
 
-		def arg_type_error_message(idx, expected, value)
-			"#{arg_message(idx)}\n" + type_error_message(expected, value)
-		end
+	def arg_type_error_message(idx, expected, value)
+		"#{arg_message(idx)}\n" + type_error_message(expected, value)
+	end
 
-		def kwarg_type_error_message(key, expected, value)
-			"#{kwarg_message(key)}\n" + type_error_message(expected, value)
-		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 arg_message(idx)
+		"for #{(idx+1).ordinalize} argument:"
+	end
 
-		def kwarg_message(key)
-			"for '#{key}' argument:"
-		end
+	def kwarg_message(key)
+		"for '#{key}' argument:"
+	end
 
 
-		def type_error_message(expected, value)
-			case expected
-			when Rtype::Behavior::Base
-				expected.error_message(value)
-			when Module
-				"Expected #{value.inspect} to be a #{expected}"
-			when Symbol
-				"Expected #{value.inspect} to respond to :#{expected}"
-			when Regexp
-				"Expected stringified #{value.inspect} to match regexp #{expected.inspect}"
-			when Range
-				"Expected #{value.inspect} to be included in range #{expected.inspect}"
-			when Array
-				if value.is_a?(Array)
-					arr = expected.map.with_index do |e, idx|
-						if e.is_a?(Array)
-							"- [#{idx}] index : {\n" + type_error_message(e, value[idx]) + "\n}"
-						else
-							"- [#{idx}] index : " + type_error_message(e, value[idx])
-						end
+	def type_error_message(expected, value)
+		case expected
+		when Rtype::Behavior::Base
+			expected.error_message(value)
+		when Module
+			"Expected #{value.inspect} to be a #{expected}"
+		when Symbol
+			"Expected #{value.inspect} to respond to :#{expected}"
+		when Regexp
+			"Expected stringified #{value.inspect} to match regexp #{expected.inspect}"
+		when Range
+			"Expected #{value.inspect} to be included in range #{expected.inspect}"
+		when Array
+			if value.is_a?(Array)
+				arr = expected.map.with_index do |e, idx|
+					if e.is_a?(Array)
+						"- [#{idx}] index : {\n" + type_error_message(e, value[idx]) + "\n}"
+					else
+						"- [#{idx}] index : " + type_error_message(e, value[idx])
 					end
-					"Expected #{value.inspect} to be an array with #{expected.length} elements:\n" + arr.join("\n")
-				else
-					"Expected #{value.inspect} to be an array"
 				end
-			when Proc
-				"Expected #{value.inspect} to return a truthy value for proc #{expected}"
-			when true
-				"Expected #{value.inspect} to be a truthy value"
-			when false
-				"Expected #{value.inspect} to be a falsy value"
-			when nil # for return
-				"Expected #{value.inspect} to be nil"
+				"Expected #{value.inspect} to be an array with #{expected.length} elements:\n" + arr.join("\n")
+			else
+				"Expected #{value.inspect} to be an array"
 			end
+		when Proc
+			"Expected #{value.inspect} to return a truthy value for proc #{expected}"
+		when true
+			"Expected #{value.inspect} to be a truthy value"
+		when false
+			"Expected #{value.inspect} to be a falsy value"
+		when nil # for return
+			"Expected #{value.inspect} to be nil"
 		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)
-		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)
+	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
+	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
-			nil
+			::Rtype.assert_return_type(return_sig, result)
+			result
 		end
+		nil
 	end
-
-	unless self.respond_to?(:valid?)
+	
+public
+	unless respond_to?(:valid?)
 	# validate argument type
-	def self.valid?(expected, value)
+	def valid?(expected, value)
 		case expected
 		when Module
 			value.is_a? expected
@@ -188,8 +199,8 @@ module Rtype
 	end
 	end
 
-	unless self.respond_to?(:assert_arguments_type)
-	def self.assert_arguments_type(expected_args, args)
+	unless respond_to?(:assert_arguments_type)
+	def assert_arguments_type(expected_args, args)
 		# `length.times` is faster than `each_with_index`
 		args.length.times do |i|
 			expected = expected_args[i]
@@ -203,8 +214,8 @@ module Rtype
 	end
 	end
 
-	unless self.respond_to?(:assert_arguments_type_with_keywords)
-	def self.assert_arguments_type_with_keywords(expected_args, args, expected_kwargs, kwargs)
+	unless respond_to?(:assert_arguments_type_with_keywords)
+	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]
@@ -226,8 +237,8 @@ module Rtype
 	end
 	end
 
-	unless self.respond_to?(:assert_return_type)
-	def self.assert_return_type(expected, result)
+	unless respond_to?(:assert_return_type)
+	def assert_return_type(expected, result)
 		if expected.nil?
 			unless result.nil?
 				raise ReturnTypeError, "for return:\n" + type_error_message(expected, result)

data/spec/rtype_spec.rb

@@ -236,29 +236,35 @@ describe Rtype do
 		describe 'true' do
 			it "is right" do
 				klass.send :rtype, :return_arg, [true] => Any
+				instance.return_arg(true)
 				instance.return_arg(123)
 			end
 			it "is wrong args" do
 				klass.send :rtype, :return_arg, [true] => Any
+				expect {instance.return_arg(false)}.to raise_error Rtype::ArgumentTypeError
 				expect {instance.return_arg(nil)}.to raise_error Rtype::ArgumentTypeError
 			end
 			it "is wrong result" do
-				klass.send :rtype, :return_nil, [Any] => true
-				expect {instance.return_nil(123)}.to raise_error Rtype::ReturnTypeError
+				klass.send :rtype, :return_arg, [Any] => true
+				expect {instance.return_arg(false)}.to raise_error Rtype::ReturnTypeError
+				expect {instance.return_arg(nil)}.to raise_error Rtype::ReturnTypeError
 			end
 		end
 
 		describe 'false' do
 			it "is right" do
 				klass.send :rtype, :return_arg, [false] => Any
+				instance.return_arg(false)
 				instance.return_arg(nil)
 			end
 			it "is wrong args" do
 				klass.send :rtype, :return_arg, [false] => Any
+				expect {instance.return_arg(true)}.to raise_error Rtype::ArgumentTypeError
 				expect {instance.return_arg(123)}.to raise_error Rtype::ArgumentTypeError
 			end
 			it "is wrong result" do
 				klass.send :rtype, :return_arg, [Any] => false
+				expect {instance.return_arg(true)}.to raise_error Rtype::ReturnTypeError
 				expect {instance.return_arg(123)}.to raise_error Rtype::ReturnTypeError
 			end
 		end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rtype
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Sputnik Gugja
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-26 00:00:00.000000000 Z
+date: 2016-03-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake