rtype-native 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b83fae70522ca7de956a791df993efd089dee772
-  data.tar.gz: 8811136c3f33df3b8f5be746f3467c01dd0c8f4b
+  metadata.gz: ef5c1668d43c941a152f041fab3d0009125ece57
+  data.tar.gz: b369a523c7a2c18980c498b6513e29d8ed152283
 SHA512:
-  metadata.gz: 0e23ed4070af234cf6bc8b26b32a97b3447eb9e708f635cca5f30d78db47abf56e2ac68415d5f6e5786ef53bc7bcc5728cac1166e8954f55d6cb46bedad02be0
-  data.tar.gz: a40e31132070f1aae22712c2cd15a0f2ec6bdea68b7fe9ce794f297a36a6c0e7adec67254b69770a238c8f742740216e65ee712f6deb3461a5fc2e6042fef83b
+  metadata.gz: 5dfc53545e477221f5de7e7f554ddbbc9b2ecda043edd7b4d1ca6d754c83e8fc04112bc5cb4795135c69541f5935aca796e4a64813bab0db8c1ba91a3bbd0ff7
+  data.tar.gz: a5b5840dff0ddf0837a80ee73a0f97818c78c3101d4426160561f23cb45c5a38e0146da6f370ed603c08b1a1061fb6cf322b4de904d070be5793ddc73cf934f9

data/README.md

@@ -37,9 +37,8 @@ Test::invert(state: 0)
   - If Java extension is used, otherwise it is not required
 
 ## Features
-- Provide type checking for arguments and return
-- Support type checking for [keyword argument](#keyword-argument)
-- [Type checking for array elements](#array)
+- Provides type checking for arguments and return
+- Supports type checking for [keyword argument](#keyword-argument)
 - [Type checking for hash elements](#hash)
 - [Duck typing](#duck-typing)
 - Custom type behavior
@@ -81,28 +80,23 @@ then, Rtype use it. (Do not `require 'rtype-java'`)
 
 ### Supported Type Behaviors
 - `Module`
-  - Value must be an instance of this module/class or one of its superclasses
+  - Value must be an instance of the module/class or one of its superclasses
   - `Any` : An alias for `BasicObject` (means Any Object)
   - `Boolean` : `true` or `false`
 - `Symbol`
-  - Value must have(respond to) a method with this name
+  - Value must have(respond to) a method with the name
 - `Regexp`
-  - Value must match this regexp pattern
+  - Value must match the regexp pattern
 - `Range`
-  - Value must be included in this range
-- `Array` (tuple)
-  - Value must be an array
-  - Each of value's elements must be valid
-  - Value's length must be equal to the array's length
-  - Of course, nested array works
-  - Example: [Array](#array)
-  - This can be used as a tuple
+  - Value must be included in the range
+- `Array`
+  - Value can be any type in the array
 - `Hash`
   - Value must be an hash
   - Each of value’s elements must be valid
   - Value's key list must be equal to the hash's key list
   - **String** key is **different** from **symbol** key
-  - vs Keyword arguments
+  - vs Keyword arguments (e.g.)
     - `[{}]` is **not** hash type argument. it is keyword argument because its position is last
     - `[{}, {}]` is empty hash type argument (first) and one empty keyword argument (second)
     - `[{}, {}, {}]` is two empty hash type argument (first, second) and empty keyword argument (last)
@@ -110,44 +104,31 @@ then, Rtype use it. (Do not `require 'rtype-java'`)
   - Of course, nested hash works
   - Example: [Hash](#hash)
 - `Proc`
-  - Value must return a truthy value for this proc
+  - Value must return a truthy value for the proc
 - `true`
   - Value must be **truthy**
 - `false`
   - Value must be **falsy**
 - `nil`
-  - Only available for **return type**. void return type in other languages
+  - Value must be nil
 - Special Behaviors
   - `Rtype::and(*types)` : Ensure value is valid for all the types
-    - `Rtype::and(*types)`
-    - `Rtype::Behavior::And[*types]`
-    - `include Rtype::Behavior; And[...]`
-    - `obj.and(*others)` (core extension)
-
-  - `Rtype::or(*types)` : Ensure value is valid for at least one of the types
-    - `Rtype::or(*types)`
-    - `Rtype::Behavior::Or[*types]`
-    - `include Rtype::Behavior; Or[...]`
-    - `obj.or(*others)` (core extension)
-
+    - `Rtype::and(*types)`, `Rtype::Behavior::And[*types]`, `include Rtype::Behavior; And[...]`
+    - `Array#comb`
+    - `Object#and(*others)`
+    
   - `Rtype::xor(*types)` : Ensure value is valid for only one of the types
-    - `Rtype::xor(*types)`
-    - `Rtype::Behavior::Xor[*types]`
-    - `include Rtype::Behavior; Xor[...]`
-    - `obj.xor(*others)` (core extension)
+    - `Rtype::xor(*types)`, `Rtype::Behavior::Xor[*types]`, `include Rtype::Behavior; Xor[...]`
+    - `Object#xor(*others)`
 
   - `Rtype::not(*types)` : Ensure value is not valid for all the types
-    - `Rtype::not(*types)`
-    - `Rtype::Behavior::Not[*types]`
-    - `include Rtype::Behavior; Not[...]`
-    - `obj.not` (core extension)
+    - `Rtype::not(*types)`, `Rtype::Behavior::Not[*types]`, `include Rtype::Behavior; Not[...]`
+    - `Object#not`
 
   - `Rtype::nilable(type)` : Ensure value can be nil
-    - `Rtype::nilable(type)`
-    - `Rtype::Behavior::Nilable[type]`
-    - `include Rtype::Behavior; Nilable[...]`
-    - `obj.nilable` (core extension)
-    - `obj.or_nil` (core extension)
+    - `Rtype::nilable(type)`, `Rtype::Behavior::Nilable[type]`, `include Rtype::Behavior; Nilable[...]`
+    - `Object#nilable`
+    - `Object#or_nil`
 
   - You can create custom behavior by extending `Rtype::Behavior::Base`
 
@@ -224,33 +205,19 @@ Duck.new.says("2") # duck: quack quack
 ```
 
 #### Array
-This can be used as a tuple.
-
 ```ruby
-rtype :func, [[Numeric, Numeric]] => Any
-def func(arr)
-  puts "Your location is (#{arr[0]}, #{arr[1]}). I will look for you. I will find you"
+rtype :ruby!, [[String, Integer]] => Any
+def ruby!(arg)
+	puts "ruby!"
 end
 
-func [1, "str"]
-# (Rtype::ArgumentTypeError) for 1st argument:
-# Expected [1, "str"] to be an array with 2 elements:
-# - [0] index : Expected 1 to be a Numeric
-# - [1] index : Expected "str" to be a Numeric
-
-func [1, 2, 3]
-# (Rtype::ArgumentTypeError) for 1st argument:
-# Expected [1, 2, 3] to be an array with 2 elements:
-# - [0] index : Expected 1 to be a Numeric
-# - [1] index : Expected 2 to be a Numeric
+func("str") # ruby!
+func(123) # ruby!
 
-func [1]
+func(nil)
 # (Rtype::ArgumentTypeError) for 1st argument:
-# Expected [1] to be an array with 2 elements:
-# - [0] index : Expected 1 to be a Numeric
-# - [1] index : Expected nil to be a Numeric
-
-func [1, 2] # Your location is (1, 2). I will look for you. I will find you
+# Expected nil to be a String
+# OR Expected nil to be a Integer
 ```
 
 #### Hash
@@ -316,7 +283,7 @@ Example.new.value
 require 'rtype'
 
 class Example
-  rtype [String.and(:func)] => Any
+  rtype [[String, :func].comb] => Any
   # also works:
   # rtype [Rtype::and(String, :func)] => Any
   def and_test(arg)
@@ -349,12 +316,12 @@ module Game
   ENEMY = [
     :name,
     :level
-  ]
+  ].comb
   
   class Player < Entity
     include Rtype::Behavior
 
-    rtype [And[*ENEMY]] => Any
+    rtype [ENEMY] => Any
     def attacks(enemy)
       "Player attacks '#{enemy.name}' (level #{enemy.level})!"
     end
@@ -565,4 +532,4 @@ Sputnik Gugja (sputnikgugja@gmail.com)
 ## License
 MIT license (@ Sputnik Gugja)
 
-See `LICENSE` file.
+See `LICENSE` file.

data/ext/rtype/c/rtype.c

@@ -1,10 +1,14 @@
 #include "rtype.h"
 
 VALUE rb_mRtype, rb_mRtypeBehavior, rb_cRtypeBehaviorBase, rb_eRtypeArgumentTypeError, rb_eRtypeTypeSignatureError, rb_eRtypeReturnTypeError;
-static ID id_to_s, id_keys, id_eqeq, id_include, id_valid, id_call;
+static ID id_to_s, id_keys, id_eqeq, id_include, id_valid, id_call, id_key;
 
 VALUE
 rb_rtype_valid(VALUE self, VALUE expected, VALUE value) {
+	long i;
+	VALUE e_keys;
+	VALUE v_keys;
+	
 	switch(TYPE(expected)) {
 		case T_MODULE:
 		case T_CLASS:
@@ -17,13 +21,12 @@ rb_rtype_valid(VALUE self, VALUE expected, VALUE value) {
 			if( !RB_TYPE_P(value, T_HASH) ) {
 				return Qfalse;
 			}
-			VALUE e_keys = rb_funcall(expected, id_keys, 0);
-			VALUE v_keys = rb_funcall(value, id_keys, 0);
+			e_keys = rb_funcall(expected, id_keys, 0);
+			v_keys = rb_funcall(value, id_keys, 0);
 			if( !RTEST(rb_funcall(e_keys, id_eqeq, 1, v_keys)) ) {
 				return Qfalse;
 			}
-
-			long i;
+			
 			for(i = 0; i < RARRAY_LEN(e_keys); i++) {
 				VALUE e_k = rb_ary_entry(e_keys, i);
 				VALUE e_v = rb_hash_aref(expected, e_k);
@@ -33,29 +36,20 @@ rb_rtype_valid(VALUE self, VALUE expected, VALUE value) {
 			}
 			return Qtrue;
 		case T_ARRAY:
-			if( !RB_TYPE_P(value, T_ARRAY) ) {
-				return Qfalse;
-			}
-			else if( RARRAY_LEN(expected) != RARRAY_LEN(value) ) {
-				return Qfalse;
-			}
-			else {
-				// 'for' loop initial declarations are only allowed in c99 mode
-				long i;
-				for(i = 0; i < RARRAY_LEN(expected); i++) {
-					VALUE e = rb_ary_entry(expected, i);
-					VALUE v = rb_ary_entry(value, i);
-					VALUE valid = rb_rtype_valid(self, e, v);
-					if(valid == Qfalse) {
-						return Qfalse;
-					}
+			for(i = 0; i < RARRAY_LEN(expected); i++) {
+				VALUE e = rb_ary_entry(expected, i);
+				VALUE valid = rb_rtype_valid(self, e, value);
+				if(valid == Qtrue) {
+					return Qtrue;
 				}
-				return Qtrue;
 			}
+			return Qfalse;
 		case T_TRUE:
 			return RTEST(value) ? Qtrue : Qfalse;
 		case T_FALSE:
 			return !RTEST(value) ? Qtrue : Qfalse;
+		case T_NIL:
+			return value == Qnil;
 		default:
 			if(rb_obj_is_kind_of(expected, rb_cRange)) {
 				return rb_funcall(expected, id_include, 1, value);
@@ -78,14 +72,17 @@ VALUE
 rb_rtype_assert_arguments_type(VALUE self, VALUE expected_args, VALUE args) {
 	// 'for' loop initial declarations are only allowed in c99 mode
 	long i;
+	long e_len = RARRAY_LEN(expected_args);
 	for(i = 0; i < RARRAY_LEN(args); i++) {
-		VALUE e = rb_ary_entry(expected_args, i);
-		VALUE v = rb_ary_entry(args, i);
-		if(e != Qnil) {
-			if( !RTEST(rb_rtype_valid(self, e, v)) ) {
-				VALUE msg = rb_funcall(rb_mRtype, rb_intern("arg_type_error_message"), 3, LONG2FIX(i), e, v);
-				rb_raise(rb_eRtypeArgumentTypeError, "%s", StringValueCStr(msg));
-			}
+		VALUE e, v;
+		if(i >= e_len) {
+			break;
+		}
+		e = rb_ary_entry(expected_args, i);
+		v = rb_ary_entry(args, i);
+		if( !RTEST(rb_rtype_valid(self, e, v)) ) {
+			VALUE msg = rb_funcall(rb_mRtype, rb_intern("arg_type_error_message"), 3, LONG2FIX(i), e, v);
+			rb_raise(rb_eRtypeArgumentTypeError, "%s", StringValueCStr(msg));
 		}
 	}
 	return Qnil;
@@ -93,8 +90,8 @@ rb_rtype_assert_arguments_type(VALUE self, VALUE expected_args, VALUE args) {
 
 static int
 kwargs_do_each(VALUE key, VALUE val, VALUE in) {
-	VALUE expected = rb_hash_aref(in, key);
-	if(expected != Qnil) {
+	if( RTEST(rb_funcall(in, id_key, 1, key)) ) {
+		VALUE expected = rb_hash_aref(in, key);
 		if( !RTEST(rb_rtype_valid((VALUE) NULL, expected, val)) ) {
 			VALUE msg = rb_funcall(rb_mRtype, rb_intern("kwarg_type_error_message"), 3, key, expected, val);
 			rb_raise(rb_eRtypeArgumentTypeError, "%s", StringValueCStr(msg));
@@ -112,17 +109,9 @@ rb_rtype_assert_arguments_type_with_keywords(VALUE self, VALUE expected_args, VA
 
 VALUE
 rb_rtype_assert_return_type(VALUE self, VALUE expected, VALUE result) {
-	if(expected == Qnil) {
-		if(result != Qnil) {
-			VALUE msg = rb_funcall(rb_mRtype, rb_intern("type_error_message"), 2, expected, result);
-			rb_raise(rb_eRtypeReturnTypeError, "for return:\n%s", StringValueCStr(msg));
-		}
-	}
-	else {
-		if( !RTEST(rb_rtype_valid(self, expected, result)) ) {
-			VALUE msg = rb_funcall(rb_mRtype, rb_intern("type_error_message"), 2, expected, result);
-			rb_raise(rb_eRtypeReturnTypeError, "for return:\n%s", StringValueCStr(msg));
-		}
+	if( !RTEST(rb_rtype_valid(self, expected, result)) ) {
+		VALUE msg = rb_funcall(rb_mRtype, rb_intern("type_error_message"), 2, expected, result);
+		rb_raise(rb_eRtypeReturnTypeError, "for return:\n%s", StringValueCStr(msg));
 	}
 	return Qnil;
 }
@@ -134,6 +123,8 @@ void Init_rtype_native(void) {
 	rb_eRtypeArgumentTypeError = rb_define_class_under(rb_mRtype, "ArgumentTypeError", rb_eArgError);
 	rb_eRtypeTypeSignatureError = rb_define_class_under(rb_mRtype, "TypeSignatureError", rb_eArgError);
 	rb_eRtypeReturnTypeError = rb_define_class_under(rb_mRtype, "ReturnTypeError", rb_eStandardError);
+	
+	rb_define_const(rb_mRtype, "NATIVE_EXT_VERSION", rb_str_new2(RTYPE_NATIVE_EXT_VERSION));
 
 	id_to_s = rb_intern("to_s");
 	id_keys = rb_intern("keys");
@@ -141,9 +132,10 @@ void Init_rtype_native(void) {
 	id_include = rb_intern("include?");
 	id_valid = rb_intern("valid?");
 	id_call = rb_intern("call");
+	id_key = rb_intern("key?");
 
 	rb_define_method(rb_mRtype, "valid?", rb_rtype_valid, 2);
 	rb_define_method(rb_mRtype, "assert_arguments_type", rb_rtype_assert_arguments_type, 2);
 	rb_define_method(rb_mRtype, "assert_arguments_type_with_keywords", rb_rtype_assert_arguments_type_with_keywords, 4);
 	rb_define_method(rb_mRtype, "assert_return_type", rb_rtype_assert_return_type, 2);
-}
+}

data/ext/rtype/c/rtype.h

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

data/spec/rtype_spec.rb

@@ -237,31 +237,30 @@ describe Rtype do
 
 		describe 'Array' do
 			it "is right" do
-				klass.send :rtype, :return_arg, [[:to_i, :to_i]] => Any
-				instance.return_arg([123, 456])
+				klass.send :rtype, :return_arg, [[:to_i]] => Any
+				instance.return_arg(123)
 
-				klass.send :rtype, :two_args, [[:to_i], [:to_i]] => Any
-				instance.two_args([123], [456])
+				klass.send :rtype, :return_arg, [[String, Integer]] => Any
+				instance.return_arg("str")
+				instance.return_arg(123)
+				
+				klass.send :rtype, :return_arg, [] => [String, Integer]
+				instance.return_arg("str")
+				instance.return_arg(123)
 			end
 			it "is wrong args" do
-				klass.send :rtype, :return_arg, [[:to_i, :to_i]] => Any
-				expect {
-					instance.return_arg([123, [true]])
-				}.to raise_error Rtype::ArgumentTypeError
+				klass.send :rtype, :return_arg, [[String, Integer]] => Any
 				expect {
-					instance.return_arg([123, true])
+					instance.return_arg(nil)
 				}.to raise_error Rtype::ArgumentTypeError
 
-				klass.send :rtype, :two_args, [[:to_i], [:to_i]] => Any
+				klass.send :rtype, :return_arg, [[String]] => Any
 				expect {
-					instance.two_args([123, 123], [123])
-				}.to raise_error Rtype::ArgumentTypeError
-				expect {
-					instance.two_args([123], 123)
+					instance.return_arg(123)
 				}.to raise_error Rtype::ArgumentTypeError
 			end
 			it "is wrong result" do
-				klass.send :rtype, :return_arg, [Any] => [:to_i, :to_i]
+				klass.send :rtype, :return_arg, [Any] => [String, Integer]
 				expect {instance.return_arg(true)}.to raise_error Rtype::ReturnTypeError
 			end
 		end
@@ -335,17 +334,19 @@ describe Rtype do
 		end
 
 		describe 'nil' do
-			it "is only for return" do
+			it "for return" do
 				klass.send :rtype, :return_nil, [] => nil
 				instance.return_nil(123)
 
 				klass.send :rtype, :return_arg, [] => nil
 				expect {instance.return_arg(123)}.to raise_error Rtype::ReturnTypeError
 			end
-			it "could not be used for args" do
+			it "for args" do
+				klass.send :rtype, :return_arg, [nil] => Any
+				instance.return_arg(nil)
 				expect {
-					klass.send :rtype, :return_arg, [nil] => Any
-				}.to raise_error Rtype::TypeSignatureError
+					instance.return_arg(123)
+				}.to raise_error Rtype::ArgumentTypeError
 			end
 		end
 
@@ -370,29 +371,6 @@ describe Rtype do
 				end
 			end
 
-			describe 'Rtype::Behavior::Or' do
-				it 'module singleton method' 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 'class singleton [] method' do
-					klass.send :rtype, :return_nil, [ Rtype::Behavior::Or[Integer, String] ] => nil
-					instance.return_nil(123)
-					instance.return_nil("abc")
-					expect {instance.return_nil(nil)}.to raise_error Rtype::ArgumentTypeError
-				end
-
-				it 'core extension method' do
-					klass.send :rtype, :return_nil, [ Integer.or(String) ] => nil
-					instance.return_nil(123)
-					instance.return_nil("abc")
-					expect {instance.return_nil(nil)}.to raise_error Rtype::ArgumentTypeError
-				end
-			end
-
 			describe 'Rtype::Behavior::Nilable' do
 				it 'module singleton method' do
 					klass.send :rtype, :return_nil, [Rtype::nilable(Integer)] => nil
@@ -480,13 +458,6 @@ describe Rtype do
 				expect {instance.sum(1, 2.0)}.to raise_error Rtype::ArgumentTypeError
 			end
 
-			it 'two array' do
-				klass.send :rtype, :sum, [[Integer], [Integer]] => Any
-				instance.sum([1], [2])
-				expect {instance.sum([1], 2)}.to raise_error Rtype::ArgumentTypeError
-				expect {instance.sum([1], ["str"])}.to raise_error Rtype::ArgumentTypeError
-			end
-
 			it 'two hash' do
 				klass.send :rtype, :two_args, [{k: Integer}, {k: Integer}, {}] => Any
 				instance.two_args({k: 123}, {k: 456}, {})
@@ -564,9 +535,9 @@ describe Rtype do
 				instance.return_arg("str")
 			end
 
-			it 'Array (tuple)' do
+			it 'Array' do
 				klass.send :rtype, :return_arg, [] => [Integer, Float]
-				expect {instance.return_arg([1, 2])}.to raise_error Rtype::ReturnTypeError
+				expect {instance.return_arg("str")}.to raise_error Rtype::ReturnTypeError
 			end
 		end
 

metadata

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