rtype 0.6.4 → 0.6.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 272dbec168fe9d7b24c0b73b7ba9096b4567cf40
-  data.tar.gz: 7a3323d9bf39563681e79f058f5f35cf595a8b1f
+  metadata.gz: e2be0f81f879eb14cec746991740c174607e0246
+  data.tar.gz: 42cdefc859a0d3b3063716bb4c8b1c064adfe9ad
 SHA512:
-  metadata.gz: 6f10da6933a0dec59ff8b60d026b19fa365594721a7ff1e97b0729c93e3d2f5329c085056b72d172500e13345be26b897b945951998174c2c79b596cd726d132
-  data.tar.gz: 75e312d85ac8f8f7a8b84b780eb1eb8f2925fef496fbf5d299959fbb8414b74d14a5dcd1a5f87ae71680b2cca68d41b32fa4e02cebcc1d2811a23ffc887d8fe6
+  metadata.gz: 8f8f677e527e1ae79b30bcb7dce0dcf0b9f13eed3212c33980c58b1e9f3272bd76ae892a606f6de89ce4693ac9a102fbe7a12ae833839e7ce59e6b00ad1a53f5
+  data.tar.gz: afbc41fd9ba4f9377c352170ea24bed21b1fdd65087563a0a04b2f8acff0a4f3d26ebde19a22b8ccc81c7f73e7049b37d5e83070e3dc67077687c2ba67f2e61a

data/README.md

@@ -29,6 +29,7 @@ Test::invert(state: 0)
 
 ## Requirements
 - Ruby >= 2.1
+  - If you need to use old ruby, see [rtype-legacy](https://github.com/sputnikgugja/rtype/tree/master/benchmark/benchmark.rb) for ruby 1.9+
 - MRI
   - If C native extension is used. otherwise it is not required
 - JRuby (JRuby 9000+)
@@ -40,6 +41,7 @@ Test::invert(state: 0)
 - [Type checking for hash elements](#hash)
 - [Duck Typing](#duck-typing)
 - [Typed Array](#typed-array)
+- [Numeric check](#special-behaviors). e.g. `Int >= 0`
 - Custom type behavior
 - ...
 
@@ -79,22 +81,21 @@ then, Rtype uses it. (**Do not** `require 'rtype-java'`)
 ## Usage
 
 ### Supported Type Behaviors
-- `Module`
-  - Value must be of this module (`is_a?`)
+- `Module` : Value must be of this module (`is_a?`)
   - `Any` : Alias for `BasicObject` (means Any Object)
   - `Boolean` : `true` or `false`
-- `Symbol`
-  - Value must respond to a method with this name
-- `Regexp`
-  - Value must match this regexp pattern
-- `Range`
-  - Value must be included in this range
-- `Array`
-  - Value can be any type in this array
+- `Symbol` : Value must respond to a method with this name
+- `Regexp` : Value must match this regexp pattern
+- `Range` : Value must be included in this range
+- `Array` : Value can be any type in this array
+- `Proc` : Value must return a truthy value for this proc
+- `true` : Value must be truthy
+- `false` : Value must be falsy
+- `nil` : Value must be nil
 - `Hash`
   - Value must be a hash
   - Each of elements must be valid
-  - Value's keys must be equal to this hash's keys
+  - Keys of the value must be equal to keys of this hash
   - **String** key is **different** from **symbol** key
   - vs. Keyword arguments (e.g.)
     - `[{}]` is **not** hash argument. it is keyword argument, because its position is last
@@ -103,44 +104,9 @@ then, Rtype uses it. (**Do not** `require 'rtype-java'`)
     - `{}` is keyword argument. non-keyword arguments must be in array.
   - Of course, nested hash works
   - Example: [Hash](#hash)
-- `Proc`
-  - Value must return a truthy value for this proc
-- `true`
-  - Value must be truthy
-- `false`
-  - Value must be falsy
-- `nil`
-  - Value must be nil
   
-- Special Behaviors
-  - `TypedArray` : Ensures value is an array with the type (type signature)
-    - `Array::of(type)` (recommended)
-    - or `Rtype::Behavior::TypedArray[type]`
-    - Example: [TypedArray](#typed-array)
-  
-  - `Num, Int, Flo` : Numeric check
-    - `Num/Int/Flo >/>=/</<=/== x`
-    - e.g. `Num >= 2` means value must be a `Numeric` and >= 2
-    - e.g. `Int >= 2` means value must be a `Integer` and >= 2
-    - e.g. `Flo >= 2` means value must be a `Float` and >= 2
-  
-  - `And` : Ensures value is valid for all given types
-    - `Rtype::and(*types)`, `Rtype::Behavior::And[*types]`
-    - or `Array#comb`, `Object#and(*others)`
-    
-  - `Xor` : Ensures value is valid for only one of given types
-    - `Rtype::xor(*types)`, `Rtype::Behavior::Xor[*types]`
-    - or `Object#xor(*others)`
-
-  - `Not` : Ensures value is not valid for all given types
-    - `Rtype::not(*types)`, `Rtype::Behavior::Not[*types]`
-    - or `Object#not`
-
-  - `Nilable` : Value can be nil
-    - `Rtype::nilable(type)`, `Rtype::Behavior::Nilable[type]`
-    - or `Object#nilable`, `Object#or_nil`
-
-  - You can create custom behavior by extending `Rtype::Behavior::Base`
+- [Special Behaviors](#special-behaviors)
+  - `TypedArray`, `Num, Int, Flo`, `And`, `Xor`, `Not`, `Nilable`
 
 ### Examples
 
@@ -424,6 +390,36 @@ Example.new.method(:test).return_type
 # => Any
 ```
 
+#### Special Behaviors
+  - `TypedArray` : Ensures value is an array with the type (type signature)
+    - `Array::of(type)` (recommended)
+    - or `Rtype::Behavior::TypedArray[type]`
+    - Example: [TypedArray](#typed-array)
+  
+  - `Num, Int, Flo` : Numeric check
+    - `Num/Int/Flo >/>=/</<=/== x`
+    - e.g. `Num >= 2` means value must be a `Numeric` and >= 2
+    - e.g. `Int >= 2` means value must be a `Integer` and >= 2
+    - e.g. `Flo >= 2` means value must be a `Float` and >= 2
+  
+  - `And` : Ensures value is valid for all given types
+    - `Rtype::and(*types)`, `Rtype::Behavior::And[*types]`
+    - or `Array#comb`, `Object#and(*others)`
+    
+  - `Xor` : Ensures value is valid for only one of given types
+    - `Rtype::xor(*types)`, `Rtype::Behavior::Xor[*types]`
+    - or `Object#xor(*others)`
+
+  - `Not` : Ensures value is not valid for all given types
+    - `Rtype::not(*types)`, `Rtype::Behavior::Not[*types]`
+    - or `Object#not`
+
+  - `Nilable` : Value can be nil
+    - `Rtype::nilable(type)`, `Rtype::Behavior::Nilable[type]`
+    - or `Object#nilable`, `Object#or_nil`
+
+  - You can create custom behaviors by extending `Rtype::Behavior::Base`
+
 ## Documentation
 [RubyDoc.info](http://www.rubydoc.info/gems/rtype)
 

data/benchmark/benchmark.rb

@@ -19,6 +19,14 @@ puts "Sig version: #{Sig::VERSION}"
 puts "Contracts version: #{Contracts::VERSION}"
 puts "Typecheck version: #{Typecheck::VERSION}"
 
+if !Rtype::NATIVE_EXT_VERSION.nil?
+	puts "Rtype with native extension"
+elsif !Rtype::JAVA_EXT_VERSION.nil?
+	puts "Rtype with java extension"
+else
+	puts "Rtype without native extension"
+end
+
 class PureTest
 	def sum(x, y)
 		x + y
@@ -189,4 +197,4 @@ Benchmark.ips do |x|
 	end
 
 	x.compare!
-end
+end

data/lib/rtype.rb

@@ -1,4 +1,4 @@
-if defined?(RUBY_ENGINE)
+if Object.const_defined?(:RUBY_ENGINE)
 	case RUBY_ENGINE
 	when "jruby"
 		begin
@@ -220,7 +220,7 @@ module Rtype
 	# Checks the arguments type signature is valid
 	# 
 	# e.g.
-	# `[Integer]`, `{key: "value"} are valid.
+	# `[Integer]`, `{key: "value"}` are valid.
 	# `Integer` is invalid
 	# 
 	# @param sig A arguments type signature
@@ -400,22 +400,27 @@ module Rtype
 private
 	# @param owner
 	# @param [Symbol] method_name
-	# @param expected_args
-	# @param expected_kwargs
+	# @param [Array] expected_args
+	# @param [Hash] expected_kwargs
 	# @param return_sig
 	# @return [void]
 	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?
+		if expected_kwargs.empty?
+			# `send` is faster than `method(...).call`
+			owner.send(:_rtype_proxy).send :define_method, method_name do |*args, &block|
 				::Rtype::assert_arguments_type(expected_args, args)
 				result = super(*args, &block)
-			else
+				::Rtype::assert_return_type(return_sig, result)
+				result
+			end
+		else
+			# `send` is faster than `method(...).call`
+			owner.send(:_rtype_proxy).send :define_method, method_name do |*args, **kwargs, &block|
 				::Rtype::assert_arguments_type_with_keywords(expected_args, args, expected_kwargs, kwargs)
 				result = super(*args, **kwargs, &block)
+				::Rtype::assert_return_type(return_sig, result)
+				result
 			end
-			::Rtype::assert_return_type(return_sig, result)
-			result
 		end
 		nil
 	end

data/lib/rtype/version.rb

@@ -1,7 +1,7 @@
 module Rtype
-	VERSION = "0.6.4".freeze
+	VERSION = "0.6.5".freeze
 	# rtype java extension version. nil If the extension is not used
-	JAVA_EXT_VERSION = nil unless defined?(JAVA_EXT_VERSION)
+	JAVA_EXT_VERSION = nil unless const_defined?(:JAVA_EXT_VERSION, false)
 	# rtype c extension version. nil If the extension is not used
-	NATIVE_EXT_VERSION = nil unless defined?(NATIVE_EXT_VERSION)
+	NATIVE_EXT_VERSION = nil unless const_defined?(:NATIVE_EXT_VERSION, false)
 end

data/spec/rtype_spec.rb

@@ -274,12 +274,12 @@ describe Rtype do
 		describe 'Hash' do
 			it "is right" do
 				klass.send :rtype, :return_arg, [{k: Integer}, {}] => Any
-				instance.return_arg({k: 123}, {})
+				instance.return_arg({k: 123})
 			end
 			it "is wrong args" do
 				klass.send :rtype, :return_arg, [{k: Integer}, {}] => Any
 				expect {
-					instance.return_arg({k: "str"}, {})
+					instance.return_arg({k: "str"})
 				}.to raise_error Rtype::ArgumentTypeError
 			end
 			it "is wrong result" do
@@ -556,15 +556,15 @@ describe Rtype do
 
 			it 'two hash' do
 				klass.send :rtype, :two_args, [{k: Integer}, {k: Integer}, {}] => Any
-				instance.two_args({k: 123}, {k: 456}, {})
+				instance.two_args({k: 123}, {k: 456})
 				expect {
-					instance.two_args({k: 123}, {}, {})
+					instance.two_args({k: 123}, {})
 				}.to raise_error Rtype::ArgumentTypeError
 				expect {
-					instance.two_args({k: 123}, 456, {})
+					instance.two_args({k: 123}, 456)
 				}.to raise_error Rtype::ArgumentTypeError
 				expect {
-					instance.two_args({k: 123}, {k: "str"}, {})
+					instance.two_args({k: 123}, {k: "str"})
 				}.to raise_error Rtype::ArgumentTypeError
 			end
 

metadata

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