literal 0.2.1 → 1.0.0.rc1

data/lib/literal/types.rb

@@ -33,68 +33,144 @@ module Literal::Types
 	autoload :UnionType, "literal/types/union_type"
 	autoload :VoidType, "literal/types/void_type"
 
-	# Matches any value except `nil`. Use `_Nilable(_Any)` or `_Void` to match any value including `nil`.
+	NilableBooleanType = NilableType.new(BooleanType)
+	NilableCallableType = NilableType.new(CallableType)
+	NilableJSONDataType = NilableType.new(JSONDataType)
+	NilableLambdaType = NilableType.new(LambdaType)
+	NilableProcableType = NilableType.new(ProcableType)
+
+	# Matches any value except `nil`. Use `_Any?` or `_Unit` to match any value including `nil`.
 	def _Any
-		Literal::Types::AnyType
+		AnyType
+	end
+
+	def _Any?
+		VoidType
 	end
 
 	# Matches if the value is an `Array` and all the elements match the given type.
 	def _Array(...)
-		Literal::Types::ArrayType.new(...)
+		ArrayType.new(...)
+	end
+
+	# Nilable version of `_Array`
+	def _Array?(...)
+		NilableType.new(
+			ArrayType.new(...),
+		)
 	end
 
 	# Matches if the value is `true` or `false`.
 	def _Boolean
-		Literal::Types::BooleanType
+		BooleanType
+	end
+
+	# Nilable version of `_Boolean`
+	def _Boolean?
+		NilableBooleanType
 	end
 
 	# Matches if the value responds to `#call`.
 	def _Callable
-		Literal::Types::CallableType
+		CallableType
+	end
+
+	# Nilabl version of `_Callable`
+	def _Callable?
+		NilableCallableType
 	end
 
 	# Matches if the value either the given class or a subclass of it.
 	def _Class(...)
-		Literal::Types::ClassType.new(...)
+		ClassType.new(...)
+	end
+
+	# Nilable version of `_Class`
+	def _Class?(...)
+		NilableType.new(
+			ClassType.new(...),
+		)
 	end
 
 	# Similar to `_Intersection`, but allows you to specify attribute constraints as keyword arguments.
 	# @example
 	# 	_Constraint(Array, size: 1..3)
 	def _Constraint(...)
-		Literal::Types::ConstraintType.new(...)
+		ConstraintType.new(...)
+	end
+
+	# Nilable version of `_Constraint`
+	def _Constraint?(...)
+		NilableType.new(
+			ConstraintType.new(...),
+		)
 	end
 
 	# Matches if the value is a descendant of the given class.
 	def _Descendant(...)
-		Literal::Types::DescendantType.new(...)
+		DescendantType.new(...)
+	end
+
+	# Nilable version of `_Descendant`
+	def _Descendant?(...)
+		NilableType.new(
+			DescendantType.new(...),
+		)
 	end
 
 	#  Matches if the value is an `Enumerable` and all its elements match the given type.
 	def _Enumerable(...)
-		Literal::Types::EnumerableType.new(...)
+		EnumerableType.new(...)
+	end
+
+	# Nilable version of `_Enumerable`
+	def _Enumerable?(...)
+		NilableType.new(
+			EnumerableType.new(...),
+		)
 	end
 
 	# Matches *"falsy"* values (`nil` and `false`).
 	def _Falsy
-		Literal::Types::FalsyType
+		FalsyType
 	end
 
 	# Matches if the value is a `Float` and matches the given constraint.
 	# You could use a `Range`, for example, as a constraint.
 	# If you don't need a constraint, use `Float` instead of `_Float`.
 	def _Float(...)
-		Literal::Types::FloatType.new(...)
+		FloatType.new(...)
+	end
+
+	# Nilable version of `_Float`
+	def _Float?(...)
+		NilableType.new(
+			FloatType.new(...),
+		)
 	end
 
 	# Matches if the value is *frozen*.
 	def _Frozen(...)
-		Literal::Types::FrozenType.new(...)
+		FrozenType.new(...)
+	end
+
+	# Nilable version of `_Frozen`
+	def _Frozen?(...)
+		NilableType.new(
+			FrozenType.new(...),
+		)
 	end
 
 	# Matches if the value is a `Hash` and all the keys and values match the given types.
 	def _Hash(...)
-		Literal::Types::HashType.new(...)
+		HashType.new(...)
+	end
+
+	# Nilable version of `_Hash`
+	def _Hash?
+		NilableType.new(
+			HashType.new,
+		)
 	end
 
 	# Matches if the value is an `Integer` and matches the given constraint.
@@ -103,95 +179,189 @@ module Literal::Types
 	# @example
 	# 	attribute :age, _Integer(18..127)
 	def _Integer(...)
-		Literal::Types::IntegerType.new(...)
+		IntegerType.new(...)
+	end
+
+	# Nilable version of `_Integer`
+	def _Integer?(...)
+		NilableType.new(
+			IntegerType(...),
+		)
 	end
 
 	# Matches if the value responds to all the given methods.
 	def _Interface(...)
-		Literal::Types::InterfaceType.new(...)
+		InterfaceType.new(...)
+	end
+
+	# Nilable version of `_Interface`
+	def _Interface?(...)
+		NilableType.new(
+			InterfaceType.new(...),
+		)
 	end
 
 	# Matches if *all* given types are matched.
 	def _Intersection(...)
-		Literal::Types::IntersectionType.new(...)
+		IntersectionType.new(...)
+	end
+
+	# Nilable version of `_Intersection`
+	def _Intersection?(...)
+		NilableType.new(
+			IntersectionType.new(...),
+		)
 	end
 
 	# Ensures the value is valid JSON data (i.e. it came from JSON.parse).
 	def _JSONData
-		Literal::Types::JSONDataType
+		JSONDataType
+	end
+
+	# Nilable version of `_JSONData`
+	def _JSONData?
+		NilableJSONDataType
 	end
 
 	# Matches if the value is a `Proc` and `#lambda?` returns truthy.
 	def _Lambda
-		Literal::Types::LambdaType
+		LambdaType
+	end
+
+	# Nilable version of `_Lambda`
+	def _Lambda?
+		NilableLambdaType
 	end
 
 	def _Map(...)
-		Literal::Types::MapType.new(...)
+		MapType.new(...)
+	end
+
+	# Nilable version of `_Map`
+	def _Map?(...)
+		NilableType.new(
+			MapType.new(...),
+		)
 	end
 
 	# Never matches any value.
 	def _Never
-		Literal::Types::NeverType
+		NeverType
 	end
 
 	# Matches if the value is either `nil` or the given type.
 	def _Nilable(...)
-		Literal::Types::NilableType.new(...)
+		NilableType.new(...)
 	end
 
 	# Matches if the given type is *not* matched.
 	def _Not(...)
-		Literal::Types::NotType.new(...)
+		NotType.new(...)
 	end
 
 	# Matches if the value is a `Proc` or responds to `#to_proc`.
 	def _Procable
-		Literal::Types::ProcableType
+		ProcableType
+	end
+
+	# Nilable version ofo `_Procable`
+	def _Procable?
+		NilableProcableType
 	end
 
 	# Matches if the value is a `Range` of the given type.
 	def _Range(...)
-		Literal::Types::RangeType.new(...)
+		RangeType.new(...)
+	end
+
+	# Nilable version of `_Range`
+	def _Range?(...)
+		NilableType.new(
+			RangeType.new(...),
+		)
 	end
 
 	# Matches if the value is a `Set` and all the elements match the given type.
 	def _Set(...)
-		Literal::Types::SetType.new(...)
+		SetType.new(...)
+	end
+
+	# Nilable version of `_Set`
+	def _Set?(...)
+		NilableType.new(
+			SetType.new(...),
+		)
 	end
 
 	# Ensures a value matches the given shape of a Hash
 	def _Shape(...)
-		Literal::Types::ShapeType.new(...)
+		ShapeType.new(...)
+	end
+
+	# Nilable version of `_Shape`
+	def _Shape?(...)
+		NilableType.new(
+			ShapeType.new(...),
+		)
 	end
 
+	# Nilable version of `_Shape`
+
 	# Matches if the value is a `String` and matches the given constraints.
 	# If you don't need any constraints, use `String` instead of `_String`.
 	def _String(...)
-		Literal::Types::StringType.new(...)
+		StringType.new(...)
+	end
+
+	# Nilable version of `_String`
+	def _String?(...)
+		NilableType.new(
+			StringType.new(...),
+		)
 	end
 
 	# Matches if the value is a `Symbol` and matches the given constraint.
 	def _Symbol(...)
-		Literal::Types::SymbolType.new(...)
+		SymbolType.new(...)
+	end
+
+	# Nilable version of `_Symbol`
+	def _Symbol?(...)
+		NilableType.new(
+			SymbolType.new(...),
+		)
 	end
 
 	# Matches *"truthy"* values (anything except `nil` and `false`).
 	def _Truthy
-		Literal::Types::TruthyType
+		TruthyType
 	end
 
 	# Matches if the value is an `Array` and each element matches the given types in order.
 	def _Tuple(...)
-		Literal::Types::TupleType.new(...)
+		TupleType.new(...)
+	end
+
+	# Nilable version of `_Typle`
+	def _Tuple?(...)
+		NilableType.new(
+			TupleType.new(...),
+		)
 	end
 
 	# Matches if *any* given type is matched.
 	def _Union(...)
-		Literal::Types::UnionType.new(...)
+		UnionType.new(...)
+	end
+
+	# Nilable version of `_Union`
+	def _Union?(...)
+		NilableType.new(
+			UnionType.new(...),
+		)
 	end
 
 	def _Void
-		Literal::Types::VoidType
+		VoidType
 	end
 end

data/lib/literal/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Literal
-	VERSION = "0.2.1"
+	VERSION = "1.0.0.rc1"
 end

data/lib/literal.rb

@@ -25,11 +25,16 @@ module Literal
 		end
 	end
 
-	def self.check(value, type)
-		if TYPE_CHECKS_DISABLED || type === value
+	def self.check(actual:, expected:)
+		if expected === actual
 			true
 		else
-			raise Literal::TypeError.expected(value, to_be_a: type)
+			context = Literal::TypeError::Context.new(expected:, actual:)
+			expected.record_literal_type_errors(context) if expected.respond_to?(:record_literal_type_errors)
+			yield context if block_given?
+			raise Literal::TypeError.new(context:)
 		end
 	end
 end
+
+require_relative "literal/rails" if defined?(Rails)

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: literal
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 1.0.0.rc1
 platform: ruby
 authors:
 - Joel Drapper
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-06-30 00:00:00.000000000 Z
+date: 2024-10-26 00:00:00.000000000 Z
 dependencies: []
-description: ''
+description: Enums, properties, generics, structured objects.
 email:
 - joel@drapper.me
 executables: []
@@ -20,7 +20,6 @@ files:
 - LICENSE.txt
 - README.md
 - lib/literal.rb
-- lib/literal.test.rb
 - lib/literal/data.rb
 - lib/literal/data_property.rb
 - lib/literal/data_structure.rb
@@ -34,6 +33,11 @@ files:
 - lib/literal/properties/data_schema.rb
 - lib/literal/properties/schema.rb
 - lib/literal/property.rb
+- lib/literal/rails.rb
+- lib/literal/rails/enum_serializer.rb
+- lib/literal/rails/enum_type.rb
+- lib/literal/rails/patches/active_record.rb
+- lib/literal/railtie.rb
 - lib/literal/struct.rb
 - lib/literal/types.rb
 - lib/literal/types/any_type.rb
@@ -91,8 +95,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.13
+rubygems_version: 3.5.18
 signing_key:
 specification_version: 4
-summary: A literal Ruby gem
+summary: A literal Ruby gem.
 test_files: []

data/lib/literal.test.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-test do
-	expect(Literal::VERSION).to_be_a String
-end