literal 1.0.0 → 1.2.0

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

@@ -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.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

data/lib/literal/struct.rb

@@ -6,4 +6,30 @@ class Literal::Struct < Literal::DataStructure
 			super
 		end
 	end
+
+	def [](key)
+		case key
+		when Symbol
+		when String
+			key = key.intern
+		else
+			raise TypeError.new("expected a string or symbol, got #{key.inspect.class}")
+		end
+
+		prop = self.class.literal_properties[key] || raise(NameError.new("unknown attribute: #{key.inspect} for #{self.class}"))
+		__send__(prop.name)
+	end
+
+	def []=(key, value)
+		case key
+		when Symbol
+		when String
+			key = key.intern
+		else
+			raise TypeError.new("expected a string or symbol, got #{key.inspect.class}")
+		end
+
+		prop = self.class.literal_properties[key] || raise(NameError.new("unknown attribute: #{key.inspect} for #{self.class}"))
+		__send__(:"#{prop.name}=", value)
+	end
 end

data/lib/literal/type.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Literal::Type
+	def >=(other)
+		self == other
+	end
+end

data/lib/literal/types/any_type.rb

@@ -1,12 +1,22 @@
 # frozen_string_literal: true
 
 # @api private
-module Literal::Types::AnyType
-	def self.inspect = "_Any"
+class Literal::Types::AnyType
+	include Literal::Type
 
-	def self.===(value)
+	def inspect
+		"_Any"
+	end
+
+	def ===(value)
 		!(nil === value)
 	end
 
+	def >=(other)
+		!(other === nil)
+	end
+
+	Instance = new.freeze
+
 	freeze
 end

data/lib/literal/types/array_type.rb

@@ -2,16 +2,31 @@
 
 # @api private
 class Literal::Types::ArrayType
+	include Literal::Type
+
 	def initialize(type)
 		@type = type
 	end
 
-	def inspect = "_Array(#{@type.inspect})"
+	attr_reader :type
+
+	def inspect
+		"_Array(#{@type.inspect})"
+	end
 
 	def ===(value)
 		Array === value && value.all?(@type)
 	end
 
+	def >=(other)
+		case other
+		when Literal::Types::ArrayType
+			@type >= other.type
+		else
+			false
+		end
+	end
+
 	def record_literal_type_errors(context)
 		unless Array === context.actual
 			return
@@ -23,4 +38,6 @@ class Literal::Types::ArrayType
 			end
 		end
 	end
+
+	freeze
 end

data/lib/literal/types/boolean_type.rb

@@ -1,12 +1,27 @@
 # frozen_string_literal: true
 
 # @api private
-module Literal::Types::BooleanType
-	def self.inspect = "_Boolean"
+class Literal::Types::BooleanType
+	include Literal::Type
 
-	def self.===(value)
+	def inspect
+		"_Boolean"
+	end
+
+	def ===(value)
 		true == value || false == value
 	end
 
+	def >=(other)
+		case other
+		when true, false, Literal::Types::BooleanType
+			true
+		else
+			false
+		end
+	end
+
+	Instance = new.freeze
+
 	freeze
 end

data/lib/literal/types/callable_type.rb

@@ -1,12 +1,31 @@
 # frozen_string_literal: true
 
 # @api private
-module Literal::Types::CallableType
-	def self.inspect = "_Callable"
+class Literal::Types::CallableType
+	include Literal::Type
 
-	def self.===(value)
+	def inspect
+		"_Callable"
+	end
+
+	def ===(value)
 		value.respond_to?(:call)
 	end
 
+	def >=(other)
+		(self == other) || (Proc == other) || (Method == other) || case other
+		when Literal::Types::IntersectionType
+			other.types.any? { |type| Literal.subtype?(type, of: self) }
+		when Literal::Types::ConstraintType
+			other.object_constraints.any? { |type| Literal.subtype?(type, of: self) }
+		when Literal::Types::InterfaceType
+			other.methods.include?(:call)
+		else
+			false
+		end
+	end
+
+	Instance = new.freeze
+
 	freeze
 end

data/lib/literal/types/class_type.rb

@@ -2,13 +2,32 @@
 
 # @api private
 class Literal::Types::ClassType
+	include Literal::Type
+
 	def initialize(type)
 		@type = type
 	end
 
-	def inspect = "_Class(#{@type.name})"
+	attr_reader :type
+
+	def inspect
+		"_Class(#{@type.name})"
+	end
 
 	def ===(value)
 		Class === value && (value == @type || value < @type)
 	end
+
+	def >=(other)
+		case other
+		when Literal::Types::ClassType
+			Literal.subtype?(other.type, of: @type)
+		when Literal::Types::DescendantType
+			(Class === other.type) && Literal.subtype?(other.type, of: @type)
+		else
+			false
+		end
+	end
+
+	freeze
 end

data/lib/literal/types/constraint_type.rb

@@ -2,12 +2,19 @@
 
 # @api private
 class Literal::Types::ConstraintType
+	include Literal::Type
+
 	def initialize(*object_constraints, **property_constraints)
 		@object_constraints = object_constraints
 		@property_constraints = property_constraints
 	end
 
-	def inspect = "_Constraint(#{inspect_constraints})"
+	attr_reader :object_constraints
+	attr_reader :property_constraints
+
+	def inspect
+		"_Constraint(#{inspect_constraints})"
+	end
 
 	def ===(value)
 		object_constraints = @object_constraints
@@ -20,11 +27,56 @@ class Literal::Types::ConstraintType
 
 		@property_constraints.each do |a, t|
 			return false unless t === value.public_send(a)
+		rescue NoMethodError => e
+			raise unless e.name == a && e.receiver == value
+			return false
 		end
 
 		true
 	end
 
+	def >=(other)
+		case other
+		when Literal::Types::ConstraintType
+			other_object_constraints = other.object_constraints
+			return false unless @object_constraints.all? do |constraint|
+				other_object_constraints.all? { |c| Literal.subtype?(c, of: 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)
+			end
+
+			true
+		when Literal::Types::IntersectionType
+			other_object_constraints = other.types
+			return false unless @object_constraints.all? do |constraint|
+				other_object_constraints.all? { |c| Literal.subtype?(c, of: constraint) }
+			end
+
+			true
+		else
+			false
+		end
+	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|
+			next unless context.actual.respond_to?(property)
+			actual = context.actual.public_send(property)
+			next if constraint === actual
+
+			context.add_child(label: ".#{property}", expected: constraint, actual:)
+		end
+	end
+
 	private
 
 	def inspect_constraints
@@ -42,4 +94,6 @@ class Literal::Types::ConstraintType
 			@property_constraints.map { |k, t| "#{k}: #{t.inspect}" }.join(", ")
 		end
 	end
+
+	freeze
 end

data/lib/literal/types/descendant_type.rb

@@ -1,13 +1,30 @@
 # frozen_string_literal: true
 
 class Literal::Types::DescendantType
+	include Literal::Type
+
 	def initialize(type)
 		@type = type
 	end
 
-	def inspect = "_Descendant(#{@type})"
+	attr_reader :type
+
+	def inspect
+		"_Descendant(#{@type})"
+	end
 
 	def ===(value)
 		Module === value && value < @type
 	end
+
+	def >=(other)
+		case other
+		when Literal::Types::DescendantType, Literal::Types::ClassType
+			Literal.subtype?(other.type, of: @type)
+		else
+			false
+		end
+	end
+
+	freeze
 end

data/lib/literal/types/enumerable_type.rb

@@ -2,13 +2,30 @@
 
 # @api private
 class Literal::Types::EnumerableType
+	include Literal::Type
+
 	def initialize(type)
 		@type = type
 	end
 
-	def inspect = "_Enumerable(#{@type.inspect})"
+	attr_reader :type
+
+	def inspect
+		"_Enumerable(#{@type.inspect})"
+	end
 
 	def ===(value)
 		Enumerable === value && value.all?(@type)
 	end
+
+	def >=(other)
+		case other
+		when Literal::Types::EnumerableType
+			Literal.subtype?(other.type, of: @type)
+		else
+			false
+		end
+	end
+
+	freeze
 end

data/lib/literal/types/falsy_type.rb

@@ -1,12 +1,31 @@
 # frozen_string_literal: true
 
 # @api private
-module Literal::Types::FalsyType
-	def self.inspect = "_Falsy"
+class Literal::Types::FalsyType
+	include Literal::Type
 
-	def self.===(value)
+	def initialize
+		freeze
+	end
+
+	def inspect
+		"_Falsy"
+	end
+
+	def ===(value)
 		!value
 	end
 
+	def >=(other)
+		case other
+		when Literal::Types::FalsyType, nil, false
+			true
+		else
+			false
+		end
+	end
+
+	Instance = new.freeze
+
 	freeze
 end

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/interface_type.rb

@@ -7,6 +7,8 @@ class Literal::Types::InterfaceType
 		@methods = methods
 	end
 
+	attr_reader :methods
+
 	def inspect = "_Interface(#{@methods.map(&:inspect).join(', ')})"
 
 	def ===(value)

data/lib/literal/types/intersection_type.rb

@@ -8,6 +8,8 @@ class Literal::Types::IntersectionType
 		@types = types
 	end
 
+	attr_reader :types
+
 	def inspect = "_Intersection(#{@types.map(&:inspect).join(', ')})"
 
 	def ===(value)
@@ -17,4 +19,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/json_data_type.rb

@@ -19,5 +19,21 @@ module Literal::Types::JSONDataType
 		end
 	end
 
+	def self.record_literal_type_errors(context)
+		case value = context.actual
+		when String, Integer, Float, true, false, nil
+			# nothing to do
+		when Hash
+			value.each do |k, v|
+				context.add_child(label: "[]", expected: String, actual: k) unless String === k
+				context.add_child(label: "[#{k.inspect}]", expected: self, actual: v) unless self === v
+			end
+		when Array
+			value.each_with_index do |item, index|
+				context.add_child(label: "[#{index}]", expected: self, actual: item) unless self === item
+			end
+		end
+	end
+
 	freeze
 end

data/lib/literal/types/map_type.rb

@@ -21,9 +21,15 @@ class Literal::Types::MapType
 			return
 		end
 
-		context.actual.each do |key, item|
-			unless @shape[key] === item
-				context.add_child(label: "[#{key.inspect}]", expected: @shape[key], actual: item)
+		@shape.each do |key, expected|
+			unless context.actual.key?(key) || expected === nil
+				context.add_child(label: "[]", expected: key, actual: nil)
+				next
+			end
+
+			actual = context.actual[key]
+			unless expected === actual
+				context.add_child(label: "[#{key.inspect}]", expected:, actual:)
 			end
 		end
 	end