rtype 0.6.8-java

data/lib/rtype/core_ext.rb

@@ -0,0 +1,274 @@
+# 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_proxy
+		unless @_rtype_proxy
+			@_rtype_proxy = ::Rtype::RtypeProxy.new
+			prepend @_rtype_proxy
+		end
+		@_rtype_proxy
+	end
+
+	# Makes the method typed
+	# 
+	# With 'annotation mode', this method works for both instance method and singleton method (class method).
+	# Without it, 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 [ArgumentError] If method_name is nil in the 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_proxy.annotation_mode = true
+				_rtype_proxy.annotation_type_sig = type_sig_info
+				nil
+			else
+				::Rtype::define_typed_method(self, method_name, type_sig_info)
+			end
+		else
+			if method_name.nil?
+				raise ArgumentError, "Annotation mode doesn't work in the outside of module"
+			else
+				rtype_self(method_name, type_sig_info)
+			end
+		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(singleton_class, method_name, type_sig_info)
+	end
+	
+	# Calls `attr_accessor` if the accessor method(getter/setter) is not defined.
+	# and makes it 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
+	def rtype_accessor(*names, type_behavior)
+		rtype_reader(*names, type_behavior)
+		rtype_writer(*names, type_behavior)
+	end
+	
+	# Calls `attr_accessor` if the accessor method(getter/setter) is not defined.
+	# and makes it 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
+	
+	# Calls `attr_reader` if the getter method is not defined.
+	# and makes it 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
+	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)
+			else
+				rtype_reader_self(name, type_behavior)
+			end
+		end
+		nil
+	end
+	
+	# Calls `attr_reader` if the getter method is not defined.
+	# and makes it 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(singleton_class, name, type_behavior)
+		end
+		nil
+	end
+	
+	# Calls `attr_writer` if the setter method is not defined.
+	# and makes it 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
+	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)
+			else
+				rtype_reader_self(name, type_behavior)
+			end
+		end
+		nil
+	end
+	
+	# Calls `attr_writer` if the setter method is not defined.
+	# and makes it 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(singleton_class, name, type_behavior)
+		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)
+		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)
+		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/method_annotator.rb

@@ -0,0 +1,31 @@
+module Rtype
+	module MethodAnnotator
+		def self.included(base)
+			base.extend ClassMethods
+		end
+
+		module ClassMethods
+			def method_added(name)
+				if @_rtype_proxy
+					proxy = _rtype_proxy
+					if proxy.annotation_mode
+						::Rtype::define_typed_method(self, name, proxy.annotation_type_sig)
+						proxy.annotation_mode = false
+						proxy.annotation_type_sig = nil
+					end
+				end
+			end
+
+			def singleton_method_added(name)
+				if @_rtype_proxy
+					proxy = _rtype_proxy
+					if proxy.annotation_mode
+						::Rtype::define_typed_method(singleton_class, name, proxy.annotation_type_sig)
+						proxy.annotation_mode = false
+						proxy.annotation_type_sig = nil
+					end
+				end
+			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/rtype_proxy.rb

@@ -0,0 +1,10 @@
+module Rtype
+	class RtypeProxy < Module
+		attr_accessor :annotation_mode
+		attr_accessor :annotation_type_sig
+		def initialize
+			@annotation_mode = false
+			@annotation_type_sig = nil
+		end
+	end
+end

data/lib/rtype/type_signature.rb

@@ -0,0 +1,10 @@
+module Rtype
+	class TypeSignature
+		attr_accessor :argument_type, :return_type
+		
+		# @return [Hash] A type signature
+		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,7 @@
+module Rtype
+	VERSION = "0.6.8".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