literal 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b459adebd387b12382d4e049a1f9211f6330bc6f77d66a8380bfbe758a4fb224
-  data.tar.gz: d771162ac9e9939e20b9478225baa23dc5d3b4d2fd0f0daa3c821277053ea88f
+  metadata.gz: d40ba211b6f7b2ad3dad97feb118d3742b43dbd2f1773daa8d6979f597cbf428
+  data.tar.gz: 1fb316fac766b9b25041c2bc201c8ddaed8d3e59ed5f5aec9c7f93f0306df921
 SHA512:
-  metadata.gz: 68c949539f7002388ccff9c0547c48988a3ccb9ae2cb3262f8ab9119f0187f8ff775c46d3b2aa8abbcc1bbb68a767427c99b48af898744c58bfa004fec3dd491
-  data.tar.gz: 872aeda1f2efb4023e9c34c324e8fba149737d5744bc735e57b0ffdbb52be6001f39360fa86c5f981d70e70b5698394eef228eef9dde2d5ca387180414aac555
+  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

@@ -9,7 +9,6 @@ class Literal::Flags
 		end
 
 		@value = value
-
 		freeze
 	end
 
@@ -138,6 +137,15 @@ class Literal::Flags
 		[@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
@@ -156,7 +164,7 @@ class Literal::Flags
 
 	# (Symbol) -> Boolean
 	def [](key)
-		@value & (2 ** self.class::FLAGS.fetch(key)) > 0
+		@value & (bitmap(key)) > 0
 	end
 
 	def |(other)
@@ -197,14 +205,19 @@ class Literal::Flags
 
 	def deconstruct_keys(keys = nil)
 		if keys
-			flags = self.class::FLAGS
 			keys.to_h do |key|
-				[key, @value & (2 ** flags.fetch(key)) > 0]
+				[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

data/lib/literal/hash.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+class Literal::Hash
+	class Generic
+		def initialize(key_type, value_type)
+			@key_type = key_type
+			@value_type = value_type
+		end
+
+		def new(**value)
+			Literal::Hash.new(value, key_type: @key_type, value_type: @value_type)
+		end
+
+		def ===(value)
+			Literal::Hash === value && @type == value.__type__
+		end
+
+		def inspect
+			"Literal::Hash(#{@type.inspect})"
+		end
+	end
+
+	include Enumerable
+
+	def initialize(value, key_type:, value_type:)
+		collection_type = Literal::Types::HashType.new(key_type, value_type)
+
+		Literal.check(actual: value, expected: collection_type) do |c|
+			c.fill_receiver(receiver: self, method: "#initialize")
+		end
+
+		@__key_type__ = key_type
+		@__value_type__ = value_type
+		@__value__ = value
+		@__collection_type__ = collection_type
+	end
+
+	attr_reader :__key_type__, :__value_type__, :__value__
+
+	def freeze
+		@__value__.freeze
+		super
+	end
+
+	def each(...)
+		@__value__.each(...)
+	end
+end

data/lib/literal/properties/schema.rb

@@ -102,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.name.name
 			buffer << " &&\n  " if i < n - 1
 			i += 1
 		end

data/lib/literal/properties.rb

@@ -6,8 +6,13 @@ module Literal::Properties
 
 	include Literal::Types
 
+	module DocString
+		# @!method initialize(...)
+	end
+
 	def self.extended(base)
 		super
+		base.include(DocString)
 		base.include(base.__send__(:__literal_extension__))
 	end
 

data/lib/literal/rails/flags_type.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+class Literal::Rails::FlagsType < ActiveModel::Type::Value
+	def initialize(flags_class)
+		@flags_class = flags_class
+		super()
+	end
+
+	def cast(value)
+		case value
+		when @flags_class
+			value
+		else
+			deserialize(value)
+		end
+	end
+
+	def serialize(value)
+		case value
+		when nil
+			nil
+		when @flags_class
+			value.to_bit_string
+		else
+			raise Literal::ArgumentError.new(
+				"Invalid value: #{value.inspect}. Expected an #{@flags_class.inspect}.",
+			)
+		end
+	end
+
+	def deserialize(value)
+		case value
+		when nil
+			nil
+		else
+			@flags_class.from_bit_string(value) || raise(
+				ArgumentError.new("Invalid value: #{value.inspect} for #{@flags_class}"),
+			)
+		end
+	end
+end

data/lib/literal/rails.rb

@@ -5,5 +5,6 @@ require_relative "rails/patches/active_record"
 
 module Literal::Rails
 	autoload :EnumType, "literal/rails/enum_type"
+	autoload :FlagsType, "literal/rails/flags_type"
 	autoload :EnumSerializer, "literal/rails/enum_serializer"
 end

data/lib/literal/railtie.rb

@@ -6,8 +6,16 @@ class Literal::Railtie < Rails::Railtie
 			Literal::Rails::EnumType.new(type)
 		end
 
+		ActiveRecord::Type.register(:literal_flags) do |name, type:|
+			Literal::Rails::FlagsType.new(type)
+		end
+
 		ActiveModel::Type.register(:literal_enum) do |name, type:|
 			Literal::Rails::EnumType.new(type)
 		end
+
+		ActiveModel::Type.register(:literal_flags) do |name, type:|
+			Literal::Rails::FlagsType.new(type)
+		end
 	end
 end

data/lib/literal/set.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+class Literal::Set
+	class Generic
+		def initialize(type)
+			@type = type
+		end
+
+		def new(*value)
+			Literal::Set.new(value.to_set, type: @type)
+		end
+
+		alias_method :[], :new
+
+		def ===(value)
+			Literal::Set === value && @type == value.__type__
+		end
+
+		def inspect
+			"Literal::Set(#{@type.inspect})"
+		end
+	end
+
+	include Enumerable
+
+	def initialize(value, type:)
+		collection_type = Literal::Types::SetType.new(type)
+
+		Literal.check(actual: value, expected: collection_type) do |c|
+			c.fill_receiver(receiver: self, method: "#initialize")
+		end
+
+		@__type__ = type
+		@__value__ = value
+		@__collection_type__ = collection_type
+	end
+
+	attr_reader :__type__, :__value__
+
+	def freeze
+		@__value__.freeze
+		super
+	end
+
+	def each(...)
+		@__value__.each(...)
+	end
+end