rtype-native 0.2.0

data/ext/rtype/rtype.c

@@ -0,0 +1,122 @@
+#include "rtype.h"
+
+VALUE rb_mRtype, rb_mRtypeBehavior, rb_cRtypeBehaviorBase, rb_eRtypeArgumentTypeError, rb_eRtypeTypeSignatureError, rb_eRtypeReturnTypeError;
+
+VALUE
+rb_rtype_valid(VALUE self, VALUE expected, VALUE value) {
+	switch(TYPE(expected)) {
+		case T_MODULE:
+		case T_CLASS:
+			return rb_obj_is_kind_of(value, expected) ? Qtrue : Qfalse;
+		case T_SYMBOL:
+			return rb_respond_to(value, rb_to_id(expected)) ? Qtrue : Qfalse;
+		case T_REGEXP:
+			return rb_reg_match( expected, rb_funcall(value, rb_intern("to_s"), 0) ) != Qnil ? Qtrue : Qfalse;
+		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;
+					}
+				}
+				return Qtrue;
+			}
+		case T_TRUE:
+			return RTEST(value) ? Qtrue : Qfalse;
+		case T_FALSE:
+			return !RTEST(value) ? Qtrue : Qfalse;
+		default:
+			if(CLASS_OF(expected) == rb_cRange) {
+				return rb_funcall(expected, rb_intern("include?"), 1, value);
+			}
+			else if(CLASS_OF(expected) == rb_cProc) {
+				return RTEST(rb_funcall(expected, rb_intern("call"), 1, value)) ? Qtrue : Qfalse;
+			}
+			else if( RTEST(rb_obj_is_kind_of(expected, rb_cRtypeBehaviorBase)) ) {
+				return rb_funcall(expected, rb_intern("valid?"), 1, value);
+			}
+			else {
+				VALUE str = rb_any_to_s(expected);
+				rb_raise(rb_eRtypeTypeSignatureError, "Invalid type signature: Unknown type behavior %s", StringValueCStr(str));
+				return Qfalse;
+			}
+	}
+}
+
+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;
+	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));
+			}
+		}
+	}
+	return Qnil;
+}
+
+static int
+kwargs_do_each(VALUE key, VALUE val, VALUE in) {
+	VALUE expected = rb_hash_aref(in, key);
+	if(expected != Qnil) {
+		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));
+		}
+	}
+	return ST_CONTINUE;
+}
+
+VALUE
+rb_rtype_assert_arguments_type_with_keywords(VALUE self, VALUE expected_args, VALUE args, VALUE expected_kwargs, VALUE kwargs) {
+	rb_rtype_assert_arguments_type(self, expected_args, args);
+	rb_hash_foreach(kwargs, kwargs_do_each, expected_kwargs);
+	return Qnil;
+}
+
+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));
+		}
+	}
+	return Qnil;
+}
+
+void Init_rtype_native(void) {
+	rb_mRtype = rb_define_module("Rtype");
+	rb_mRtypeBehavior = rb_define_module_under(rb_mRtype, "Behavior");
+	rb_cRtypeBehaviorBase = rb_define_class_under(rb_mRtypeBehavior, "Base", rb_cObject);
+	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_singleton_method(rb_mRtype, "valid?", rb_rtype_valid, 2);
+	rb_define_singleton_method(rb_mRtype, "assert_arguments_type", rb_rtype_assert_arguments_type, 2);
+	rb_define_singleton_method(rb_mRtype, "assert_arguments_type_with_keywords", rb_rtype_assert_arguments_type_with_keywords, 4);
+	rb_define_singleton_method(rb_mRtype, "assert_return_type", rb_rtype_assert_return_type, 2);
+}

data/ext/rtype/rtype.h

@@ -0,0 +1,5 @@
+#ifndef RTYPE_H
+	#define RTYPE_H
+	#include "ruby.h"
+	#include <string.h>
+#endif

data/spec/rtype_spec.rb

@@ -0,0 +1,541 @@
+require_relative 'spec_helper'
+
+describe Rtype do
+	let(:klass) do
+		Class.new do
+			attr_accessor :value
+
+			def initialize
+				@value = 123
+			end
+
+			def return_arg(obj)
+				obj
+			end
+
+			def three_args(a, b, c)
+			end
+
+			def three_kwargs(a:, b:, c:)
+			end
+
+			def return_nil(obj)
+				nil
+			end
+
+			def sum(a, b)
+				a + b
+			end
+
+			def kwarg(a:)
+				a
+			end
+
+			def sum_kwargs(a:, b:)
+				a + b
+			end
+
+			def arg_and_kwarg(a, b:)
+			end
+
+			def arg_and_kwargs(a, b:, c:)
+			end
+
+			def args_and_kwargs(a, b, c:, d:)
+			end
+
+			protected
+			def protected_func
+			end
+
+			private
+			def private_func
+			end
+		end
+	end
+
+	let(:instance) do
+		klass.new
+	end
+
+	describe 'Kernel#rtype' do
+		it "outside of module" do
+			rtype :test_args, [String] => Any
+			def test_args(str)
+			end
+
+			expect {test_args 123}.to raise_error Rtype::ArgumentTypeError
+
+			rtype :test_return, [] => String
+			def test_return
+				369
+			end
+
+			expect {test_return}.to raise_error Rtype::ReturnTypeError
+		end
+
+		it "in module" do
+			class TestClass
+				rtype :test_args, [String] => Any
+				def test_args(str)
+				end
+			end
+
+			expect {TestClass.new.test_args 123}.to raise_error Rtype::ArgumentTypeError
+
+			class TestClass
+				rtype :test_return, [] => String
+				def test_return
+					369
+				end
+			end
+
+			expect {TestClass.new.test_return}.to raise_error Rtype::ReturnTypeError
+		end
+	end
+
+	it "Kernel#rtype_self" do
+		class TestClass
+			rtype_self :static_test_args, [String] => Any
+			def self.static_test_args(str)
+			end
+		end
+
+		expect {TestClass::static_test_args 123}.to raise_error Rtype::ArgumentTypeError
+
+		class TestClass
+			rtype_self :static_test_return, [] => String
+			def self.static_test_return
+				369
+			end
+		end
+
+		expect {TestClass::static_test_return}.to raise_error Rtype::ReturnTypeError
+	end
+
+	it 'Kernel#rtype_accessor' do
+		class TestClass
+			rtype_accessor :value, String
+			attr_accessor :value
+
+			def initialize
+				@value = 123
+			end
+		end
+		expect {TestClass.new.value = 123}.to raise_error Rtype::ArgumentTypeError
+		expect {TestClass.new.value}.to raise_error Rtype::ReturnTypeError
+	end
+
+	it 'Kernel#rtype_accessor_self' do
+		class TestClass
+			@@val = 123
+
+			rtype_accessor_self :value, String
+			def self.value=(val)
+				@@val = val
+			end
+			def self.value
+				@@val
+			end
+		end
+		expect {TestClass::value = 123}.to raise_error Rtype::ArgumentTypeError
+		expect {TestClass::value}.to raise_error Rtype::ReturnTypeError
+	end
+
+	describe 'Test type behaviors' do
+		describe 'Module' do
+			it "is right" do
+				klass.send :rtype, :return_arg, [String] => Any
+				instance.return_arg("This is a string!")
+			end
+			it "is wrong" do
+				klass.send :rtype, :return_arg, [String] => Any
+				expect {instance.return_arg(123)}.to raise_error Rtype::ArgumentTypeError
+			end
+			it "is wrong result" do
+				klass.send :rtype, :return_nil, [Any] => String
+				expect {instance.return_nil("This is a string!")}.to raise_error Rtype::ReturnTypeError
+			end
+		end
+
+		describe 'Symbol' do
+			it "is right" do
+				klass.send :rtype, :return_arg, [:to_i] => Any
+				instance.return_arg(123)
+			end
+			it "is wrong args" do
+				klass.send :rtype, :return_arg, [:to_i] => Any
+				expect {instance.return_arg(true)}.to raise_error Rtype::ArgumentTypeError
+			end
+			it "is wrong result" do
+				klass.send :rtype, :return_nil, [Any] => :odd?
+				expect {instance.return_nil(123)}.to raise_error Rtype::ReturnTypeError
+			end
+		end
+
+		describe 'Regexp' do
+			it "is right" do
+				klass.send :rtype, :return_arg, [/cuba/] => Any
+				instance.return_arg("cuba")
+			end
+			it "is wrong args" do
+				klass.send :rtype, :return_arg, [/cuba/] => Any
+				expect {instance.return_arg("brazil")}.to raise_error Rtype::ArgumentTypeError
+			end
+			it "is wrong result" do
+				klass.send :rtype, :return_nil, [Any] => /cuba/
+				expect {instance.return_nil("cuba")}.to raise_error Rtype::ReturnTypeError
+			end
+		end
+
+		describe 'Range' do
+			it "is right" do
+				klass.send :rtype, :return_arg, [1..10] => Any
+				instance.return_arg(5)
+			end
+			it "is wrong args" do
+				klass.send :rtype, :return_arg, [1..10] => Any
+				expect {instance.return_arg(1001)}.to raise_error Rtype::ArgumentTypeError
+			end
+			it "is wrong result" do
+				klass.send :rtype, :return_nil, [Any] => 1..10
+				expect {instance.return_nil(5)}.to raise_error Rtype::ReturnTypeError
+			end
+		end
+
+		describe 'Array' do
+			it "is right" do
+				klass.send :rtype, :return_arg, [[:to_i, :to_i]] => Any
+				instance.return_arg([123, 456])
+			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
+			end
+			it "is wrong result" do
+				klass.send :rtype, :return_arg, [Any] => [:to_i, :to_i]
+				expect {instance.return_arg(true)}.to raise_error Rtype::ReturnTypeError
+			end
+		end
+
+		describe 'Proc' do
+			it "is right" do
+				klass.send :rtype, :return_arg, [->(arg){!arg.nil?}] => Any
+				instance.return_arg(123)
+			end
+			it "is wrong args" do
+				klass.send :rtype, :return_arg, [->(arg){!arg.nil?}] => Any
+				expect {instance.return_arg(nil)}.to raise_error Rtype::ArgumentTypeError
+			end
+			it "is wrong result" do
+				klass.send :rtype, :return_nil, [Any] => ->(arg){!arg.nil?}
+				expect {instance.return_nil(123)}.to raise_error Rtype::ReturnTypeError
+			end
+		end
+
+		describe 'true' do
+			it "is right" do
+				klass.send :rtype, :return_arg, [true] => Any
+				instance.return_arg(123)
+			end
+			it "is wrong args" do
+				klass.send :rtype, :return_arg, [true] => Any
+				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
+			end
+		end
+
+		describe 'false' do
+			it "is right" do
+				klass.send :rtype, :return_arg, [false] => Any
+				instance.return_arg(nil)
+			end
+			it "is wrong args" do
+				klass.send :rtype, :return_arg, [false] => Any
+				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(123)}.to raise_error Rtype::ReturnTypeError
+			end
+		end
+
+		describe 'nil' do
+			it "is only 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
+				expect {
+					klass.send :rtype, :return_arg, [nil] => Any
+				}.to raise_error Rtype::TypeSignatureError
+			end
+		end
+
+		describe 'Special type behaviors' do
+			it 'Rtype::Behavior::And' do
+				klass.send :rtype, :return_nil, [Rtype.and(:to_i, :chars)] => nil
+				instance.return_nil("Hello")
+				expect {instance.return_nil(123)}.to raise_error Rtype::ArgumentTypeError
+			end
+
+			it 'Rtype::Behavior::Or' 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 'Rtype::Behavior::Nilable' do
+				klass.send :rtype, :return_nil, [Rtype.nilable(Integer)] => nil
+				instance.return_nil(nil)
+				instance.return_nil(123)
+				expect {instance.return_nil("abc")}.to raise_error Rtype::ArgumentTypeError
+			end
+
+			it 'Rtype::Behavior::Not' do
+				klass.send :rtype, :return_nil, [Rtype.not(String)] => nil
+				instance.return_nil(123)
+				expect {instance.return_nil("abc")}.to raise_error Rtype::ArgumentTypeError
+			end
+
+			it 'Rtype::Behavior::Xor' do
+				klass.send :rtype, :return_nil, [Rtype.xor(:to_i, String)] => nil
+				instance.return_nil(123)
+				expect {instance.return_nil("abc")}.to raise_error Rtype::ArgumentTypeError
+			end
+		end
+	end
+
+	describe 'Signature' do
+		describe 'check arguments' do
+			it 'nothing' do
+				klass.send :rtype, :sum, [] => Any
+				instance.sum(1, 2)
+				instance.sum(1, 2.0)
+				instance.sum(1.0, 2.0)
+				instance.sum("a", "b")
+			end
+
+			it 'two' do
+				klass.send :rtype, :sum, [Integer, Integer] => Any
+				expect {instance.sum(1, 2.0)}.to raise_error Rtype::ArgumentTypeError
+			end
+
+			it 'one keyword argument' do
+				klass.send :rtype, :kwarg, {a: Float} => Any
+				expect {instance.kwarg(a: 1)}.to raise_error Rtype::ArgumentTypeError
+			end
+
+			it 'two keyword argument' do
+				klass.send :rtype, :sum_kwargs, {a: Integer, b: Float} => Any
+				expect {instance.sum_kwargs(a: 1, b: 2)}.to raise_error Rtype::ArgumentTypeError
+			end
+
+			it 'one with one keyword argument' do
+				klass.send :rtype, :arg_and_kwarg, [Integer, {b: Float}] => Any
+				expect {instance.arg_and_kwarg(1, b: 2)}.to raise_error Rtype::ArgumentTypeError
+			end
+
+			it 'one with two keyword argument' do
+				klass.send :rtype, :arg_and_kwargs, [Integer, {c: String, d: String}] => Any
+				expect {instance.arg_and_kwargs(1, b: 2, c: 3)}.to raise_error Rtype::ArgumentTypeError
+			end
+
+			it 'two with two keyword argument' do
+				klass.send :rtype, :args_and_kwargs, [Integer, Integer, {c: String, d: String}] => Any
+				expect {instance.args_and_kwargs(1, 2, c: 3, d: 4)}.to raise_error Rtype::ArgumentTypeError
+			end
+
+			it 'string key could not be used for keyword argument' do
+				expect {
+					klass.send :rtype, :kwarg, {'a' => Float} => Any
+				}.to raise_error Rtype::TypeSignatureError
+			end
+
+			it 'only symbol key is used for keyword argument' do
+				klass.send :rtype, :kwarg, {:a => Float} => Any
+				expect {instance.kwarg(a: 1)}.to raise_error Rtype::ArgumentTypeError
+				expect {instance.kwarg(:a => 1)}.to raise_error Rtype::ArgumentTypeError
+			end
+		end
+
+		describe 'check return' do
+			it 'Any' do
+				klass.send :rtype, :return_arg, [] => Any
+				instance.return_arg("str")
+			end
+
+			it 'Array (tuple)' do
+				klass.send :rtype, :return_arg, [] => [Integer, Float]
+				expect {instance.return_arg([1, 2])}.to raise_error Rtype::ReturnTypeError
+			end
+		end
+
+		it 'check arguments and return value' do
+			klass.send :rtype, :return_nil, [Float] => nil
+			expect {instance.return_nil(123)}.to raise_error Rtype::ArgumentTypeError
+			klass.send :rtype, :return_nil, [Integer] => Integer
+			expect {instance.return_nil(123)}.to raise_error Rtype::ReturnTypeError
+		end
+
+		describe 'wrong case' do
+			describe 'invalid signature form' do
+				it 'invalid argument signature' do
+					expect {
+						klass.send :rtype, :return_arg, Any => nil
+					}.to raise_error Rtype::TypeSignatureError
+				end
+				it 'invalid return signature' do
+					expect {
+						klass.send :rtype, :return_arg, [] => {}
+					}.to raise_error Rtype::TypeSignatureError
+				end
+
+				it 'invalid type behavior in arguments' do
+					expect {
+						klass.send :rtype, :sum_kwargs, [{a: Integer}, {b: Integer}] => Any
+					}.to raise_error Rtype::TypeSignatureError
+					expect {
+						klass.send :rtype, :return_arg, [123] => Any
+					}.to raise_error Rtype::TypeSignatureError
+					expect {
+						klass.send :rtype, :return_arg, ["abc"] => Any
+					}.to raise_error Rtype::TypeSignatureError
+					expect {
+						klass.send :rtype, :kwarg, {a: 123} => Any
+					}.to raise_error Rtype::TypeSignatureError
+					expect {
+						klass.send :rtype, :kwarg, {a: {b: Integer}} => Any
+					}.to raise_error Rtype::TypeSignatureError
+					expect {
+						klass.send :rtype, :kwarg, {Object.new => Integer} => Any
+					}.to raise_error Rtype::TypeSignatureError
+				end
+
+				it 'invalid type behavior in return' do
+					expect {
+						klass.send :rtype, :return_arg, [] => 123
+					}.to raise_error Rtype::TypeSignatureError
+					expect {
+						klass.send :rtype, :return_arg, [] => "abc"
+					}.to raise_error Rtype::TypeSignatureError
+				end
+			end
+		end
+	end
+
+	describe "Implementation" do
+		it 'can be called before method definition' do
+			class TestClass
+				rtype :method_def, [Integer] => Any
+				def method_def(i)
+				end
+			end
+			expect {
+				TestClass.new.method_def("abc")
+			}.to raise_error Rtype::ArgumentTypeError
+		end
+
+		it 'can be called after method definition' do
+			class TestClass
+				def method_def_2(i)
+				end
+				rtype :method_def_2, [Integer] => Any
+			end
+			expect {
+				TestClass.new.method_def_2("abc")
+			}.to raise_error Rtype::ArgumentTypeError
+		end
+
+		it 'method name can be both symbol and string' do
+			class TestClass
+				rtype 'method_def_3', [Integer] => Any
+				def method_def_3(i)
+				end
+				rtype :method_def_4, [Integer] => Any
+				def method_def_4(i)
+				end
+			end
+			expect {
+				TestClass.new.method_def_3("abc")
+			}.to raise_error Rtype::ArgumentTypeError
+			expect {
+				TestClass.new.method_def_4("abc")
+			}.to raise_error Rtype::ArgumentTypeError
+		end
+
+		describe 'method visibility works' do
+			it 'protected' do
+				expect {instance.protected_func}.to raise_error NoMethodError
+			end
+			it 'private' do
+				expect {instance.private_func}.to raise_error NoMethodError
+			end
+		end
+
+		context 'with empty argument signature' do
+			it 'accept any arguments' do
+				klass.send :rtype, :three_args, [] => Any
+				instance.three_args("abc", 123, 456)
+			end
+		end
+
+		context 'when args length is more than arg signature length' do
+			it 'type checking ignore rest args' do
+				klass.send :rtype, :three_args, [String] => Any
+				instance.three_args("abc", 123, 456)
+			end
+		end
+
+		context 'when keyword args contain a key not configured to rtype' do
+			it 'type checking ignore the key' do
+				klass.send :rtype, :three_kwargs, {a: String} => Any
+				instance.three_kwargs(a: "abc", b: 123, c: 456)
+			end
+		end
+	end
+
+	describe "Call Rtype`s static method directly" do
+		it 'Rtype::define_typed_method' do
+			Rtype::define_typed_method klass, :return_arg, [String] => Any
+			expect {instance.return_arg(123)}.to raise_error Rtype::ArgumentTypeError
+		end
+
+		it 'Rtype::define_typed_accessor' do
+			Rtype::define_typed_accessor klass, :value, String
+			expect { instance.value = 123 }.to raise_error Rtype::ArgumentTypeError
+			expect { instance.value }.to raise_error Rtype::ReturnTypeError
+		end
+		
+		it 'Rtype::valid?' do
+			expect {
+				Rtype::valid?("Invalid type behavior", "Test Value")
+			}.to raise_error Rtype::TypeSignatureError
+		end
+		
+		it 'Rtype::assert_arguments_type' do
+			expect {
+				Rtype::assert_arguments_type([Integer, String], [123, 123])
+			}.to raise_error Rtype::ArgumentTypeError
+		end
+		
+		it 'Rtype::assert_arguments_type_with_keywords' do
+			expect {
+				Rtype::assert_arguments_type_with_keywords([Integer, String], [123, "abc"], {arg: String}, {arg: 123})
+			}.to raise_error Rtype::ArgumentTypeError
+		end
+		
+		it 'Rtype::assert_return_type' do
+			expect {
+				Rtype::assert_return_type nil, "No nil"
+			}.to raise_error Rtype::ReturnTypeError
+		end
+	end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'coveralls'
+Coveralls.wear!
+
+require 'rtype'
+require 'rspec'