literal 0.1.0 → 0.2.0

data/lib/literal/types/never_type.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# @api private
+module Literal::Types::NeverType
+	def self.inspect = "_Never"
+
+	def self.===(value)
+		false
+	end
+
+	freeze
+end

data/lib/literal/types/nilable_type.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# @api private
+class Literal::Types::NilableType
+	def initialize(type)
+		@type = type
+	end
+
+	def inspect = "_Nilable(#{@type.inspect})"
+
+	def ===(value)
+		nil === value || @type === value
+	end
+end

data/lib/literal/types/not_type.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# @api private
+class Literal::Types::NotType
+	def initialize(type)
+		@type = type
+	end
+
+	def inspect = "_Not(#{@type.inspect})"
+
+	def ===(value)
+		!(@type === value)
+	end
+end

data/lib/literal/types/procable_type.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# @api private
+module Literal::Types::ProcableType
+	def self.inspect = "_Procable"
+
+	def self.===(value)
+		Proc === value || value.respond_to?(:to_proc)
+	end
+
+	freeze
+end

data/lib/literal/types/range_type.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# @api private
+class Literal::Types::RangeType
+	def initialize(type)
+		@type = type
+	end
+
+	def inspect = "_Range(#{@type.inspect})"
+
+	def ===(value)
+		Range === value && (
+			(
+				@type === value.begin && (nil === value.end || @type === value.end)
+			) || (
+				@type === value.end && nil === value.begin
+			)
+		)
+	end
+end

data/lib/literal/types/set_type.rb

@@ -1,13 +1,14 @@
+# frozen_string_literal: true
+
+# @api private
 class Literal::Types::SetType
-  def initialize(type)
-    @type = type
-  end
+	def initialize(type)
+		@type = type
+	end
 
-  def inspect
-    "Set(#{@type.inspect})"
-  end
+	def inspect = "_Set(#{@type.inspect})"
 
-  def ===(value)
-    value.is_a?(::Set) && value.all? { |item| @type === item }
-  end
+	def ===(value)
+		Set === value && value.all? { |item| @type === item }
+	end
 end

data/lib/literal/types/string_type.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# @api private
+class Literal::Types::StringType < Literal::Types::ConstraintType
+	def inspect = "_String(#{@constraint.inspect})"
+
+	def ===(value)
+		String === value && super
+	end
+end

data/lib/literal/types/symbol_type.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# @api private
+class Literal::Types::SymbolType < Literal::Types::ConstraintType
+	def inspect = "_Symbol(#{@constraint.inspect})"
+
+	def ===(value)
+		Symbol === value && super
+	end
+end

data/lib/literal/types/truthy_type.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# @api private
+module Literal::Types::TruthyType
+	def self.inspect = "_Truthy"
+
+	def self.===(value)
+		!!value
+	end
+
+	freeze
+end

data/lib/literal/types/tuple_type.rb

@@ -1,13 +1,16 @@
+# frozen_string_literal: true
+
+# @api private
 class Literal::Types::TupleType
-  def initialize(*types)
-    @types = types
-  end
+	def initialize(*types)
+		raise Literal::ArgumentError.new("_Tuple type must have at least one type.") if types.size < 1
+
+		@types = types
+	end
 
-  def inspect
-    "Tuple(#{@types.map(&:inspect).join(", ")})"
-  end
+	def inspect = "_Tuple(#{@types.map(&:inspect).join(', ')})"
 
-  def ===(value)
-    value.is_a?(::Enumerable) && value.size == @types.size && value.zip(@types).all? { |value, type| type === value }
-  end
+	def ===(value)
+		Array === value && value.size == @types.size && @types.each_with_index.all? { |t, i| t === value[i] }
+	end
 end

data/lib/literal/types/union_type.rb

@@ -1,13 +1,47 @@
+# frozen_string_literal: true
+
 class Literal::Types::UnionType
-  def initialize(*types)
-    @types = types
-  end
+	include Enumerable
+
+	def initialize(*types)
+		raise Literal::ArgumentError.new("_Union type must have at least one type.") if types.size < 1
+
+		@types = Set[]
+		load_types(types)
+		@types.freeze
+	end
+
+	def inspect = "_Union(#{@types.inspect})"
+
+	def ===(value)
+		@types.any? { |type| type === value }
+	end
+
+	def each(&)
+		@types.each(&)
+	end
+
+	def deconstruct
+		@types.to_a
+	end
+
+	def [](key)
+		if @types.include?(key)
+			key
+		else
+			raise ArgumentError.new("#{key} not in #{inspect}")
+		end
+	end
+
+	protected
+
+	attr_reader :types
 
-  def inspect
-    "Union(#{@types.map(&:inspect).join(", ")})"
-  end
+	private
 
-  def ===(value)
-    @types.any? { |type| type === value }
-  end
+	def load_types(types)
+		types.each do |type|
+			(Literal::Types::UnionType === type) ? load_types(type.types) : @types << type
+		end
+	end
 end

data/lib/literal/types/void_type.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# @api private
+module Literal::Types::VoidType
+	def self.inspect = "_Void"
+
+	def self.===(_)
+		true
+	end
+
+	freeze
+end

data/lib/literal/types.rb

@@ -1,56 +1,197 @@
+# frozen_string_literal: true
+
 module Literal::Types
-  def _Union(*types)
-    raise Literal::ArgumentError, "Union type must have at least two types." if types.size < 2
-    Literal::Types::UnionType.new(*types)
-  end
-
-  def _Array(type)
-    Literal::Types::ArrayType.new(type)
-  end
-
-  def _Set(type)
-    Literal::Types::SetType.new(type)
-  end
-
-  def _Enumerable(type)
-    Literal::Types::EnumerableType.new(type)
-  end
-
-  def _Hash(key_type, value_type)
-    Literal::Types::HashType.new(key_type, value_type)
-  end
-
-  def _Interface(*methods)
-    raise Literal::ArgumentError, "Interface type must have at least one method." if methods.size < 1
-    Literal::Types::InterfaceType.new(*methods)
-  end
-
-  def _Maybe(type)
-    _Union(type, nil)
-  end
-
-  def _Any
-    Literal::Types::AnyType
-  end
-
-  def _Boolean
-    Literal::Types::BooleanType
-  end
-
-  def _Class(type)
-    Literal::Types::ClassType.new(type)
-  end
-
-  def _Tuple(*types)
-    raise Literal::ArgumentError, "Tuple type must have at least one type." if types.size < 1
-    Literal::Types::TupleType.new(*types)
-  end
-
-  def _Integer(range)
-    Literal::Types::IntegerType.new(range)
-  end
-
-  def _Float(range)
-    Literal::Types::FloatType.new(range)
-  end
+	autoload :AnyType, "literal/types/any_type"
+	autoload :ArrayType, "literal/types/array_type"
+	autoload :BooleanType, "literal/types/boolean_type"
+	autoload :CallableType, "literal/types/callable_type"
+	autoload :ClassType, "literal/types/class_type"
+	autoload :ConstraintType, "literal/types/constraint_type"
+	autoload :DescendantType, "literal/types/descendant_type"
+	autoload :EnumerableType, "literal/types/enumerable_type"
+	autoload :FalsyType, "literal/types/falsy_type"
+	autoload :FloatType, "literal/types/float_type"
+	autoload :FrozenType, "literal/types/frozen_type"
+	autoload :HashType, "literal/types/hash_type"
+	autoload :IntegerType, "literal/types/integer_type"
+	autoload :InterfaceType, "literal/types/interface_type"
+	autoload :IntersectionType, "literal/types/intersection_type"
+	autoload :JSONDataType, "literal/types/json_data_type"
+	autoload :LambdaType, "literal/types/lambda_type"
+	autoload :MapType, "literal/types/map_type"
+	autoload :NeverType, "literal/types/never_type"
+	autoload :NilableType, "literal/types/nilable_type"
+	autoload :NotType, "literal/types/not_type"
+	autoload :ProcableType, "literal/types/procable_type"
+	autoload :RangeType, "literal/types/range_type"
+	autoload :SetType, "literal/types/set_type"
+	autoload :ShapeType, "literal/types/shape_type"
+	autoload :StringType, "literal/types/string_type"
+	autoload :SymbolType, "literal/types/symbol_type"
+	autoload :TruthyType, "literal/types/truthy_type"
+	autoload :TupleType, "literal/types/tuple_type"
+	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`.
+	def _Any
+		Literal::Types::AnyType
+	end
+
+	# Matches if the value is an `Array` and all the elements match the given type.
+	def _Array(...)
+		Literal::Types::ArrayType.new(...)
+	end
+
+	# Matches if the value is `true` or `false`.
+	def _Boolean
+		Literal::Types::BooleanType
+	end
+
+	# Matches if the value responds to `#call`.
+	def _Callable
+		Literal::Types::CallableType
+	end
+
+	# Matches if the value either the given class or a subclass of it.
+	def _Class(...)
+		Literal::Types::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(...)
+	end
+
+	# Matches if the value is a descendant of the given class.
+	def _Descendant(...)
+		Literal::Types::DescendantType.new(...)
+	end
+
+	#  Matches if the value is an `Enumerable` and all its elements match the given type.
+	def _Enumerable(...)
+		Literal::Types::EnumerableType.new(...)
+	end
+
+	# Matches *"falsy"* values (`nil` and `false`).
+	def _Falsy
+		Literal::Types::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(...)
+	end
+
+	# Matches if the value is *frozen*.
+	def _Frozen(...)
+		Literal::Types::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(...)
+	end
+
+	# Matches if the value is an `Integer` and matches the given constraint.
+	# You could use a `Range`, for example, as a constraint.
+	# If you don't need a constraint, use `Integer` instead of `_Integer`.
+	# @example
+	# 	attribute :age, _Integer(18..127)
+	def _Integer(...)
+		Literal::Types::IntegerType.new(...)
+	end
+
+	# Matches if the value responds to all the given methods.
+	def _Interface(...)
+		Literal::Types::InterfaceType.new(...)
+	end
+
+	# Matches if *all* given types are matched.
+	def _Intersection(...)
+		Literal::Types::IntersectionType.new(...)
+	end
+
+	# Ensures the value is valid JSON data (i.e. it came from JSON.parse).
+	def _JSONData
+		Literal::Types::JSONDataType
+	end
+
+	# Matches if the value is a `Proc` and `#lambda?` returns truthy.
+	def _Lambda
+		Literal::Types::LambdaType
+	end
+
+	def _Map(...)
+		Literal::Types::MapType.new(...)
+	end
+
+	# Never matches any value.
+	def _Never
+		Literal::Types::NeverType
+	end
+
+	# Matches if the value is either `nil` or the given type.
+	def _Nilable(...)
+		Literal::Types::NilableType.new(...)
+	end
+
+	# Matches if the given type is *not* matched.
+	def _Not(...)
+		Literal::Types::NotType.new(...)
+	end
+
+	# Matches if the value is a `Proc` or responds to `#to_proc`.
+	def _Procable
+		Literal::Types::ProcableType
+	end
+
+	# Matches if the value is a `Range` of the given type.
+	def _Range(...)
+		Literal::Types::RangeType.new(...)
+	end
+
+	# Matches if the value is a `Set` and all the elements match the given type.
+	def _Set(...)
+		Literal::Types::SetType.new(...)
+	end
+
+	# Ensures a value matches the given shape of a Hash
+	def _Shape(...)
+		Literal::Types::ShapeType.new(...)
+	end
+
+	# 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(...)
+	end
+
+	# Matches if the value is a `Symbol` and matches the given constraint.
+	def _Symbol(...)
+		Literal::Types::SymbolType.new(...)
+	end
+
+	# Matches *"truthy"* values (anything except `nil` and `false`).
+	def _Truthy
+		Literal::Types::TruthyType
+	end
+
+	# Matches if the value is an `Array` and each element matches the given types in order.
+	def _Tuple(...)
+		Literal::Types::TupleType.new(...)
+	end
+
+	# Matches if *any* given type is matched.
+	def _Union(...)
+		Literal::Types::UnionType.new(...)
+	end
+
+	def _Void
+		Literal::Types::VoidType
+	end
 end

data/lib/literal/version.rb

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

data/lib/literal.rb

@@ -1,17 +1,35 @@
 # frozen_string_literal: true
 
-require_relative "literal/version"
-
 module Literal
-  Loader = Zeitwerk::Loader.for_gem.tap(&:setup)
+	TYPE_CHECKS_DISABLED = ENV["LITERAL_TYPE_CHECKS"] == "false"
+
+	autoload :Data, "literal/data"
+	autoload :DataProperty, "literal/data_property"
+	autoload :DataStructure, "literal/data_structure"
+	autoload :Enum, "literal/enum"
+	autoload :Null, "literal/null"
+	autoload :Object, "literal/object"
+	autoload :Properties, "literal/properties"
+	autoload :Property, "literal/property"
+	autoload :Struct, "literal/struct"
+	autoload :Types, "literal/types"
 
-  module Error; end
+	# Errors
+	autoload :Error, "literal/errors/error"
+	autoload :TypeError, "literal/errors/type_error"
+	autoload :ArgumentError, "literal/errors/argument_error"
 
-  class TypeError < ::TypeError
-    include Error
-  end
+	def self.Enum(type)
+		Class.new(Literal::Enum) do
+			prop :value, type, :positional
+		end
+	end
 
-  class ArgumentError < ::ArgumentError
-    include Error
-  end
+	def self.check(value, type)
+		if TYPE_CHECKS_DISABLED || type === value
+			true
+		else
+			raise Literal::TypeError.expected(value, to_be_a: type)
+		end
+	end
 end

data/lib/literal.test.rb

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

metadata

@@ -1,58 +1,81 @@
 --- !ruby/object:Gem::Specification
 name: literal
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Joel Drapper
 autorequire:
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2023-05-03 00:00:00.000000000 Z
+date: 2024-06-30 00:00:00.000000000 Z
 dependencies: []
-description: Strict Attributes is a gem that allows you to define strict attributes
-  on your models.
+description: ''
 email:
 - joel@drapper.me
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- CHANGELOG.md
-- CODE_OF_CONDUCT.md
-- Gemfile
-- Gemfile.lock
 - LICENSE.txt
 - README.md
-- Rakefile
 - lib/literal.rb
-- lib/literal/attributes.rb
+- lib/literal.test.rb
 - lib/literal/data.rb
-- lib/literal/initializer.rb
-- lib/literal/model.rb
+- lib/literal/data_property.rb
+- lib/literal/data_structure.rb
+- lib/literal/enum.rb
+- lib/literal/errors/argument_error.rb
+- lib/literal/errors/error.rb
+- lib/literal/errors/type_error.rb
+- lib/literal/null.rb
+- lib/literal/object.rb
+- lib/literal/properties.rb
+- lib/literal/properties/data_schema.rb
+- lib/literal/properties/schema.rb
+- lib/literal/property.rb
 - lib/literal/struct.rb
 - lib/literal/types.rb
 - lib/literal/types/any_type.rb
 - lib/literal/types/array_type.rb
 - lib/literal/types/boolean_type.rb
+- lib/literal/types/callable_type.rb
 - lib/literal/types/class_type.rb
+- lib/literal/types/constraint_type.rb
+- lib/literal/types/descendant_type.rb
 - lib/literal/types/enumerable_type.rb
+- lib/literal/types/falsy_type.rb
 - lib/literal/types/float_type.rb
+- lib/literal/types/frozen_type.rb
 - lib/literal/types/hash_type.rb
 - lib/literal/types/integer_type.rb
 - lib/literal/types/interface_type.rb
+- lib/literal/types/intersection_type.rb
+- lib/literal/types/json_data_type.rb
+- lib/literal/types/lambda_type.rb
+- lib/literal/types/map_type.rb
+- lib/literal/types/never_type.rb
+- lib/literal/types/nilable_type.rb
+- lib/literal/types/not_type.rb
+- lib/literal/types/procable_type.rb
+- lib/literal/types/range_type.rb
 - lib/literal/types/set_type.rb
+- lib/literal/types/string_type.rb
+- lib/literal/types/symbol_type.rb
+- lib/literal/types/truthy_type.rb
 - lib/literal/types/tuple_type.rb
 - lib/literal/types/union_type.rb
+- lib/literal/types/void_type.rb
 - lib/literal/version.rb
-- literal.gemspec
 homepage: https://github.com/joeldrapper/literal
 licenses:
 - MIT
 metadata:
   homepage_uri: https://github.com/joeldrapper/literal
   source_code_uri: https://github.com/joeldrapper/literal
-  changelog_uri: https://github.com/joeldrapper/literal/blob/master/CHANGELOG.md
+  changelog_uri: https://github.com/joeldrapper/literal/blob/main/CHANGELOG.md
+  funding_uri: https://github.com/sponsors/joeldrapper
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -61,16 +84,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.6
+rubygems_version: 3.5.13
 signing_key:
 specification_version: 4
-summary: Strict Attributes is a gem that allows you to define strict attributes on
-  your models.
+summary: A literal Ruby gem
 test_files: []

data/CHANGELOG.md

@@ -1,5 +0,0 @@
-## [Unreleased]
-
-## [0.1.0] - 2023-05-03
-
-- Initial release