literal 0.1.0 → 0.2.0

data/lib/literal/properties.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Literal::Properties
+	autoload :Schema, "literal/properties/schema"
+	autoload :DataSchema, "literal/properties/data_schema"
+
+	include Literal::Types
+
+	def prop(name, type, kind = :keyword, reader: false, writer: false, predicate: false, default: nil, &coercion)
+		if default && !(Proc === default || default.frozen?)
+			raise Literal::ArgumentError.new("The default must be a frozen object or a Proc.")
+		end
+
+		unless Literal::Property::VISIBILITY_OPTIONS.include?(reader)
+			raise Literal::ArgumentError.new("The reader must be one of #{Literal::Property::VISIBILITY_OPTIONS.map(&:inspect).join(', ')}.")
+		end
+
+		unless Literal::Property::VISIBILITY_OPTIONS.include?(writer)
+			raise Literal::ArgumentError.new("The writer must be one of #{Literal::Property::VISIBILITY_OPTIONS.map(&:inspect).join(', ')}.")
+		end
+
+		unless Literal::Property::VISIBILITY_OPTIONS.include?(predicate)
+				raise Literal::ArgumentError.new("The predicate must be one of #{Literal::Property::VISIBILITY_OPTIONS.map(&:inspect).join(', ')}.")
+		end
+
+		if reader && :class == name
+			raise Literal::ArgumentError.new(
+				"The `:class` property should not be defined as a reader because it breaks Ruby's `Object#class` method, which Literal itself depends on.",
+			)
+		end
+
+		unless Literal::Property::KIND_OPTIONS.include?(kind)
+			raise Literal::ArgumentError.new("The kind must be one of #{Literal::Property::KIND_OPTIONS.map(&:inspect).join(', ')}.")
+		end
+
+		property = __literal_property_class__.new(
+			name:,
+			type:,
+			kind:,
+			reader:,
+			writer:,
+			predicate:,
+			default:,
+			coercion:,
+		)
+
+		literal_properties << property
+		__define_literal_methods__(property)
+		include(__literal_extension__)
+	end
+
+	def literal_properties
+		return @literal_properties if defined?(@literal_properties)
+
+		if superclass.is_a?(Literal::Properties)
+			@literal_properties = superclass.literal_properties.dup
+		else
+			@literal_properties = Literal::Properties::Schema.new
+		end
+	end
+
+	private
+
+	def __literal_property_class__
+		Literal::Property
+	end
+
+	def __define_literal_methods__(new_property)
+		__literal_extension__.module_eval(
+			__generate_literal_methods__(new_property),
+		)
+	end
+
+	def __literal_extension__
+		if defined?(@__literal_extension__)
+			@__literal_extension__
+		else
+			@__literal_extension__ = Module.new
+		end
+	end
+
+	def __generate_literal_methods__(new_property, buffer = +"")
+		buffer << "# frozen_string_literal: true\n"
+		literal_properties.generate_initializer(buffer)
+		literal_properties.generate_to_h(buffer)
+		new_property.generate_writer_method(buffer) if new_property.writer
+		new_property.generate_reader_method(buffer) if new_property.reader
+		new_property.generate_predicate_method(buffer) if new_property.predicate
+		buffer
+	end
+end

data/lib/literal/property.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+class Literal::Property
+	ORDER = { :positional => 0, :* => 1, :keyword => 2, :** => 3, :& => 4 }.freeze
+	RUBY_KEYWORDS = %i[alias and begin break case class def do else elsif end ensure false for if in module next nil not or redo rescue retry return self super then true undef unless until when while yield].to_h { |k| [k, "__#{k}__"] }.freeze
+
+	VISIBILITY_OPTIONS = Set[false, :private, :protected, :public].freeze
+	KIND_OPTIONS = Set[:positional, :*, :keyword, :**, :&].freeze
+
+	include Comparable
+
+	def initialize(name:, type:, kind:, reader:, writer:, predicate:, default:, coercion:)
+		@name = name
+		@type = type
+		@kind = kind
+		@reader = reader
+		@writer = writer
+		@predicate = predicate
+		@default = default
+		@coercion = coercion
+	end
+
+	attr_reader :name, :type, :kind, :reader, :writer, :predicate, :default, :coercion
+
+	def optional?
+		default? || @type === nil
+	end
+
+	def required?
+		!optional?
+	end
+
+	def keyword?
+		@kind == :keyword
+	end
+
+	def positional?
+		@kind == :positional
+	end
+
+	def splat?
+		@kind == :*
+	end
+
+	def double_splat?
+		@kind == :**
+	end
+
+	def block?
+		@kind == :&
+	end
+
+	def default?
+			nil != @default
+	end
+
+	def <=>(other)
+		ORDER[@kind] <=> ORDER[other.kind]
+	end
+
+	def coerce(value, context:)
+		context.instance_exec(value, &@coercion)
+	end
+
+	def ruby_keyword?
+		!!RUBY_KEYWORDS[@name]
+	end
+
+	def escaped_name
+		RUBY_KEYWORDS[@name] || @name.name
+	end
+
+	def default_value
+		case @default
+			when Proc then @default.call
+			else @default
+		end
+	end
+
+	def check(value)
+		Literal.check(value, @type)
+	end
+
+	def generate_reader_method(buffer = +"")
+		buffer <<
+			(@reader ? @reader.name : "public") <<
+			" def " <<
+			@name.name <<
+			"\nvalue = @" <<
+			@name.name <<
+			"\nvalue\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(value)\n" <<
+				"@#{@name.name} = value\nend\n"
+		end
+	end
+
+	def generate_predicate_method(buffer = +"")
+		buffer <<
+			(@predicate ? @predicate.name : "public") <<
+			" def " <<
+			@name.name <<
+			"?\n" <<
+			"!!@" <<
+			@name.name <<
+			"\n" <<
+			"end\n"
+	end
+
+	def generate_initializer_handle_property(buffer = +"")
+		buffer << "# " << @name.name << "\n" <<
+			"property = properties[:" << @name.name << "]\n"
+
+		if @kind == :keyword && ruby_keyword?
+			generate_initializer_escape_keyword(buffer)
+		end
+
+		if default?
+			generate_initializer_assign_default(buffer)
+		end
+
+		if @coercion
+			generate_initializer_coerce_property(buffer)
+		end
+
+		unless Literal::TYPE_CHECKS_DISABLED
+			generate_initializer_check_type(buffer)
+		end
+
+		generate_initializer_assign_value(buffer)
+	end
+
+	private
+
+	def generate_initializer_escape_keyword(buffer = +"")
+		buffer <<
+			escaped_name <<
+			" = binding.local_variable_get(:" <<
+			@name.name <<
+			")\n"
+	end
+
+	def generate_initializer_coerce_property(buffer = +"")
+		buffer <<
+			escaped_name <<
+			"= property.coerce(" <<
+			escaped_name <<
+			", context: self)\n"
+	end
+
+	def generate_initializer_assign_default(buffer = +"")
+		buffer <<
+			"if " <<
+			((@kind == :&) ? "nil" : "Literal::Null") <<
+			" == " <<
+			escaped_name <<
+			"\n" <<
+			escaped_name <<
+			" = property.default_value\nend\n"
+	end
+
+	def generate_initializer_check_type(buffer = +"")
+		buffer <<
+			"unless property.type === " << escaped_name << "\n" <<
+			"raise Literal::TypeError.expected(" << escaped_name << ", to_be_a: property.type)\n" <<
+			"end\n"
+	end
+
+	def generate_initializer_assign_value(buffer = +"")
+		buffer <<
+			"@" <<
+			@name.name <<
+			" = " <<
+			escaped_name <<
+			"\n"
+	end
+end

data/lib/literal/struct.rb

@@ -1,35 +1,9 @@
-class Literal::Struct
-  extend Literal::Types
-  include Literal::Initializer
-
-  def initialize(...)
-    @attributes = {}
-    super
-  end
-
-  def self.__attributes__
-    return @__attributes__ if defined?(@__attributes__)
-    @__attributes__ = superclass.is_a?(self) ? superclass.__attributes__.dup : []
-  end
-
-  def self.attribute(name, type, writer: :private)
-    __attributes__ << name
-
-    writer_name = :"#{name}="
-
-    define_method writer_name do |value|
-      raise Literal::TypeError, "Expected #{name}: `#{value.inspect}` to be: `#{type.inspect}`." unless type === value
-      @attributes[name] = value
-    end
-
-    define_method name do
-      @attributes[name]
-    end
-
-    name
-  end
-
-  def to_h
-    @attributes.dup
-  end
+# frozen_string_literal: true
+
+class Literal::Struct < Literal::DataStructure
+	class << self
+		def prop(name, type, kind = :keyword, reader: :public, writer: :public, default: nil)
+			super
+		end
+	end
 end

data/lib/literal/types/any_type.rb

@@ -1,5 +1,12 @@
+# frozen_string_literal: true
+
+# @api private
 module Literal::Types::AnyType
-  def self.===(value)
-    true
-  end
+	def self.inspect = "_Any"
+
+	def self.===(value)
+		!(nil === value)
+	end
+
+	freeze
 end

data/lib/literal/types/array_type.rb

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

data/lib/literal/types/boolean_type.rb

@@ -1 +1,18 @@
-Literal::Types::BooleanType = Literal::Types::UnionType.new(true, false)
+# frozen_string_literal: true
+
+# @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/callable_type.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# @api private
+module Literal::Types::CallableType
+	def self.inspect = "_Callable"
+
+	def self.===(value)
+		value.respond_to?(:call)
+	end
+
+	freeze
+end

data/lib/literal/types/class_type.rb

@@ -1,13 +1,14 @@
+# frozen_string_literal: true
+
+# @api private
 class Literal::Types::ClassType
-  def initialize(type)
-    @type = type
-  end
+	def initialize(type)
+		@type = type
+	end
 
-  def inspect
-    "Class(#{@type.name})"
-  end
+	def inspect = "_Class(#{@type.name})"
 
-  def ===(value)
-    value.is_a?(::Class) && (value == @type || value < @type)
-  end
+	def ===(value)
+		Class === value && (value == @type || value < @type)
+	end
 end

data/lib/literal/types/constraint_type.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# @api private
+class Literal::Types::ConstraintType
+	def initialize(*object_constraints, **property_constraints)
+		@object_constraints = object_constraints
+		@property_constraints = property_constraints
+	end
+
+	def inspect = "_Constraint(#{@object_constraints.inspect}, #{@property_constraints.inspect})"
+
+	def ===(value)
+		@object_constraints.all? { |t| t === value } &&
+			@property_constraints.all? { |a, t| t === value.public_send(a) }
+	end
+end

data/lib/literal/types/descendant_type.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class Literal::Types::DescendantType
+	def initialize(type)
+		@type = type
+	end
+
+	def inspect = "_Descendant(#{@type})"
+
+	def ===(value)
+		Module === value && value < @type
+	end
+end

data/lib/literal/types/enumerable_type.rb

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

data/lib/literal/types/falsy_type.rb

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

data/lib/literal/types/float_type.rb

@@ -1,13 +1,10 @@
-class Literal::Types::FloatType
-  def initialize(range)
-    @range = range
-  end
+# frozen_string_literal: true
 
-  def inspect
-    "Float(#{@range})"
-  end
+# @api private
+class Literal::Types::FloatType < Literal::Types::ConstraintType
+	def inspect = "_Float(#{@range})"
 
-  def ===(other)
-    other.is_a?(::Float) && @range === other
-  end
+	def ===(value)
+		Float === value && super
+	end
 end

data/lib/literal/types/frozen_type.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# @api private
+class Literal::Types::FrozenType
+	def initialize(type)
+		@type = type
+	end
+
+	def inspect = "_Frozen(#{@type.inspect})"
+
+	def ===(value)
+		value.frozen? && @type === value
+	end
+end

data/lib/literal/types/hash_type.rb

@@ -1,14 +1,15 @@
+# frozen_string_literal: true
+
+# @api private
 class Literal::Types::HashType
-  def initialize(key_type, value_type)
-    @key_type = key_type
-    @value_type = value_type
-  end
+	def initialize(key_type, value_type)
+		@key_type = key_type
+		@value_type = value_type
+	end
 
-  def inspect
-    "Hash(#{@key_type.inspect}, #{@value_type.inspect})"
-  end
+	def inspect = "_Hash(#{@key_type.inspect}, #{@value_type.inspect})"
 
-  def ===(value)
-    value.is_a?(::Hash) && value.all? { |key, value| @key_type === key && @value_type === value }
-  end
+	def ===(value)
+		Hash === value && value.all? { |k, v| @key_type === k && @value_type === v }
+	end
 end

data/lib/literal/types/integer_type.rb

@@ -1,13 +1,10 @@
-class Literal::Types::IntegerType
-  def initialize(range)
-    @range = range
-  end
+# frozen_string_literal: true
 
-  def inspect
-    "Integer(#{@range})"
-  end
+# @api private
+class Literal::Types::IntegerType < Literal::Types::ConstraintType
+	def inspect = "_Integer(#{@range})"
 
-  def ===(other)
-    other.is_a?(::Integer) && @range === other
-  end
+	def ===(value)
+		Integer === value && super
+	end
 end

data/lib/literal/types/interface_type.rb

@@ -1,13 +1,15 @@
+# frozen_string_literal: true
+
+# @api private
 class Literal::Types::InterfaceType
-  def initialize(*methods)
-    @methods = methods
-  end
+	def initialize(*methods)
+		raise Literal::ArgumentError.new("_Interface type must have at least one method.") if methods.size < 1
+		@methods = methods
+	end
 
-  def inspect
-    "Interface(#{@methods.map(&:inspect).join(", ")})"
-  end
+	def inspect = "_Interface(#{@methods.map(&:inspect).join(', ')})"
 
-  def ===(other)
-    @methods.all? { |method| other.respond_to?(method) }
-  end
+	def ===(value)
+		@methods.all? { |m| value.respond_to?(m) }
+	end
 end

data/lib/literal/types/intersection_type.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# @api private
+class Literal::Types::IntersectionType
+	def initialize(*types)
+		raise Literal::ArgumentError.new("_Intersection type must have at least one type.") if types.size < 1
+
+		@types = types
+	end
+
+	def inspect = "_Intersection(#{@types.map(&:inspect).join(', ')})"
+
+	def ===(value)
+		@types.all? { |type| type === value }
+	end
+
+	def nil?
+		@types.all?(&:nil?)
+	end
+end

data/lib/literal/types/json_data_type.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# @api private
+module Literal::Types::JSONDataType
+	def self.inspect = "_JSONData"
+
+	def self.===(value)
+		case value
+		when String, Integer, Float, true, false, nil
+			true
+		when Hash
+			value.all? { |k, v| String === k && self === v }
+		when Array
+			value.all?(self)
+		else
+			false
+		end
+	end
+
+	freeze
+end

data/lib/literal/types/lambda_type.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# @api private
+module Literal::Types::LambdaType
+	def self.inspect = "_Lambda"
+
+	def self.===(value)
+		Proc === value && value.lambda?
+	end
+
+	freeze
+end

data/lib/literal/types/map_type.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# @api private
+class Literal::Types::MapType
+	def initialize(**shape)
+		@shape = shape
+	end
+
+	def inspect
+		"_Map(#{@shape.inspect})"
+	end
+
+	def ===(other)
+		@shape.all? { |k, t| t === other[k] }
+	end
+end