rtype 0.0.2

data/lib/rtype/behavior/or.rb

@@ -0,0 +1,24 @@
+module Rtype
+	module Behavior
+		class Or < Base
+			def initialize(*types)
+				@types = types
+			end
+
+			def valid?(value)
+				@types.any? do |e|
+					Rtype::valid? e, value
+				end
+			end
+
+			def error_message(value)
+				arr = @types.map { |e| Rtype::type_error_message(e, value) }
+				arr.join "\nOR "
+			end
+		end
+	end
+
+	def self.or(*args)
+		Behavior::Or[*args]
+	end
+end

data/lib/rtype/behavior/xor.rb

@@ -0,0 +1,25 @@
+module Rtype
+	module Behavior
+		class Xor < Base
+			def initialize(*types)
+				@types = types
+			end
+
+			def valid?(value)
+				result = @types.map do |e|
+					Rtype::valid? e, value
+				end
+				result.count(true) == 1
+			end
+
+			def error_message(value)
+				arr = @types.map { |e| Rtype::type_error_message(e, value) }
+				arr.join "\nXOR "
+			end
+		end
+	end
+
+	def self.xor(*args)
+		Behavior::Xor[*args]
+	end
+end

data/lib/rtype/behavior.rb

@@ -0,0 +1,11 @@
+module Rtype
+	module Behavior
+	end
+end
+
+require_relative 'behavior/base'
+require_relative 'behavior/or'
+require_relative 'behavior/and'
+require_relative 'behavior/xor'
+require_relative 'behavior/not'
+require_relative 'behavior/nilable'

data/lib/rtype/core_ext.rb

@@ -0,0 +1,60 @@
+module Boolean; end
+class TrueClass; include Boolean; end
+class FalseClass; include Boolean; end
+Any = BasicObject
+
+module Kernel
+private
+	def _rtype_proxy
+		unless @_rtype_proxy
+			@_rtype_proxy = Module.new
+			prepend @_rtype_proxy
+		end
+		@_rtype_proxy
+	end
+
+	def rtype(method_name, type_sig_info)
+		if is_a?(Module)
+			::Rtype.define_typed_method(self, method_name, type_sig_info)
+		else
+			rtype_self(method_name, type_sig_info)
+		end
+	end
+
+	def rtype_self(method_name, type_sig_info)
+		::Rtype.define_typed_method(singleton_class, method_name, type_sig_info)
+	end
+end
+
+class Method
+	def type_signature
+		::Rtype.type_signatures[owner][name]
+	end
+
+	def type_info
+		type_signature.info
+	end
+
+	def argument_type
+		type_signature.argument_type
+	end
+
+	def return_type
+		type_signature.return_type
+	end
+end
+
+class Fixnum
+	def ordinalize
+	    if (11..13).include?(self % 100)
+			"#{self}th"
+	    else
+			case self % 10
+			when 1; "#{self}st"
+			when 2; "#{self}nd"
+			when 3; "#{self}rd"
+			else "#{self}th"
+			end
+	    end
+	end
+end

data/lib/rtype/return_type_error.rb

@@ -0,0 +1,4 @@
+module Rtype
+	class ReturnTypeError < StandardError
+	end
+end

data/lib/rtype/type_signature.rb

@@ -0,0 +1,9 @@
+module Rtype
+	class TypeSignature
+		attr_accessor :argument_type, :return_type
+
+		def info
+			{argument_type => return_type}
+		end
+	end
+end

data/lib/rtype/type_signature_error.rb

@@ -0,0 +1,4 @@
+module Rtype
+	class TypeSignatureError < ArgumentError
+	end
+end

data/lib/rtype/version.rb

@@ -0,0 +1,3 @@
+module Rtype
+	VERSION = "0.0.2".freeze
+end

data/lib/rtype.rb

@@ -0,0 +1,172 @@
+require_relative 'rtype/core_ext'
+require_relative 'rtype/version'
+require_relative 'rtype/type_signature_error'
+require_relative 'rtype/argument_type_error'
+require_relative 'rtype/return_type_error'
+require_relative 'rtype/type_signature'
+require_relative 'rtype/behavior'
+
+module Rtype
+	# This is just the 'information'
+	# Any change of this doesn't affect type checking
+	@@type_signatures = Hash.new({})
+
+	class << self
+		def define_typed_method(owner, method_name, type_sig_info)
+			raise TypeSignatureError, "Invalid type signature" unless valid_type_sig_info_form?(type_sig_info)
+			method_name = method_name.to_sym
+			raise ArgumentError, "method_name is nil" if method_name.nil?
+
+			el = type_sig_info.first
+			arg_sig = el[0]
+			return_sig = el[1]
+
+			if arg_sig.is_a?(Array)
+				expected_args = arg_sig
+				if expected_args.last.is_a?(Hash)
+					expected_kwargs = expected_args.pop
+				else
+					expected_kwargs = {}
+				end
+			elsif arg_sig.is_a?(Hash)
+				expected_args = []
+				expected_kwargs = arg_sig
+			end
+
+			expected_args.each { |e| valid?(e, nil) }
+			if expected_kwargs.keys.any? { |e| !e.is_a?(Symbol) }
+				raise TypeSignatureError, "Invalid type signature: keyword arguments contain non-symbol key"
+			end
+			expected_kwargs.each_value { |e| valid?(e, nil) }
+			valid?(return_sig, nil) unless return_sig.nil?
+
+			sig = TypeSignature.new
+			sig.argument_type = arg_sig
+			sig.return_type = return_sig
+			@@type_signatures[owner][method_name] = sig
+
+			owner.method(:_rtype_proxy).call.send :define_method, method_name do |*args, **kwargs, &block|
+				if kwargs.empty?
+					::Rtype.assert_arguments_type(expected_args, args)
+					result = super(*args, &block)
+				else
+					::Rtype.assert_arguments_type(expected_args, args)
+					::Rtype.assert_keyword_arguments_type(expected_kwargs, kwargs)
+					result = super(*args, **kwargs, &block)
+				end
+				::Rtype.assert_return_type(return_sig, result)
+				result
+			end
+		end
+
+		# validate argument type
+		def valid?(expected, value)
+			case expected
+			when Rtype::Behavior::Base
+				expected.valid? value
+			when Module
+				value.is_a? expected
+			when Symbol
+				value.respond_to? expected
+			when Regexp
+				!!(expected =~ value.to_s)
+			when Range
+				expected.include?(value)
+			when Array
+				return false unless value.is_a?(Array)
+				return false unless expected.length == value.length
+				idx = -1
+				expected.all? { |e| idx += 1; valid?(e, value[idx]) }
+			when Proc
+				!!expected.call(value)
+			when true
+				!!value
+			when false
+				!value
+			else
+				raise TypeSignatureError, "Invalid type signature: Unknown type behavior #{expected}"
+			end
+		end
+
+		def type_signatures
+			@@type_signatures
+		end
+
+		def assert_arguments_type(expected_args, args)
+			args.each_with_index do |value, idx|
+				expected = expected_args[idx]
+				unless expected.nil?
+					unless valid?(expected, value)
+						raise ArgumentTypeError, "for #{(idx+1).ordinalize} argument:\n" + type_error_message(expected, value)
+					end
+				end
+			end
+		end
+
+		def assert_keyword_arguments_type(expected_kwargs, kwargs)
+			kwargs.each do |key, value|
+				expected = expected_kwargs[key]
+				unless expected.nil?
+					unless valid?(expected, value)
+						raise ArgumentTypeError, "for '#{key}' argument:\n" + type_error_message(expected, value)
+					end
+				end
+			end
+		end
+
+		def assert_return_type(expected, result)
+			if expected.nil?
+				unless result.nil?
+					raise ReturnTypeError, "for return:\n" + type_error_message(expected, result)
+				end
+			else
+				unless valid?(expected, result)
+					raise ReturnTypeError, "for return:\n" + type_error_message(expected, result)
+				end
+			end
+		end
+
+		def type_error_message(expected, value)
+			case expected
+			when Rtype::Behavior::Base
+				expected.error_message(value)
+			when Module
+				"Expected #{value.inspect} to be a #{expected}"
+			when Symbol
+				"Expected #{value.inspect} to respond to :#{expected}"
+			when Regexp
+				"Expected stringified #{value.inspect} to match regexp #{expected.inspect}"
+			when Range
+				"Expected #{value.inspect} to be included in range #{expected.inspect}"
+			when Array
+				if value.is_a?(Array)
+					arr = expected.map.with_index do |e, idx|
+						if e.is_a?(Array)
+							"- [#{idx}] index : {\n" + type_error_message(e, value[idx]) + "\n}"
+						else
+							"- [#{idx}] index : " + type_error_message(e, value[idx])
+						end
+					end
+					"Expected #{value.inspect} to be an array with #{expected.length} elements:\n" + arr.join("\n")
+				else
+					"Expected #{value.inspect} to be an array"
+				end
+			when Proc
+				"Expected #{value.inspect} to return a truthy value for proc #{expected}"
+			when true
+				"Expected #{value.inspect} to be a truthy value"
+			when false
+				"Expected #{value.inspect} to be a falsy value"
+			when nil # for return
+				"Expected #{value.inspect} to be nil"
+			end
+		end
+
+	private
+		def valid_type_sig_info_form?(hash)
+			return false unless hash.is_a?(Hash)
+			arg_sig = hash.first[0]
+			arg_sig.is_a?(Array) || arg_sig.is_a?(Hash)
+		end
+	end
+end