public extension PureYAML.Emitting { /// Block-style YAML serializer for ``PureYAML/Model/Value``. struct Dumper: Sendable { public var options: Options public init(options: Options = .default) { self.options = options } public func dump(_ value: PureYAML.Model.Value) -> String { switch options.collectionStyle { case .block: render(value, indent: 0).joined(separator: "\n") + "\n" case .flow: renderFlowDocument(value) } } } } extension PureYAML.Emitting.Dumper { func render( _ value: PureYAML.Model.Value, indent: Int, ) -> [String] { switch value { case let .mapping(mapping): renderMapping(mapping, indent: indent) case let .sequence(values): renderSequence(values, indent: indent) default: renderScalarNode(value, indent: indent) } } func renderSequence( _ values: [PureYAML.Model.Value], indent: Int, ) -> [String] { let prefix = String(repeating: " ", count: indent) guard !values.isEmpty else { return [prefix + "[]"] } return values.flatMap { value in if let emptyCollection = renderEmptyCollectionLiteral(value) { return [prefix + "- " + emptyCollection] } switch value { case .mapping, .sequence: return [prefix + "-"] + render(value, indent: indent + 2) default: return renderSequenceScalarItem(value, indent: indent) } } } func renderFlowDocument(_ value: PureYAML.Model.Value) -> String { switch value { case .mapping, .sequence: renderFlow(value) + "\n" default: renderScalarNode(value, indent: 0).joined(separator: "\n") + "\n" } } func renderFlow(_ value: PureYAML.Model.Value) -> String { switch value { case let .mapping(mapping): renderFlowMapping(mapping) case let .sequence(values): renderFlowSequence(values) default: renderFlowScalar(value) } } func renderFlowSequence(_ values: [PureYAML.Model.Value]) -> String { let items = values .map(renderFlow) .joined(separator: ", ") return "[\(items)]" } func renderEmptyCollectionLiteral(_ value: PureYAML.Model.Value) -> String? { switch value { case let .mapping(mapping) where mapping.pairs.isEmpty: "{}" case let .sequence(values) where values.isEmpty: "[]" default: nil } } func renderFlowScalar(_ value: PureYAML.Model.Value) -> String { switch value { case .null: "null" case let .bool(value): value ? "true" : "false" case let .int(value): String(value) case let .double(value): String(value) case let .string(value): renderFlowString(value) case .sequence, .mapping: "" } } func renderScalarNode( _ value: PureYAML.Model.Value, indent: Int, ) -> [String] { let prefix = String(repeating: " ", count: indent) if let lines = renderLiteralBlockString(value, contentIndent: indent + 2) { return [prefix + lines.header] + lines.content } return [prefix + renderScalar(value)] } func renderMappingScalarPair( _ pair: PureYAML.Model.Pair, indent: Int, ) -> [String] { let prefix = String(repeating: " ", count: indent) let key = escapeKey(pair.key) if let lines = renderLiteralBlockString(pair.value, contentIndent: indent + 2) { return [prefix + key + ": " + lines.header] + lines.content } return [prefix + key + ": " + renderScalar(pair.value)] } func renderSequenceScalarItem( _ value: PureYAML.Model.Value, indent: Int, ) -> [String] { let prefix = String(repeating: " ", count: indent) if let lines = renderLiteralBlockString(value, contentIndent: indent + 2) { return [prefix + "- " + lines.header] + lines.content } return [prefix + "- " + renderScalar(value)] } func renderScalar(_ value: PureYAML.Model.Value) -> String { switch value { case .null: "null" case let .bool(value): value ? "true" : "false" case let .int(value): String(value) case let .double(value): String(value) case let .string(value): renderString(value) case .sequence, .mapping: "" } } func renderString(_ value: String) -> String { switch options.scalarStyle { case .quoted: quote(value) case .plainWhenSafe: canRenderPlainString(value) ? value : quote(value) case .literalBlockWhenMultiline: quote(value) } } func renderFlowString(_ value: String) -> String { switch options.scalarStyle { case .plainWhenSafe: canRenderFlowPlainString(value) ? value : quote(value) case .quoted, .literalBlockWhenMultiline: quote(value) } } func renderLiteralBlockString( _ value: PureYAML.Model.Value, contentIndent: Int, ) -> (header: String, content: [String])? { guard case let .string(string) = value, options.scalarStyle == .literalBlockWhenMultiline, canRenderLiteralBlockString(string) else { return nil } let keepsTrailingNewline = string.hasSuffix("\n") let header = keepsTrailingNewline ? "|" : "|-" let contentSource = keepsTrailingNewline ? String(string.dropLast()) : string let prefix = String(repeating: " ", count: contentIndent) let content = contentSource.split(separator: "\n", omittingEmptySubsequences: false) .map { prefix + String($0) } return (header, content) } 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 { var output = "\"" for character in value { switch character { case "\"": output += "\\\"" case "\\": output += "\\\\" case "\n": output += "\\n" case "\r": output += "\\r" case "\t": output += "\\t" default: output.append(character) } } output += "\"" return output } }