literal 1.0.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0d4ade41b16e56d3e05c85771d12ffedffa1e5d0c33998890c1fdd0b8b8503bf
-  data.tar.gz: 7bb21c5e0ab2318825dd19efe878f38db2469f3a6f500615ebf2300723b7438f
+  metadata.gz: d40ba211b6f7b2ad3dad97feb118d3742b43dbd2f1773daa8d6979f597cbf428
+  data.tar.gz: 1fb316fac766b9b25041c2bc201c8ddaed8d3e59ed5f5aec9c7f93f0306df921
 SHA512:
-  metadata.gz: e56f4aaefec78d299254174dcf6a5aded7cb59970291ef55bdb3a88392c230d26efe07c8a18471c9484acd5e6f477f63b6639e7accf712ca7c9aad18720cd84f
-  data.tar.gz: a60595864a2f267ded92ca14603eb74b0b42deddfa2167fd582e5ebfaee83f0348569d498755e03e088a83ff647149c1159d8758fbb3c4a1c4ebada0d43a0571
+  metadata.gz: 37fee8ee4d14f41573f5a4ce2d27d3d98bc1b78a54a35d850a41fbeedfc7e1b1f6f8a3533cbb82c35b81212079d4f495ad17cde8651a7b56fff3e6ecb99b5078
+  data.tar.gz: ca6fa6e45d9a344880ebbbfba69c82f9444809ad4b6645e89c4cc0c89c58e78ac66d2edf80612cb2084bac0b46b9c0a686458983f47ff5716f4016b9545f723c

data/lib/literal/array.rb

@@ -0,0 +1,428 @@
+# frozen_string_literal: true
+
+class Literal::Array
+	class Generic
+		include Literal::Type
+
+		def initialize(type)
+			@type = type
+		end
+
+		attr_reader :type
+
+		def new(*value)
+			Literal::Array.new(value, type: @type)
+		end
+
+		alias_method :[], :new
+
+		def ===(value)
+			Literal::Array === value && Literal.subtype?(value.__type__, of: @type)
+		end
+
+		def >=(other)
+			case other
+			when Literal::Array::Generic
+				@type >= other.type
+			else
+				false
+			end
+		end
+
+		def inspect
+			"Literal::Array(#{@type.inspect})"
+		end
+	end
+
+	include Enumerable
+	include Literal::Types
+
+	def initialize(value, type:)
+		Literal.check(actual: value, expected: _Array(type)) do |c|
+			c.fill_receiver(receiver: self, method: "#initialize")
+		end
+
+		@__type__ = type
+		@__value__ = value
+	end
+
+	def __initialize_without_check__(value, type:)
+		@__type__ = type
+		@__value__ = value
+		self
+	end
+
+	# Used to create a new Literal::Array with the same type and collection type but a new value. The value is not checked.
+	def __with__(value)
+		Literal::Array.allocate.__initialize_without_check__(
+			value,
+			type: @__type__,
+		)
+	end
+
+	attr_reader :__type__, :__value__
+
+	def &(other)
+		case other
+		when ::Array
+			__with__(@__value__ & other)
+		when Literal::Array
+			__with__(@__value__ & other.__value__)
+		else
+			raise ArgumentError.new("Cannot perform bitwise AND with #{other.class.name}.")
+		end
+	end
+
+	def *(times)
+		case times
+		when String
+			@__value__ * times
+		else
+			__with__(@__value__ * times)
+		end
+	end
+
+	def +(other)
+		case other
+		when ::Array
+			Literal.check(actual: other, expected: _Array(@__type__)) do |c|
+				c.fill_receiver(receiver: self, method: "#+")
+			end
+
+			__with__(@__value__ + other)
+		when Literal::Array(@__type__)
+			__with__(@__value__ + other.__value__)
+		when Literal::Array
+			raise Literal::TypeError.new(
+				context: Literal::TypeError::Context.new(
+					expected: Literal::Array(@__type__),
+					actual: other
+				)
+			)
+		else
+			raise ArgumentError.new("Cannot perform `+` with #{other.class.name}.")
+		end
+	end
+
+	def -(other)
+		case other
+		when ::Array
+			__with__(@__value__ - other)
+		when Literal::Array
+			__with__(@__value__ - other.__value__)
+		else
+			raise ArgumentError.new("Cannot perform `-` with #{other.class.name}.")
+		end
+	end
+
+	def <<(value)
+		Literal.check(actual: value, expected: @__type__) do |c|
+			c.fill_receiver(receiver: self, method: "#<<")
+		end
+
+		@__value__ << value
+		self
+	end
+
+	def <=>(other)
+		case other
+		when ::Array
+			@__value__ <=> other
+		when Literal::Array
+			@__value__ <=> other.__value__
+		else
+			raise ArgumentError.new("Cannot perform `<=>` with #{other.class.name}.")
+		end
+	end
+
+	def ==(other)
+		Literal::Array === other && @__value__ == other.__value__
+	end
+
+	def [](index)
+		@__value__[index]
+	end
+
+	def []=(index, value)
+		Literal.check(actual: value, expected: @__type__) do |c|
+			c.fill_receiver(receiver: self, method: "#[]=")
+		end
+
+		@__value__[index] = value
+	end
+
+	def all?(...)
+		@__value__.all?(...)
+	end
+
+	def any?(...)
+		@__value__.any?(...)
+	end
+
+	def assoc(...)
+		@__value__.assoc(...)
+	end
+
+	def at(...)
+		@__value__.at(...)
+	end
+
+	def bsearch(...)
+		@__value__.bsearch(...)
+	end
+
+	def clear(...)
+		@__value__.clear(...)
+		self
+	end
+
+	def compact
+		# @TODO if this is an array of nils, we should return an emtpy array
+		__with__(@__value__)
+	end
+
+	def compact!
+		# @TODO if this is an array of nils, we should set @__value__ = [] and return self
+		nil
+	end
+
+	def count(...)
+		@__value__.count(...)
+	end
+
+	def dig(...)
+		@__value__.dig(...)
+	end
+
+	def drop(...)
+		__with__(@__value__.drop(...))
+	end
+
+	def drop_while(...)
+		__with__(@__value__.drop_while(...))
+	end
+
+	def each(...)
+		@__value__.each(...)
+	end
+
+	def empty?
+		@__value__.empty?
+	end
+
+	alias_method :eql?, :==
+
+	def filter(...)
+		__with__(@__value__.filter(...))
+	end
+
+	def filter!(...)
+		@__value__.filter!(...)
+		self
+	end
+
+	def first(...)
+		@__value__.first(...)
+	end
+
+	def freeze
+		@__value__.freeze
+		super
+	end
+
+	def insert(index, *value)
+		Literal.check(actual: value, expected: _Array(@__type__)) do |c|
+			c.fill_receiver(receiver: self, method: "#insert")
+		end
+
+		@__value__.insert(index, *value)
+		self
+	end
+
+	def intersection(*values)
+		values.map! do |value|
+			case value
+			when Literal::Array
+				value.__value__
+			else
+				value
+			end
+		end
+
+		__with__(@__value__.intersection(*values))
+	end
+
+	def last(...)
+		@__value__.last(...)
+	end
+
+	def length(...)
+		@__value__.length(...)
+	end
+
+	def map(type, &block)
+		my_type = @__type__
+		transform_type = Literal::TRANSFORMS.dig(my_type, block)
+
+		if transform_type && Literal.subtype?(transform_type, of: my_type)
+			Literal::Array.allocate.__initialize_without_check__(
+				@__value__.map(&block),
+				type:,
+			)
+		else
+			Literal::Array.new(@__value__.map(&block), type:)
+		end
+	end
+
+	alias_method :collect, :map
+
+	# TODO: we can make this faster
+	def map!(&)
+		new_array = map(@__type__, &)
+		@__value__ = new_array.__value__
+		self
+	end
+
+	alias_method :collect!, :map!
+
+	def max(n = nil, &)
+		if n
+			__with__(@__value__.max(n, &))
+		else
+			@__value__.max(&)
+		end
+	end
+
+	def min(n = nil, &)
+		if n
+			__with__(@__value__.min(n, &))
+		else
+			@__value__.min(&)
+		end
+	end
+
+	def minmax(...)
+		__with__(@__value__.minmax(...))
+	end
+
+	def one?(...)
+		@__value__.one?(...)
+	end
+
+	def pop(...)
+		@__value__.pop(...)
+	end
+
+	def push(*value)
+		Literal.check(actual: value, expected: _Array(@__type__)) do |c|
+			c.fill_receiver(receiver: self, method: "#push")
+		end
+
+		@__value__.push(*value)
+		self
+	end
+
+	alias_method :append, :push
+
+	def reject(...)
+		__with__(@__value__.reject(...))
+	end
+
+	def reject!(...)
+		@__value__.reject!(...)
+		self
+	end
+
+	def replace(value)
+		case value
+		when Array
+			Literal.check(actual: value, expected: _Array(@__type__)) do |c|
+				c.fill_receiver(receiver: self, method: "#replace")
+			end
+
+			@__value__.replace(value)
+		when Literal::Array(@__type__)
+			@__value__.replace(value.__value__)
+		when Literal::Array
+			raise Literal::TypeError.new(
+				context: Literal::TypeError::Context.new(expected: @__type__, actual: value.__type__)
+			)
+		else
+			raise ArgumentError.new("#replace expects Array argument")
+		end
+
+		self
+	end
+
+	def sample(...)
+		@__value__.sample(...)
+	end
+
+	def shift(...)
+		@__value__.shift(...)
+	end
+
+	def size(...)
+		@__value__.size(...)
+	end
+
+	def sort(...)
+		__with__(@__value__.sort(...))
+	end
+
+	def sort!(...)
+		@__value__.sort!(...)
+		self
+	end
+
+	def to_a
+		@__value__.dup
+	end
+
+	alias_method :to_ary, :to_a
+
+	def uniq
+		__with__(@__value__.uniq)
+	end
+
+	def uniq!(...)
+		@__value__.uniq!(...) ? self : nil
+	end
+
+	def unshift(value)
+		Literal.check(actual: value, expected: @__type__) do |c|
+			c.fill_receiver(receiver: self, method: "#unshift")
+		end
+
+		@__value__.unshift(value)
+		self
+	end
+
+	alias_method :prepend, :unshift
+
+	def values_at(*indexes)
+		unless @__type__ === nil
+			max_value = length - 1
+			min_value = -length
+
+			indexes.each do |index|
+				case index
+				when Integer
+					if index < min_value || index > max_value
+						raise IndexError.new("index #{index} out of range")
+					end
+				when Range
+					if index.begin < min_value || index.end > max_value
+						raise IndexError.new("index #{index} out of range")
+					end
+				else
+					raise ArgumentError.new("Invalid index: #{index.inspect}")
+				end
+			end
+		end
+
+		__with__(
+			@__value__.values_at(*indexes)
+		)
+	end
+end

data/lib/literal/data_structure.rb

@@ -10,16 +10,6 @@ class Literal::DataStructure
 		object
 	end
 
-	def [](key)
-		instance_variable_get(:"@#{key}")
-	end
-
-	def []=(key, value)
-		# TODO: Sync error array w/ generated setter
-		@literal_properties[key].check(value) { |c| raise NotImplementedError }
-		instance_variable_set(:"@#{key}", value)
-	end
-
 	def to_h
 		{}
 	end

data/lib/literal/flags.rb

@@ -0,0 +1,245 @@
+# 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
+
+	def with(**attributes)
+		new_val = attributes.reduce(value) do |value, (k, v)|
+			v ? value |= bitmap(k) : value &= ~(bitmap(k))
+			value
+		end
+
+		self.class.allocate.__initialize_from_value__(new_val)
+	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 & (bitmap(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
+			keys.to_h do |key|
+				[key, @value & (bitmap(key)) > 0]
+			end
+		else
+			to_h
+		end
+	end
+
+	private
+
+	def bitmap(key)
+		2 ** self.class::FLAGS.fetch(key)
+	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