Control characters, DEL, the C1 controls, U+2028, U+2029, U+FEFF, U+FFFE and U+FFFF were written as they are, where the reader refused them, folded U+0085, U+2028 and U+2029 to a space, or dropped a leading U+FEFF. They are now written as the escape that stands for each, in a quoted string, and never plain or in a literal block.
181 lines
6.2 KiB
Swift
181 lines
6.2 KiB
Swift
// MARK: - Scalar analysis
|
|
|
|
extension PureYAML.Emitting.Dumper {
|
|
func canRenderLiteralBlockString(_ value: String) -> Bool {
|
|
guard value.contains("\n"), !value.contains("\r"), !value.contains("\t"), !value.unicodeScalars.contains(where: mustEscape) else {
|
|
return false
|
|
}
|
|
|
|
let contentSource = value.hasSuffix("\n") ? String(value.dropLast()) : value
|
|
guard !contentSource.isEmpty else {
|
|
return false
|
|
}
|
|
|
|
return contentSource
|
|
.split(separator: "\n", omittingEmptySubsequences: false)
|
|
.allSatisfy(canRenderLiteralBlockLine)
|
|
}
|
|
|
|
func canRenderLiteralBlockLine(_ line: Substring) -> Bool {
|
|
guard !line.isEmpty, line.first?.isWhitespace == false, line.last?.isWhitespace == false else {
|
|
return false
|
|
}
|
|
let value = String(line)
|
|
guard !containsCommentStart(value), !containsMappingSeparator(value), let first = line.first else {
|
|
return false
|
|
}
|
|
return canRenderLiteralBlockLineStarting(with: first, line: line)
|
|
}
|
|
|
|
func canRenderLiteralBlockLineStarting(
|
|
with first: Character,
|
|
line: Substring,
|
|
) -> Bool {
|
|
switch first {
|
|
case "#", ",", "[", "]", "{", "}", "&", "*", "!", "|", ">", "'", "\"", "`":
|
|
false
|
|
case "-":
|
|
!hasOnlyIndicator(first, line: line) && line.dropFirst().first != " "
|
|
case "?":
|
|
!hasOnlyIndicator(first, line: line) && line.dropFirst().first != " "
|
|
case ":":
|
|
!hasOnlyIndicator(first, line: line) && line.dropFirst().first != " "
|
|
default:
|
|
true
|
|
}
|
|
}
|
|
|
|
func hasOnlyIndicator(
|
|
_ indicator: Character,
|
|
line: Substring,
|
|
) -> Bool {
|
|
line.count == 1 && line.first == indicator
|
|
}
|
|
|
|
func containsCommentStart(_ value: String) -> Bool {
|
|
var previousWasWhitespace = true
|
|
for character in value {
|
|
if character == "#", previousWasWhitespace {
|
|
return true
|
|
}
|
|
previousWasWhitespace = character.isWhitespace
|
|
}
|
|
return false
|
|
}
|
|
|
|
func containsMappingSeparator(_ value: String) -> Bool {
|
|
var previousWasColon = false
|
|
for character in value {
|
|
if previousWasColon, isMappingSeparatorBoundary(character) {
|
|
return true
|
|
}
|
|
previousWasColon = character == ":"
|
|
}
|
|
return previousWasColon
|
|
}
|
|
|
|
func isMappingSeparatorBoundary(_ character: Character) -> Bool {
|
|
character.isWhitespace
|
|
|| character == ","
|
|
|| character == "]"
|
|
|| character == "}"
|
|
}
|
|
|
|
func canRenderPlainString(_ value: String) -> Bool {
|
|
guard !value.isEmpty, value.first?.isWhitespace == false, value.last?.isWhitespace == false else {
|
|
return false
|
|
}
|
|
// By unicode scalar: CR+LF is one Character in Swift, so `contains("\n")` is false for it and a string with a CRLF break would be written raw.
|
|
guard !value.unicodeScalars.contains(where: { $0 == "\n" || $0 == "\r" || $0 == "\t" || mustEscape($0) }), !isReservedPlainScalar(value), !isNumberLikePlainScalar(value),
|
|
let first = value.first, !isPlainScalarIndicator(first)
|
|
else {
|
|
return false
|
|
}
|
|
// A trailing `:` reparses as a mapping key with an empty value, so a
|
|
// scalar that ends in one cannot render plain even though no `:` is
|
|
// followed by a space inside it.
|
|
guard value.last != ":" else {
|
|
return false
|
|
}
|
|
// `<<` as a key is the merge key, and `...` at the start of a line ends the document.
|
|
guard value != "<<", value != "...", !value.hasPrefix("... ") else {
|
|
return false
|
|
}
|
|
return !containsColonSpace(value) && !value.contains("#")
|
|
}
|
|
|
|
func canRenderFlowPlainString(_ value: String) -> Bool {
|
|
canRenderPlainString(value) && !containsFlowDelimiter(value)
|
|
}
|
|
|
|
func containsFlowDelimiter(_ value: String) -> Bool {
|
|
value.contains(",")
|
|
|| value.contains("[")
|
|
|| value.contains("]")
|
|
|| value.contains("{")
|
|
|| value.contains("}")
|
|
}
|
|
|
|
func containsColonSpace(_ value: String) -> Bool {
|
|
var previousWasColon = false
|
|
for character in value {
|
|
if previousWasColon, character == " " {
|
|
return true
|
|
}
|
|
previousWasColon = character == ":"
|
|
}
|
|
return false
|
|
}
|
|
|
|
/// A word the parser reads as something other than a string (null, a boolean, a number): written plain, a string of it would come back changed.
|
|
func isReservedPlainScalar(_ value: String) -> Bool {
|
|
!PureYAML.Parsing.PlainScalar.readsAsString(value)
|
|
}
|
|
|
|
func isNumberLikePlainScalar(_ value: String) -> Bool {
|
|
if Int(value) != nil, !value.contains(".") {
|
|
return true
|
|
}
|
|
if value.contains(".") || value.contains("e") || value.contains("E") {
|
|
return Double(value) != nil
|
|
}
|
|
return false
|
|
}
|
|
|
|
func isPlainScalarIndicator(_ character: Character) -> Bool {
|
|
"-?:,[]{}#&*!|>'\"%@`".contains(character)
|
|
}
|
|
|
|
func escapeKey(_ key: String) -> String {
|
|
canRenderPlainString(key) ? key : quote(key)
|
|
}
|
|
|
|
func quote(_ value: String) -> String {
|
|
// Iterate over unicode scalars, not Characters: a CR+LF pair forms a
|
|
// single extended grapheme cluster in Swift, so a Character-level switch
|
|
// would match neither "\r" nor "\n" and emit the line break unescaped,
|
|
// which does not round-trip through the folding parser.
|
|
var output = "\""
|
|
for scalar in value.unicodeScalars {
|
|
switch scalar {
|
|
case "\"":
|
|
output += "\\\""
|
|
case "\\":
|
|
output += "\\\\"
|
|
case "\n":
|
|
output += "\\n"
|
|
case "\r":
|
|
output += "\\r"
|
|
case "\t":
|
|
output += "\\t"
|
|
case _ where mustEscape(scalar):
|
|
output += escape(scalar)
|
|
default:
|
|
output.unicodeScalars.append(scalar)
|
|
}
|
|
}
|
|
output += "\""
|
|
return output
|
|
}
|
|
}
|