rtype-legacy-native 0.0.2 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 78f16cb1988c7d824e6d4fdcfccac5bfd1311942
-  data.tar.gz: 0b0fe4fe87767fe802278f6ca5c063d91eeb160f
+  metadata.gz: fbcad8735dfcab9290ac1583500134355040592b
+  data.tar.gz: 8540f84a446ea302a6128cb081eb9b63ee6a61d9
 SHA512:
-  metadata.gz: 8ec922603d4b9aa80661c40a4b4c18a1e8f1d1cb226831e50cb706dd955aafb05fa4a672533d6cb8ca46a10a64fd8adbc1a5803f60e56c3273b960169a24fe8f
-  data.tar.gz: 8e85c32de15c0a07d7c9b77ed63ff8b084e7476fd3dd310f7381136bd79c5f54e9dcfcfd1d1d6e163d7dd5676b5717d338ae5a159b1633402530efe539baee38
+  metadata.gz: 98331f96aa08994c35f1e8996813965353d6f396cdd70ebbb8c68d5cf9968ff2ff7996c676ade051cebcdcaf9b608da68792af4ea098053600229fff16d1237a
+  data.tar.gz: ce85db1f8e1693972625086c4dc6bf666573eabd8f9a83217b53eb24b93847696f1ff1efb12a4ec1f7486ffbe2a4c58eaf24100eb2a1b11593d93f5c5843a9ce

data/README.md

@@ -12,7 +12,9 @@ class Test
     a.to_i + b
   end
 
-  rtype [{state: Boolean}. {}] => Boolean
+  # Second hash is keyword argument signature
+  # (syntax compatibility with 'rtype' gem)
+  rtype [{state: Boolean}, {}] => Boolean
   def self.invert(opts)
     !opts[:state]
   end
@@ -22,7 +24,7 @@ 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 1st argument:
 # Expected {:state=>0} to be a hash with 1 elements:
 # - state : Expected 0 to be a Boolean
@@ -47,8 +49,10 @@ Test::invert(state: 0)
 - Provides type checking for arguments and return
 - [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
 - ...
 
@@ -74,16 +78,8 @@ gem 'rtype-legacy-native'
 ```
 then, Rtype Legacy uses it. (**Do not** `require 'rtype-legacy-native'`)
 
-#### Java extension for JRuby
-Run
-```ruby
-gem install rtype-legacy-java
-```
-or add to your `Gemfile`:
-```ruby
-gem 'rtype-legacy-java'
-```
-then, Rtype Legacy uses it. (**Do not** `require 'rtype-legacy-java'`)
+#### Java extension for JRuby is automatic
+**Do not** `require 'rtype-java'`
 
 ## Usage
 
@@ -113,7 +109,7 @@ then, Rtype Legacy uses it. (**Do not** `require 'rtype-legacy-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
 
@@ -209,10 +205,12 @@ func({"msg" => "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'
@@ -266,6 +264,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'
@@ -358,9 +379,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`
@@ -369,19 +395,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`
@@ -392,7 +418,7 @@ Example.new.method(:test).return_type
 ## Benchmarks
 Result of `rake benchmark` ([source](https://github.com/sputnikgugja/rtype-legacy/tree/master/benchmark/benchmark.rb))
 
-Rubype and Sig don't support 1.9 ruby. Typecheck raise an error in my environment
+Rubype and Sig don't support 1.9 ruby. Typecheck raises an error in my environment
 
 ### MRI
 ```

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/legacy/c/rtype_legacy.h

@@ -2,5 +2,5 @@
 	#define RTYPE_LEGACY_H
 	#include "ruby.h"
 	#include <string.h>
-	#define RTYPE_NATIVE_EXT_VERSION "0.0.2"
+	#define RTYPE_NATIVE_EXT_VERSION "0.0.4"
 #endif

data/spec/rtype_legacy_spec.rb

@@ -152,6 +152,93 @@ describe Rtype::Legacy do
 		expect {TestClass::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
 		describe 'Module' do
 			it "is right" do
@@ -451,6 +538,65 @@ describe Rtype::Legacy 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

data/spec/spec_helper.rb

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

metadata

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