literal 1.7.0 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2c4292f514f586e16d0d477cc57e9a8b1f38771a8124f9ed933b67aa167550a0
-  data.tar.gz: 48dc63568c23368fb5c1577a57833720ca272c2aeca24dfc33e26271ed378497
+  metadata.gz: '09739f3793221d93a906cbfbf62075a48fe06c02130ad99a4defab048bf43641'
+  data.tar.gz: 3df8df84ac14d6d3a8942f2c563f441d989b38589dbd961ebe5cd37c06abe670
 SHA512:
-  metadata.gz: d79162f89f5088923b2a18ffb2d77214401e18f2d992d2535ab85a4f73b0adbf4430bf385dd846f860e7c0c984508bd6a4d48296a13883fefdb1eb8ef0ac51eb
-  data.tar.gz: d0cbebd25520b382b6ea73d22b9b2120b15831d7b51d6b2deb99bfd2adaa1c53cfeadbf4b6c3f7af6e97ea634991c49fe5e49d559c2efcf228ec2e9fe942daf1
+  metadata.gz: b981a63d59128471ce98bec6e6f49d094a991d1e5f86568430e3625333e2de623f169bf586509bde463e2aff3acc25420953628e2691f74e841fabdbe0959d0a
+  data.tar.gz: 60311bfab274436f61b3d4c900f60cf6ef1926db1bf59da1b0ece278c769f01cad55093d87121967b9b957b437634216af501366c9ded606b5e52b5162779d96

data/lib/literal/array.rb

@@ -493,8 +493,17 @@ class Literal::Array
 		self
 	end
 
+	def reverse(...)
+		__with__(@__value__.reverse(...))
+	end
+
 	alias_method :initialize_copy, :replace
 
+	def reverse!
+		@__value__.reverse!
+		self
+	end
+
 	def rotate(...)
 		__with__(@__value__.rotate(...))
 	end

data/lib/literal/data_structure.rb

@@ -14,6 +14,8 @@ class Literal::DataStructure
 		{}
 	end
 
+	alias to_hash to_h
+
 	def deconstruct
 		to_h.values
 	end

data/lib/literal/enum.rb

@@ -86,9 +86,9 @@ class Literal::Enum
 			object = const_get(name)
 
 			if self === 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 }
+				predicate_name = name.to_s.gsub(/(?<=[A-Z])(?=[A-Z][a-z])|(?<=[a-z\d])(?=[A-Z])/, "_").downcase
+				define_method("#{predicate_name}?") { self == object }
 				object.freeze
 			end
 		end

data/lib/literal/flags.rb

@@ -213,9 +213,7 @@ class Literal::Flags
 		end
 	end
 
-	private
-
-	def bitmap(key)
+	private def bitmap(key)
 		2 ** self.class::FLAGS.fetch(key)
 	end
 end

data/lib/literal/properties/schema.rb

@@ -78,6 +78,7 @@ class Literal::Properties::Schema
 		end
 
 		buffer << "  }\n" << "end\n"
+		buffer << "alias to_hash to_h\n"
 	end
 
 	def generate_hash(buffer = +"")
@@ -111,9 +112,7 @@ class Literal::Properties::Schema
 		buffer << "alias eql? ==\n"
 	end
 
-	private
-
-	def generate_initializer_params(buffer = +"")
+	private def generate_initializer_params(buffer = +"")
 		sorted_properties = @sorted_properties
 		i, n = 0, sorted_properties.size
 		while i < n
@@ -153,12 +152,12 @@ class Literal::Properties::Schema
 		buffer
 	end
 
-	def generate_initializer_body(buffer = +"")
+	private def generate_initializer_body(buffer = +"")
 		buffer << "  __properties__ = self.class.literal_properties.properties_index\n"
 		generate_initializer_handle_properties(@sorted_properties, buffer)
 	end
 
-	def generate_initializer_handle_properties(properties, buffer = +"")
+	private def generate_initializer_handle_properties(properties, buffer = +"")
 		i, n = 0, properties.size
 		while i < n
 			properties[i].generate_initializer_handle_property(buffer)

data/lib/literal/properties.rb

@@ -68,36 +68,36 @@ module Literal::Properties
 		end
 	end
 
-	private
-
-	def __literal_property_class__
+	private def __literal_property_class__
 		Literal::Property
 	end
 
-	def __define_literal_methods__(new_property)
+	private def __define_literal_methods__(new_property)
 		code =	__generate_literal_methods__(new_property)
 		__literal_extension__.module_eval(code)
 	end
 
-	def __literal_extension__
+	private def __literal_extension__
 		if defined?(@__literal_extension__)
 			@__literal_extension__
 		else
 			@__literal_extension__ = Module.new do
 				def initialize
-					after_initialize if respond_to?(:after_initialize)
+					after_initialize if respond_to?(:after_initialize, true)
 				end
 
 				def to_h
 					{}
 				end
 
+				alias to_hash to_h
+
 				set_temporary_name "Literal::Properties(Extension)" if respond_to?(:set_temporary_name)
 			end
 		end
 	end
 
-	def __generate_literal_methods__(new_property, buffer = +"")
+	private def __generate_literal_methods__(new_property, buffer = +"")
 		buffer << "# frozen_string_literal: true\n"
 		literal_properties.generate_initializer(buffer)
 		literal_properties.generate_to_h(buffer)

data/lib/literal/property.rb

@@ -87,9 +87,9 @@ class Literal::Property
 		RUBY_KEYWORDS[@name] || @name.name
 	end
 
-	def default_value
+	def default_value(receiver)
 		case @default
-			when Proc then @default.call
+			when Proc then receiver.instance_exec(&@default)
 			else @default
 		end
 	end
@@ -164,9 +164,7 @@ class Literal::Property
 		generate_initializer_assign_value(buffer)
 	end
 
-	private
-
-	def generate_initializer_escape_keyword(buffer = +"")
+	private def generate_initializer_escape_keyword(buffer = +"")
 		buffer <<
 			escaped_name <<
 			" = binding.local_variable_get(:" <<
@@ -174,7 +172,7 @@ class Literal::Property
 			")\n"
 	end
 
-	def generate_initializer_coerce_property(buffer = +"")
+	private def generate_initializer_coerce_property(buffer = +"")
 		buffer <<
 			escaped_name <<
 			"= __property__.coerce(" <<
@@ -182,7 +180,7 @@ class Literal::Property
 			", context: self)\n"
 	end
 
-	def generate_initializer_assign_default(buffer = +"")
+	private def generate_initializer_assign_default(buffer = +"")
 		buffer <<
 			"  if " <<
 			((@kind == :&) ? "nil" : "Literal::Null") <<
@@ -190,15 +188,15 @@ class Literal::Property
 			escaped_name <<
 			"\n    " <<
 			escaped_name <<
-			" = __property__.default_value\n  end\n"
+			" = __property__.default_value(self)\n  end\n"
 	end
 
-	def generate_initializer_check_type(buffer = +"")
+	private def generate_initializer_check_type(buffer = +"")
 		buffer <<
 			"  __property__.check_initializer(self, " << escaped_name << ")\n"
 	end
 
-	def generate_initializer_assign_value(buffer = +"")
+	private def generate_initializer_assign_value(buffer = +"")
 		buffer <<
 			"  @" <<
 			@name.name <<

data/lib/literal/rails/active_record_relation_patch.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Literal::Rails
+	module ActiveRecordRelationPatch
+		def Relation(model)
+			RelationType.new(model)
+		end
+	end
+end

data/lib/literal/rails/relation_type.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Literal::Rails
+	class RelationType
+		def initialize(model_class)
+			unless Class === model_class && model_class < ActiveRecord::Base
+				raise Literal::TypeError.new(
+						context: Literal::TypeError::Context.new(
+							expected: ActiveRecord::Base, actual: model_class
+						)
+					)
+			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
+end

data/lib/literal/railtie.rb

@@ -1,15 +1,42 @@
 # frozen_string_literal: true
 
+module Literal::Rails
+	if defined?(::ActiveJob)
+		require_relative "rails/enum_serializer"
+	end
+
+	if defined?(::ActiveRecord::Relation)
+		require_relative "rails/relation_type"
+		require_relative "rails/active_record_relation_patch"
+		::ActiveRecord.extend(ActiveRecordRelationPatch)
+	end
+end
+
 class Literal::Railtie < Rails::Railtie
-	initializer "literal.register_literal_enum_type" do
-		[ActiveRecord::Type, ActiveModel::Type].each do |registry|
-			registry.register(:literal_enum) do |name, type:|
+	if defined?(::ActiveModel::Type)
+		require_relative "rails/enum_type"
+		require_relative "rails/flags_type"
+
+		initializer "literal.register_active_model_types" do
+			ActiveModel::Type.register(:literal_enum) do |name, type:|
 				Literal::Rails::EnumType.new(type)
 			end
 
-			registry.register(:literal_flags) do |name, type:|
+			ActiveModel::Type.register(:literal_flags) do |name, type:|
 				Literal::Rails::FlagsType.new(type)
 			end
 		end
+
+		if defined?(::ActiveRecord::Type)
+			initializer "literal.register_active_record_types" 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
+			end
+		end
 	end
 end

data/lib/literal/types/constraint_type.rb

@@ -4,7 +4,7 @@
 class Literal::Types::ConstraintType
 	include Literal::Type
 
-	def initialize(*object_constraints, **property_constraints)
+	def initialize(object_constraints, property_constraints)
 		@object_constraints = object_constraints
 		@property_constraints = property_constraints
 		freeze
@@ -85,19 +85,17 @@ class Literal::Types::ConstraintType
 		end
 	end
 
-	private
-
-	def inspect_constraints
+	private def inspect_constraints
 		[inspect_object_constraints, inspect_property_constraints].compact.join(", ")
 	end
 
-	def inspect_object_constraints
+	private def inspect_object_constraints
 		if @object_constraints.length > 0
 			@object_constraints.map(&:inspect).join(", ")
 		end
 	end
 
-	def inspect_property_constraints
+	private def inspect_property_constraints
 		if @property_constraints.length > 0
 			@property_constraints.map { |k, t| "#{k}: #{t.inspect}" }.join(", ")
 		end

data/lib/literal/types/interface_type.rb

@@ -7,7 +7,7 @@ class Literal::Types::InterfaceType
 	# List of `===` method owners where the comparison will only match for objects with the same class
 	OwnClassTypeMethodOwners = Set[String, Integer, Kernel, Float, NilClass, TrueClass, FalseClass].freeze
 
-	def initialize(*methods)
+	def initialize(methods)
 		raise Literal::ArgumentError.new("_Interface type must have at least one method.") if methods.size < 1
 		@methods = methods.to_set.freeze
 		freeze

data/lib/literal/types/intersection_type.rb

@@ -4,7 +4,7 @@
 class Literal::Types::IntersectionType
 	include Literal::Type
 
-	def initialize(*types)
+	def initialize(types)
 		raise Literal::ArgumentError.new("_Intersection type must have at least one type.") if types.size < 1
 
 		@types = types

data/lib/literal/types/map_type.rb

@@ -4,7 +4,7 @@
 class Literal::Types::MapType
 	include Literal::Type
 
-	def initialize(**shape)
+	def initialize(shape)
 		@shape = shape
 		freeze
 	end

data/lib/literal/types/tuple_type.rb

@@ -4,7 +4,7 @@
 class Literal::Types::TupleType
 	include Literal::Type
 
-	def initialize(*types)
+	def initialize(types)
 		raise Literal::ArgumentError.new("_Tuple type must have at least one type.") if types.size < 1
 
 		@types = types

data/lib/literal/types/union_type.rb

@@ -4,7 +4,7 @@ class Literal::Types::UnionType
 	include Enumerable
 	include Literal::Type
 
-	def initialize(*queue)
+	def initialize(queue)
 		raise Literal::ArgumentError.new("_Union type must have at least one type.") if queue.size < 1
 		types = []
 		primitives = Set[]
@@ -22,11 +22,9 @@ class Literal::Types::UnionType
 		end
 
 		types.uniq!
-		@types = types
-		@primitives = primitives
+		@types = types.freeze
+		@primitives = primitives.freeze
 
-		@types.freeze
-		@primitives.freeze
 		freeze
 	end
 

data/lib/literal/types/unit_type.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# @api private
+class Literal::Types::UnitType
+	include Literal::Type
+
+	EQUAL_METHOD = BasicObject.instance_method(:equal?)
+
+	def initialize(object)
+		@object = object
+		freeze
+	end
+
+	attr_reader :object
+
+	def ===(value)
+		EQUAL_METHOD.bind_call(@object, value)
+	end
+
+	def >=(other)
+		case other
+		when Literal::Types::UnitType
+			EQUAL_METHOD.bind_call(@object, other.object)
+		else
+			false
+		end
+	end
+
+	freeze
+end

data/lib/literal/types.rb

@@ -95,7 +95,7 @@ module Literal::Types
 		if a.length == 1 && k.length == 0
 			a[0]
 		else
-			ConstraintType.new(*a, **k)
+			ConstraintType.new(a, k)
 		end
 	end
 
@@ -234,8 +234,8 @@ module Literal::Types
 	end
 
 	# Matches if the value responds to all the given methods.
-	def _Interface(...)
-		InterfaceType.new(...)
+	def _Interface(*methods)
+		InterfaceType.new(methods)
 	end
 
 	# Nilable version of `_Interface`
@@ -246,8 +246,8 @@ module Literal::Types
 	end
 
 	# Matches if *all* given types are matched.
-	def _Intersection(...)
-		IntersectionType.new(...)
+	def _Intersection(*types)
+		IntersectionType.new(types)
 	end
 
 	# Nilable version of `_Intersection`
@@ -258,13 +258,19 @@ module Literal::Types
 	end
 
 	# Ensures the value is valid JSON data (i.e. it came from JSON.parse).
-	def _JSONData
-		JSONDataType::Instance
+	def _JSONData(*a, **k)
+		if a.length > 0 || k.length > 0
+			_Constraint(JSONDataType::Instance, *a, **k)
+		else
+			JSONDataType::Instance
+		end
 	end
 
 	# Nilable version of `_JSONData`
-	def _JSONData?
-		NilableJSONDataType
+	def _JSONData?(...)
+		_Nilable(
+			_JSONData(...)
+		)
 	end
 
 	# Matches if the value is a `Proc` and `#lambda?` returns truthy.
@@ -280,8 +286,8 @@ module Literal::Types
 	# ```ruby
 	# _Map(name: String, age: Integer)
 	# ```
-	def _Map(...)
-		MapType.new(...)
+	def _Map(**shape)
+		MapType.new(shape)
 	end
 
 	# Nilable version of `_Map`
@@ -305,15 +311,35 @@ module Literal::Types
 	end
 
 	# Matches if the given type is *not* matched.
-	def _Not(type)
-		case type
-		when NotType
-			type.type
+	def _Not(*types)
+		if types.length > 1
+			NotType.new(
+				_Union(*types)
+			)
 		else
-			NotType.new(type)
+			type = types[0]
+
+			case type
+			when NotType
+				type.type
+			else
+				NotType.new(type)
+			end
 		end
 	end
 
+	def _Pattern(regex, &block)
+		raise ArgumentError.new("Block required for Pattern") unless block
+
+		-> (value) {
+			if (data = regex.match(value))
+				!!block.call(*data.captures, **data.named_captures&.transform_keys(&:to_sym))
+			else
+				false
+			end
+		}
+	end
+
 	def _Predicate(message, &block)
 		PredicateType.new(message:, block:)
 	end
@@ -399,8 +425,8 @@ module Literal::Types
 	# ```ruby
 	# _Tuple(String, Integer, Integer)
 	# ```
-	def _Tuple(...)
-		TupleType.new(...)
+	def _Tuple(*types)
+		TupleType.new(types)
 	end
 
 	# Nilable version of `_Typle`
@@ -414,8 +440,8 @@ module Literal::Types
 	end
 
 	# Matches if *any* given type is matched.
-	def _Union(...)
-		UnionType.new(...)
+	def _Union(*types)
+		UnionType.new(types)
 	end
 
 	# Nilable version of `_Union`
@@ -425,6 +451,18 @@ module Literal::Types
 		)
 	end
 
+	# The unit type is a type that matches only the same object
+	def _Unit(object)
+		UnitType.new(object)
+	end
+
+	# Nilable version of `_Unit`
+	def _Unit?(...)
+		_Nilable(
+			_Unit(...)
+		)
+	end
+
 	def _Void
 		VoidType::Instance
 	end

data/lib/literal/version.rb

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

data/lib/literal.rb

@@ -5,6 +5,10 @@ require_relative "literal/version"
 
 module Literal
 	Loader = Zeitwerk::Loader.for_gem.tap do |loader|
+		loader.ignore("#{__dir__}/literal/rails")
+		loader.ignore("#{__dir__}/literal/railtie.rb")
+		loader.ignore("#{__dir__}/ruby_lsp")
+
 		loader.inflector.inflect(
 			"json_data_type" => "JSONDataType"
 		)
@@ -123,4 +127,4 @@ module Literal
 	end
 end
 
-require_relative "literal/rails" if defined?(Rails)
+require_relative "literal/railtie" if defined?(Rails)

data/lib/ruby_lsp/literal/addon.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "ruby_lsp/addon"
+
+module RubyLsp
+	module Literal
+		class Addon < ::RubyLsp::Addon
+			def activate(global_state, message_queue)
+			end
+
+			def deactivate
+			end
+
+			def name
+				"Literal"
+			end
+
+			def version
+				"0.1.0"
+			end
+		end
+
+		class MyIndexingEnhancement < RubyIndexer::Enhancement
+			def on_call_node_enter(node)
+				name = node.name
+				owner = @listener.current_owner
+				location = node.location
+				arguments = node.arguments&.arguments
+
+				return unless owner
+				return unless :prop == name
+
+				args = arguments&.reject { |it| it.is_a?(Prism::KeywordHashNode) }
+				kwargs = arguments.find { |it| it.is_a?(Prism::KeywordHashNode) }&.elements.to_h do |element|
+					case element
+					in { key: Prism::SymbolNode[unescaped: String => key], value: value }
+						[key, value]
+					end
+				end
+
+				case args
+				in [Prism::SymbolNode[unescaped: String => prop_name], *]
+					@listener.instance_exec do
+						@index.add(RubyIndexer::Entry::InstanceVariable.new(
+							"@#{prop_name}",
+							@uri,
+							RubyIndexer::Location.from_prism_location(node.location, @code_units_cache),
+							collect_comments(node),
+							owner,
+						))
+					end
+
+					if kwargs["reader"] in Prism::SymbolNode[unescaped: "private" | "protected" | "public" => visibility]
+						@listener.add_method(prop_name, location, [
+							RubyIndexer::Entry::Signature.new([]),
+						], visibility: visibility.to_sym)
+					end
+
+					if kwargs["writer"] in Prism::SymbolNode[unescaped: "private" | "protected" | "public" => visibility]
+						@listener.add_method("#{prop_name}=", location, [
+							RubyIndexer::Entry::Signature.new([
+								RubyIndexer::Entry::RequiredParameter.new(name: "value"),
+							]),
+						], visibility: visibility.to_sym)
+					end
+				end
+			end
+		end
+	end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: literal
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 1.8.0
 platform: ruby
 authors:
 - Joel Drapper
@@ -54,11 +54,11 @@ files:
 - lib/literal/properties/data_schema.rb
 - lib/literal/properties/schema.rb
 - lib/literal/property.rb
-- lib/literal/rails.rb
+- lib/literal/rails/active_record_relation_patch.rb
 - lib/literal/rails/enum_serializer.rb
 - lib/literal/rails/enum_type.rb
 - lib/literal/rails/flags_type.rb
-- lib/literal/rails/patches/active_record.rb
+- lib/literal/rails/relation_type.rb
 - lib/literal/railtie.rb
 - lib/literal/result.rb
 - lib/literal/set.rb
@@ -92,9 +92,11 @@ files:
 - lib/literal/types/truthy_type.rb
 - lib/literal/types/tuple_type.rb
 - lib/literal/types/union_type.rb
+- lib/literal/types/unit_type.rb
 - lib/literal/types/void_type.rb
 - lib/literal/value.rb
 - lib/literal/version.rb
+- lib/ruby_lsp/literal/addon.rb
 homepage: https://literal.fun
 licenses:
 - MIT

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

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecord
-	class RelationType
-		def initialize(model_class)
-			unless Class === model_class && model_class < ActiveRecord::Base
-				raise Literal::TypeError.new(
-					context: Literal::TypeError::Context.new(
-						expected: ActiveRecord::Base, actual: model_class
-					)
-				)
-			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

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "railtie"
-require_relative "rails/patches/active_record"
-
-module Literal::Rails
-end