rtype-native 0.6.6 → 0.6.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c9296a99a60b8f7ea3ec34c5464aad09d27c6ccd
-  data.tar.gz: ec627f0a0fc11a3fbf9182d194954bb6d98a3dde
+  metadata.gz: 1532be5637819ff82d30dbd34a3ce0314af8cb04
+  data.tar.gz: b2ed2031f2ba992c59005fbd9008ac3de99ea89e
 SHA512:
-  metadata.gz: 111203e0c9cc7ce0b0ee3c25eea6ee7e74d4c7bb604af1de6466788aaa5ec72668e2f3691232bcd1769dd1376bd0a7218923a45dcdf5bdda99f6679a7f64bfb0
-  data.tar.gz: d4b8c28841bd430666a1fe08114fdc3c505bdb7ebfa03b50db7ac20048462a03085bebe99443c7e9f9662b7155ef11890d54581a605ffea5841883dbea43f674
+  metadata.gz: 007445e116ded093152f2bba33fc8d56259a16fbaa9e7cbe0848110053152b2040d8ff682f532aa81e0945a41d64e2692924fdaff40f0ee86581c0022bef9efb
+  data.tar.gz: fe39ccf6a59187b32c869a4fd09dc05d2fc0ba68a6a452e008297d0f3cb3c8eddd777fea51b0f81cb9e1910f0ff341155e3f43a89fcb0dc270f05914d12b0461

data/README.md

@@ -12,17 +12,27 @@ class Test
     a.to_i + b
   end
 
-  rtype {state: Boolean} => Boolean
+  rtype [{state: Boolean}] => Boolean
   def self.invert(state:)
     !state
   end
+
+  # Hashes of hashes params require () to prevent invalid syntax
+  rtype({state: Boolean} => Boolean)
+  def self.invert2(state:)
+    !state
+  end
 end
 
 Test.new.sum(123, "asd")
 # (Rtype::ArgumentTypeError) for 2nd argument:
 # Expected "asd" to be a Numeric
 
-Test::invert(state: 0)
+Test.invert(state: 0)
+# (Rtype::ArgumentTypeError) for 'state' argument:
+# Expected 0 to be a Boolean
+
+Test.invert2(state: 0)
 # (Rtype::ArgumentTypeError) for 'state' argument:
 # Expected 0 to be a Boolean
 ```
@@ -40,8 +50,10 @@ Test::invert(state: 0)
 - Provides type checking for [Keyword Argument](#keyword-argument)
 - [Type checking for hash elements](#hash)
 - [Duck Typing](#duck-typing)
-- [Typed Array](#typed-array)
+- [Typed Array](#typed-array), Typed Set, Typed Hash
 - [Numeric check](#special-behaviors). e.g. `Int >= 0`
+- [Type checking for getter and setter](#attr_accessor-with-rtype)
+- [float_accessor](#float_accessor), [bool_accessor](#bool_accessor)
 - Custom type behavior
 - ...
 
@@ -67,16 +79,8 @@ gem 'rtype-native'
 ```
 then, Rtype uses it. (**Do not** `require 'rtype-native'`)
 
-#### Java extension for JRuby
-Run
-```ruby
-gem install rtype-java
-```
-or add to your `Gemfile`:
-```ruby
-gem 'rtype-java'
-```
-then, Rtype uses it. (**Do not** `require 'rtype-java'`)
+#### Java extension for JRuby is automatic
+**Do not** `require 'rtype-java'`
 
 ## Usage
 
@@ -106,7 +110,7 @@ then, Rtype uses it. (**Do not** `require 'rtype-java'`)
   - Example: [Hash](#hash)
   
 - [Special Behaviors](#special-behaviors)
-  - `TypedArray`, `Num, Int, Flo`, `And`, `Xor`, `Not`, `Nilable`
+  - `TypedArray, TypedSet, TypedHash`, `Num, Int, Flo`, `And`, `Xor`, `Not`, `Nilable`
 
 ### Examples
 
@@ -204,34 +208,35 @@ def func(hash)
   puts hash[:msg]
 end
 
-# last hash is not hash argument but keyword arguments
-func({}, {})
+func({})
 # (Rtype::ArgumentTypeError) for 1st argument:
 # Expected {} to be a hash with 1 elements:
 # - msg : Expected nil to be a String
 
-func({msg: 123}, {})
+func({msg: 123})
 # (Rtype::ArgumentTypeError) for 1st argument:
 # Expected {:msg=>123} to be a hash with 1 elements:
 # - msg : Expected 123 to be a String
 
-func({msg: "hello", key: 'value'}, {})
+func({msg: "hello", key: 'value'})
 # (Rtype::ArgumentTypeError) for 1st argument:
 # Expected {:msg=>"hello", :key=>"value"} to be a hash with 1 elements:
 # - msg : Expected "hello" to be a String
 
-func({"msg" => "hello hash"}, {})
+func({"msg" => "hello hash"})
 # (Rtype::ArgumentTypeError) for 1st argument:
 # Expected {"msg"=>"hello hash"} to be a hash with 1 elements:
 # - msg : Expected nil to be a String
 
-func({msg: "hello hash"}, {}) # hello hash
+func({msg: "hello hash"}) # hello hash
 ```
 
-#### rtype with attr_accessor
-`rtype_accessor` : calls `attr_accessor` if the accessor method(getter/setter) is not defined. and makes it typed
+#### attr_accessor with rtype
+- `rtype_accessor(*names, type)` : calls `attr_accessor` if the accessor methods(getter/setter) are not defined. and makes it typed
+- `rtype_reader(*names, type)` : calls `attr_reader` if the getters are not defined. and makes it typed
+- `rtype_writer(*names, type)` : calls `attr_writer` if the setters are not defined. and makes it typed
 
-You can use `rtype_accessor_self` for static accessor.
+You can use `rtype_accessor_self` for static accessor. (`rtype_reader_self`, `rtype_writer_self` also exist)
 
 ```ruby
 require 'rtype'
@@ -285,6 +290,29 @@ sum([1, 2, 3]) # => 6
 sum([1.0, 2, 3]) # => 6.0
 ```
 
+#### float_accessor
+```ruby
+class Point
+  float_accessor :x, :y
+end
+
+v = Point.new
+v.x = 1
+v.x # => 1.0 (always Float)
+```
+
+#### bool_accessor
+```ruby
+class Human
+  bool_accessor :hungry
+end
+
+a = Human.new
+a.hungry = true
+a.hungry? # => true
+a.hungry # NoMethodError
+```
+
 #### `rtype`
 ```ruby
 require 'rtype'
@@ -392,9 +420,14 @@ Example.new.method(:test).return_type
 
 #### Special Behaviors
   - `TypedArray` : Ensures value is an array with the type (type signature)
-    - `Array::of(type)` (recommended)
-    - or `Rtype::Behavior::TypedArray[type]`
+    - `Array.of(type)` (recommended)
     - Example: [TypedArray](#typed-array)
+    
+  - `TypedSet` : Ensures value is a set with the type (type signature)
+    - `Set.of(type)` (recommended)
+    
+  - `TypedHash` : Ensures value is a hash with the type (type signature)
+    - `Hash.of(key_type, value_type)` (recommended)
   
   - `Num, Int, Flo` : Numeric check
     - `Num/Int/Flo >/>=/</<=/== x`
@@ -403,19 +436,19 @@ Example.new.method(:test).return_type
     - 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]`
+    - `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]`
+    - `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]`
+    - `Rtype.not(*types)`, `Rtype::Behavior::Not[*types]`
     - or `Object#not`
 
   - `Nilable` : Value can be nil
-    - `Rtype::nilable(type)`, `Rtype::Behavior::Nilable[type]`
+    - `Rtype.nilable(type)`, `Rtype::Behavior::Nilable[type]`
     - or `Object#nilable`, `Object#or_nil`
 
   - You can create custom behaviors by extending `Rtype::Behavior::Base`

data/Rakefile

@@ -8,5 +8,5 @@ task :default => [:spec]
 # Benchmark
 desc "Compare with pure ruby and other gems"
 task :benchmark do
-  ruby "benchmark/benchmark.rb"
+	ruby "benchmark/benchmark.rb"
 end

data/ext/rtype/c/rtype.h

@@ -2,5 +2,5 @@
 	#define RTYPE_H
 	#include "ruby.h"
 	#include <string.h>
-	#define RTYPE_NATIVE_EXT_VERSION "0.6.6"
+	#define RTYPE_NATIVE_EXT_VERSION "0.6.8"
 #endif

data/spec/rtype_spec.rb

@@ -46,6 +46,10 @@ describe Rtype do
 
 			def args_and_kwargs(a, b, c:, d:)
 			end
+			
+			public
+			def public_func
+			end
 
 			protected
 			def protected_func
@@ -149,7 +153,7 @@ describe Rtype do
 	end
 
 	it 'Kernel#rtype_accessor' do
-		class TestClass
+		class AccessorTestClass
 			rtype_accessor :value, :value2, String
 
 			def initialize
@@ -157,23 +161,109 @@ describe Rtype do
 				@value2 = 123
 			end
 		end
-		expect {TestClass.new.value = 123}.to raise_error Rtype::ArgumentTypeError
-		expect {TestClass.new.value}.to raise_error Rtype::ReturnTypeError
-		expect {TestClass.new.value2 = 123}.to raise_error Rtype::ArgumentTypeError
-		expect {TestClass.new.value2}.to raise_error Rtype::ReturnTypeError
+		expect {AccessorTestClass.new.value = 123}.to raise_error Rtype::ArgumentTypeError
+		expect {AccessorTestClass.new.value}.to raise_error Rtype::ReturnTypeError
+		expect {AccessorTestClass.new.value2 = 123}.to raise_error Rtype::ArgumentTypeError
+		expect {AccessorTestClass.new.value2}.to raise_error Rtype::ReturnTypeError
 	end
 
 	it 'Kernel#rtype_accessor_self' do
-		class TestClass
+		class AccessorTestClass
 			@@value = 123
 			@@value2 = 123
-
 			rtype_accessor_self :value, :value2, String
 		end
-		expect {TestClass::value = 123}.to raise_error Rtype::ArgumentTypeError
-		expect {TestClass::value}.to raise_error Rtype::ReturnTypeError
-		expect {TestClass::value2 = 123}.to raise_error Rtype::ArgumentTypeError
-		expect {TestClass::value2}.to raise_error Rtype::ReturnTypeError
+		expect {AccessorTestClass::value = 123}.to raise_error Rtype::ArgumentTypeError
+		expect {AccessorTestClass::value}.to raise_error Rtype::ReturnTypeError
+		expect {AccessorTestClass::value2 = 123}.to raise_error Rtype::ArgumentTypeError
+		expect {AccessorTestClass::value2}.to raise_error Rtype::ReturnTypeError
+	end
+
+	it 'Kernel#rtype_reader' do
+		class ReaderTestClass
+			rtype_reader :value, :value2, String
+
+			def initialize
+				@value = 123
+				@value2 = 123
+			end
+		end
+		expect {ReaderTestClass.new.value}.to raise_error Rtype::ReturnTypeError
+		expect {ReaderTestClass.new.value2}.to raise_error Rtype::ReturnTypeError
+	end
+
+	it 'Kernel#rtype_reader_self' do
+		class ReaderTestClass
+			@@value = 123
+			@@value2 = 123
+			rtype_reader_self :value, :value2, String
+		end
+		expect {ReaderTestClass::value}.to raise_error Rtype::ReturnTypeError
+		expect {ReaderTestClass::value2}.to raise_error Rtype::ReturnTypeError
+	end
+
+	it 'Kernel#rtype_writer' do
+		class WriterTestClass
+			rtype_writer :value, :value2, String
+
+			def initialize
+				@value = 123
+				@value2 = 123
+			end
+		end
+		expect {WriterTestClass.new.value = 123}.to raise_error Rtype::ArgumentTypeError
+		expect {WriterTestClass.new.value2 = 123}.to raise_error Rtype::ArgumentTypeError
+	end
+
+	it 'Kernel#rtype_writer_self' do
+		class WriterTestClass
+			@@value = 123
+			@@value2 = 123
+			rtype_writer_self :value, :value2, String
+		end
+		expect {WriterTestClass::value = 123}.to raise_error Rtype::ArgumentTypeError
+		expect {WriterTestClass::value2 = 123}.to raise_error Rtype::ArgumentTypeError
+	end
+
+	it 'Kernel#float_accessor' do
+		class FloatAccessorTestClass
+			float_accessor :float, :int
+			
+			def initialize
+				@float = 10.0
+				@int = 10
+			end
+		end
+		
+		float_accessor_test = FloatAccessorTestClass.new
+		
+		float_accessor_test.float
+		expect {float_accessor_test.int}.to raise_error Rtype::ReturnTypeError
+		float_accessor_test.float = 5.0
+		float_accessor_test.float = 5
+		expect(float_accessor_test.float).to eql(5.0) # be(expected) => passes if actual.eql?(expected)
+		expect(float_accessor_test.float).not_to eql(5)
+	end
+
+	it 'Kernel#bool_accessor' do
+		class BoolAccessorTestClass
+			bool_accessor :state, :invalid_var
+			
+			def initialize
+				@state = false
+				@invalid_var = 123
+			end
+		end
+		
+		bool_accessor_test = BoolAccessorTestClass.new
+		
+		bool_accessor_test.state?
+		expect {bool_accessor_test.state}.to raise_error NoMethodError
+		expect(bool_accessor_test.state?).to eql(false)
+		bool_accessor_test.state = true
+		expect(bool_accessor_test.state?).to eql(true)
+		expect {bool_accessor_test.state = 123}.to raise_error Rtype::ArgumentTypeError
+		expect {bool_accessor_test.invalid_var?}.to raise_error Rtype::ReturnTypeError
 	end
 
 	describe 'Test type behaviors' do
@@ -475,6 +565,65 @@ describe Rtype do
 				end
 			end
 			
+			describe 'Rtype::Behavior::TypedSet' do
+				it 'class singleton [] method' do
+					klass.send :rtype, :return_nil, [ Rtype::Behavior::TypedSet[Integer] ] => nil
+					instance.return_nil( Set.new([123]) )
+					expect {instance.return_nil(123)}.to raise_error Rtype::ArgumentTypeError
+					expect { instance.return_nil(Set.new([1.0])) }.to raise_error Rtype::ArgumentTypeError
+				end
+
+				it 'core extension method (Set::of)' do
+					klass.send :rtype, :return_nil, [ Set.of(Integer) ] => nil
+					instance.return_nil( Set.new([123]) )
+					expect {instance.return_nil(123)}.to raise_error Rtype::ArgumentTypeError
+					expect { instance.return_nil(Set.new([1.0])) }.to raise_error Rtype::ArgumentTypeError
+				end
+				
+				it 'complicated type sig' do
+					klass.send :rtype, :return_nil, [ Set.of(:to_i.and(:chars)) ] => nil
+					instance.return_nil( Set.new(["hello"]) )
+					expect {instance.return_nil("hello")}.to raise_error Rtype::ArgumentTypeError
+					expect { instance.return_nil(Set.new([123])) }.to raise_error Rtype::ArgumentTypeError
+				end
+				
+				it 'allows empty set' do
+					klass.send :rtype, :return_nil, [ Set.of(Integer) ] => nil
+					instance.return_nil(Set.new)
+				end
+			end
+			
+			describe 'Rtype::Behavior::TypedHash' do
+				it 'class singleton [] method' do
+					klass.send :rtype, :return_nil, [ Rtype::Behavior::TypedHash[Symbol, Integer] ] => nil
+					instance.return_nil( {key: 123} )
+					expect {instance.return_nil(:key)}.to raise_error Rtype::ArgumentTypeError
+					expect {instance.return_nil(123)}.to raise_error Rtype::ArgumentTypeError
+					expect {instance.return_nil( {"key" => 123} )}.to raise_error Rtype::ArgumentTypeError
+				end
+
+				it 'core extension method (Hash::of)' do
+					klass.send :rtype, :return_nil, [ Hash.of(Symbol, Integer) ] => nil
+					instance.return_nil( {key: 123} )
+					expect {instance.return_nil(:key)}.to raise_error Rtype::ArgumentTypeError
+					expect {instance.return_nil(123)}.to raise_error Rtype::ArgumentTypeError
+					expect {instance.return_nil( {"key" => 123} )}.to raise_error Rtype::ArgumentTypeError
+				end
+				
+				it 'complicated type sig' do
+					klass.send :rtype, :return_nil, [ Hash.of(:to_i.and(:chars), :to_i.and(:chars)) ] => nil
+					instance.return_nil( {"key" => "val"} )
+					expect {instance.return_nil("hello")}.to raise_error Rtype::ArgumentTypeError
+					expect {instance.return_nil( {key: "val"} )}.to raise_error Rtype::ArgumentTypeError
+					expect {instance.return_nil( {"key" => :val} )}.to raise_error Rtype::ArgumentTypeError
+				end
+				
+				it 'allows empty hash' do
+					klass.send :rtype, :return_nil, [ Hash.of(Symbol, Integer) ] => nil
+					instance.return_nil({})
+				end
+			end
+			
 			describe 'Numeric check' do
 				it 'Num (Numeric)' do
 					klass.send :rtype, :return_nil, [Num >= 0] => Any
@@ -751,6 +900,10 @@ describe Rtype do
 				klass.send :rtype, :private_func, [] => Any
 				expect {instance.private_func}.to raise_error NoMethodError
 			end
+			it 'public' do
+				klass.send :rtype, :public_func, [] => Any
+				instance.public_func
+			end
 		end
 
 		context 'with empty argument signature' do
@@ -816,6 +969,32 @@ describe Rtype do
 			AnnotationTest2.new.inst_one(123)
 			AnnotationTest2::static_two(123)
 		end
+
+		context 'when rtype signature duplicated' do
+			it 'the latest have priority' do
+				class PriorityTest1
+					rtype :test_priority, [String] => Any
+					def test_priority(arg)
+					end
+					rtype :test_priority, [Integer] => Any
+				end
+				
+				PriorityTest1.new.test_priority(1)
+				expect { PriorityTest1.new.test_priority("str") }.to raise_error Rtype::ArgumentTypeError
+			end
+			
+			it 'annotation mode have priority in contemporaneous signatures' do
+				class PriorityTest2
+					rtype :test_priority, [String] => Any
+					rtype [Integer] => Any
+					def test_priority(arg)
+					end
+				end
+				
+				PriorityTest2.new.test_priority(1)
+				expect { PriorityTest2.new.test_priority("str") }.to raise_error Rtype::ArgumentTypeError
+			end
+		end
 	end
 
 	describe "Call Rtype`s static method directly" do

data/spec/spec_helper.rb

@@ -3,6 +3,7 @@ Coveralls.wear!
 
 require 'rtype'
 require 'rspec'
+require 'set'
 
 if !Rtype::NATIVE_EXT_VERSION.nil?
 	puts "Rtype with native extension"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rtype-native
 version: !ruby/object:Gem::Version
-  version: 0.6.6
+  version: 0.6.8
 platform: ruby
 authors:
 - Sputnik Gugja
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-01 00:00:00.000000000 Z
+date: 2016-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rtype
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.6.6
+        version: 0.6.8
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.6.6
+        version: 0.6.8
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement