231 lines
7.4 KiB
Swift
231 lines
7.4 KiB
Swift
extension PureYAML.Tagged {
|
|
struct EventComposer {
|
|
var events: [PureYAML.Parsing.Event]
|
|
var index: Int
|
|
var anchors: [String: PureYAML.Tagged.Node]
|
|
let scalarParser: PureYAML.Parsing.Parser
|
|
|
|
init(
|
|
events: [PureYAML.Parsing.Event],
|
|
scalarParser: PureYAML.Parsing.Parser,
|
|
) {
|
|
self.events = events
|
|
index = 0
|
|
anchors = [:]
|
|
self.scalarParser = scalarParser
|
|
}
|
|
|
|
mutating func compose() throws -> PureYAML.Tagged.Node {
|
|
_ = try expect("stream start") { event in
|
|
if case .streamStart = event {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
_ = try expect("document start") { event in
|
|
if case .documentStart = event {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
let value = try composeNode()
|
|
_ = try expect("document end") { event in
|
|
if case .documentEnd = event {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
if case let .documentStart(mark)? = current {
|
|
throw PureYAML.Parsing.ParseError.unsupportedMultiDocumentStream(line: mark.line)
|
|
}
|
|
_ = try expect("stream end") { event in
|
|
if case .streamEnd = event {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
return value
|
|
}
|
|
|
|
mutating func composeStream() throws -> [PureYAML.Tagged.Document] {
|
|
_ = try expect("stream start") { event in
|
|
if case .streamStart = event {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
var documents: [PureYAML.Tagged.Document] = []
|
|
while current?.isStreamEnd != true {
|
|
_ = try expect("document start") { event in
|
|
if case .documentStart = event {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
anchors = [:]
|
|
let node = try composeNode()
|
|
_ = try expect("document end") { event in
|
|
if case .documentEnd = event {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
documents.append(.init(index: documents.count, node: node))
|
|
}
|
|
|
|
_ = try expect("stream end") { event in
|
|
if case .streamEnd = event {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
return documents
|
|
}
|
|
}
|
|
}
|
|
|
|
extension PureYAML.Tagged.EventComposer {
|
|
mutating func composeNode() throws -> PureYAML.Tagged.Node {
|
|
guard let event = current else {
|
|
throw unexpectedEvent(expected: "YAML node")
|
|
}
|
|
|
|
switch event {
|
|
case let .alias(anchor, mark):
|
|
index += 1
|
|
guard let value = anchors[anchor] else {
|
|
throw PureYAML.Parsing.ParseError.undefinedAlias(
|
|
anchor: anchor,
|
|
line: mark.line,
|
|
column: mark.column,
|
|
)
|
|
}
|
|
return value
|
|
case let .mappingStart(anchor, tag, _, _):
|
|
let value = try composeMapping(tag: tag)
|
|
store(value, anchor: anchor)
|
|
return value
|
|
case let .scalar(value, anchor, tag, style, mark):
|
|
index += 1
|
|
let scalar = try PureYAML.Tagged.Scalar(
|
|
rawValue: value,
|
|
value: scalarParser.composeScalarValue(
|
|
value,
|
|
tag: tag,
|
|
style: style,
|
|
mark: mark,
|
|
),
|
|
tag: .normalized(tag),
|
|
)
|
|
let node = PureYAML.Tagged.Node.scalar(scalar)
|
|
store(node, anchor: anchor)
|
|
return node
|
|
case let .sequenceStart(anchor, tag, _, _):
|
|
let value = try composeSequence(tag: tag)
|
|
store(value, anchor: anchor)
|
|
return value
|
|
default:
|
|
throw unexpectedEvent(expected: "YAML node")
|
|
}
|
|
}
|
|
|
|
mutating func composeSequence(tag: String?) throws -> PureYAML.Tagged.Node {
|
|
_ = try expect("sequence start") { event in
|
|
if case .sequenceStart = event {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
var values: [PureYAML.Tagged.Node] = []
|
|
while current?.isSequenceEnd != true {
|
|
try values.append(composeNode())
|
|
}
|
|
_ = try expect("sequence end") { $0.isSequenceEnd }
|
|
return .sequence(.init(values: values, tag: .normalized(tag)))
|
|
}
|
|
|
|
mutating func composeMapping(tag: String?) throws -> PureYAML.Tagged.Node {
|
|
_ = try expect("mapping start") { event in
|
|
if case .mappingStart = event {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
var pairs: [PureYAML.Tagged.Pair] = []
|
|
while current?.isMappingEnd != true {
|
|
let key = try composeMappingKey()
|
|
let value = try composeNode()
|
|
pairs.append(.init(key: key.value, keyTag: key.tag, value: value))
|
|
}
|
|
_ = try expect("mapping end") { $0.isMappingEnd }
|
|
return .mapping(.init(pairs: pairs, tag: .normalized(tag)))
|
|
}
|
|
|
|
mutating func composeMappingKey() throws -> ComposedMappingKey {
|
|
guard let event = current else {
|
|
throw unexpectedEvent(expected: "mapping key")
|
|
}
|
|
guard case let .scalar(value, anchor, tag, style, mark) = event else {
|
|
let mark = event.mark
|
|
throw PureYAML.Parsing.ParseError.expectedScalarKey(line: mark.line, column: mark.column)
|
|
}
|
|
index += 1
|
|
let scalar = try PureYAML.Tagged.Scalar(
|
|
rawValue: value,
|
|
value: scalarParser.composeScalarValue(value, tag: tag, style: style, mark: mark),
|
|
tag: .normalized(tag),
|
|
)
|
|
store(.scalar(scalar), anchor: anchor)
|
|
return ComposedMappingKey(value: value, tag: .normalized(tag))
|
|
}
|
|
}
|
|
|
|
extension PureYAML.Tagged.EventComposer {
|
|
struct ComposedMappingKey {
|
|
var value: String
|
|
var tag: PureYAML.Tagged.Tag?
|
|
}
|
|
|
|
var current: PureYAML.Parsing.Event? {
|
|
guard events.indices.contains(index) else {
|
|
return nil
|
|
}
|
|
return events[index]
|
|
}
|
|
|
|
mutating func store(
|
|
_ value: PureYAML.Tagged.Node,
|
|
anchor: String?,
|
|
) {
|
|
guard let anchor else {
|
|
return
|
|
}
|
|
anchors[anchor] = value
|
|
}
|
|
|
|
mutating func expect(
|
|
_ expected: String,
|
|
matching: (PureYAML.Parsing.Event) -> Bool,
|
|
) throws -> PureYAML.Parsing.Event {
|
|
guard let event = current else {
|
|
throw unexpectedEvent(expected: expected)
|
|
}
|
|
guard matching(event) else {
|
|
throw unexpectedEvent(expected: expected)
|
|
}
|
|
index += 1
|
|
return event
|
|
}
|
|
|
|
func unexpectedEvent(expected: String) -> PureYAML.Parsing.ParseError {
|
|
let mark = current?.mark ?? events.last?.mark ?? .start
|
|
return PureYAML.Parsing.ParseError.unexpectedEvent(
|
|
expected: expected,
|
|
actual: current?.description ?? "end of events",
|
|
line: mark.line,
|
|
column: mark.column,
|
|
)
|
|
}
|
|
}
|