rtype-legacy 0.0.4-java

data/lib/rtype/behavior/core_ext.rb

@@ -0,0 +1,174 @@
+class Object
+	# @return [Rtype::Behavior::And]
+	def and(*others)
+		::Rtype::and(self, *others)
+	end
+
+	# @return [Rtype::Behavior::Nilable]
+	def nilable
+		::Rtype::nilable(self)
+	end
+	alias_method :or_nil, :nilable
+
+	# @return [Rtype::Behavior::Not]
+	def not
+		::Rtype::not(self)
+	end
+
+	# @return [Rtype::Behavior::Xor]
+	def xor(*others)
+		::Rtype::xor(self, *others)
+	end
+end
+
+class Array
+	# @return [Rtype::Behavior::TypedArray]
+	def self.of(type_sig)
+		::Rtype::Behavior::TypedArray.new(type_sig)
+	end
+	
+	# @return [Rtype::Behavior::And]
+	def comb
+		::Rtype::Behavior::And[*self]
+	end
+end
+
+class Set
+	# @return [Rtype::Behavior::TypedSet]
+	def self.of(type_sig)
+		::Rtype::Behavior::TypedSet.new(type_sig)
+	end
+end
+
+class Hash
+	# @return [Rtype::Behavior::TypedHash]
+	def self.of(key_type, value_type)
+		::Rtype::Behavior::TypedHash.new(key_type, value_type)
+	end
+end
+
+class Num
+	# @param [Numeric] x
+	# @return [Rtype::Behavior::NumericCheck]
+	# @example Value must be a Numeric and > 2
+	#   rtype [Num > 2] => Any
+	def self.>(x)
+		::Rtype::Behavior::NumericCheck.new(:>, x)
+	end
+
+	# @param [Numeric] x
+	# @return [Rtype::Behavior::NumericCheck]
+	# @example Value must be a Numeric and > 2
+	#   rtype [Num > 2] => Any
+	def self.>=(x)
+		::Rtype::Behavior::NumericCheck.new(:>=, x)
+	end
+
+	# @param [Numeric] x
+	# @return [Rtype::Behavior::NumericCheck]
+	# @example Value must be a Numeric and > 2
+	#   rtype [Num > 2] => Any
+	def self.<(x)
+		::Rtype::Behavior::NumericCheck.new(:<, x)
+	end
+
+	# @param [Numeric] x
+	# @return [Rtype::Behavior::NumericCheck]
+	# @example Value must be a Numeric and > 2
+	#   rtype [Num > 2] => Any
+	def self.<=(x)
+		::Rtype::Behavior::NumericCheck.new(:<=, x)
+	end
+	
+	# @param [Numeric] x
+	# @return [Rtype::Behavior::NumericCheck]
+	# @example Value must be a Numeric and > 2
+	#   rtype [Num > 2] => Any
+	def self.==(x)
+		::Rtype::Behavior::NumericCheck.new(:==, x)
+	end
+end
+
+class Int
+	# @param [Numeric] x
+	# @return [Rtype::Behavior::IntegerCheck]
+	# @example Value must be a Integer and > 2
+	#   rtype [Int > 2] => Any
+	def self.>(x)
+		::Rtype::Behavior::IntegerCheck.new(:>, x)
+	end
+
+	# @param [Numeric] x
+	# @return [Rtype::Behavior::IntegerCheck]
+	# @example Value must be a Integer and > 2
+	#   rtype [Int > 2] => Any
+	def self.>=(x)
+		::Rtype::Behavior::IntegerCheck.new(:>=, x)
+	end
+
+	# @param [Numeric] x
+	# @return [Rtype::Behavior::IntegerCheck]
+	# @example Value must be a Integer and > 2
+	#   rtype [Int > 2] => Any
+	def self.<(x)
+		::Rtype::Behavior::IntegerCheck.new(:<, x)
+	end
+
+	# @param [Numeric] x
+	# @return [Rtype::Behavior::IntegerCheck]
+	# @example Value must be a Integer and > 2
+	#   rtype [Int > 2] => Any
+	def self.<=(x)
+		::Rtype::Behavior::IntegerCheck.new(:<=, x)
+	end
+	
+	# @param [Numeric] x
+	# @return [Rtype::Behavior::IntegerCheck]
+	# @example Value must be a Integer and > 2
+	#   rtype [Int > 2] => Any
+	def self.==(x)
+		::Rtype::Behavior::IntegerCheck.new(:==, x)
+	end
+end
+
+class Flo
+	# @param [Numeric] x
+	# @return [Rtype::Behavior::FloatCheck]
+	# @example Value must be a Float and > 2
+	#   rtype [Flo > 2] => Any
+	def self.>(x)
+		::Rtype::Behavior::FloatCheck.new(:>, x)
+	end
+
+	# @param [Numeric] x
+	# @return [Rtype::Behavior::FloatCheck]
+	# @example Value must be a Float and > 2
+	#   rtype [Flo > 2] => Any
+	def self.>=(x)
+		::Rtype::Behavior::FloatCheck.new(:>=, x)
+	end
+
+	# @param [Numeric] x
+	# @return [Rtype::Behavior::FloatCheck]
+	# @example Value must be a Float and > 2
+	#   rtype [Flo > 2] => Any
+	def self.<(x)
+		::Rtype::Behavior::FloatCheck.new(:<, x)
+	end
+
+	# @param [Numeric] x
+	# @return [Rtype::Behavior::FloatCheck]
+	# @example Value must be a Float and > 2
+	#   rtype [Flo > 2] => Any
+	def self.<=(x)
+		::Rtype::Behavior::FloatCheck.new(:<=, x)
+	end
+	
+	# @param [Numeric] x
+	# @return [Rtype::Behavior::FloatCheck]
+	# @example Value must be a Float and > 2
+	#   rtype [Flo > 2] => Any
+	def self.==(x)
+		::Rtype::Behavior::FloatCheck.new(:==, x)
+	end
+end

data/lib/rtype/behavior/float_check.rb

@@ -0,0 +1,17 @@
+module Rtype
+	module Behavior
+		class FloatCheck < NumericCheck
+			def valid?(value)
+				if value.is_a?(Float)
+					@lambda.call(value)
+				else
+					false
+				end
+			end
+
+			def error_message(value)
+				"Expected #{value.inspect} to be a float #{@condition} #{@x}"
+			end
+		end
+	end
+end

data/lib/rtype/behavior/integer_check.rb

@@ -0,0 +1,17 @@
+module Rtype
+	module Behavior
+		class IntegerCheck < NumericCheck
+			def valid?(value)
+				if value.is_a?(Integer)
+					@lambda.call(value)
+				else
+					false
+				end
+			end
+
+			def error_message(value)
+				"Expected #{value.inspect} to be an integer #{@condition} #{@x}"
+			end
+		end
+	end
+end

data/lib/rtype/behavior/nilable.rb

@@ -0,0 +1,21 @@
+module Rtype
+	module Behavior
+		class Nilable < Base
+			def initialize(type)
+				@type = type
+			end
+
+			def valid?(value)
+				value.nil? || Rtype::valid?(@type, value)
+			end
+
+			def error_message(value)
+				Rtype::type_error_message(@type, value) + "\nOR " + Rtype::type_error_message(nil, value)
+			end
+		end
+	end
+
+	def nilable(*args)
+		Behavior::Nilable[*args]
+	end
+end

data/lib/rtype/behavior/not.rb

@@ -0,0 +1,24 @@
+module Rtype
+	module Behavior
+		class Not < Base
+			def initialize(*types)
+				@types = types
+			end
+
+			def valid?(value)
+				@types.all? do |e|
+					!Rtype::valid?(e, value)
+				end
+			end
+
+			def error_message(value)
+				arr = @types.map { |e| "NOT " + Rtype::type_error_message(e, value) }
+				arr.join "\nAND "
+			end
+		end
+	end
+
+	def not(*args)
+		Behavior::Not[*args]
+	end
+end

data/lib/rtype/behavior/numeric_check.rb

@@ -0,0 +1,42 @@
+module Rtype
+	module Behavior
+		class NumericCheck < Base
+			@@conditions = [
+				:>, :<, :>=, :<=, :==
+			]
+			
+			# @param [Symbol] condition
+			# @param [Numeric] x
+			def initialize(condition, x)
+				raise ArgumentError, "Invalid condition '#{condition}'" unless @@conditions.include?(condition)
+				raise ArgumentError, "x is not a Numeric" unless x.is_a?(Numeric)
+				@condition = condition
+				@x = x
+				@lambda = case condition
+					when :>
+						lambda { |obj| obj > @x }
+					when :<
+						lambda { |obj| obj < @x }
+					when :>=
+						lambda { |obj| obj >= @x }
+					when :<=
+						lambda { |obj| obj <= @x }
+					when :==
+						lambda { |obj| obj == @x }
+				end
+			end
+			
+			def valid?(value)
+				if value.is_a?(Numeric)
+					@lambda.call(value)
+				else
+					false
+				end
+			end
+
+			def error_message(value)
+				"Expected #{value.inspect} to be a numeric #{@condition} #{@x}"
+			end
+		end
+	end
+end

data/lib/rtype/behavior/typed_array.rb

@@ -0,0 +1,26 @@
+module Rtype
+	module Behavior
+		# Typed array behavior. empty array allowed
+		class TypedArray < Base
+			def initialize(type)
+				@type = type
+				Rtype.assert_valid_argument_type_sig_element(@type)
+			end
+
+			def valid?(value)
+				if value.is_a?(Array)
+					any = value.any? do |e|
+						!Rtype::valid?(@type, e)
+					end
+					!any
+				else
+					false
+				end
+			end
+
+			def error_message(value)
+				"Expected #{value.inspect} to be an array with type #{@type.inspect}"
+			end
+		end
+	end
+end

data/lib/rtype/behavior/typed_hash.rb

@@ -0,0 +1,29 @@
+module Rtype
+	module Behavior
+		# Typed hash behavior. empty hash allowed
+		class TypedHash < Base
+			def initialize(key_type, value_type)
+				@ktype = key_type
+				@vtype = value_type
+				Rtype.assert_valid_argument_type_sig_element(@ktype)
+				Rtype.assert_valid_argument_type_sig_element(@vtype)
+			end
+
+			def valid?(value)
+				if value.is_a?(Hash)
+					any = value.any? do |k, v|
+						!Rtype::valid?(@ktype, k) ||
+						!Rtype::valid?(@vtype, v)
+					end
+					!any
+				else
+					false
+				end
+			end
+
+			def error_message(value)
+				"Expected #{value.inspect} to be a hash with key type #{@ktype.inspect} and value type #{@vtype.inspect}"
+			end
+		end
+	end
+end

data/lib/rtype/behavior/typed_set.rb

@@ -0,0 +1,26 @@
+module Rtype
+	module Behavior
+		# Typed set behavior. empty set allowed
+		class TypedSet < Base
+			def initialize(type)
+				@type = type
+				Rtype.assert_valid_argument_type_sig_element(@type)
+			end
+
+			def valid?(value)
+				if value.is_a?(Set)
+					any = value.any? do |e|
+						!Rtype::valid?(@type, e)
+					end
+					!any
+				else
+					false
+				end
+			end
+
+			def error_message(value)
+				"Expected #{value.inspect} to be a set with type #{@type.inspect}"
+			end
+		end
+	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 xor(*args)
+		Behavior::Xor[*args]
+	end
+end

data/lib/rtype/behavior.rb

@@ -0,0 +1,17 @@
+module Rtype
+	module Behavior
+	end
+end
+
+require_relative 'behavior/base'
+require_relative 'behavior/and'
+require_relative 'behavior/xor'
+require_relative 'behavior/not'
+require_relative 'behavior/nilable'
+require_relative 'behavior/typed_array'
+require_relative 'behavior/typed_set'
+require_relative 'behavior/typed_hash'
+require_relative 'behavior/numeric_check'
+require_relative 'behavior/integer_check'
+require_relative 'behavior/float_check'
+require_relative 'behavior/core_ext'

data/lib/rtype/core_ext.rb

@@ -0,0 +1,266 @@
+# true or false
+module Boolean; end
+class TrueClass; include Boolean; end
+class FalseClass; include Boolean; end
+
+Any = BasicObject
+
+class Object
+	include ::Rtype::MethodAnnotator
+end
+
+module Kernel
+private
+	def _rtype_component
+		unless @_rtype_component
+			@_rtype_component = ::Rtype::RtypeComponent.new
+		end
+		@_rtype_component
+	end
+
+	# Makes the method typed
+	# 
+	# With 'annotation mode', this method works for both instance method and singleton method (class method).
+	# Without it (specifying method name), this method only works for instance method.
+	# 
+	# @param [#to_sym, nil] method_name The name of method. If nil, annotation mode works
+	# @param [Hash] type_sig_info A type signature. e.g. [Integer] => Any
+	# @return [void]
+	# 
+	# @note Annotation mode doesn't work in the outside of module
+	# @raise [RuntimeError] If called outside of module
+	# @raise [TypeSignatureError] If type_sig_info is invalid
+	def rtype(method_name=nil, type_sig_info)
+		if is_a?(Module)
+			if method_name.nil?
+				::Rtype::assert_valid_type_sig(type_sig_info)
+				_rtype_component.annotation_mode = true
+				_rtype_component.annotation_type_sig = type_sig_info
+				nil
+			else
+				::Rtype::define_typed_method(self, method_name, type_sig_info, false)
+			end
+		else
+			raise "rtype doesn't work in the outside of module"
+		end
+	end
+
+	# Makes the singleton method (class method) typed
+	# 
+	# @param [#to_sym] method_name
+	# @param [Hash] type_sig_info A type signature. e.g. [Integer] => Any
+	# @return [void]
+	# 
+	# @raise [ArgumentError] If method_name is nil
+	# @raise [TypeSignatureError] If type_sig_info is invalid
+	def rtype_self(method_name, type_sig_info)
+		::Rtype.define_typed_method(self, method_name, type_sig_info, true)
+	end
+	
+	# Makes the accessor methods (getter and setter) typed
+	# 
+	# @param [Array<#to_sym>] names
+	# @param type_behavior A type behavior
+	# @return [void]
+	# 
+	# @raise [ArgumentError] If names contains nil
+	# @raise [TypeSignatureError] If type_behavior is invalid
+	# @raise [RuntimeError] If called outside of module
+	# @see #rtype
+	def rtype_accessor(*names, type_behavior)
+		rtype_reader(*names, type_behavior)
+		rtype_writer(*names, type_behavior)
+	end
+	
+	# Makes the accessor methods (getter and setter) typed
+	# 
+	# @param [Array<#to_sym>] names
+	# @param type_behavior A type behavior
+	# @return [void]
+	# 
+	# @raise [ArgumentError] If names contains nil
+	# @raise [TypeSignatureError] If type_behavior is invalid
+	# @see #rtype_self
+	def rtype_accessor_self(*names, type_behavior)
+		rtype_reader_self(*names, type_behavior)
+		rtype_writer_self(*names, type_behavior)
+	end
+	
+	# Makes the getter methods typed
+	# 
+	# @param [Array<#to_sym>] names
+	# @param type_behavior A type behavior
+	# @return [void]
+	# 
+	# @raise [ArgumentError] If names contains nil
+	# @raise [TypeSignatureError] If type_behavior is invalid
+	# @raise [RuntimeError] If called outside of module
+	# @see #rtype
+	def rtype_reader(*names, type_behavior)
+		names.each do |name|
+			raise ArgumentError, "names contains nil" if name.nil?
+			
+			name = name.to_sym
+			if !respond_to?(name)
+				attr_reader name
+			end
+
+			if is_a?(Module)
+				::Rtype::define_typed_reader(self, name, type_behavior, false)
+			else
+				raise "rtype_reader doesn't work in the outside of module"
+			end
+		end
+		nil
+	end
+	
+	# Makes the getter methods typed
+	# 
+	# @param [Array<#to_sym>] names
+	# @param type_behavior A type behavior
+	# @return [void]
+	# 
+	# @raise [ArgumentError] If names contains nil
+	# @raise [TypeSignatureError] If type_behavior is invalid
+	# @see #rtype_self
+	def rtype_reader_self(*names, type_behavior)
+		names.each do |name|
+			raise ArgumentError, "names contains nil" if name.nil?
+			
+			name = name.to_sym
+			if !respond_to?(name)
+				singleton_class.send(:attr_reader, name)
+			end
+			::Rtype::define_typed_reader(self, name, type_behavior, true)
+		end
+		nil
+	end
+	
+	# Makes the setter methods typed
+	# 
+	# @param [Array<#to_sym>] names
+	# @param type_behavior A type behavior
+	# @return [void]
+	# 
+	# @raise [ArgumentError] If names contains nil
+	# @raise [TypeSignatureError] If type_behavior is invalid
+	# @raise [RuntimeError] If called outside of module
+	# @see #rtype
+	def rtype_writer(*names, type_behavior)
+		names.each do |name|
+			raise ArgumentError, "names contains nil" if name.nil?
+			
+			name = name.to_sym
+			if !respond_to?(:"#{name}=")
+				attr_writer name
+			end
+
+			if is_a?(Module)
+				::Rtype::define_typed_writer(self, name, type_behavior, false)
+			else
+				raise "rtype_writer doesn't work in the outside of module"
+			end
+		end
+		nil
+	end
+	
+	# Makes the setter methods typed
+	# 
+	# @param [Array<#to_sym>] names
+	# @param type_behavior A type behavior
+	# @return [void]
+	# 
+	# @raise [ArgumentError] If names contains nil
+	# @raise [TypeSignatureError] If type_behavior is invalid
+	# @see #rtype_self
+	def rtype_writer_self(*names, type_behavior)
+		names.each do |name|
+			raise ArgumentError, "names contains nil" if name.nil?
+			
+			name = name.to_sym
+			if !respond_to?(:"#{name}=")
+				singleton_class.send(:attr_writer, name)
+			end
+			::Rtype::define_typed_writer(self, name, type_behavior, true)
+		end
+		nil
+	end
+	
+	# Creates getter, setter methods.
+	# The getter method is typed with Float
+	# and the setter method is typed with Numeric.
+	# 
+	# If the setter is called with a numeric given,
+	# the setter convert the numeric to a float, and store it.
+	# 
+	# As a result, setter can accept a Numeric(Integer/Float), and getter always returns a Float
+	# 
+	# @param [Array<#to_sym>] names
+	# @return [void]
+	# 
+	# @raise [ArgumentError] If names contains nil
+	def float_accessor(*names)
+		names.each do |name|
+			raise ArgumentError, "names contains nil" if name.nil?
+			
+			name = name.to_sym
+			rtype_reader name, Float
+			define_method(:"#{name}=") do |val|
+				instance_variable_set(:"@#{name}", val.to_f)
+			end
+			::Rtype::define_typed_writer(self, name, Numeric, false)
+		end
+		nil
+	end
+	
+	# Creates getter, setter methods. And makes it typed with Boolean.
+	# The name of the getter ends with `?`.
+	# 
+	# e.g. `bool_accessor :closed` will create `closed=` and `closed?` methods
+	# 
+	# @param [Array<#to_sym>] names
+	# @return [void]
+	# 
+	# @raise [ArgumentError] If names contains nil
+	def bool_accessor(*names)
+		names.each do |name|
+			raise ArgumentError, "names contains nil" if name.nil?
+			
+			name = name.to_sym
+			rtype_writer name, Boolean
+			define_method(:"#{name}?") do
+				instance_variable_get(:"@#{name}")
+			end
+			::Rtype::define_typed_reader(self, :"#{name}?", Boolean, false)
+		end
+		nil
+	end
+end
+
+class Method
+	# @return [Boolean] Whether the method is typed with rtype
+	def typed?
+		!!::Rtype.type_signatures[owner][name]
+	end
+
+	# @return [TypeSignature]
+	def type_signature
+		::Rtype.type_signatures[owner][name]
+	end
+
+	# @return [Hash]
+	# @see TypeSignature#info
+	def type_info
+		::Rtype.type_signatures[owner][name].info
+	end
+	
+	# @return [Array, Hash]
+	def argument_type
+		::Rtype.type_signatures[owner][name].argument_type
+	end
+
+	# @return A type behavior
+	def return_type
+		::Rtype.type_signatures[owner][name].return_type
+	end
+end

data/lib/rtype/legacy/version.rb

@@ -0,0 +1,9 @@
+module Rtype
+	module Legacy
+		VERSION = "0.0.4".freeze
+		# rtype java extension version. nil If the extension is not used
+		JAVA_EXT_VERSION = nil unless const_defined?(:JAVA_EXT_VERSION, false)
+		# rtype c extension version. nil If the extension is not used
+		NATIVE_EXT_VERSION = nil unless const_defined?(:NATIVE_EXT_VERSION, false)
+	end
+end