Mihaela M
d4ba594012
Port the located value tree onto the hand-rolled engine, reusing the
engine-agnostic located layer (Model.LocatedValue, LocatedPair,
SourcePosition, SourceRange, and the located composer helper) authored
on the conformance branch. The streaming composer now builds a parallel
located tree behind an opt-in tracksLocations flag, exposed as
parseLocated / parseStreamLocated; the plain Value path stays
byte-identical, gated behind the flag.
The scalar event carries the scanner token's end mark, so a located
scalar spans the whole token (end exclusive, one past the last
character) rather than being start-anchored. The hand-rolled scanner
already tracked token end marks, so this surfaces information the engine
was already computing.
Also stop emitting a spurious null document for a comment-only or empty
stream: YAML 1.2 gives such a stream zero documents, while the
single-document value API still maps it to null, so parse("") is
unchanged.
A whole-suite test proves the located projection equals a plain parse
for every passing case; the value, event-dump, and conformance suites
stay green (507 tests).
91 lines
3.2 KiB
Swift
91 lines
3.2 KiB
Swift
public extension PureYAML {
|
|
/// Parses a YAML document into a ``Model/Value`` tree.
|
|
static func parse(_ yaml: String) throws -> Model.Value {
|
|
try Parsing.Parser().parse(yaml)
|
|
}
|
|
|
|
/// Parses a YAML stream into indexed documents.
|
|
static func parseStream(_ yaml: String) throws -> [Stream.Document] {
|
|
try Parsing.Parser().parseStream(yaml)
|
|
}
|
|
|
|
/// Parses a YAML document into a located value tree, annotating every node with its source
|
|
/// span. The plain ``parse(_:)`` is unaffected; positions are strictly opt-in.
|
|
static func parseLocated(_ yaml: String) throws -> Model.LocatedValue {
|
|
try Parsing.Parser().parseLocated(yaml)
|
|
}
|
|
|
|
/// Parses a YAML stream into one located value tree per document, in document order.
|
|
static func parseStreamLocated(_ yaml: String) throws -> [Model.LocatedValue] {
|
|
try Parsing.Parser().parseStreamLocated(yaml)
|
|
}
|
|
|
|
/// Serializes a ``Model/Value`` tree into YAML with the selected options.
|
|
static func dump(
|
|
_ value: Model.Value,
|
|
options: Emitting.Options = .default,
|
|
) -> String {
|
|
Emitting.Dumper(options: options).dump(value)
|
|
}
|
|
|
|
/// Serializes indexed YAML stream documents with explicit document starts.
|
|
static func dump(
|
|
_ documents: [Stream.Document],
|
|
options: Emitting.Options = .default,
|
|
) -> String {
|
|
Emitting.Dumper(options: options).dump(documents)
|
|
}
|
|
|
|
/// Validates a parsed YAML value with the default validation rules.
|
|
@discardableResult
|
|
static func validate(
|
|
_ value: Model.Value,
|
|
using validator: Validation.Validator = .init(),
|
|
strict: Bool = true,
|
|
) throws -> [Validation.Issue] {
|
|
try validator.validate(value, strict: strict)
|
|
}
|
|
|
|
/// Validates parsed YAML stream documents while preserving document indexes.
|
|
@discardableResult
|
|
static func validate(
|
|
_ documents: [Stream.Document],
|
|
using validator: Validation.Validator = .init(),
|
|
strict: Bool = true,
|
|
) throws -> [Stream.Issue] {
|
|
try validator.validate(documents, strict: strict)
|
|
}
|
|
|
|
/// Decodes a typed value from a YAML value tree.
|
|
static func decode<Value: Decodable>(
|
|
_: Value.Type = Value.self,
|
|
from value: Model.Value,
|
|
) throws -> Value {
|
|
try validate(value)
|
|
return try Value(from: Decoding.Decoder(value: value, validatesInput: false))
|
|
}
|
|
|
|
/// Parses YAML and decodes a typed value from the resulting value tree.
|
|
static func decode<Value: Decodable>(
|
|
_ type: Value.Type = Value.self,
|
|
from yaml: String,
|
|
) throws -> Value {
|
|
try decode(type, from: parse(yaml))
|
|
}
|
|
|
|
/// Encodes a typed value into a YAML value tree.
|
|
static func encode<Value: Encodable>(_ value: Value) throws -> Model.Value {
|
|
let encoder = Encoding.Encoder()
|
|
try value.encode(to: encoder)
|
|
return try encoder.encodedValue()
|
|
}
|
|
|
|
/// Encodes a typed value and serializes the resulting value tree as YAML.
|
|
static func encodeToYAML(
|
|
_ value: some Encodable,
|
|
options: Emitting.Options = .default,
|
|
) throws -> String {
|
|
try dump(encode(value), options: options)
|
|
}
|
|
}
|