Mihaela Mihaljevic
bf2dc4ece7
The validation module already implemented the composable-rule idiom under its own names (Check/Issue/SubjectContext) and a value-type Validator with duplicated traversal machinery per layer. Renamed the core types to the canonical names (Validation/ValidationError/ValidationErrorCollection/ ValidationContext/BuiltinValidation/AnyValidation), converted Validator to a reference-type class with the two-tier default-rule split, and genericized it over both Subject and Document via a new Traversable protocol so the model and tagged layers share one walk engine instead of two copies. Wired the JSON-representability rule set into the same shape and closed the two missing pieces (unwrap combinator, JSON coverage/config-pin tests).
101 lines
3.6 KiB
Swift
101 lines
3.6 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)
|
|
}
|
|
|
|
/// Serializes a tag-preserving node tree into YAML, re-emitting anchors,
|
|
/// aliases (as `*name` references, not expanded copies), explicit tags,
|
|
/// and per-node presentation styles.
|
|
static func dump(
|
|
_ node: Tagged.Node,
|
|
options: Emitting.Options = .default,
|
|
) -> String {
|
|
Tagged.Dumper(options: options).dump(node)
|
|
}
|
|
|
|
/// Validates a parsed YAML value with the default validation rules.
|
|
@discardableResult
|
|
static func validate(
|
|
_ value: Model.Value,
|
|
using validator: Validation.Validator<Model.Value, Model.Value> = .init(),
|
|
strict: Bool = true,
|
|
) throws -> [Validation.ValidationError] {
|
|
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<Model.Value, Model.Value> = .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)
|
|
}
|
|
}
|