literal 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8ee13d939895155fc3ce4ae1717036b565b0a59d7a4e87b50ea0a1390cc40bf3
-  data.tar.gz: 42df47f2efce39eb14976d226645adb7a9dacc681948a71a9254ca44e19d8d1f
+  metadata.gz: e3b0596d3836316a8c9f2dc13b42707da7e4b158cdf17af864c22be88856e76c
+  data.tar.gz: be38909c66845eb4d09187803903f46cbe8d4392d0245d089aa7aec03c0ac7af
 SHA512:
-  metadata.gz: f3a9b286744de95185baea476e8d7387238912aeb7f956eeef4e7b203bd0a55313885baaf6c5e71e27eb6d252961d44f850ede7e09abbc05c323c88a099be6f6
-  data.tar.gz: f2cc33927ce452c94b3146dc7714cd9078cd532da5523afbbae5372ec2a5aa0319460db07525d9d7a5d709deb9ff929b804d0f3a86425f3d4844bf641a5a669b
+  metadata.gz: cfe44962b770aa87464249cd41540e2c26cce61a1b59292fca71b3d79331595483214e22eaa907e3b8453d49a75365219291d196854d843ec09ac1c4ed3b19dd
+  data.tar.gz: 3b6cd6cfeb4fd440c43385462ac3147606389f2afe046eab45cdd3cd9b626dc1fd6e7cdce39c4c5f9b060ea659b99b6ffb7a9ab930a5edb393a11e64f7234557

data/README.md

@@ -1,3 +1,3 @@
 # A Literal Ruby Gem
 
-See the website for [documentation](https://literal.fun/docs).
+See the website for [documentation](https://literal.fun/docs/).

data/lib/literal/array.rb

@@ -32,6 +32,19 @@ class Literal::Array
 		def inspect
 			"Literal::Array(#{@type.inspect})"
 		end
+
+		def coerce(value)
+			case value
+			when self
+				value
+			when Array
+				Literal::Array.new(value, type: @type)
+			end
+		end
+
+		def to_proc
+			method(:coerce).to_proc
+		end
 	end
 
 	include Enumerable
@@ -224,6 +237,10 @@ class Literal::Array
 		@__value__.each(...)
 	end
 
+	def each_index(...)
+		@__value__.each_index(...)
+	end
+
 	def empty?
 		@__value__.empty?
 	end
@@ -276,7 +293,7 @@ class Literal::Array
 	end
 
 	def inspect
-		@__value__.inspect
+		"Literal::Array(#{@__type__.inspect})#{@__value__.inspect}"
 	end
 
 	def intersect?(other)
@@ -497,6 +514,7 @@ class Literal::Array
 
 	def select!(...)
 		@__value__.select!(...)
+		self
 	end
 
 	def shift(...)
@@ -525,17 +543,50 @@ class Literal::Array
 		self
 	end
 
+	def sort_by!(...)
+		@__value__.sort_by!(...)
+		self
+	end
+
 	def take(...)
 		__with__(@__value__.take(...))
 	end
 
+	def take_while(...)
+		__with__(@__value__.take_while(...))
+	end
+
+	def transpose
+		case @__type__
+		when Literal::Tuple::Generic
+			tuple_types = @__type__.types
+			new_array_types = tuple_types.map { |t| Literal::Array(t) }
+
+			Literal::Tuple(*new_array_types).new(
+				*new_array_types.each_with_index.map do |t, i|
+					t.new(
+						*@__value__.map { |it| it[i] }
+					)
+				end
+			)
+		when Literal::Array::Generic
+			__with__(
+				@__value__.map(&:to_a).transpose.map! { |it| @__type__.new(*it) }
+			)
+		else
+			@__value__.transpose
+		end
+	end
+
 	def to_a
 		@__value__.dup
 	end
 
 	alias_method :to_ary, :to_a
 
-	alias_method :to_s, :inspect
+	def to_s
+		@__value__.to_s
+	end
 
 	def uniq
 		__with__(@__value__.uniq)
@@ -607,4 +658,75 @@ class Literal::Array
 	def fetch(...)
 		@__value__.fetch(...)
 	end
+
+	def zip(*others)
+		other_types = others.map do |other|
+			case other
+			when Literal::Array
+				other.__type__
+			when Array
+				_Any?
+			else
+				raise ArgumentError
+			end
+		end
+
+		tuple = Literal::Tuple(
+			@__type__,
+			*other_types
+		)
+
+		my_length = length
+		max_length = [my_length, *others.map(&:length)].max
+
+		# Check we match the max length or our type is nilable
+		unless my_length == max_length || @__type__ === nil
+			raise ArgumentError.new(<<~MESSAGE)
+				The literal array could not be zipped becuase its type is not nilable and it has fewer items than the maximum number of items in the other arrays.
+
+				You can either make the type of this array nilable, or add more items so its length matches the others.
+
+				#{inspect}
+			MESSAGE
+		end
+
+		# Check others match the max length or their types is nilable
+		others.each_with_index do |other, index|
+			unless other.length == max_length || other_types[index] === nil
+				raise ArgumentError.new(<<~MESSAGE)
+					The literal array could not be zipped becuase its type is not nilable and it has fewer items than the maximum number of items in the other arrays.
+
+					You can either make the type of this array nilable, or add more items so its length matches the others.
+
+					#{inspect}
+				MESSAGE
+			end
+		end
+
+		i = 0
+
+		if block_given?
+			while i < max_length
+				yield tuple.new(
+					@__value__[i],
+					*others.map { |it| it[i] }
+				)
+				i += 1
+			end
+
+			nil
+		else
+			result_value = []
+
+			while i < max_length
+				result_value << tuple.new(
+					@__value__[i],
+					*others.map { |it| it[i] }
+				)
+				i += 1
+			end
+
+			__with__(result_value)
+		end
+	end
 end

data/lib/literal/enum.rb

@@ -9,17 +9,19 @@ class Literal::Enum
 		attr_reader :members
 
 		def values = @values.keys
+		def names = @names
 
-		def prop(name, type, kind = :keyword, reader: :public, default: nil)
-			super(name, type, kind, reader:, writer: false, default:)
+		def prop(name, type, kind = :keyword, reader: :public, predicate: false, default: nil)
+			super(name, type, kind, reader:, writer: false, predicate:, default:)
 		end
 
 		def inherited(subclass)
 			subclass.instance_exec do
 				@values = {}
-				@members = Set[]
+				@members = []
+				@indexes_definitions = {}
 				@indexes = {}
-				@index = {}
+				@names = {}
 			end
 
 			if RUBY_ENGINE != "truffleruby"
@@ -32,8 +34,16 @@ class Literal::Enum
 			end
 		end
 
+		def position_of(member)
+			coerce(member).__position__
+		end
+
+		def at_position(n)
+			@members[n]
+		end
+
 		def index(name, type, unique: true, &block)
-			@indexes[name] = [type, unique, block || name.to_proc]
+			@indexes_definitions[name] = [type, unique, block || name.to_proc]
 		end
 
 		def where(**kwargs)
@@ -43,11 +53,11 @@ class Literal::Enum
 
 			key, value = kwargs.first
 
-			types = @indexes.fetch(key)
+			types = @indexes_definitions.fetch(key)
 			type = types.first
 			Literal.check(actual: value, expected: type) { |c| raise NotImplementedError }
 
-			@index.fetch(key)[value]
+			@indexes.fetch(key)[value]
 		end
 
 		def find_by(**kwargs)
@@ -57,15 +67,15 @@ class Literal::Enum
 
 			key, value = kwargs.first
 
-			unless @indexes.fetch(key)[1]
+			unless @indexes_definitions.fetch(key)[1]
 				raise ArgumentError.new("You can only use `find_by` on unique indexes.")
 			end
 
-			unless (type = @indexes.fetch(key)[0]) === value
+			unless (type = @indexes_definitions.fetch(key)[0]) === value
 				raise Literal::TypeError.expected(value, to_be_a: type)
 			end
 
-			@index.fetch(key)[value]&.first
+			@indexes.fetch(key)[value]&.first
 		end
 
 		def _load(data)
@@ -77,12 +87,8 @@ class Literal::Enum
 			object = const_get(name)
 
 			if self === object
-				if @values.key?(object.value)
-					raise ArgumentError.new("The value #{object.value} is already used by #{@values[object.value].name}.")
-				end
-				object.instance_variable_set(:@name, name)
-				@values[object.value] = object
-				@members << object
+				# object.instance_variable_set(:@name, name)
+				@names[object] = name
 				define_method("#{name.to_s.gsub(/([^A-Z])([A-Z]+)/, '\1_\2').downcase}?") { self == object }
 				object.freeze
 			end
@@ -90,12 +96,21 @@ class Literal::Enum
 
 		def new(*args, **kwargs, &block)
 			raise ArgumentError if frozen?
+
 			new_object = super(*args, **kwargs, &nil)
 
-			if block
-				new_object.instance_exec(&block)
+			if @values.key?(new_object.value)
+				raise ArgumentError.new("The value #{new_object.value} is already used by #{@values[new_object.value].name}.")
 			end
 
+			@values[new_object.value] = new_object
+
+			new_object.instance_variable_set(:@__position__, @members.length)
+
+			@members << new_object
+
+			new_object.instance_exec(&block) if block
+
 			new_object
 		end
 
@@ -106,7 +121,7 @@ class Literal::Enum
 				constants(false).each { |name| const_added(name) }
 			end
 
-			@indexes.each do |name, (type, unique, block)|
+			@indexes_definitions.each do |name, (type, unique, block)|
 				index = @members.group_by(&block).freeze
 
 				index.each do |key, values|
@@ -119,7 +134,7 @@ class Literal::Enum
 					end
 				end
 
-				@index[name] = index
+				@indexes[name] = index
 			end
 
 			@values.freeze
@@ -149,8 +164,20 @@ class Literal::Enum
 			case value
 			when self
 				value
+			when Symbol
+				self[value] || begin
+					const_get(value)
+				rescue NameError
+					raise ArgumentError.new(
+						"Can't coerce #{value.inspect} into a #{inspect}."
+					)
+				end
 			else
-				self[value]
+				self[value] || raise(
+					ArgumentError.new(
+						"Can't coerce #{value.inspect} into a #{inspect}."
+					)
+				)
 			end
 		end
 
@@ -167,20 +194,13 @@ class Literal::Enum
 		end
 	end
 
-	def initialize(name, value, &block)
-		@name = name
-		@value = value
-		instance_exec(&block) if block
-		freeze
-	end
-
-	attr_reader :value
-
 	def name
-		"#{self.class.name}::#{@name}"
+		klass = self.class
+		"#{klass.name}::#{klass.names[self]}"
 	end
 
 	alias_method :inspect, :name
+	alias_method :to_s, :name
 
 	def deconstruct
 		[@value]
@@ -194,4 +214,27 @@ class Literal::Enum
 	def _dump(level)
 		Marshal.dump(@value)
 	end
+
+	def <=>(other)
+		case other
+		when self.class
+			@__position__ <=> other.__position__
+		else
+			raise ArgumentError.new("Can't compare instances of #{other.class} to instances of #{self.class}")
+		end
+	end
+
+	def succ
+		self.class.members[@__position__ + 1]
+	end
+
+	def pred
+		if @__position__ <= 0
+			nil
+		else
+			self.class.members[@__position__ - 1]
+		end
+	end
+
+	attr_reader :__position__
 end

data/lib/literal/failure.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Literal::Failure < Literal::Result
+	def initialize(error)
+		@error = error
+	end
+end

data/lib/literal/null.rb

@@ -5,5 +5,9 @@ module Literal::Null
 		"Literal::Null"
 	end
 
+	def self.===(value)
+		self == value
+	end
+
 	freeze
 end

data/lib/literal/property.rb

@@ -118,29 +118,18 @@ class Literal::Property
 			"\n  value\nend\n"
 	end
 
-	if Literal::TYPE_CHECKS_DISABLED
-		def generate_writer_method(buffer = +"")
-			buffer <<
-				(@writer ? @writer.name : "public") <<
-				" def " <<
-				@name.name <<
-				"=(value)\n" <<
-				"  @#{@name.name} = value\nend\n"
-		end
-	else # type checks are enabled
-		def generate_writer_method(buffer = +"")
-			buffer <<
-				(@writer ? @writer.name : "public") <<
-				" def " <<
-				@name.name <<
-				"=(value)\n" <<
-				"  self.class.literal_properties[:" <<
-				@name.name <<
-				"].check_writer(self, value)\n" <<
-				"  @" << @name.name << " = value\n" <<
-				"rescue Literal::TypeError => error\n  error.set_backtrace(caller(1))\n  raise\n" <<
-				"end\n"
-		end
+	def generate_writer_method(buffer = +"")
+		buffer <<
+			(@writer ? @writer.name : "public") <<
+			" def " <<
+			@name.name <<
+			"=(value)\n" <<
+			"  self.class.literal_properties[:" <<
+			@name.name <<
+			"].check_writer(self, value)\n" <<
+			"  @" << @name.name << " = value\n" <<
+			"rescue Literal::TypeError => error\n  error.set_backtrace(caller(1))\n  raise\n" <<
+			"end\n"
 	end
 
 	def generate_predicate_method(buffer = +"")
@@ -171,10 +160,7 @@ class Literal::Property
 			generate_initializer_coerce_property(buffer)
 		end
 
-		unless Literal::TYPE_CHECKS_DISABLED
-			generate_initializer_check_type(buffer)
-		end
-
+		generate_initializer_check_type(buffer)
 		generate_initializer_assign_value(buffer)
 	end
 

data/lib/literal/rails/enum_type.rb

@@ -8,10 +8,10 @@ class Literal::Rails::EnumType < ActiveModel::Type::Value
 
 	def cast(value)
 		case value
-		when @enum
-			value
+		when nil
+			nil
 		else
-			deserialize(value)
+			@enum.coerce(value)
 		end
 	end
 
@@ -19,12 +19,8 @@ class Literal::Rails::EnumType < ActiveModel::Type::Value
 		case value
 		when nil
 			nil
-		when @enum
-			value.value
 		else
-			raise Literal::ArgumentError.new(
-				"Invalid value: #{value.inspect}. Expected an #{@enum.inspect}.",
-			)
+			@enum.coerce(value).value
 		end
 	end
 
@@ -33,9 +29,7 @@ class Literal::Rails::EnumType < ActiveModel::Type::Value
 		when nil
 			nil
 		else
-			@enum[value] || raise(
-				ArgumentError.new("Invalid value: #{value.inspect} for #{@enum}"),
-			)
+			@enum.coerce(value)
 		end
 	end
 end

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

@@ -4,9 +4,10 @@ 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,
+				raise Literal::TypeError.new(
+					context: Literal::TypeError::Context.new(
+						expected: ActiveRecord::Base, actual: model_class
+					)
 				)
 			end
 

data/lib/literal/railtie.rb

@@ -2,20 +2,14 @@
 
 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
-
-		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)
+		[ActiveRecord::Type, ActiveModel::Type].each do |registry|
+			registry.register(:literal_enum) do |name, type:|
+				Literal::Rails::EnumType.new(type)
+			end
+
+			registry.register(:literal_flags) do |name, type:|
+				Literal::Rails::FlagsType.new(type)
+			end
 		end
 	end
 end

data/lib/literal/result.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class Literal::Result
+end

data/lib/literal/success.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Literal::Success < Literal::Result
+	def initialize(value)
+		@value = value
+	end
+end

data/lib/literal/transforms.rb

@@ -54,6 +54,7 @@ Literal::TRANSFORMS = {
 		to_str: String,
 		upcase: String,
 		valid_encoding?: Literal::Types::BooleanType::Instance,
+		to_i: Integer,
 	},
 	Numeric => {
 		to_i: Integer,

data/lib/literal/tuple.rb

@@ -56,5 +56,17 @@ class Literal::Tuple
 		@__types__ = types
 	end
 
+	def inspect
+		"Literal::Tuple(#{@__types__.map(&:inspect).join(', ')})#{@__values__.inspect}"
+	end
+
 	attr_reader :__values__, :__types__
+
+	def ==(other)
+		(Literal::Tuple === other) && (@__values__ == other.__values__)
+	end
+
+	def [](index)
+		@__values__[index]
+	end
 end

data/lib/literal/types/constraint_type.rb

@@ -25,14 +25,19 @@ class Literal::Types::ConstraintType
 			i += 1
 		end
 
+		result = true
+
 		@property_constraints.each do |a, t|
-			return false unless t === value.public_send(a)
+			# We intentionally don’t return early here becuase it triggers an allocation.
+			if result && !(t === value.public_send(a))
+				result = false
+			end
 		rescue NoMethodError => e
 			raise unless e.name == a && e.receiver == value
 			return false
 		end
 
-		true
+		result
 	end
 
 	def >=(other)

data/lib/literal/types.rb

@@ -103,6 +103,19 @@ module Literal::Types
 		)
 	end
 
+	# Matches if the value is a `Date` and matches the given constraints.
+	# If you don't need any constraints, use `Date` instead of `_Date`.
+	def _Date(...)
+		_Constraint(Date, ...)
+	end
+
+	# Nilable version of `_Date`
+	def _Date?(...)
+		_Nilable(
+			_Date(...)
+		)
+	end
+
 	def _Deferred(...)
 		DeferredType.new(...)
 	end
@@ -324,6 +337,19 @@ module Literal::Types
 		)
 	end
 
+	# Matches if the value is a `Time` and matches the given constraints.
+	# If you don't need any constraints, use `Time` instead of `_Time`.
+	def _Time(...)
+		_Constraint(Time, ...)
+	end
+
+	# Nilable version of `_Time`
+	def _Time?(...)
+		_Nilable(
+			_Time(...)
+		)
+	end
+
 	# Matches *"truthy"* values (anything except `nil` and `false`).
 	def _Truthy
 		TruthyType::Instance

data/lib/literal/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Literal
-	VERSION = "1.4.0"
+	VERSION = "1.5.0"
 end

data/lib/literal.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 module Literal
-	TYPE_CHECKS_DISABLED = ENV["LITERAL_TYPE_CHECKS"] == "false"
-
 	autoload :Array, "literal/array"
 	autoload :Data, "literal/data"
 	autoload :DataProperty, "literal/data_property"
@@ -33,7 +31,7 @@ module Literal
 
 	def self.Enum(type)
 		Class.new(Literal::Enum) do
-			prop :value, type, :positional
+			prop :value, type, :positional, reader: :public
 		end
 	end
 

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: literal
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Joel Drapper
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-10 00:00:00.000000000 Z
+date: 2025-01-17 00:00:00.000000000 Z
 dependencies: []
 description: Enums, properties, generics, structured objects and runtime type checking.
 email:
@@ -28,6 +27,7 @@ files:
 - lib/literal/errors/argument_error.rb
 - lib/literal/errors/error.rb
 - lib/literal/errors/type_error.rb
+- lib/literal/failure.rb
 - lib/literal/flags.rb
 - lib/literal/hash.rb
 - lib/literal/null.rb
@@ -42,8 +42,10 @@ files:
 - lib/literal/rails/flags_type.rb
 - lib/literal/rails/patches/active_record.rb
 - lib/literal/railtie.rb
+- lib/literal/result.rb
 - lib/literal/set.rb
 - lib/literal/struct.rb
+- lib/literal/success.rb
 - lib/literal/transforms.rb
 - lib/literal/tuple.rb
 - lib/literal/type.rb
@@ -81,7 +83,6 @@ metadata:
   changelog_uri: https://github.com/joeldrapper/literal/releases
   funding_uri: https://github.com/sponsors/joeldrapper
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -96,8 +97,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.18
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Enums, properties, generics, structured objects and runtime type checking.
 test_files: []