A sweet and swifty YAML parser built on LibYAML.
Building Yams requires Xcode 14.0+ or a Swift 5.7+ toolchain with the Swift Package Manager or CMake and Ninja.
CMake 3.17.2 or newer is required, along with Ninja 1.9.0 or newer.
When building for non-Apple platforms:
cmake -B /path/to/build -G Ninja -S /path/to/yams -DCMAKE_BUILD_TYPE=Release -DFoundation_DIR=/path/to/foundation/build/cmake/modules
cmake --build /path/to/build
To build for Apple platforms (macOS, iOS, tvOS, watchOS), there is no need to separately build Foundation because it is included as part of the SDK:
cmake -B /path/to/build -G Ninja -S /path/to/yams -DCMAKE_BUILD_TYPE=Release
cmake --build /path/to/build
Add .package(url: "https://github.com/jpsim/Yams.git", from: "5.1.3")
to your
Package.swift
file's dependencies
.
Add pod 'Yams'
to your Podfile
.
Add github "jpsim/Yams"
to your Cartfile
.
In your WORKSPACE file
YAMS_GIT_SHA = "SOME_SHA"
http_archive(
name = "com_github_jpsim_yams",
urls = [
"https://github.com/jpsim/Yams/archive/%s.zip" % YAMS_GIT_SHA,
],
strip_prefix = "Yams-%s" % YAMS_GIT_SHA,
)
Yams has three groups of conversion APIs:
one for use with Codable
types,
another for Swift Standard Library types,
and a third one for a Yams-native representation.
Codable
typesYams.Node
.YAMLEncoder.encode(_:)
Produces a YAML String
from an instance of type conforming to Encodable
.YAMLDecoder.decode(_:from:)
Decodes an instance of type conforming to Decodable
from YAML String
or
Data
.import Foundation
import Yams
struct S: Codable {
var p: String
}
let s = S(p: "test")
let encoder = YAMLEncoder()
let encodedYAML = try encoder.encode(s)
encodedYAML == """
p: test
"""
let decoder = YAMLDecoder()
let decoded = try decoder.decode(S.self, from: encodedYAML)
s.p == decoded.p
Yams.Node
representation by matching regular expressions.JSONSerialization
or if the input is already standard library types
(Any
, Dictionary
, Array
, etc.).Yams.dump(object:)
Produces a YAML String
from an instance of Swift Standard Library types.Yams.load(yaml:)
Produces an instance of Swift Standard Library types as Any
from YAML
String
.// [String: Any]
let dictionary: [String: Any] = ["key": "value"]
let mapYAML: String = try Yams.dump(object: dictionary)
mapYAML == """
key: value
"""
let loadedDictionary = try Yams.load(yaml: mapYAML) as? [String: Any]
// [Any]
let array: [Int] = [1, 2, 3]
let sequenceYAML: String = try Yams.dump(object: array)
sequenceYAML == """
- 1
- 2
- 3
"""
let loadedArray: [Int]? = try Yams.load(yaml: sequenceYAML) as? [Int]
// Any
let string = "string"
let scalarYAML: String = try Yams.dump(object: string)
scalarYAML == """
string
"""
let loadedString: String? = try Yams.load(yaml: scalarYAML) as? String
Yams.Node
Yams.serialize(node:)
Produces a YAML String
from an instance of Node
.Yams.compose(yaml:)
Produces an instance of Node
from YAML String
.var map: Yams.Node = [
"array": [
1, 2, 3
]
]
map.mapping?.style = .flow
map["array"]?.sequence?.style = .flow
let yaml = try Yams.serialize(node: map)
yaml == """
{array: [1, 2, 3]}
"""
let node = try Yams.compose(yaml: yaml)
map == node
When Apple's Combine framework is available, YAMLDecoder
conforms to the
TopLevelDecoder
protocol, which allows it to be used with the
decode(type:decoder:)
operator:
import Combine
import Foundation
import Yams
func fetchBook(from url: URL) -> AnyPublisher<Book, Error> {
URLSession.shared.dataTaskPublisher(for: url)
.map(\.data)
.decode(type: Book.self, decoder: YAMLDecoder())
.eraseToAnyPublisher()
}
Both Yams and libYAML are MIT licensed.