literal 0.2.0 → 1.0.0.rc1

data/lib/literal/rails/enum_serializer.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class Literal::Rails::EnumSerializer < ActiveJob::Serializers::ObjectSerializer
+	def serialize?(object)
+		Literal::Enum === object
+	end
+
+	def serialize(object)
+		super([
+			0,
+			object.class.name,
+			object.value,
+		])
+	end
+
+	def deserialize(payload)
+		_version, class_name, value = payload
+		class_name.constantize[value]
+	end
+end

data/lib/literal/rails/enum_type.rb

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

data/lib/literal/rails/patches/active_record.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+	class RelationType
+		def initialize(model_class)
+			unless Class === model_class && model_class < ActiveRecord::Base
+				raise Literal::TypeError.expected(
+					model_class,
+					to_be_a: ActiveRecord::Base,
+				)
+			end
+
+			@model_class = model_class
+		end
+
+		def inspect = "ActiveRecord::Relation(#{@model_class.name})"
+
+		def ===(value)
+			case value
+			when ActiveRecord::Relation, ActiveRecord::Associations::CollectionProxy, ActiveRecord::AssociationRelation
+				@model_class == value.model || value.model < @model_class
+			else
+				false
+			end
+		end
+	end
+
+	def self.Relation(model)
+		RelationType.new(model)
+	end
+end

data/lib/literal/rails.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "railtie"
+require_relative "rails/patches/active_record"
+
+module Literal::Rails
+	autoload :EnumType, "literal/rails/enum_type"
+	autoload :EnumSerializer, "literal/rails/enum_serializer"
+end

data/lib/literal/railtie.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class Literal::Railtie < Rails::Railtie
+	initializer "literal.register_literal_enum_type" do
+		ActiveRecord::Type.register(:literal_enum) do |name, type:|
+			Literal::Rails::EnumType.new(type)
+		end
+
+		ActiveModel::Type.register(:literal_enum) do |name, type:|
+			Literal::Rails::EnumType.new(type)
+		end
+	end
+end

data/lib/literal/types/array_type.rb

@@ -9,6 +9,18 @@ class Literal::Types::ArrayType
 	def inspect = "_Array(#{@type.inspect})"
 
 	def ===(value)
-		Array === value && value.all? { |item| @type === item }
+		Array === value && value.all?(@type)
+	end
+
+	def record_literal_type_errors(context)
+		unless Array === context.actual
+			return
+		end
+
+		context.actual.each_with_index do |item, index|
+			unless @type === item
+				context.add_child(label: "[#{index}]", expected: @type, actual: item)
+			end
+		end
 	end
 end

data/lib/literal/types/boolean_type.rb

@@ -2,17 +2,11 @@
 
 # @api private
 module Literal::Types::BooleanType
-	COERCION = proc { |value| !!value }
-
 	def self.inspect = "_Boolean"
 
 	def self.===(value)
 		true == value || false == value
 	end
 
-	def to_proc
-		COERCION
-	end
-
 	freeze
 end

data/lib/literal/types/constraint_type.rb

@@ -7,10 +7,39 @@ class Literal::Types::ConstraintType
 		@property_constraints = property_constraints
 	end
 
-	def inspect = "_Constraint(#{@object_constraints.inspect}, #{@property_constraints.inspect})"
+	def inspect = "_Constraint(#{inspect_constraints})"
 
 	def ===(value)
-		@object_constraints.all? { |t| t === value } &&
-			@property_constraints.all? { |a, t| t === value.public_send(a) }
+		object_constraints = @object_constraints
+
+		i, len = 0, object_constraints.size
+		while i < len
+			return false unless object_constraints[i] === value
+			i += 1
+		end
+
+		@property_constraints.each do |a, t|
+			return false unless t === value.public_send(a)
+		end
+
+		true
+	end
+
+	private
+
+	def inspect_constraints
+		[inspect_object_constraints, inspect_property_constraints].compact.join(", ")
+	end
+
+	def inspect_object_constraints
+		if @object_constraints.length > 0
+			@object_constraints.map(&:inspect).join(", ")
+		end
+	end
+
+	def inspect_property_constraints
+		if @property_constraints.length > 0
+			@property_constraints.map { |k, t| "#{k}: #{t.inspect}" }.join(", ")
+		end
 	end
 end

data/lib/literal/types/enumerable_type.rb

@@ -9,6 +9,6 @@ class Literal::Types::EnumerableType
 	def inspect = "_Enumerable(#{@type.inspect})"
 
 	def ===(value)
-		Enumerable === value && value.all? { |item| @type === item }
+		Enumerable === value && value.all?(@type)
 	end
 end

data/lib/literal/types/float_type.rb

@@ -2,7 +2,7 @@
 
 # @api private
 class Literal::Types::FloatType < Literal::Types::ConstraintType
-	def inspect = "_Float(#{@range})"
+	def inspect = "_Float(#{inspect_constraints})"
 
 	def ===(value)
 		Float === value && super

data/lib/literal/types/hash_type.rb

@@ -10,6 +10,12 @@ class Literal::Types::HashType
 	def inspect = "_Hash(#{@key_type.inspect}, #{@value_type.inspect})"
 
 	def ===(value)
-		Hash === value && value.all? { |k, v| @key_type === k && @value_type === v }
+		return false unless Hash === value
+
+		value.each do |k, v|
+			return false unless @key_type === k && @value_type === v
+		end
+
+		true
 	end
 end

data/lib/literal/types/integer_type.rb

@@ -2,7 +2,7 @@
 
 # @api private
 class Literal::Types::IntegerType < Literal::Types::ConstraintType
-	def inspect = "_Integer(#{@range})"
+	def inspect = "_Integer(#{inspect_constraints})"
 
 	def ===(value)
 		Integer === value && super

data/lib/literal/types/json_data_type.rb

@@ -9,7 +9,9 @@ module Literal::Types::JSONDataType
 		when String, Integer, Float, true, false, nil
 			true
 		when Hash
-			value.all? { |k, v| String === k && self === v }
+			value.each do |k, v|
+				return false unless String === k && self === v
+			end
 		when Array
 			value.all?(self)
 		else

data/lib/literal/types/map_type.rb

@@ -11,6 +11,20 @@ class Literal::Types::MapType
 	end
 
 	def ===(other)
-		@shape.all? { |k, t| t === other[k] }
+		Hash === other && @shape.each do |k, v|
+			return false unless v === other[k]
+		end
+	end
+
+	def record_literal_type_errors(context)
+		unless Hash === context.actual
+			return
+		end
+
+		context.actual.each do |key, item|
+			unless @shape[key] === item
+				context.add_child(label: "[#{key.inspect}]", expected: @shape[key], actual: item)
+			end
+		end
 	end
 end

data/lib/literal/types/set_type.rb

@@ -9,6 +9,12 @@ class Literal::Types::SetType
 	def inspect = "_Set(#{@type.inspect})"
 
 	def ===(value)
-		Set === value && value.all? { |item| @type === item }
+		return false unless Set === value
+
+		value.each do |v|
+			return false unless @type === v
+		end
+
+		true
 	end
 end

data/lib/literal/types/string_type.rb

@@ -2,7 +2,7 @@
 
 # @api private
 class Literal::Types::StringType < Literal::Types::ConstraintType
-	def inspect = "_String(#{@constraint.inspect})"
+	def inspect = "_String(#{inspect_constraints})"
 
 	def ===(value)
 		String === value && super

data/lib/literal/types/symbol_type.rb

@@ -2,7 +2,7 @@
 
 # @api private
 class Literal::Types::SymbolType < Literal::Types::ConstraintType
-	def inspect = "_Symbol(#{@constraint.inspect})"
+	def inspect = "_Symbol(#{inspect_constraints})"
 
 	def ===(value)
 		Symbol === value && super

data/lib/literal/types/tuple_type.rb

@@ -11,6 +11,16 @@ class Literal::Types::TupleType
 	def inspect = "_Tuple(#{@types.map(&:inspect).join(', ')})"
 
 	def ===(value)
-		Array === value && value.size == @types.size && @types.each_with_index.all? { |t, i| t === value[i] }
+		return false unless Array === value
+		types = @types
+		return false unless value.size == types.size
+
+		i, len = 0, types.size
+		while i < len
+			return false unless types[i] === value[i]
+			i += 1
+		end
+
+		true
 	end
 end

data/lib/literal/types/union_type.rb

@@ -6,15 +6,21 @@ class Literal::Types::UnionType
 	def initialize(*types)
 		raise Literal::ArgumentError.new("_Union type must have at least one type.") if types.size < 1
 
-		@types = Set[]
+		@types = []
 		load_types(types)
+		@types.uniq!
 		@types.freeze
 	end
 
 	def inspect = "_Union(#{@types.inspect})"
 
 	def ===(value)
-		@types.any? { |type| type === value }
+		types = @types
+		i, len = 0, types.size
+		while i < len
+			return true if types[i] === value
+			i += 1
+		end
 	end
 
 	def each(&)