literal 1.1.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b459adebd387b12382d4e049a1f9211f6330bc6f77d66a8380bfbe758a4fb224
-  data.tar.gz: d771162ac9e9939e20b9478225baa23dc5d3b4d2fd0f0daa3c821277053ea88f
+  metadata.gz: 9721432521677aa431dda4e94240521a54a8ac21ece07fef009393544d19214d
+  data.tar.gz: c5b41c95f4c24ff4fad28869bf61ff93174118a2d3e5890928961b382bf9b285
 SHA512:
-  metadata.gz: 68c949539f7002388ccff9c0547c48988a3ccb9ae2cb3262f8ab9119f0187f8ff775c46d3b2aa8abbcc1bbb68a767427c99b48af898744c58bfa004fec3dd491
-  data.tar.gz: 872aeda1f2efb4023e9c34c324e8fba149737d5744bc735e57b0ffdbb52be6001f39360fa86c5f981d70e70b5698394eef228eef9dde2d5ca387180414aac555
+  metadata.gz: 715a03576aed152e2fd5737236eb227dd98da9f02b421a14722395a3b9992dc667302574490955f0f9d81192dc5f64f793d916b196bc4509244afad5daa8a37b
+  data.tar.gz: 475df2645d537e5c8151ba6431e1469fdcfdd1a80d766489bfa00b135f3c3e57a86b0c09c7e6738c6033609a69864a596660a0b5498bd6762e314588a67bac35

data/lib/literal/array.rb

@@ -0,0 +1,544 @@
+# 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 combination(...)
+		@__value__.combination(...)
+		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 delete(...)
+		@__value__.delete(...)
+	end
+
+	def delete_at(...)
+		@__value__.delete_at(...)
+	end
+
+	def delete_if(...)
+		@__value__.delete_if(...)
+		self
+	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 flatten(...)
+		__with__(@__value__.flatten(...))
+	end
+
+	def first(...)
+		@__value__.first(...)
+	end
+
+	def flatten!(...)
+		@__value__.flatten!(...) ? self : nil
+	end
+
+	def freeze
+		@__value__.freeze
+		super
+	end
+
+	alias_method :index, :find_index
+
+	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 inspect
+		@__value__.inspect
+	end
+
+	def intersect?(other)
+		case other
+		when ::Array
+			@__value__.intersect?(other)
+		when Literal::Array
+			@__value__.intersect?(other.__value__)
+		else
+			raise ArgumentError.new("Cannot perform `intersect?` with #{other.class.name}.")
+		end
+	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	join(...)
+		@__value__.join(...)
+	end
+
+	def keep_if(...)
+		return_value = @__value__.keep_if(...)
+		case return_value
+		when Array
+			self
+		else
+			return_value
+		end
+	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 sum(...)
+		@__value__.sum(...)
+	end
+
+	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 narrow(type)
+		unless Literal.subtype?(type, of: @__type__)
+			raise ArgumentError.new("Cannot narrow #{@__type__} to #{type}")
+		end
+
+		if __type__ != type
+			@__value__.each do |item|
+				Literal.check(actual: item, expected: type) do |c|
+					c.fill_receiver(receiver: self, method: "#narrow")
+				end
+			end
+		end
+
+		Literal::Array.allocate.__initialize_without_check__(
+			@__value__,
+			type:,
+		)
+	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 select(...)
+		__with__(@__value__.select(...))
+	end
+
+	def select!(...)
+		@__value__.select!(...)
+	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
+
+	alias_method :to_s, :inspect
+
+	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
+
+	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 fetch(...)
+		@__value__.fetch(...)
+	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/deferred_type.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class Literal::Types::DeferredType
+	include Literal::Type
+
+	def initialize(&block)
+		@block = block
+	end
+
+	attr_reader :block
+
+	def inspect
+		"_Deferred"
+	end
+
+	def ===(other)
+		@block.call === other
+	end
+
+	def >=(other)
+		Literal.subtype?(other, of: @block.call)
+	end
+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
@@ -154,7 +154,7 @@ class Literal::Properties::Schema
 	end
 
 	def generate_initializer_body(buffer = +"")
-		buffer << "  properties = self.class.literal_properties.properties_index\n"
+		buffer << "  __properties__ = self.class.literal_properties.properties_index\n"
 		generate_initializer_handle_properties(@sorted_properties, buffer)
 	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