literal 1.0.0.rc1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 75c7cc8853143bd8f4ac74b7fc4a5b5d2812bd39c0b4f696a87c2ffc0fb31046
-  data.tar.gz: 7781d6362e9ae8f75d0156809f95b0c1f8a37df855356173c9b6f09428419bc0
+  metadata.gz: b459adebd387b12382d4e049a1f9211f6330bc6f77d66a8380bfbe758a4fb224
+  data.tar.gz: d771162ac9e9939e20b9478225baa23dc5d3b4d2fd0f0daa3c821277053ea88f
 SHA512:
-  metadata.gz: 6acc2552c11ff3c5f12877b5597f9a6a138bf4901f5fce3801004e286b522c6263fa2454621ac4f5511f553af073d5113d96cd1af1045bc9e44c014c15ab7420
-  data.tar.gz: 6f9b205b3343426385185ebd0ea0e04164f6a06f9d42d6cb34c542c8d12a98ab327e274b336fb13d389e7380f5bd79831eb2b508f2d019cd6143658db40f3195
+  metadata.gz: 68c949539f7002388ccff9c0547c48988a3ccb9ae2cb3262f8ab9119f0187f8ff775c46d3b2aa8abbcc1bbb68a767427c99b48af898744c58bfa004fec3dd491
+  data.tar.gz: 872aeda1f2efb4023e9c34c324e8fba149737d5744bc735e57b0ffdbb52be6001f39360fa86c5f981d70e70b5698394eef228eef9dde2d5ca387180414aac555

data/README.md

@@ -1,3 +1,3 @@
-# A Literal Ruby Gem [WIP]
+# A Literal Ruby Gem
 
 See the website for [documentation](https://literal.fun/docs).

data/lib/literal/enum.rb

@@ -142,8 +142,17 @@ class Literal::Enum
 			@values.fetch(...)
 		end
 
+		def coerce(value)
+			case value
+			when self
+				value
+			else
+				self[value]
+			end
+		end
+
 		def to_proc
-			method(:cast).to_proc
+			method(:coerce).to_proc
 		end
 
 		def to_h(*args)

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

@@ -25,7 +25,6 @@ module Literal::Types
 	autoload :ProcableType, "literal/types/procable_type"
 	autoload :RangeType, "literal/types/range_type"
 	autoload :SetType, "literal/types/set_type"
-	autoload :ShapeType, "literal/types/shape_type"
 	autoload :StringType, "literal/types/string_type"
 	autoload :SymbolType, "literal/types/symbol_type"
 	autoload :TruthyType, "literal/types/truthy_type"
@@ -39,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
@@ -293,20 +292,6 @@ module Literal::Types
 		)
 	end
 
-	# Ensures a value matches the given shape of a Hash
-	def _Shape(...)
-		ShapeType.new(...)
-	end
-
-	# Nilable version of `_Shape`
-	def _Shape?(...)
-		NilableType.new(
-			ShapeType.new(...),
-		)
-	end
-
-	# Nilable version of `_Shape`
-
 	# Matches if the value is a `String` and matches the given constraints.
 	# If you don't need any constraints, use `String` instead of `_String`.
 	def _String(...)

data/lib/literal/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Literal
-	VERSION = "1.0.0.rc1"
+	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,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: literal
 version: !ruby/object:Gem::Version
-  version: 1.0.0.rc1
+  version: 1.1.0
 platform: ruby
 authors:
 - Joel Drapper
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-26 00:00:00.000000000 Z
+date: 2024-11-07 00:00:00.000000000 Z
 dependencies: []
-description: Enums, properties, generics, structured objects.
+description: A literal Ruby gem.
 email:
 - joel@drapper.me
 executables: []
@@ -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
@@ -71,11 +72,11 @@ files:
 - lib/literal/types/union_type.rb
 - lib/literal/types/void_type.rb
 - lib/literal/version.rb
-homepage: https://github.com/joeldrapper/literal
+homepage: https://literal.fun
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/joeldrapper/literal
+  homepage_uri: https://literal.fun
   source_code_uri: https://github.com/joeldrapper/literal
   changelog_uri: https://github.com/joeldrapper/literal/blob/main/CHANGELOG.md
   funding_uri: https://github.com/sponsors/joeldrapper
@@ -98,5 +99,5 @@ requirements: []
 rubygems_version: 3.5.18
 signing_key:
 specification_version: 4
-summary: A literal Ruby gem.
+summary: Enums, properties, generics, structured objects and runtime type checking.
 test_files: []