literal 1.5.0 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e3b0596d3836316a8c9f2dc13b42707da7e4b158cdf17af864c22be88856e76c
-  data.tar.gz: be38909c66845eb4d09187803903f46cbe8d4392d0245d089aa7aec03c0ac7af
+  metadata.gz: 2c4292f514f586e16d0d477cc57e9a8b1f38771a8124f9ed933b67aa167550a0
+  data.tar.gz: 48dc63568c23368fb5c1577a57833720ca272c2aeca24dfc33e26271ed378497
 SHA512:
-  metadata.gz: cfe44962b770aa87464249cd41540e2c26cce61a1b59292fca71b3d79331595483214e22eaa907e3b8453d49a75365219291d196854d843ec09ac1c4ed3b19dd
-  data.tar.gz: 3b6cd6cfeb4fd440c43385462ac3147606389f2afe046eab45cdd3cd9b626dc1fd6e7cdce39c4c5f9b060ea659b99b6ffb7a9ab930a5edb393a11e64f7234557
+  metadata.gz: d79162f89f5088923b2a18ffb2d77214401e18f2d992d2535ab85a4f73b0adbf4430bf385dd846f860e7c0c984508bd6a4d48296a13883fefdb1eb8ef0ac51eb
+  data.tar.gz: d0cbebd25520b382b6ea73d22b9b2120b15831d7b51d6b2deb99bfd2adaa1c53cfeadbf4b6c3f7af6e97ea634991c49fe5e49d559c2efcf228ec2e9fe942daf1

data/lib/literal/array.rb

@@ -17,13 +17,13 @@ class Literal::Array
 		alias_method :[], :new
 
 		def ===(value)
-			Literal::Array === value && Literal.subtype?(value.__type__, of: @type)
+			Literal::Array === value && Literal.subtype?(value.__type__, @type)
 		end
 
 		def >=(other)
 			case other
 			when Literal::Array::Generic
-				Literal.subtype?(other.type, of: @type)
+				Literal.subtype?(other.type, @type)
 			else
 				false
 			end
@@ -51,7 +51,7 @@ class Literal::Array
 	include Literal::Types
 
 	def initialize(value, type:)
-		Literal.check(actual: value, expected: _Array(type)) do |c|
+		Literal.check(value, _Array(type)) do |c|
 			c.fill_receiver(receiver: self, method: "#initialize")
 		end
 
@@ -98,7 +98,7 @@ class Literal::Array
 	def +(other)
 		case other
 		when ::Array
-			Literal.check(actual: other, expected: _Array(@__type__)) do |c|
+			Literal.check(other, _Array(@__type__)) do |c|
 				c.fill_receiver(receiver: self, method: "#+")
 			end
 
@@ -129,7 +129,7 @@ class Literal::Array
 	end
 
 	def <<(value)
-		Literal.check(actual: value, expected: @__type__) do |c|
+		Literal.check(value, @__type__) do |c|
 			c.fill_receiver(receiver: self, method: "#<<")
 		end
 
@@ -157,7 +157,7 @@ class Literal::Array
 	end
 
 	def []=(index, value)
-		Literal.check(actual: value, expected: @__type__) do |c|
+		Literal.check(value, @__type__) do |c|
 			c.fill_receiver(receiver: self, method: "#[]=")
 		end
 
@@ -284,7 +284,7 @@ class Literal::Array
 	alias_method :index, :find_index
 
 	def insert(index, *value)
-		Literal.check(actual: value, expected: _Array(@__type__)) do |c|
+		Literal.check(value, _Array(@__type__)) do |c|
 			c.fill_receiver(receiver: self, method: "#insert")
 		end
 
@@ -344,9 +344,9 @@ class Literal::Array
 
 	def map(type, &block)
 		my_type = @__type__
-		transform_type = Literal::TRANSFORMS.dig(my_type, block)
+		transform_type = Literal::Transforms.dig(my_type, block)
 
-		if transform_type && Literal.subtype?(transform_type, of: my_type)
+		if transform_type && Literal.subtype?(transform_type, my_type)
 			Literal::Array.allocate.__initialize_without_check__(
 				@__value__.map(&block),
 				type:,
@@ -392,13 +392,13 @@ class Literal::Array
 	end
 
 	def narrow(type)
-		unless Literal.subtype?(type, of: @__type__)
+		unless Literal.subtype?(type, @__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|
+				Literal.check(item, type) do |c|
 					c.fill_receiver(receiver: self, method: "#narrow")
 				end
 			end
@@ -453,7 +453,7 @@ class Literal::Array
 	end
 
 	def push(*value)
-		Literal.check(actual: value, expected: _Array(@__type__)) do |c|
+		Literal.check(value, _Array(@__type__)) do |c|
 			c.fill_receiver(receiver: self, method: "#push")
 		end
 
@@ -475,7 +475,7 @@ class Literal::Array
 	def replace(value)
 		case value
 		when Array
-			Literal.check(actual: value, expected: _Array(@__type__)) do |c|
+			Literal.check(value, _Array(@__type__)) do |c|
 				c.fill_receiver(receiver: self, method: "#replace")
 			end
 
@@ -597,7 +597,7 @@ class Literal::Array
 	end
 
 	def unshift(value)
-		Literal.check(actual: value, expected: @__type__) do |c|
+		Literal.check(value, @__type__) do |c|
 			c.fill_receiver(receiver: self, method: "#unshift")
 		end
 
@@ -636,7 +636,7 @@ class Literal::Array
 	def |(other)
 		case other
 		when ::Array
-			Literal.check(actual: other, expected: _Array(@__type__)) do |c|
+			Literal.check(other, _Array(@__type__)) do |c|
 				c.fill_receiver(receiver: self, method: "#|")
 			end
 

data/lib/literal/data_structure.rb

@@ -38,7 +38,7 @@ class Literal::DataStructure
 	end
 
 	def marshal_dump
-		[1, to_h, frozen?]
+		[1, to_h, frozen?].freeze
 	end
 
 	def hash
@@ -46,9 +46,10 @@ class Literal::DataStructure
 	end
 
 	def ==(other)
-		other.is_a?(self.class) && other.class.literal_properties.empty?
+		self.class === other && other.class.literal_properties.empty?
 	end
-	alias eql? ==
+
+	alias_method :eql?, :==
 
 	def self.__generate_literal_methods__(new_property, buffer = +"")
 		super

data/lib/literal/delegator.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class Literal::Delegator < SimpleDelegator
+	def self.to_proc
+		-> (value) { new(value) }
+	end
+
+	def self.[](value)
+		new(value)
+	end
+
+	def initialize(value)
+		Literal.check(value, __type__)
+		super
+		freeze
+	end
+
+	def ===(other)
+		self.class === other && __getobj__ == other.__getobj__
+	end
+
+	alias_method :==, :===
+
+	freeze
+end

data/lib/literal/enum.rb

@@ -24,7 +24,7 @@ class Literal::Enum
 				@names = {}
 			end
 
-			if RUBY_ENGINE != "truffleruby"
+			if subclass.name && RUBY_ENGINE != "truffleruby"
 				TracePoint.trace(:end) do |tp|
 					if tp.self == subclass
 						tp.self.__after_defined__
@@ -55,7 +55,7 @@ class Literal::Enum
 
 			types = @indexes_definitions.fetch(key)
 			type = types.first
-			Literal.check(actual: value, expected: type) { |c| raise NotImplementedError }
+			Literal.check(value, type) { |c| raise NotImplementedError }
 
 			@indexes.fetch(key)[value]
 		end
@@ -71,9 +71,8 @@ class Literal::Enum
 				raise ArgumentError.new("You can only use `find_by` on unique indexes.")
 			end
 
-			unless (type = @indexes_definitions.fetch(key)[0]) === value
-				raise Literal::TypeError.expected(value, to_be_a: type)
-			end
+			type = @indexes_definitions.fetch(key)[0]
+			Literal.check(value, type)
 
 			@indexes.fetch(key)[value]&.first
 		end

data/lib/literal/flags/flags_16.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Literal::Flags16 < Literal::Flags
+	BYTES = 2
+	BITS = BYTES * 8
+	PACKER = "S"
+end

data/lib/literal/flags/flags_32.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Literal::Flags32 < Literal::Flags
+	BYTES = 4
+	BITS = BYTES * 8
+	PACKER = "L"
+end

data/lib/literal/flags/flags_64.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Literal::Flags64 < Literal::Flags
+	BYTES = 8
+	BITS = BYTES * 8
+	PACKER = "Q"
+end

data/lib/literal/flags/flags_8.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Literal::Flags8 < Literal::Flags
+	BYTES = 1
+	BITS = BYTES * 8
+	PACKER = "C"
+end

data/lib/literal/flags.rb

@@ -219,27 +219,3 @@ class Literal::Flags
 		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

data/lib/literal/hash.rb

@@ -25,7 +25,7 @@ class Literal::Hash
 	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|
+		Literal.check(value, collection_type) do |c|
 			c.fill_receiver(receiver: self, method: "#initialize")
 		end
 

data/lib/literal/properties/schema.rb

@@ -62,7 +62,7 @@ class Literal::Properties::Schema
 	end
 
 	def generate_after_initializer(buffer = +"")
-		buffer << "  after_initialize if respond_to?(:after_initialize)\n"
+		buffer << "  after_initialize if respond_to?(:after_initialize, true)\n"
 	end
 
 	def generate_to_h(buffer = +"")
@@ -96,13 +96,13 @@ class Literal::Properties::Schema
 
 	def generate_eq(buffer = +"")
 		buffer << "def ==(other)\n"
-		buffer << "  return false unless other.is_a?(self.class) && other.class.literal_properties.size == self.class.literal_properties.size\n"
+		buffer << "  return false unless self.class === other && other.class.literal_properties.size == self.class.literal_properties.size\n"
 
 		sorted_properties = @sorted_properties
 		i, n = 0, sorted_properties.size
 		while i < n
 			property = sorted_properties[i]
-			buffer << "  @" << property.name.name << " == other." << property.name.name
+			buffer << "  @#{property.name.name} == other.instance_variable_get(:@#{property.name.name})"
 			buffer << " &&\n  " if i < n - 1
 			i += 1
 		end

data/lib/literal/properties.rb

@@ -1,9 +1,6 @@
 # frozen_string_literal: true
 
 module Literal::Properties
-	autoload :Schema, "literal/properties/schema"
-	autoload :DataSchema, "literal/properties/data_schema"
-
 	include Literal::Types
 
 	module DocString
@@ -30,7 +27,7 @@ module Literal::Properties
 		end
 
 		unless Literal::Property::VISIBILITY_OPTIONS.include?(predicate)
-				raise Literal::ArgumentError.new("The predicate must be one of #{Literal::Property::VISIBILITY_OPTIONS.map(&:inspect).join(', ')}.")
+			raise Literal::ArgumentError.new("The predicate must be one of #{Literal::Property::VISIBILITY_OPTIONS.map(&:inspect).join(', ')}.")
 		end
 
 		if reader && :class == name
@@ -57,12 +54,14 @@ module Literal::Properties
 		literal_properties << property
 		__define_literal_methods__(property)
 		include(__literal_extension__)
+
+		name
 	end
 
 	def literal_properties
 		return @literal_properties if defined?(@literal_properties)
 
-		if superclass.is_a?(Literal::Properties)
+		if Literal::Properties === superclass
 			@literal_properties = superclass.literal_properties.dup
 		else
 			@literal_properties = Literal::Properties::Schema.new
@@ -90,7 +89,7 @@ module Literal::Properties
 				end
 
 				def to_h
-						{}
+					{}
 				end
 
 				set_temporary_name "Literal::Properties(Extension)" if respond_to?(:set_temporary_name)

data/lib/literal/property.rb

@@ -97,15 +97,15 @@ class Literal::Property
 	def check(value, &)
 		raise ArgumentError.new("Cannot check type without a block") unless block_given?
 
-		Literal.check(actual: value, expected: @type, &)
+		Literal.check(value, @type, &)
 	end
 
 	def check_writer(receiver, value)
-		Literal.check(actual: value, expected: @type) { |c| c.fill_receiver(receiver:, method: "##{@name.name}=(value)") }
+		Literal.check(value, @type) { |c| c.fill_receiver(receiver:, method: "##{@name.name}=(value)") }
 	end
 
 	def check_initializer(receiver, value)
-		Literal.check(actual: value, expected: @type) { |c| c.fill_receiver(receiver:, method: "#initialize", label: param) }
+		Literal.check(value, @type) { |c| c.fill_receiver(receiver:, method: "#initialize", label: param) }
 	end
 
 	def generate_reader_method(buffer = +"")

data/lib/literal/rails/enum_type.rb

@@ -6,6 +6,10 @@ class Literal::Rails::EnumType < ActiveModel::Type::Value
 		super()
 	end
 
+	def type
+		:literal_enum
+	end
+
 	def cast(value)
 		case value
 		when nil

data/lib/literal/rails.rb

@@ -4,7 +4,4 @@ require_relative "railtie"
 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/set.rb

@@ -26,7 +26,7 @@ class Literal::Set
 	def initialize(value, type:)
 		collection_type = Literal::Types::SetType.new(type)
 
-		Literal.check(actual: value, expected: collection_type) do |c|
+		Literal.check(value, collection_type) do |c|
 			c.fill_receiver(receiver: self, method: "#initialize")
 		end
 

data/lib/literal/transforms.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # A map of core types to transform Procs mapping to the new type.
-Literal::TRANSFORMS = {
+Literal::Transforms = {
 	Integer => {
 		abs: Integer,
 		ceil: Integer,
@@ -140,4 +140,4 @@ Literal::TRANSFORMS = {
 		to_s: String,
 		year: Integer,
 	},
-}.transform_values! { |it| it.transform_keys(&:to_proc) }.freeze
+}.transform_values! { |it| it.transform_keys(&:to_proc).freeze }.freeze

data/lib/literal/tuple.rb

@@ -19,7 +19,7 @@ class Literal::Tuple
 
 			i, len = 0, types.size
 			while i < len
-				return false unless Literal.subtype?(other_types[i], of: types[i])
+				return false unless Literal.subtype?(other_types[i], types[i])
 				i += 1
 			end
 
@@ -36,7 +36,7 @@ class Literal::Tuple
 
 				i, len = 0, types.size
 				while i < len
-					return false unless Literal.subtype?(other_types[i], of: types[i])
+					return false unless Literal.subtype?(other_types[i], types[i])
 					i += 1
 				end
 

data/lib/literal/types/array_type.rb

@@ -6,6 +6,7 @@ class Literal::Types::ArrayType
 
 	def initialize(type)
 		@type = type
+		freeze
 	end
 
 	attr_reader :type

data/lib/literal/types/class_type.rb

@@ -6,6 +6,7 @@ class Literal::Types::ClassType
 
 	def initialize(type)
 		@type = type
+		freeze
 	end
 
 	attr_reader :type
@@ -21,9 +22,9 @@ class Literal::Types::ClassType
 	def >=(other)
 		case other
 		when Literal::Types::ClassType
-			Literal.subtype?(other.type, of: @type)
+			Literal.subtype?(other.type, @type)
 		when Literal::Types::DescendantType
-			(Class === other.type) && Literal.subtype?(other.type, of: @type)
+			(Class === other.type) && Literal.subtype?(other.type, @type)
 		else
 			false
 		end

data/lib/literal/types/constraint_type.rb

@@ -7,6 +7,7 @@ class Literal::Types::ConstraintType
 	def initialize(*object_constraints, **property_constraints)
 		@object_constraints = object_constraints
 		@property_constraints = property_constraints
+		freeze
 	end
 
 	attr_reader :object_constraints
@@ -45,24 +46,24 @@ class Literal::Types::ConstraintType
 		when Literal::Types::ConstraintType
 			other_object_constraints = other.object_constraints
 			return false unless @object_constraints.all? do |constraint|
-				other_object_constraints.any? { |c| Literal.subtype?(c, of: constraint) }
+				other_object_constraints.any? { |c| Literal.subtype?(c, constraint) }
 			end
 
 			other_property_constraints = other.property_constraints
 			return false unless @property_constraints.all? do |k, v|
-				Literal.subtype?(other_property_constraints[k], of: v)
+				Literal.subtype?(other_property_constraints[k], v)
 			end
 
 			true
 		when Literal::Types::IntersectionType
 			other_object_constraints = other.types
 			return false unless @object_constraints.all? do |constraint|
-				other_object_constraints.any? { |c| Literal.subtype?(c, of: constraint) }
+				other_object_constraints.any? { |c| Literal.subtype?(c, constraint) }
 			end
 
 			true
 		when Literal::Types::FrozenType
-			@object_constraints.all? { |constraint| Literal.subtype?(other.type, of: constraint) }
+			@object_constraints.all? { |constraint| Literal.subtype?(other.type, constraint) }
 		else
 			false
 		end

data/lib/literal/{deferred_type.rb → types/deferred_type.rb}

@@ -18,6 +18,6 @@ class Literal::Types::DeferredType
 	end
 
 	def >=(other)
-		Literal.subtype?(other, of: @block.call)
+		Literal.subtype?(other, @block.call)
 	end
 end

data/lib/literal/types/descendant_type.rb

@@ -5,6 +5,7 @@ class Literal::Types::DescendantType
 
 	def initialize(type)
 		@type = type
+		freeze
 	end
 
 	attr_reader :type
@@ -20,7 +21,7 @@ class Literal::Types::DescendantType
 	def >=(other)
 		case other
 		when Literal::Types::DescendantType, Literal::Types::ClassType
-			Literal.subtype?(other.type, of: @type)
+			Literal.subtype?(other.type, @type)
 		else
 			false
 		end

data/lib/literal/types/enumerable_type.rb

@@ -6,6 +6,7 @@ class Literal::Types::EnumerableType
 
 	def initialize(type)
 		@type = type
+		freeze
 	end
 
 	attr_reader :type
@@ -21,7 +22,7 @@ class Literal::Types::EnumerableType
 	def >=(other)
 		case other
 		when Literal::Types::EnumerableType
-			Literal.subtype?(other.type, of: @type)
+			Literal.subtype?(other.type, @type)
 		else
 			false
 		end

data/lib/literal/types/frozen_type.rb

@@ -12,6 +12,7 @@ class Literal::Types::FrozenType
 		end
 
 		@type = type
+		freeze
 	end
 
 	attr_reader :type
@@ -30,11 +31,11 @@ class Literal::Types::FrozenType
 			@type >= other.type
 		when Literal::Types::ConstraintType
 			type_match = false
-			frozen_match = Literal.subtype?(other.property_constraints[:frozen?], of: true)
+			frozen_match = Literal.subtype?(other.property_constraints[:frozen?], true)
 
 			other.object_constraints.each do |constraint|
 				frozen_match ||= ALWAYS_FROZEN.include?(constraint)
-				type_match ||= Literal.subtype?(constraint, of: @type)
+				type_match ||= Literal.subtype?(constraint, @type)
 				return true if frozen_match && type_match
 			end
 

data/lib/literal/types/hash_type.rb

@@ -7,6 +7,7 @@ class Literal::Types::HashType
 	def initialize(key_type, value_type)
 		@key_type = key_type
 		@value_type = value_type
+		freeze
 	end
 
 	attr_reader :key_type, :value_type
@@ -29,9 +30,9 @@ class Literal::Types::HashType
 		case other
 		when Literal::Types::HashType
 			(
-				Literal.subtype?(other.key_type, of: @key_type)
+				Literal.subtype?(other.key_type, @key_type)
 			) && (
-				Literal.subtype?(other.value_type, of: @value_type)
+				Literal.subtype?(other.value_type, @value_type)
 			)
 		else
 			false

data/lib/literal/types/interface_type.rb

@@ -2,18 +2,15 @@
 
 # @api private
 class Literal::Types::InterfaceType
-	# TODO: We can generate this and make it much more extensive.
-	METHOD_TYPE_MAPPINGS = {
-		:call => Set[Proc, Method],
-		:to_proc => Set[Proc, Method],
-		:to_s => Set[String],
-	}.freeze
-
 	include Literal::Type
 
+	# List of `===` method owners where the comparison will only match for objects with the same class
+	OwnClassTypeMethodOwners = Set[String, Integer, Kernel, Float, NilClass, TrueClass, FalseClass].freeze
+
 	def initialize(*methods)
 		raise Literal::ArgumentError.new("_Interface type must have at least one method.") if methods.size < 1
-		@methods = methods
+		@methods = methods.to_set.freeze
+		freeze
 	end
 
 	attr_reader :methods
@@ -23,21 +20,30 @@ class Literal::Types::InterfaceType
 	end
 
 	def ===(value)
-		@methods.all? { |m| value.respond_to?(m) }
+		@methods.each do |method|
+			return false unless value.respond_to?(method)
+		end
+
+		true
 	end
 
 	def >=(other)
 		case other
 		when Literal::Types::InterfaceType
-			@methods.all? { |m| other.methods.include?(m) }
+			@methods.subset?(other.methods)
 		when Module
-			@methods.map { |m| METHOD_TYPE_MAPPINGS[m] }.all? { |types| types&.include?(other) }
+			public_methods = other.public_instance_methods.to_set
+			@methods.subset?(public_methods)
 		when Literal::Types::IntersectionType
-			other.types.any? { |type| Literal.subtype?(type, of: self) }
+			other.types.any? { |type| Literal.subtype?(type, self) }
 		when Literal::Types::ConstraintType
-			other.object_constraints.any? { |type| Literal.subtype?(type, of: self) }
+			other.object_constraints.any? { |type| Literal.subtype?(type, self) }
 		else
-			false
+			if OwnClassTypeMethodOwners.include?(other.method(:===).owner)
+				self === other
+			else
+				false
+			end
 		end
 	end