literal 1.1.0 → 1.3.0

data/lib/literal/property.rb

@@ -157,7 +157,7 @@ class Literal::Property
 
 	def generate_initializer_handle_property(buffer = +"")
 		buffer << "  # " << @name.name << "\n" <<
-			"  property = properties[:" << @name.name << "]\n"
+			"  property = __properties__[:" << @name.name << "]\n"
 
 		if @kind == :keyword && ruby_keyword?
 			generate_initializer_escape_keyword(buffer)

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

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+# A map of core types to transform Procs mapping to the new type.
+Literal::TRANSFORMS = {
+	Integer => {
+		abs: Integer,
+		ceil: Integer,
+		chr: String,
+		denominator: Integer,
+		even?: Literal::Types::BooleanType::Instance,
+		floor: Integer,
+		hash: Integer,
+		inspect: String,
+		integer?: true,
+		magnitude: Integer,
+		negative?: Literal::Types::BooleanType::Instance,
+		next: Integer,
+		numerator: Integer,
+		odd?: Literal::Types::BooleanType::Instance,
+		ord: Integer,
+		positive?: Literal::Types::BooleanType::Instance,
+		pred: Integer,
+		round: Integer,
+		size: Integer,
+		succ: Integer,
+		to_f: Float,
+		to_i: Integer,
+		to_int: Integer,
+		to_r: Rational,
+		to_s: String,
+		truncate: Integer,
+		zero?: Literal::Types::BooleanType::Instance,
+	},
+	String => {
+		ascii_only?: Literal::Types::BooleanType::Instance,
+		bytesize: Integer,
+		capitalize: String,
+		chomp: String,
+		chop: String,
+		downcase: String,
+		dump: String,
+		empty?: Literal::Types::BooleanType::Instance,
+		hash: Integer,
+		inspect: String,
+		length: Integer,
+		lstrip: String,
+		ord: Integer,
+		reverse: String,
+		rstrip: String,
+		scrub: String,
+		size: Integer,
+		strip: String,
+		swapcase: String,
+		to_str: String,
+		upcase: String,
+		valid_encoding?: Literal::Types::BooleanType::Instance,
+	},
+	Numeric => {
+		to_i: Integer,
+		to_f: Float,
+		to_s: String,
+	},
+	Array => {
+		size: Integer,
+		length: Integer,
+		empty?: Literal::Types::BooleanType::Instance,
+		sort: Array,
+		to_a: Array,
+		to_ary: Array,
+	},
+	Hash => {
+		empty?: Literal::Types::BooleanType::Instance,
+		inspect: String,
+		keys: Array,
+		length: Integer,
+		size: Integer,
+		to_a: Array,
+		to_h: Hash,
+		to_s: String,
+		values: Array,
+	},
+	Set => {
+		empty?: Literal::Types::BooleanType::Instance,
+		inspect: String,
+		length: Integer,
+		size: Integer,
+		to_a: Array,
+		to_s: String,
+	},
+	Float => {
+		abs: Float,
+		ceil: Integer,
+		floor: Integer,
+		nan?: Literal::Types::BooleanType::Instance,
+		negative?: Literal::Types::BooleanType::Instance,
+		positive?: Literal::Types::BooleanType::Instance,
+		round: Integer,
+		to_i: Integer,
+		to_s: String,
+		truncate: Integer,
+		zero?: Literal::Types::BooleanType::Instance,
+	},
+	Symbol => {
+		empty?: Literal::Types::BooleanType::Instance,
+		inspect: String,
+		length: Integer,
+		size: Integer,
+		to_s: String,
+		to_sym: Symbol,
+	},
+	Range => {
+		begin: Object,
+		end: Object,
+		exclude_end?: Literal::Types::BooleanType::Instance,
+		first: Object,
+		last: Object,
+		max: Object,
+		min: Object,
+		size: Integer,
+		to_a: Array,
+		to_s: String,
+	},
+	Regexp => {
+		casefold?: Literal::Types::BooleanType::Instance,
+		inspect: String,
+		source: String,
+		to_s: String,
+	},
+	Time => {
+		day: Integer,
+		hour: Integer,
+		inspect: String,
+		min: Integer,
+		month: Integer,
+		sec: Integer,
+		to_a: Array,
+		to_f: Float,
+		to_i: Integer,
+		to_s: String,
+		year: Integer,
+	},
+}.transform_values! { |it| it.transform_keys(&:to_proc) }.freeze

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
+	Instance = new.freeze
 
-	def self.===(value)
+	include Literal::Type
+
+	def inspect
+		"_Any"
+	end
+
+	def ===(value)
 		!(nil === value)
 	end
 
+	def >=(other)
+		!(other === nil)
+	end
+
 	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
+	Instance = new.freeze
 
-	def self.===(value)
+	include Literal::Type
+
+	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
+
 	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,42 @@ 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.any? { |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.any? { |c| Literal.subtype?(c, of: constraint) }
+			end
+
+			true
+		when Literal::Types::FrozenType
+			@object_constraints.all? { |constraint| Literal.subtype?(other.type, of: constraint) }
+		else
+			false
+		end
+	end
+
 	def record_literal_type_errors(context)
 		@object_constraints.each do |constraint|
 			next if constraint === context.actual
@@ -33,6 +71,7 @@ class Literal::Types::ConstraintType
 		end
 
 		@property_constraints.each do |property, constraint|
+			next unless context.actual.respond_to?(property)
 			actual = context.actual.public_send(property)
 			next if constraint === actual
 
@@ -57,4 +96,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
+	Instance = new.freeze
 
-	def self.===(value)
+	include Literal::Type
+
+	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
+
 	freeze
 end

data/lib/literal/types/frozen_type.rb

@@ -2,13 +2,47 @@
 
 # @api private
 class Literal::Types::FrozenType
+	ALWAYS_FROZEN = Set[Symbol, Integer, Float, Numeric, true, false, nil].freeze
+
+	include Literal::Type
+
 	def initialize(type)
+		if ALWAYS_FROZEN.include?(type)
+			warn "_Frozen type is redundant for #{type.inspect} since it is always frozen."
+		end
+
 		@type = type
 	end
 
-	def inspect = "_Frozen(#{@type.inspect})"
+	attr_reader :type
+
+	def inspect
+		"_Frozen(#{@type.inspect})"
+	end
 
 	def ===(value)
 		value.frozen? && @type === value
 	end
+
+	def >=(other)
+		case other
+		when Literal::Types::FrozenType
+			@type >= other.type
+		when Literal::Types::ConstraintType
+			type_match = false
+			frozen_match = Literal.subtype?(other.property_constraints[:frozen?], of: true)
+
+			other.object_constraints.each do |constraint|
+				frozen_match ||= ALWAYS_FROZEN.include?(constraint)
+				type_match ||= Literal.subtype?(constraint, of: @type)
+				return true if frozen_match && type_match
+			end
+
+			false
+		else
+			false
+		end
+	end
+
+	freeze
 end