Completes issue #10. Canonical mode follows libyaml's canonical layout on both the Model and Tagged dump paths (tags explicit, scalars double quoted, flow one entry per line, anchors and aliases preserved on the Tagged path). explicitDocumentStart/End wrap the body in --- and ... markers. lineWidth wraps overflowing flow collections one entry per line and folds plain block scalars at single-space boundaries, vetoing any fold that would manufacture syntax, so values always reparse unchanged. Closes #10
182 lines
5.6 KiB
Swift
182 lines
5.6 KiB
Swift
// MARK: - Scalar analysis
|
|
|
|
extension PureYAML.Emitting.Dumper {
|
|
func canRenderLiteralBlockString(_ value: String) -> Bool {
|
|
guard value.contains("\n"), !value.contains("\r"), !value.contains("\t") 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) else {
|
|
return false
|
|
}
|
|
guard 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 else {
|
|
return false
|
|
}
|
|
guard value.first?.isWhitespace == false, value.last?.isWhitespace == false else {
|
|
return false
|
|
}
|
|
guard !value.contains("\n"), !value.contains("\r"), !value.contains("\t") else {
|
|
return false
|
|
}
|
|
guard !isReservedPlainScalar(value), !isNumberLikePlainScalar(value) else {
|
|
return false
|
|
}
|
|
guard let first = value.first, !isPlainScalarIndicator(first) 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
|
|
}
|
|
|
|
func isReservedPlainScalar(_ value: String) -> Bool {
|
|
switch value {
|
|
case "~", "null", "Null", "NULL", "true", "True", "TRUE", "false", "False", "FALSE":
|
|
true
|
|
default:
|
|
false
|
|
}
|
|
}
|
|
|
|
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"
|
|
default:
|
|
output.unicodeScalars.append(scalar)
|
|
}
|
|
}
|
|
output += "\""
|
|
return output
|
|
}
|
|
}
|