soml-lang 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1da7419c0865c3f10d59dab2f4e5b8d638b814a11ed322a2885c7d6e3e3aecee
-  data.tar.gz: ed89f8ed61c0c624cf3023ec9f3199b76eec6e7f090992df90409f065e175937
+  metadata.gz: 451e02a56833294ea93a0ebb269889d8c20c377329572e6a27090a2d2a6a621b
+  data.tar.gz: 2956309298dbd2934603257d28903ee913b30f4a34a45f11261a09f6b96487a8
 SHA512:
-  metadata.gz: de26c20a01ef8fa144bf98402e2ae7d145f9b1ba22dfbd7b8fa02c283a3e66efbdf0060a9d5718ace01f1240384af0090c19717a802e3563e8c1d9f4534f182a
-  data.tar.gz: 65dce6ea77612c06ab6b5d656f1aa4bd030306c590416013b508797b47dd03ebedd3faa7be0ab9deb83d79d246ebc8b448cd7b1ed4db86f4f39d9e600351009c
+  metadata.gz: 43bba0ce5a930333bcd33bb064a989e8a9cbb9b71bf409358778087c646f1a324306a264d5d8c575c76511ec2a56ef844c1b64198c8e1237ae12adc7b77adcd4
+  data.tar.gz: 57e43736b8cace1e4f049e34186f1cb4a47dc125ca854956fc93dc66ee732a5c465def2935dd9c96e0693b35d229ae5d1e2ae5668e9ba9edc2669c596055e7af

data/lib/soml/duration.rb

@@ -29,9 +29,7 @@ module SOML
 		# @return [Duration]
 		# @raise [ParseError] When `text` is not a valid duration.
 		# @raise [TypeError] When `text` is not a string.
-		def self.parse(text)
-			Parser.new(text).parse_duration_literal
-		end
+		def self.parse(text) = Parser.new(text).parse_duration_literal
 
 		# Make a duration from a number of seconds, the inverse of {#to_r}. The seconds are rounded to the nearest nanosecond, because a `Float` such as `0.1` is not exact.
 		#
@@ -80,15 +78,11 @@ module SOML
 
 		# @return [Duration] The same length in the other direction.
 		# @raise [RangeError] For the most negative duration, whose opposite is outside the 64-bit range.
-		def -@
-			Duration.new(nanoseconds: -nanoseconds)
-		end
+		def -@ = Duration.new(nanoseconds: -nanoseconds)
 
 		# @return [Duration]
 		# @raise [RangeError] For the most negative duration, whose length is outside the 64-bit range.
-		def abs
-			negative? ? -self : self
-		end
+		def abs = negative? ? -self : self
 
 		# A number has no unit, so only a duration can be added.
 		#
@@ -100,27 +94,19 @@ module SOML
 		# @example
 		#   SOML::Duration.parse('1h') + SOML::Duration.parse('30m')
 		#   #=> #<SOML::Duration 1h30m>
-		def +(other)
-			Duration.new(nanoseconds: nanoseconds + nanoseconds_of(other))
-		end
+		def +(other) = Duration.new(nanoseconds: nanoseconds + nanoseconds_of(other))
 
 		# @param other [Duration]
 		# @return [Duration]
 		# @raise [TypeError] When `other` is not a duration.
 		# @raise [RangeError] When the difference is outside the 64-bit range.
-		def -(other)
-			Duration.new(nanoseconds: nanoseconds - nanoseconds_of(other))
-		end
+		def -(other) = Duration.new(nanoseconds: nanoseconds - nanoseconds_of(other))
 
 		# @return [Rational] The length in seconds, exactly.
-		def to_r
-			Rational(nanoseconds, 1_000_000_000)
-		end
+		def to_r = Rational(nanoseconds, 1_000_000_000)
 
 		# @return [Float] The length in seconds, for `sleep` and `Timeout.timeout`.
-		def to_f
-			nanoseconds.fdiv(1_000_000_000)
-		end
+		def to_f = nanoseconds.fdiv(1_000_000_000)
 
 		# @return [String] The canonical spelling, such as `1h30m`, `1.5s`, or `0s`.
 		def to_s
@@ -128,32 +114,24 @@ module SOML
 			return +'0s' if nanoseconds.zero?
 
 			magnitude = nanoseconds.abs
-			hours, rest = magnitude.divmod(3_600_000_000_000)
-			minutes, rest = rest.divmod(60_000_000_000)
-			seconds, fraction = rest.divmod(1_000_000_000)
+			hours, rest = magnitude.divmod(DURATION_UNITS['h'])
+			minutes, rest = rest.divmod(DURATION_UNITS['m'])
+			seconds, fraction = rest.divmod(DURATION_UNITS['s'])
 			text = nanoseconds.negative? ? +'-' : +''
 			text << "#{hours}h" if hours.positive?
 			text << "#{minutes}m" if minutes.positive?
 
-			if seconds.positive? || fraction.positive?
-				text << seconds.to_s
-				# The fraction is written like an instant's: nine digits with the trailing zeros removed.
-				text << ".#{format('%09d', fraction).sub(/0+\z/, '')}" if fraction.positive?
-				text << 's'
-			end
+			# The fraction is written like an instant's: nine digits with the trailing zeros removed.
+			text << "#{seconds}#{Generator.format_fraction(fraction)}s" if seconds.positive? || fraction.positive?
 
 			text
 		end
 
 		# @return [String]
-		def inspect
-			"#<SOML::Duration #{self}>"
-		end
+		def inspect = "#<SOML::Duration #{self}>"
 
 		# @api private
-		def pretty_print(printer)
-			printer.text(inspect)
-		end
+		def pretty_print(printer) = printer.text(inspect)
 
 		private
 

data/lib/soml/edit.rb

@@ -13,13 +13,20 @@ module SOML
 		private_constant :Removal, :Replacement
 
 		# @param source [String] The document.
-		# @param path [Array<String, Symbol, Integer>]
+		# @param path [Array<String, Symbol, Integer>, Tree::MemberNode, Tree::ObjectNode, Tree::ArrayNode, Tree::ScalarNode]
 		# @param value [Object] The new value, unless `delete` is true.
 		# @param delete [Boolean] Whether to remove the value instead.
 		def initialize(source, path, value, delete:)
+			case path
+			when Tree::MemberNode, Tree::ObjectNode, Tree::ArrayNode, Tree::ScalarNode
+				tree = Tree.new(source, lean: true)
+				path = node_path(tree.body, path)
+				raise ArgumentError, 'The node must be a member or a non-root value from the same source' unless path
+			end
+
 			# `Array#all?` on something else than an array, such as a hash, would read it in another way.
 			unless Array === path && !path.empty? && path.all? { |segment| (Integer === segment && !segment.negative?) || String === segment || Symbol === segment }
-				raise TypeError, 'The path must be a non-empty array of keys and array indexes'
+				raise TypeError, 'The path must be a non-empty array of keys and array indexes, or a member or value node from SOML.parse_tree'
 			end
 
 			# A key is checked as `generate` checks one, and read as the UTF-8 string it names, so that a symbol finds its string. A key of a removal is not written, so a carriage return in it is no error: it finds nothing.
@@ -38,7 +45,7 @@ module SOML
 			@value = value
 			@delete = delete
 
-			tree = Tree.new(source)
+			tree ||= Tree.new(source, lean: true)
 			@source = tree.source
 			# The same bytes, for the searches for a line break from an offset that may be inside a character, such as the last byte of a line that ends with `é`, which `String#byterindex` refuses in UTF-8.
 			@bytes = @source.b
@@ -52,7 +59,7 @@ module SOML
 			# The end of each comment, by its start, so that the trivia between tokens can be skipped.
 			@comment_ends = @comments.to_h { [it.start, it.finish] }
 			# The start of each block comment, by its end, so that the comments before a member or an item can be found.
-			@block_comment_starts = @comments.select { it.type == :block }.to_h { [it.finish, it.start] }
+			@block_comment_starts = @comments.filter_map { [it.finish, it.start] if it.type == :block }.to_h
 		end
 
 		# @return [String] The changed document.
@@ -83,6 +90,25 @@ module SOML
 
 		private
 
+		# Resolve a parsed node to the path that the editor follows, or `nil` when it is not a member or a non-root value of `body`. Matching complete nodes also rejects mismatched spans or values; callers must still use the same source. The search goes down through the one member or item whose span holds the node, so it reads one of them at each level.
+		def node_path(body, target)
+			path = []
+			container = body
+
+			while container.type == :object || container.type == :array
+				is_object = container.type == :object
+				items = is_object ? container.members : container.elements
+				index = items.bsearch_index { it.finish > target.start }
+				item = index && items[index]
+				return if item.nil? || item.start > target.start
+
+				path << (is_object ? item.key.value : index)
+				return path if item == target || (is_object && item.value == target)
+
+				container = is_object ? item.value : item
+			end
+		end
+
 		def edit_in_array(array, index, depth)
 			position = @path[index]
 			raise TypeError, "Cannot edit #{describe_path(@path)}, because #{describe_parent(index)} is an array, so it needs an index, not a key" unless Integer === position
@@ -140,7 +166,7 @@ module SOML
 
 			return if @delete
 
-			written_key = SOML.bare_key?(key) ? key : Generator.new.generate_value(key, 0)
+			written_key = Generator.format_key(key)
 			new_value = nest(index + 1)
 			insert(object, object.members.last) { |indentation| "#{written_key}: #{value_text(new_value, index + 1, depth + 1, indentation, object)}" }
 		end
@@ -192,7 +218,7 @@ module SOML
 			# When the removed item is the last one and has no comma after it, it takes the comma before it, so that no trailing comma is left, as `[1, 2]` becomes `[1]`.
 			takes_comma_before = node.equal?(items.last) && @source.getbyte(skip_trivia(node.finish)) != 0x2C
 			removal = node_removal(node, takes_comma_before)
-			take_blank_line(removal, container, content_start(container)) if removal.is_whole_lines
+			take_blank_line(removal, container) if removal.is_whole_lines
 
 			if items.length == 1 && braced?(container) && !comment_left?(container, removal)
 				@replacements << Replacement.new(container.start + 1, container.finish - 1, '')
@@ -267,21 +293,22 @@ module SOML
 			Removal.new(is_last ? skip_spaces_back(start) : start, after, false)
 		end
 
-		# Widens a removal of whole lines by a blank line that would otherwise be left next to another blank line, or directly inside a bracket. `content_start` is the container's, from `content_start`.
-		def take_blank_line(removal, container, content_start)
+		# Widens a removal of whole lines by a blank line that would otherwise be left next to another blank line, or directly inside a bracket.
+		def take_blank_line(removal, container)
 			is_blank_before = removal.start.positive? && blank_line?(line_start(removal.start - 1))
 			is_blank_after = removal.finish < @length && blank_line?(removal.finish)
 
 			if is_blank_before && (is_blank_after || at_closing?(removal.finish, container))
 				removal.start = line_start(removal.start - 1)
-			elsif is_blank_after && removal.start == content_start
-				removal.finish = @bytes.byteindex("\n", removal.finish) + 1
+			elsif is_blank_after && removal.start == content_start(container)
+				# The line is blank, so its line break follows its spaces.
+				removal.finish = skip_spaces(removal.finish) + 1
 			end
 		end
 
 		# The offset after the blank lines that start at `offset`.
 		def skip_blank_lines(offset)
-			offset = @bytes.byteindex("\n", offset) + 1 while offset < @length && blank_line?(offset)
+			offset = skip_spaces(offset) + 1 while blank_line?(offset)
 			offset
 		end
 
@@ -299,9 +326,7 @@ module SOML
 			line_end && skip_blank_lines(line_end + 1)
 		end
 
-		def blank_line?(line_start)
-			@source.getbyte(skip_spaces(line_start)) == 0x0A
-		end
+		def blank_line?(line_start) = @source.getbyte(skip_spaces(line_start)) == 0x0A
 
 		def line_start(offset)
 			return 0 if offset.zero?
@@ -435,13 +460,9 @@ module SOML
 			offset
 		end
 
-		def space?(byte)
-			byte == 0x20 || byte == 0x09
-		end
+		def space?(byte) = byte == 0x20 || byte == 0x09
 
-		def braced?(container)
-			container.type == :array || container.braced
-		end
+		def braced?(container) = container.type == :array || container.braced
 
 		# `@value` inside new objects for the keys of the path from `index` on. An index there names an item of an array that does not exist yet, so it raises an `IndexError`.
 		def nest(index)
@@ -461,8 +482,6 @@ module SOML
 		def describe_path(path) = Parser.describe_path(path)
 
 		# The value that holds `@path[index]`.
-		def describe_parent(index)
-			index.zero? ? 'the document' : describe_path(@path.first(index))
-		end
+		def describe_parent(index) = index.zero? ? 'the document' : describe_path(@path.first(index))
 	end
 end

data/lib/soml/error.rb

@@ -2,7 +2,19 @@
 
 module SOML
 	# The base class of the errors this library raises.
-	class Error < StandardError; end
+	class Error < StandardError
+		# Characters that a terminal acts on rather than shows: control characters other than tab, and bidirectional controls. They are replaced in an error message, so that printing it cannot run a terminal escape or reorder the text.
+		UNPRINTABLE = /[\p{Bidi_Control}[\p{Cc}&&[^\t]]]/
+
+		private_constant :UNPRINTABLE
+
+		# `text` with the characters that a terminal acts on replaced, for every message that can show a value or a name from the caller.
+		#
+		# @api private
+		# @param text [String]
+		# @return [String]
+		def self.sanitize(text) = text.gsub(UNPRINTABLE, "\uFFFD")
+	end
 
 	# Raised by {SOML.parse}, {SOML.load_file}, and {SOML::Duration.parse} when the input is not valid.
 	#
@@ -21,10 +33,7 @@ module SOML
 		CONTEXT_LINES = 2
 		MAX_LINE_WIDTH = 100
 
-		# Characters that a terminal acts on rather than shows: control characters other than tab, and bidirectional controls. They are replaced in an error message, so that printing it cannot run a terminal escape or reorder the text.
-		UNPRINTABLE = /[\p{Bidi_Control}[\p{Cc}&&[^\t]]]/
-
-		private_constant :CONTEXT_LINES, :MAX_LINE_WIDTH, :UNPRINTABLE
+		private_constant :CONTEXT_LINES, :MAX_LINE_WIDTH
 
 		# @return [String] What is wrong, without the position.
 		attr_reader :reason
@@ -47,7 +56,7 @@ module SOML
 		# @param byte_offset [Integer] Where the error is in `source`, in bytes.
 		# @param path [String, nil] The file the source is from.
 		def initialize(reason, source, byte_offset, path = nil)
-			@reason = sanitize(reason)
+			@reason = Error.sanitize(reason)
 
 			# A copy, which shares the bytes, so that a caller that changes its string afterwards does not change the code frame.
 			@source = source.dup
@@ -75,9 +84,7 @@ module SOML
 		# The message and the code frame, which Ruby shows for an uncaught error.
 		#
 		# @return [String]
-		def detailed_message(highlight: false, **)
-			"#{super}\n\n#{code_frame}"
-		end
+		def detailed_message(highlight: false, **) = "#{super}\n\n#{code_frame}"
 
 		private
 
@@ -95,11 +102,10 @@ module SOML
 			gutter_width = @line.to_s.length
 			output = []
 
-			line_starts.each_with_index do |line_start, index|
-				number = first_line + index
+			line_starts.each.with_index(first_line) do |line_start, number|
 				is_error_line = number == @line
 				line_end = @source.index("\n", line_start) || @source.length
-				text, pointer = clip(sanitize(@source[line_start...line_end]), is_error_line ? @offset - line_start : 0)
+				text, pointer = clip(Error.sanitize(@source[line_start...line_end]), is_error_line ? @offset - line_start : 0)
 				gutter = "#{is_error_line ? '>' : ' '} #{number.to_s.rjust(gutter_width)} |"
 				output << (text.empty? ? gutter : "#{gutter} #{text}")
 
@@ -124,13 +130,9 @@ module SOML
 			["#{prefix}#{text[start...finish]}#{suffix}", pointer - start + prefix.length]
 		end
 
-		def sanitize(text)
-			text.gsub(UNPRINTABLE, "\uFFFD")
-		end
-
 		# The path in UTF-8, so that it joins the reason, with what is not printable replaced, as in the reason.
 		def show_path(path)
-			sanitize(Parser.lossy_utf8(path))
+			Error.sanitize(Parser.lossy_utf8(path))
 		end
 	end
 
@@ -158,7 +160,15 @@ module SOML
 		# @api private
 		def initialize(reason)
 			@path = []
+
+			# The reason may name a class or show a value, as in `Cannot generate a Foo`, which can hold anything, so it is sanitized as the reason of a `ParseError` is.
+			super(Error.sanitize(reason))
+		end
+
+		# A copy, as made by `raise error, 'Other'`, has its own path, so that adding to the path of one does not change the other.
+		def initialize_copy(other)
 			super
+			@path = @path.dup
 		end
 
 		# @return [String] The reason, and the path to the value when it is not the top-level value.

data/lib/soml/format.rb

@@ -5,6 +5,11 @@ module SOML
 	#
 	# @api private
 	class Printer
+		# The brackets of a container, by its type, so that writing one allocates no array for them.
+		BRACKETS = Ractor.make_shareable({object: ['{', '}'], array: ['[', ']']})
+
+		private_constant :BRACKETS
+
 		# @param tree [Tree]
 		def initialize(tree)
 			@source = tree.source
@@ -27,6 +32,7 @@ module SOML
 
 		# Starts a new line at `level`, with one blank line before it when the source had one.
 		def new_line(level, is_blank)
+			# The first line of the file has no line break before it.
 			return if @output.empty?
 
 			@output << (is_blank ? "\n\n" : "\n") << INDENTS[level]
@@ -100,6 +106,7 @@ module SOML
 
 			# Between two items there is only whitespace, comments, and at most one comma.
 			while index < finish
+				# A comma inside a comment is not one. Each jump lands on the line feed after a line comment, or on the `/` of a block comment's end, and the loop steps past it.
 				case source.getbyte(index)
 				when 0x2C # ,
 					return index
@@ -123,11 +130,12 @@ module SOML
 			item_end = nil
 			# Whether a comment may stay at the end of the line before it, which needs an item or an opening bracket there.
 			can_trail = is_bracketed
+			# Whether the list has written something other than a comment at the end of the opening bracket's line. A blank line is kept only after that, so none is left directly inside the bracket or at the start of the file.
 			has_written = false
 			is_on_same_line = false
 
 			# One more round than there are items, for the comments after the last one.
-			(0..items.length).each do |index|
+			0.upto(items.length) do |index|
 				item = items[index]
 				item_start = item ? item.start : finish
 				comma = is_bracketed ? find_comma(previous_end, item_start) : nil
@@ -176,7 +184,7 @@ module SOML
 			previous_end = start + 1
 			has_written_token = false
 
-			(0..items.length).each do |index|
+			0.upto(items.length) do |index|
 				item = items[index]
 				item_start = item ? item.start : finish - 1
 				# The comma after the last item is left out.
@@ -290,8 +298,10 @@ module SOML
 				return
 			end
 
-			opening, closing, items = node.type == :object ? ['{', '}', node.members] : ['[', ']', node.elements]
+			opening, closing = BRACKETS[node.type]
+			items = node.type == :object ? node.members : node.elements
 
+			# Every comment before the container is already written, so a next comment that ends by `finish` is inside it. A container that holds only comments is not empty.
 			if items.empty? && peek_comment(finish).nil?
 				@output << opening << closing
 				return
@@ -323,7 +333,7 @@ module SOML
 			old_length = 0
 			old_length += 1 while (byte = closing.getbyte(old_length)) == 0x20 || byte == 0x09
 
-			lines.each_with_index.map do |line, index|
+			lines.map.with_index do |line, index|
 				index.zero? || !line.match?(NOT_BLANK_CHARACTER) ? line : indentation + line.byteslice(old_length, line.bytesize - old_length)
 			end.join("\n")
 		end

data/lib/soml/generator.rb

@@ -22,6 +22,18 @@ module SOML
 
 		private_constant :NEEDS_ESCAPED_BYTE, :ESCAPED_CHARACTER, :ESCAPES
 
+		# A key as a document writes it, bare when it can be, for {Parser} to suggest a key and for {Editor} to write a new member.
+		#
+		# @param key [String] A key that {#member_name} checked.
+		# @return [String]
+		def self.format_key(key) = SOML.bare_key?(key) ? key : new.generate_value(key, 0)
+
+		# The fraction of a second of an instant or a duration as a document writes it: a point and nine digits with the trailing zeros removed, or nothing when there is none.
+		#
+		# @param nanoseconds [Integer] The fraction, below one second.
+		# @return [String]
+		def self.format_fraction(nanoseconds) = nanoseconds.zero? ? '' : ".#{nanoseconds.to_s.rjust(9, '0').rstrip('0')}"
+
 		# @param canonical [Boolean] Whether members are sorted by key, as in canonical form, rather than kept in the order of their hash.
 		# @param one_line [Boolean] Whether a container is written on one line, as in `[1, {a: 2}]`, for {Editor} to write a value inside a container that is on one line.
 		def initialize(canonical: false, one_line: false)
@@ -130,7 +142,7 @@ module SOML
 			enter(value, depth)
 			inner_indent = INDENTS[indent.length + 1]
 
-			if value.is_a?(Array)
+			if Array === value
 				write_array(value, depth, indent, inner_indent)
 			else
 				write_hash(value, depth, indent, inner_indent)
@@ -216,29 +228,28 @@ module SOML
 		# Sorts the keys by their UTF-8 names. UTF-8 byte order is code point order, which is the canonical order.
 		def sort_keys!(keys)
 			# The common cases, all keys strings or all symbols in UTF-8 or US-ASCII, sort the keys themselves, because then their byte order is the order of their UTF-8 names. A string from `Symbol#to_s` is in US-ASCII. Anything else, such as a symbol in ISO-8859-1, sorts the keys by their UTF-8 names.
-			if keys.all? { |key| String === key && utf8_compatible?(key) } || keys.all? { |key| Symbol === key && utf8_compatible?(key) }
+			if keys.all? { String === it && utf8_compatible?(it) } || keys.all? { Symbol === it && utf8_compatible?(it) }
 				keys.sort!
 			else
-				keys.replace(keys.map { |key| [member_name(key), key] }.sort_by!(&:first).map!(&:last))
+				keys.sort_by! { member_name(it) }
 			end
 		end
 
-		def utf8_compatible?(key)
-			key.encoding == Encoding::UTF_8 || key.encoding == Encoding::US_ASCII
-		end
+		def utf8_compatible?(key) = key.encoding == Encoding::UTF_8 || key.encoding == Encoding::US_ASCII
 
 		# A key that `member_name` checked, so it is valid UTF-8 without a carriage return.
 		def write_key(key)
 			if SOML.bare_key?(key)
 				@buffer << key
 			else
-				write_string(key)
+				write_quoted(key)
 			end
 		end
 
-		def write_string(string)
-			string = to_utf8(string, 'string')
+		def write_string(string) = write_quoted(to_utf8(string, 'string'))
 
+		# Writes a valid UTF-8 string between quotes, as a `'...'` string when it can be one.
+		def write_quoted(string)
 			# One scan settles the common case: no quote and no control character.
 			index = 0
 			length = string.bytesize
@@ -291,7 +302,7 @@ module SOML
 
 			mantissa, exponent = text.delete_prefix('-').split('e')
 			whole, fraction = mantissa.split('.')
-			digits = "#{whole}#{fraction}".sub(/0+\z/, '')
+			digits = "#{whole}#{fraction}".rstrip('0')
 			length = digits.length
 
 			# The decimal point is after `point` digits, so the value is 0.digits × 10^point.
@@ -312,30 +323,29 @@ module SOML
 		end
 
 		def format_instant(time)
-			utc = time.getutc
+			# `getutc` makes a copy, which a time in UTC, as `SOML.parse` returns it, does not need.
+			utc = time.utc? ? time : time.getutc
 			nanoseconds = utc.nsec
 
-			# A time made from a float, such as `Time.at(Time.now.to_f)`, has the float's binary fraction.
-			raise GenerateError, "Cannot generate the instant #{time.inspect}, because it has a fraction of a second finer than a nanosecond. Round it to nanoseconds with time.round(9)" unless utc.subsec * 1_000_000_000 == nanoseconds
-			raise GenerateError, "Cannot generate the instant #{time.inspect}, because in UTC it falls outside the years 0001 to 9999" unless utc.year.between?(1, 9999)
-
-			text = format('%04d-%02d-%02dT%02d:%02d:%02d', utc.year, utc.month, utc.day, utc.hour, utc.min, utc.sec)
+			# A time made from a float, such as `Time.at(Time.now.to_f)`, has the float's binary fraction. A subclass of `Time` may define its own `inspect`.
+			raise GenerateError, "Cannot generate the instant #{Time.instance_method(:inspect).bind_call(time)}, because it has a fraction of a second finer than a nanosecond. Round it to nanoseconds with time.round(9)" unless (1_000_000_000 % utc.subsec.denominator).zero?
+			raise GenerateError, "Cannot generate the instant #{Time.instance_method(:inspect).bind_call(time)}, because in UTC it falls outside the years 0001 to 9999" unless utc.year.between?(1, 9999)
 
-			# The fraction is nine digits with the trailing zeros removed.
-			text << ".#{format('%09d', nanoseconds).sub(/0+\z/, '')}" if nanoseconds.positive?
-			text << 'Z'
+			# The year is 0001 to 9999, so `xmlschema` writes four digits, and a time in UTC ends with `Z`.
+			text = utc.xmlschema
+			nanoseconds.zero? ? text : "#{text.chop}#{Generator.format_fraction(nanoseconds)}Z"
 		end
 
-		# The class is read with `Kernel#class`, which a `BasicObject` does not have. An anonymous class, such as one from `Data.define`, is named by its nearest named superclass.
+		# An anonymous class, such as one from `Data.define`, is named by its nearest named superclass.
 		def describe(value)
 			case value
 			when nil, true, false
 				value.inspect
 			else
-				type = Kernel.instance_method(:class).bind_call(value)
+				type = Parser.class_of(value)
 				named = type
-				named = named.superclass until named.name
-				name = Parser.lossy_utf8(named.equal?(type) ? type.name : "anonymous #{named.name}")
+				named = named.superclass until (name = Parser.module_name(named))
+				name = Parser.lossy_utf8(named.equal?(type) ? name : "anonymous #{name}")
 				"#{name.match?(/\A[AEIOUaeiou]/) ? 'an' : 'a'} #{name}"
 			end
 		end