types 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9009b2973c8d9b30fbc68da3eb4088ef28672339e593e63ed92f7f1685daf35
-  data.tar.gz: 45cbaae7e30b4603f59e7b95e8d85768edd8c8ded3df216c2c7087fdae839216
+  metadata.gz: 21a7be2b61d63c443516b9dcd51088fd9febe5b4a75361d99ccf0c3348e15261
+  data.tar.gz: 76ad7f162e268407e20a17cb2cf89701675a9672ed352ba27c4746d9bdabd3a2
 SHA512:
-  metadata.gz: 1cbda8d764a40a9adb42358620e21a5091dd98dee66904d14e170a96f58fdfc744ad4c613beccb5ec0f52ec17ca2b61261f4a58c664e7eb5bbe41b7788f95f88
-  data.tar.gz: 34341cc300faea4cfb3053388d928d84b32432e128c17ba3c7641ea757d65fbaab706683352731e6b13c67620e0e7f9d32bc84a9957f390346e69b70fc9defc9
+  metadata.gz: 5172ce882b220e0555aea69d66568b53968a3f07139596a00864c72cadfc9a729ccabb4fa34bad26ff8b356e4b2eb52e2596540777fd80d2b9c3fcc4a49b297f
+  data.tar.gz: dad9326a9a932c28d413dfe30c6b19451d2f6c5e8e2f302ec8b4d4b2a469a9b9e7a52bad8571bb809e8d0e39f934f97e0635aae7c09b6e845020b2d7a47a570b

data/lib/types/any.rb

@@ -4,7 +4,7 @@
 # Copyright, 2022-2025, by Samuel Williams.
 
 module Types
-	# Represents a union of multiple types. The first type to match the input is used.
+	# Represents a union of multiple types. The first type to match the input is used. If no types are specified, this matches any type or value.
 	#
 	# ```ruby
 	# type = Types::Any(Types::String, Types::Integer)
@@ -15,23 +15,29 @@ module Types
 		def initialize(types)
 			@types = types
 		end
-
+		
 		# @returns [Any] a new {Any} with the other type appended.
 		# @parameter other [Type] The type instance to append.
 		def | other
 			self.class.new([*@types, other])
 		end
-
+		
 		# @returns [Boolean] true if any of the listed types is composite.
 		def composite?
-			@types.any? {|type| type.composite?}
+			@types.any?(&:composite?)
 		end
-
+		
 		# Parses the input using the listed types in order, returning the first one that succeeds.
 		# @parameter input [String] the input to parse.
 		# @returns [Object] the parsed value.
 		# @raises [ArgumentError] if no type can parse the input.
 		def parse(input)
+			# If there are no types, we can just return the input.
+			return input if @types.empty?
+			
+			# We need to track the last error, because we want to raise the last error that occurred, if any:
+			last_error = nil
+			
 			@types.each do |type|
 				return type.parse(input)
 			rescue => error
@@ -59,9 +65,14 @@ module Types
 			end
 		end
 		
+		# Returns the RBS type string for the union of the listed types. If there are no types, it returns `untyped`.
 		# @returns [String] the RBS type string, e.g. `String | Integer`.
 		def to_rbs
-			@types.map(&:to_rbs).join(" | ")
+			if @types.empty?
+				"untyped"
+			else
+				@types.map(&:to_rbs).join(" | ")
+			end
 		end
 	end
 	

data/lib/types/array.rb

@@ -57,6 +57,12 @@ module Types
 			"Array[#{@item_type.to_rbs}]"
 		end
 		
+		# Resolves to the actual Ruby Array class.
+		# @returns [Class] The Array class.
+		def resolve
+			::Array
+		end
+		
 		private
 		
 		def parse_string(input)

data/lib/types/boolean.rb

@@ -29,10 +29,16 @@ module Types
 				raise ArgumentError, "Cannot coerce #{input.inspect} into Boolean!"
 			end
 		end
-
+		
 		# @returns [String] the RBS type string, e.g. `bool`.
 		def self.to_rbs
 			"bool"
 		end
+		
+		# Resolves to nil since Ruby doesn't have a single Boolean class.
+		# @returns [nil] Returns nil as there's no single Ruby Boolean class.
+		def self.resolve
+			nil
+		end
 	end
 end

data/lib/types/class.rb

@@ -29,15 +29,24 @@ module Types
 			true
 		end
 		
+		# Resolve the base class if possible.
+		# @returns [Class] the resolved base class.
+		def resolve
+			Object.const_get(@base.to_s)
+		rescue NameError
+			nil
+		end
+		
 		# Parses the input as a class, optionally checking the base class constraint.
 		# @parameter input [String] The class name to parse.
 		# @returns [Class] the parsed class.
 		# @raises [ArgumentError] if the class is not a subclass of the base.
 		def parse(input)
 			klass = Object.const_get(input)
+			base = self.resolve
 			
-			if @base and !klass.ancestors.include?(@base)
-				raise ArgumentError, "Class #{klass} is not a subclass of #{@base}!"
+			if base and !klass.ancestors.include?(base)
+				raise ArgumentError, "Class #{klass} is not a subclass of #{base}!"
 			end
 			
 			return klass
@@ -66,6 +75,12 @@ module Types
 			
 			return klass
 		end
+		
+		# Resolves to the actual Ruby Class class.
+		# @returns [Class] The Class class.
+		def self.resolve
+			::Class
+		end
 	end
 	
 	# Constructs a {Class} type with an optional base class constraint.

data/lib/types/decimal.rb

@@ -23,10 +23,19 @@ module Types
 		def self.parse(input)
 			case input
 			when ::Float
-				BigDecimal(input, ::Float::DIG+1)
+				Kernel.BigDecimal(input, ::Float::DIG+1)
 			else
-				BigDecimal(input)
+				Kernel.BigDecimal(input)
 			end
 		end
+		
+		# Resolves to the actual Ruby BigDecimal class.
+		# @returns [Class] The BigDecimal class.
+		def self.resolve
+			::BigDecimal
+		end
 	end
+	
+	# Alias for the Decimal type.
+	BigDecimal = Decimal
 end

data/lib/types/float.rb

@@ -27,5 +27,11 @@ module Types
 		def self.to_rbs
 			"Float"
 		end
+		
+		# Resolves to the actual Ruby Float class.
+		# @returns [Class] The Float class.
+		def self.resolve
+			::Float
+		end
 	end
 end

data/lib/types/hash.rb

@@ -52,6 +52,12 @@ module Types
 			"{ #{@key_type.to_rbs} => #{@value_type.to_rbs} }"
 		end
 		
+		# Resolves to the actual Ruby Hash class.
+		# @returns [Class] The Hash class.
+		def resolve
+			::Hash
+		end
+		
 		private
 		
 		def parse_string(input)

data/lib/types/integer.rb

@@ -27,5 +27,11 @@ module Types
 		def self.to_rbs
 			"Integer"
 		end
+		
+		# Resolves to the actual Ruby Integer class.
+		# @returns [Class] The Integer class.
+		def self.resolve
+			::Integer
+		end
 	end
 end

data/lib/types/method.rb

@@ -57,7 +57,7 @@ module Types
 		
 		# @returns [String] the RBS type string, e.g. `Method[Receiver, (Args) -> Return]`.
 		def to_rbs
-			argument_types = @argument_types.map {|t| t.to_rbs}.join(", ")
+			argument_types = @argument_types.map(&:to_rbs).join(", ")
 			return_type = @return_type ? @return_type.to_rbs : "void"
 			
 			return "Method[#{@receiver_type}, (#{argument_types}) -> #{return_type}]"

data/lib/types/named.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require_relative "generic"
+
+module Types
+	# Represents a named type that may not be defined yet.
+	#
+	# ```ruby
+	# type = Types::Named("CustomType")
+	# type.parse(value) # => value (pass-through)
+	# ```
+	class Named < Module
+		include Generic
+		
+		# Initialize with a type name.
+		# @parameter name [String] The name of the type.
+		def initialize(name)
+			@name = name
+		end
+		
+		# @returns [String] The name of the type.
+		attr :name
+		
+		# @returns [Boolean] whether the type is absolute.
+		def absolute?
+			@name.start_with?("::")
+		end
+		
+		# @returns [Boolean] whether the type is relative.
+		def relative?
+			!absolute?
+		end
+		
+		# Parses the input by passing it through unchanged.
+		# @parameter input [Object] The value to parse.
+		# @returns [Object] The input value unchanged.
+		def parse(input)
+			if resolved = self.resolve
+				if resolved.respond_to?(:load)
+					return resolved.load(input)
+				elsif resolved.respond_to?(:parse)
+					return resolved.parse(input)
+				else
+					raise ArgumentError, "Type #{@name} does not implement .load or .parse!"
+				end
+			else
+				raise ArgumentError, "Unknown type: #{@name}"
+			end
+		end
+		
+		# Resolves the named type to the actual Ruby type if it exists.
+		# @returns [Class | Module | Nil] The resolved Ruby type or nil if not found.
+		def resolve
+			Object.const_get(@name)
+		rescue NameError
+			nil
+		end
+		
+		# @returns [String] the RBS type string using the name.
+		def to_rbs
+			@name
+		end
+		
+		# @returns [String] the string representation of the named type.
+		def to_s
+			@name
+		end
+		
+		def inspect
+			"<#{self.class} #{@name}>"
+		end
+		
+		# @returns [Boolean] true if other is a Named type with the same name.
+		def == other
+			other.is_a?(Named) && @name == other.name
+		end
+		
+		# @returns [Integer] hash code based on the name.
+		def hash
+			@name.hash
+		end
+		
+		# @returns [Boolean] whether this type is composite.
+		def composite?
+			false
+		end
+		
+		# Handles missing constants by creating nested Named types.
+		# This allows parsing of nested type signatures like Foo::Bar.
+		# @parameter name [Symbol] The name of the missing constant.
+		# @returns [Named] A Named type representing the nested unknown type.
+		def const_missing(name)
+			Named.new("#{@name}::#{name}")
+		end
+	end
+	
+	# Constructs a {Named} type with the given name.
+	# @parameter name [String] The name of the type.
+	# @returns [Named] a new {Named} type.
+	def self.Named(name)
+		Named.new(name)
+	end
+end

data/lib/types/nil.rb

@@ -31,5 +31,11 @@ module Types
 		def self.to_rbs
 			"nil"
 		end
+		
+		# Resolves to the actual Ruby NilClass.
+		# @returns [Class] The NilClass.
+		def self.resolve
+			::NilClass
+		end
 	end
 end

data/lib/types/string.rb

@@ -26,5 +26,11 @@ module Types
 		def self.to_rbs
 			"String"
 		end
+		
+		# Resolves to the actual Ruby String class.
+		# @returns [Class] The String class.
+		def self.resolve
+			::String
+		end
 	end
 end

data/lib/types/symbol.rb

@@ -26,5 +26,11 @@ module Types
 		def self.to_rbs
 			"Symbol"
 		end
+		
+		# Resolves to the actual Ruby Symbol class.
+		# @returns [Class] The Symbol class.
+		def self.resolve
+			::Symbol
+		end
 	end
 end

data/lib/types/tuple.rb

@@ -44,6 +44,12 @@ module Types
 			end
 		end
 		
+		# Resolves to the actual Ruby Array class, since there is no direct support for tuples in Ruby.
+		# @returns [Class] The Array class.
+		def resolve
+			::Array
+		end
+		
 		# @returns [String] the string representation of the tuple type.
 		def to_s
 			"Tuple(#{@item_types.join(', ')})"
@@ -51,7 +57,7 @@ module Types
 		
 		# @returns [String] the RBS type string, e.g. `[String, Integer]`.
 		def to_rbs
-			"[#{@item_types.map {|t| t.to_rbs}.join(', ')}]"
+			"[#{@item_types.map(&:to_rbs).join(', ')}]"
 		end
 		
 		private

data/lib/types/version.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2022-2024, by Samuel Williams.
+# Copyright, 2022-2025, by Samuel Williams.
 
 module Types
-	VERSION = "0.3.0"
+	VERSION = "0.4.0"
 end

data/lib/types.rb

@@ -17,6 +17,7 @@ require_relative "types/integer"
 require_relative "types/interface"
 require_relative "types/lambda"
 require_relative "types/method"
+require_relative "types/named"
 require_relative "types/nil"
 require_relative "types/numeric"
 require_relative "types/string"
@@ -32,17 +33,34 @@ module Types
 	# ```ruby
 	# Types.parse("Array(String)") # => Types::Array(Types::String)
 	# ```
-	VALID_SIGNATURE = /\A[a-zA-Z\(\):,_|\s]+\z/
-
+	VALID_SIGNATURE = /\A[a-zA-Z0-9\(\):,_|\s]+\z/
+	
 	# Parses a type signature string and returns the corresponding type instance.
 	# @parameter signature [String] The type signature to parse.
 	# @returns [Object] The type instance.
 	# @raises [ArgumentError] if the signature is invalid.
 	def self.parse(signature)
 		if signature =~ VALID_SIGNATURE
-			eval(signature, binding)
+			# Replace leading :: with Top:: to handle absolute type paths
+			normalized_signature = signature.gsub(/(?<=\A|\W)::/, "TOP::")
+			eval(normalized_signature, binding)
 		else
 			raise ArgumentError, "Invalid type signature: #{signature.inspect}!"
 		end
 	end
+	
+	# Handles absolute type paths by creating absolute Named types for unknown types.
+	module TOP
+		def self.const_missing(name)
+			Named.new("::#{name}")
+		end
+	end
+	
+	# Handles missing constants by creating Named types for unknown types.
+	# This allows parsing of type signatures with unknown types.
+	# @parameter name [Symbol] The name of the missing constant.
+	# @returns [Named] A Named type representing the unknown type.
+	def self.const_missing(name)
+		Named(name.to_s)
+	end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: types
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Samuel Williams
@@ -58,6 +58,7 @@ files:
 - lib/types/interface.rb
 - lib/types/lambda.rb
 - lib/types/method.rb
+- lib/types/named.rb
 - lib/types/nil.rb
 - lib/types/numeric.rb
 - lib/types/string.rb