literal 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0d4ade41b16e56d3e05c85771d12ffedffa1e5d0c33998890c1fdd0b8b8503bf
-  data.tar.gz: 7bb21c5e0ab2318825dd19efe878f38db2469f3a6f500615ebf2300723b7438f
+  metadata.gz: b459adebd387b12382d4e049a1f9211f6330bc6f77d66a8380bfbe758a4fb224
+  data.tar.gz: d771162ac9e9939e20b9478225baa23dc5d3b4d2fd0f0daa3c821277053ea88f
 SHA512:
-  metadata.gz: e56f4aaefec78d299254174dcf6a5aded7cb59970291ef55bdb3a88392c230d26efe07c8a18471c9484acd5e6f477f63b6639e7accf712ca7c9aad18720cd84f
-  data.tar.gz: a60595864a2f267ded92ca14603eb74b0b42deddfa2167fd582e5ebfaee83f0348569d498755e03e088a83ff647149c1159d8758fbb3c4a1c4ebada0d43a0571
+  metadata.gz: 68c949539f7002388ccff9c0547c48988a3ccb9ae2cb3262f8ab9119f0187f8ff775c46d3b2aa8abbcc1bbb68a767427c99b48af898744c58bfa004fec3dd491
+  data.tar.gz: 872aeda1f2efb4023e9c34c324e8fba149737d5744bc735e57b0ffdbb52be6001f39360fa86c5f981d70e70b5698394eef228eef9dde2d5ca387180414aac555

data/lib/literal/flags.rb

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+class Literal::Flags
+	include Enumerable
+
+	def initialize(value = 0, **new_flags)
+		if new_flags.length > 0
+			value = self.class.calculate_from_hash(new_flags)
+		end
+
+		@value = value
+
+		freeze
+	end
+
+	def __initialize_from_value__(value)
+		@value = value
+		freeze
+	end
+
+	attr_reader :value
+
+	def self.define(**flags)
+		raise ArgumentError if frozen?
+		unique_values = flags.values
+		unique_values.uniq!
+
+		if unique_values.length != flags.length
+			raise Literal::ArgumentError.new("Flags must be unique.")
+		end
+
+		const_set(:FLAGS, flags.dup.freeze)
+
+		flags.each do |name, bit|
+			class_eval <<~RUBY, __FILE__, __LINE__ + 1
+				# frozen_string_literal: true
+
+				def #{name}?
+					@value & (2 ** #{bit}) > 0
+				end
+			RUBY
+		end
+
+		freeze
+	end
+
+	# () -> (Integer) -> Literal::Flags
+	def self.to_proc
+		proc { |value| new(value) }
+	end
+
+	# (Integer) -> String
+	def self.calculate_bit_string(value)
+		value.to_s(2).rjust(self::BITS, "0")
+	end
+
+	# (Array(Boolean)) -> Integer
+	def self.calculate_from_array(array)
+		array.reverse_each.with_index.reduce(0) do |value, (bit, index)|
+			value | (bit ? 1 << index : 0)
+		end
+	end
+
+	# (Hash(Symbol, Boolean)) -> Integer
+	def self.calculate_from_hash(hash)
+		flags = self::FLAGS
+		hash.reduce(0) do |value, (key, bit)|
+			value | (bit ? 2 ** flags.fetch(key) : 0)
+		end
+	end
+
+	# (Integer) -> Array(Symbol)
+	def self.calculate_tokens(value)
+		flags = self::FLAGS
+		flags.keys.select { |t| value & (2 ** flags.fetch(t)) > 0 }
+	end
+
+	# (Integer) -> Array(Boolean)
+	def self.calculate_array(value)
+		bits = self::BITS
+		Array.new(bits) { |i| (value & (2 ** (bits - 1 - i)) > 0) }
+	end
+
+	# (Array(Symbol)) -> Integer
+	def self.calculate_from_tokens(tokens)
+		flags = self::FLAGS
+		tokens.reduce(0) { |f, t| f | (2 ** flags.fetch(t)) }
+	end
+
+	# (Integer) -> Hash(Symbol, Boolean)
+	def self.calculate_hash_from_value(value)
+		self::FLAGS.transform_values do |bit|
+			(value & (2 ** bit)) > 0
+		end
+	end
+
+	# () -> Array(Symbol)
+	def self.keys
+		@flags.keys
+	end
+
+	# (String) -> Literal::Flags
+	def self.from_bit_string(bit_string)
+		from_int(bit_string.to_i(2))
+	end
+
+	# (Array(Boolean)) -> Literal::Flags
+	def self.from_array(array)
+		if array.length != self::BITS
+			raise Literal::ArgumentError.new("The array must have #{self::BITS} items.")
+		end
+
+		from_int(calculate_from_array(array))
+	end
+
+	# (Array(Symbol)) -> Literal::Flags
+	def self.from_tokens(tokens)
+		from_int(calculate_from_tokens(tokens))
+	end
+
+	# (Integer) -> Literal::Flags
+	def self.from_int(value)
+		allocate.__initialize_from_value__(value)
+	end
+
+	# (String) -> Integer
+	def self.unpack_int(value)
+		value.unpack1(self::PACKER)
+	end
+
+	# (String) -> Literal::Flags
+	def self.unpack(value)
+		new(unpack_int(value))
+	end
+
+	# () -> String
+	def pack
+		[@value].pack(self.class::PACKER)
+	end
+
+	# () -> String
+	def inspect
+		to_h.inspect
+	end
+
+	# () -> Hash(Symbol, Boolean)
+	def to_h
+		self.class.calculate_hash_from_value(@value)
+	end
+
+	def each
+		self.class::FLAGS.each do |key, bit|
+			yield key, @value & (2 ** bit) > 0
+		end
+	end
+
+	# (Symbol) -> Boolean
+	def [](key)
+		@value & (2 ** self.class::FLAGS.fetch(key)) > 0
+	end
+
+	def |(other)
+		case other
+		when Literal::Flags
+			self.class.new(@value | other.value)
+		when Integer
+			self.class.new(@value | other)
+		end
+	end
+
+	def &(other)
+		case other
+		when Literal::Flags
+			self.class.new(@value & other.value)
+		when Integer
+			self.class.new(@value & other)
+		end
+	end
+
+	def to_i
+		@value
+	end
+
+	def to_bit_string
+		self.class.calculate_bit_string(@value)
+	end
+
+	def to_tokens
+		self.class.calculate_tokens(@value)
+	end
+
+	def to_a
+		self.class.calculate_array(@value)
+	end
+
+	alias_method :deconstruct, :to_a
+
+	def deconstruct_keys(keys = nil)
+		if keys
+			flags = self.class::FLAGS
+			keys.to_h do |key|
+				[key, @value & (2 ** flags.fetch(key)) > 0]
+			end
+		else
+			to_h
+		end
+	end
+end
+
+class Literal::Flags8 < Literal::Flags
+	BYTES = 1
+	BITS = BYTES * 8
+	PACKER = "C"
+end
+
+class Literal::Flags16 < Literal::Flags
+	BYTES = 2
+	BITS = BYTES * 8
+	PACKER = "S"
+end
+
+class Literal::Flags32 < Literal::Flags
+	BYTES = 4
+	BITS = BYTES * 8
+	PACKER = "L"
+end
+
+class Literal::Flags64 < Literal::Flags
+	BYTES = 8
+	BITS = BYTES * 8
+	PACKER = "Q"
+end

data/lib/literal/properties/schema.rb

@@ -47,8 +47,10 @@ class Literal::Properties::Schema
 	end
 
 	def generate_initializer(buffer = +"")
-		buffer << "alias initialize initialize\n"
-		buffer << "def initialize(#{generate_initializer_params})\n"
+		buffer << "alias initialize initialize\n" \
+			"def initialize("
+		generate_initializer_params(buffer)
+		buffer << ")\n"
 		generate_initializer_body(buffer)
 		buffer << "" \
 			"rescue Literal::TypeError => error\n" \
@@ -100,7 +102,7 @@ class Literal::Properties::Schema
 		i, n = 0, sorted_properties.size
 		while i < n
 			property = sorted_properties[i]
-			buffer << "  @" << property.name.name << " == other.#{property.escaped_name}"
+			buffer << "  @" << property.name.name << " == other." << property.escaped_name
 			buffer << " &&\n  " if i < n - 1
 			i += 1
 		end

data/lib/literal/types/constraint_type.rb

@@ -25,6 +25,21 @@ class Literal::Types::ConstraintType
 		true
 	end
 
+	def record_literal_type_errors(context)
+		@object_constraints.each do |constraint|
+			next if constraint === context.actual
+
+			context.add_child(label: inspect, expected: constraint, actual: context.actual)
+		end
+
+		@property_constraints.each do |property, constraint|
+			actual = context.actual.public_send(property)
+			next if constraint === actual
+
+			context.add_child(label: ".#{property}", expected: constraint, actual:)
+		end
+	end
+
 	private
 
 	def inspect_constraints

data/lib/literal/types/hash_type.rb

@@ -18,4 +18,21 @@ class Literal::Types::HashType
 
 		true
 	end
+
+	def record_literal_type_errors(context)
+		unless Hash === context.actual
+			return
+		end
+
+		context.actual.each do |key, item|
+			unless @key_type === key
+				context.add_child(label: "[]", expected: @key_type, actual: key)
+				next
+			end
+
+			unless @value_type === item
+				context.add_child(label: "[#{key.inspect}]", expected: @value_type, actual: item)
+			end
+		end
+	end
 end

data/lib/literal/types/intersection_type.rb

@@ -17,4 +17,12 @@ class Literal::Types::IntersectionType
 	def nil?
 		@types.all?(&:nil?)
 	end
+
+	def record_literal_type_errors(context)
+		@types.each do |type|
+			next if type === context.actual
+
+			context.add_child(label: inspect, expected: type, actual: context.actual)
+		end
+	end
 end

data/lib/literal/types/map_type.rb

@@ -22,8 +22,13 @@ class Literal::Types::MapType
 		end
 
 		context.actual.each do |key, item|
-			unless @shape[key] === item
-				context.add_child(label: "[#{key.inspect}]", expected: @shape[key], actual: item)
+			unless (expected = @shape[key])
+				context.add_child(label: "[]", expected: @shape.keys, actual: key)
+				next
+			end
+
+			unless expected === item
+				context.add_child(label: "[#{key.inspect}]", expected:, actual: item)
 			end
 		end
 	end

data/lib/literal/types/tuple_type.rb

@@ -23,4 +23,20 @@ class Literal::Types::TupleType
 
 		true
 	end
+
+	def record_literal_type_errors(context)
+		return unless Array === context.actual
+
+		len = [@types.size, context.actual.size].max
+		i = 0
+		while i < len
+			actual = context.actual[i]
+			if !(expected = @types[i])
+				context.add_child(label: "[#{i}]", expected: Literal::Types::NeverType, actual:)
+			elsif !(expected === actual)
+				context.add_child(label: "[#{i}]", expected:, actual:)
+			end
+			i += 1
+		end
+	end
 end

data/lib/literal/types.rb

@@ -38,7 +38,7 @@ module Literal::Types
 	NilableLambdaType = NilableType.new(LambdaType)
 	NilableProcableType = NilableType.new(ProcableType)
 
-	# Matches any value except `nil`. Use `_Any?` or `_Unit` to match any value including `nil`.
+	# Matches any value except `nil`. Use `_Any?` or `_Void` to match any value including `nil`.
 	def _Any
 		AnyType
 	end

data/lib/literal/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Literal
-	VERSION = "1.0.0"
+	VERSION = "1.1.0"
 end

data/lib/literal.rb

@@ -13,6 +13,11 @@ module Literal
 	autoload :Property, "literal/property"
 	autoload :Struct, "literal/struct"
 	autoload :Types, "literal/types"
+	autoload :Flags, "literal/flags"
+	autoload :Flags8, "literal/flags"
+	autoload :Flags16, "literal/flags"
+	autoload :Flags32, "literal/flags"
+	autoload :Flags64, "literal/flags"
 
 	# Errors
 	autoload :Error, "literal/errors/error"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: literal
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Joel Drapper
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-01 00:00:00.000000000 Z
+date: 2024-11-07 00:00:00.000000000 Z
 dependencies: []
 description: A literal Ruby gem.
 email:
@@ -27,6 +27,7 @@ files:
 - lib/literal/errors/argument_error.rb
 - lib/literal/errors/error.rb
 - lib/literal/errors/type_error.rb
+- lib/literal/flags.rb
 - lib/literal/null.rb
 - lib/literal/object.rb
 - lib/literal/properties.rb