├── .gitignore ├── LICENSE ├── Package.swift ├── Readme.md ├── Sources ├── Info.plist ├── Yaml.h └── Yaml │ ├── YAMLOperators.swift │ ├── YAMLParser.swift │ ├── YAMLRegex.swift │ ├── YAMLResult.swift │ ├── YAMLTokenizer.swift │ └── Yaml.swift ├── Tests ├── Info.plist ├── LinuxMain.swift └── YamlTests │ ├── ExampleTests.swift │ └── YamlTests.swift ├── Yaml.podspec ├── Yaml.xcodeproj ├── .gitignore ├── project.pbxproj ├── xcshareddata │ └── xcschemes │ │ ├── Yaml OSX.xcscheme │ │ ├── Yaml iOS.xcscheme │ │ └── Yaml tvOS.xcscheme └── xcuserdata │ └── behrang.xcuserdatad │ └── xcschemes │ └── xcschememanagement.plist └── Yaml.xcworkspace └── contents.xcworkspacedata /.gitignore: -------------------------------------------------------------------------------- 1 | ###SublimeText### 2 | 3 | # cache files for sublime text 4 | *.tmlanguage.cache 5 | *.tmPreferences.cache 6 | *.stTheme.cache 7 | 8 | # workspace files are user-specific 9 | *.sublime-workspace 10 | 11 | # project files should be checked into the repository, unless a significant 12 | # proportion of contributors will probably not be using SublimeText 13 | # *.sublime-project 14 | 15 | # sftp configuration file 16 | sftp-config.json 17 | 18 | .DS_Store 19 | /.build 20 | /Packages 21 | /*.xcodeproj -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2015 Behrang Noruzi Niya 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /Package.swift: -------------------------------------------------------------------------------- 1 | // swift-tools-version:4.1 2 | // The swift-tools-version declares the minimum version of Swift required to build this package. 3 | 4 | import PackageDescription 5 | 6 | let package = Package( 7 | name: "Yaml", 8 | products: [ 9 | // Products define the executables and libraries produced by a package, and make them visible to other packages. 10 | .library( 11 | name: "Yaml", 12 | targets: ["Yaml"]), 13 | ], 14 | dependencies: [ 15 | // Dependencies declare other packages that this package depends on. 16 | // .package(url: /* package url */, from: "1.0.0"), 17 | ], 18 | targets: [ 19 | // Targets are the basic building blocks of a package. A target can define a module or a test suite. 20 | // Targets can depend on other targets in this package, and on products in packages which this package depends on. 21 | .target( 22 | name: "Yaml", 23 | dependencies: []), 24 | .testTarget( 25 | name: "YamlTests", 26 | dependencies: ["Yaml"]), 27 | ] 28 | ) 29 | -------------------------------------------------------------------------------- /Readme.md: -------------------------------------------------------------------------------- 1 | # YamlSwift 2 | 3 | Load [YAML](http://yaml.org) and [JSON](http://json.org) documents using [Swift](http://www.apple.com/swift/). 4 | 5 | `YamlSwift` parses a string of YAML document(s) (or a JSON document) and returns a `Yaml` enum value representing that string. 6 | 7 | 8 | 9 | 10 | 11 | ## Install 12 | 13 | Use [Carthage](https://github.com/Carthage/Carthage) to build and install. 14 | 15 | Or use [CocoaPods](https://cocoapods.org/) : 16 | Add `pod 'Yaml'` to your `Podfile` and run `pod install`. 17 | 18 | It supports Swift Package Manager. 19 | 20 | ``` 21 | .package( 22 | url: "https://github.com/behrang/YamlSwift.git", 23 | from: "3.4.4") 24 | 25 | ``` 26 | 27 | And: 28 | 29 | ``` 30 | .target( 31 | name: "YourProject", 32 | dependencies: ["Yaml"]), 33 | ``` 34 | 35 | ## API 36 | 37 | 38 | 39 | 40 | 41 | ### import 42 | 43 | To use it, you should import it using the following statement: 44 | 45 | ```swift 46 | import Yaml 47 | ``` 48 | 49 | 50 | 51 | 52 | 53 | ### Yaml 54 | 55 | A Yaml value can be any of these cases: 56 | 57 | ```swift 58 | enum Yaml { 59 | case null 60 | case bool(Bool) 61 | case int(Int) 62 | case double(Double) 63 | case string(String) 64 | case array([Yaml]) 65 | case dictionary([Yaml: Yaml]) 66 | } 67 | ``` 68 | 69 | 70 | 71 | 72 | 73 | ### Yaml.load 74 | 75 | ```swift 76 | Yaml.load (String) throws -> Yaml 77 | ``` 78 | 79 | Takes a string of a YAML document and returns a `Yaml` enum. 80 | 81 | ```swift 82 | let value = try! Yaml.load("a: 1\nb: 2") 83 | print(value["a"]) // Int(1) 84 | print(value["b"]) // Int(2) 85 | print(value["c"]) // Null 86 | ``` 87 | 88 | If the input document is invalid or contains more than one YAML document, an error is thrown. 89 | 90 | ```swift 91 | do { 92 | let value = try Yaml.load("a\nb: 2") 93 | } 94 | catch { 95 | print(error) // expected end, near "b: 2" 96 | } 97 | 98 | ``` 99 | 100 | 101 | 102 | 103 | 104 | ### Yaml.loadMultiple 105 | 106 | ```swift 107 | Yaml.loadMultiple (String) throws -> [Yaml] 108 | ``` 109 | 110 | Takes a string of one or more YAML documents and returns `[Yaml]`. 111 | 112 | ```swift 113 | let value = try! Yaml.loadMultiple("---\na: 1\nb: 2\n---\na: 3\nb: 4") 114 | print(value[0]["a"]) // Int(1) 115 | print(value[1]["a"]) // Int(3) 116 | ``` 117 | 118 | It will throw an error if an error is encountered in any of the documents. 119 | 120 | 121 | 122 | 123 | 124 | ### Yaml#[Int] -> Yaml 125 | 126 | ```swift 127 | value[Int] -> Yaml 128 | value[Int] = Yaml 129 | ``` 130 | 131 | If used on a `Yaml.array` value, it will return the value at the specified index. If the index is invalid or the value is not a `Yaml.array`, `Yaml.null` is returned. You can also set a value at a specific index. Enough elements will be added to the wrapped array to set the specified index. If the value is not a `Yaml.array`, it will change to it after set. 132 | 133 | ```swift 134 | var value = try! Yaml.load("- Behrang\n- Maryam") 135 | print(value[0]) // String(Behrang) 136 | print(value[1]) // String(Maryam) 137 | print(value[2]) // Null 138 | value[2] = "Radin" 139 | print(value[2]) // String(Radin) 140 | ``` 141 | 142 | 143 | 144 | 145 | 146 | ### Yaml#[Yaml] -> Yaml 147 | 148 | ```swift 149 | value[Yaml] -> Yaml 150 | value[Yaml] = Yaml 151 | ``` 152 | 153 | If used on a `Yaml.dictionary` value, it will return the value for the specified key. If a value for the specified key does not exist, or value is not a `Yaml.dictionary`, `Yaml.null` is returned. You can also set a value for a specific key. If the value is not a `Yaml.dictionary`, it will change to it after set. 154 | 155 | Since `Yaml` is a literal convertible type, you can pass simple values to this method. 156 | 157 | ```swift 158 | var value = try! Yaml.load("first name: Behrang\nlast name: Noruzi Niya") 159 | print(value["first name"]) // String(Behrang) 160 | print(value["last name"]) // String(Noruzi Niya) 161 | print(value["age"]) // Null 162 | value["first name"] = "Radin" 163 | value["age"] = 1 164 | print(value["first name"]) // String(Radin) 165 | print(value["last name"]) // String(Noruzi Niya) 166 | print(value["age"]) // Int(1) 167 | ``` 168 | 169 | 170 | 171 | 172 | 173 | ### Yaml#bool 174 | 175 | ```swift 176 | value.bool -> Bool? 177 | ``` 178 | 179 | Returns an `Optional` value. If the value is a `Yaml.bool` value, the wrapped value is returned. Otherwise `nil` is returned. 180 | 181 | ```swift 182 | let value = try! Yaml.load("animate: true\nshow tip: false\nusage: 25") 183 | print(value["animate"].bool) // Optional(true) 184 | print(value["show tip"].bool) // Optional(false) 185 | print(value["usage"].bool) // nil 186 | ``` 187 | 188 | 189 | 190 | 191 | 192 | ### Yaml#int 193 | 194 | ```swift 195 | value.int -> Int? 196 | ``` 197 | 198 | Returns an `Optional` value. If the value is a `Yaml.int` value, the wrapped value is returned. Otherwise `nil` is returned. 199 | 200 | ```swift 201 | let value = try! Yaml.load("a: 1\nb: 2.0\nc: 2.5") 202 | print(value["a"].int) // Optional(1) 203 | print(value["b"].int) // Optional(2) 204 | print(value["c"].int) // nil 205 | ``` 206 | 207 | 208 | 209 | 210 | 211 | ### Yaml#double 212 | 213 | ```swift 214 | value.double -> Double? 215 | ``` 216 | 217 | Returns an `Optional` value. If the value is a `Yaml.double` value, the wrapped value is returned. Otherwise `nil` is returned. 218 | 219 | ```swift 220 | let value = try! Yaml.load("a: 1\nb: 2.0\nc: 2.5\nd: true") 221 | print(value["a"].double) // Optional(1.0) 222 | print(value["b"].double) // Optional(2.0) 223 | print(value["c"].double) // Optional(2.5) 224 | print(value["d"].double) // nil 225 | ``` 226 | 227 | 228 | 229 | 230 | 231 | ### Yaml#string 232 | 233 | ```swift 234 | value.string -> String? 235 | ``` 236 | 237 | Returns an `Optional` value. If the value is a `Yaml.string` value, the wrapped value is returned. Otherwise `nil` is returned. 238 | 239 | ```swift 240 | let value = try! Yaml.load("first name: Behrang\nlast name: Noruzi Niya\nage: 33") 241 | print(value["first name"].string) // Optional("Behrang") 242 | print(value["last name"].string) // Optional("Noruzi Niya") 243 | print(value["age"].string) // nil 244 | ``` 245 | 246 | 247 | 248 | 249 | 250 | ### Yaml#array 251 | 252 | ```swift 253 | value.array -> [Yaml]? 254 | ``` 255 | 256 | Returns an `Optional>` value. If the value is a `Yaml.array` value, the wrapped value is returned. Otherwise `nil` is returned. 257 | 258 | ```swift 259 | let value = try! Yaml.load("languages:\n - Swift: true\n - Objective C: false") 260 | print(value.array) // nil 261 | print(value["languages"].array) // Optional([Dictionary([String(Swift): Bool(true)]), Dictionary([String(Objective C): Bool(false)])]) 262 | ``` 263 | 264 | 265 | 266 | 267 | 268 | ### Yaml#dictionary 269 | 270 | ```swift 271 | value.dictionary -> [Yaml: Yaml]? 272 | ``` 273 | 274 | Returns an `Optional>` value. If the value is a `Yaml.dictionary` value, the wrapped value is returned. Otherwise `nil` is returned. 275 | 276 | ```swift 277 | let value = try! Yaml.load("- Swift: true\n- Objective C: false") 278 | print(value.dictionary) // nil 279 | print(value[0].dictionary) // Optional([String(Swift): Bool(true)]) 280 | ``` 281 | 282 | 283 | 284 | 285 | 286 | ### Yaml#count 287 | 288 | ```swift 289 | value.count -> Int? 290 | ``` 291 | 292 | Returns an `Optional` value. If the value is either a `Yaml.array` or a `Yaml.dictionary` value, the count of elements is returned. Otherwise `nil` is returned. 293 | 294 | ```swift 295 | let value = try! Yaml.load("- Swift: true\n- Objective C: false") 296 | print(value.count) // Optional(2) 297 | print(value[0].count) // Optional(1) 298 | print(value[0]["Swift"].count) // nil 299 | ``` 300 | 301 | 302 | 303 | 304 | 305 | ## License 306 | 307 | MIT 308 | -------------------------------------------------------------------------------- /Sources/Info.plist: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | CFBundleDevelopmentRegion 6 | en 7 | CFBundleExecutable 8 | $(EXECUTABLE_NAME) 9 | CFBundleIdentifier 10 | $(PRODUCT_BUNDLE_IDENTIFIER) 11 | CFBundleInfoDictionaryVersion 12 | 6.0 13 | CFBundleName 14 | $(PRODUCT_NAME) 15 | CFBundlePackageType 16 | FMWK 17 | CFBundleShortVersionString 18 | 1.0 19 | CFBundleSignature 20 | ???? 21 | CFBundleVersion 22 | $(CURRENT_PROJECT_VERSION) 23 | NSPrincipalClass 24 | 25 | 26 | 27 | -------------------------------------------------------------------------------- /Sources/Yaml.h: -------------------------------------------------------------------------------- 1 | // 2 | // Yaml.h 3 | // Yaml 4 | // 5 | // Created by Gregory Higley on 8/5/15. 6 | // 7 | // 8 | 9 | #import 10 | 11 | //! Project version number for Yaml. 12 | FOUNDATION_EXPORT double YamlVersionNumber; 13 | 14 | //! Project version string for Yaml. 15 | FOUNDATION_EXPORT const unsigned char YamlVersionString[]; 16 | 17 | // In this header, you should import all the public headers of your framework using statements like #import 18 | 19 | 20 | -------------------------------------------------------------------------------- /Sources/Yaml/YAMLOperators.swift: -------------------------------------------------------------------------------- 1 | infix operator |>: Functional 2 | func |> (x: T, f: (T) -> U) -> U { 3 | return f(x) 4 | } 5 | 6 | 7 | -------------------------------------------------------------------------------- /Sources/Yaml/YAMLParser.swift: -------------------------------------------------------------------------------- 1 | import Foundation 2 | 3 | private typealias Resulter = Yaml 4 | 5 | 6 | extension Yaml { 7 | 8 | struct Context { 9 | let tokens: [Yaml.TokenMatch] 10 | let aliases: [String.SubSequence: Yaml] 11 | 12 | init (_ tokens: [Yaml.TokenMatch], _ aliases: [String.SubSequence: Yaml] = [:]) { 13 | self.tokens = tokens 14 | self.aliases = aliases 15 | } 16 | 17 | static private let commentRegex = try! NSRegularExpression(pattern: "#\\s*(?.+)\\s*$") 18 | 19 | static private func getCommentText(_ comment: String) -> String? { 20 | if let match = Context.commentRegex.firstMatch(in: comment, range: NSRange(location: 0, length: comment.count)) { 21 | if let textRange = Range(match.range(withName: "text"), in: comment) { 22 | return String(comment[textRange]) 23 | } 24 | } 25 | 26 | return nil 27 | } 28 | 29 | static func makeDocParser(preserveComments: Bool = false) -> (([Yaml.TokenMatch]) -> YAMLResult) { 30 | func parseDoc (_ tokens: [Yaml.TokenMatch]) -> YAMLResult { 31 | let c = Resulter.lift(Context(tokens)) 32 | let header = c >>=- parseHeader 33 | 34 | if preserveComments { 35 | var updatedTokens = [Yaml.TokenMatch]() 36 | var updatedAliases = [String.SubSequence: Yaml]() 37 | 38 | if case let .value(context) = header { 39 | updatedTokens = context.tokens 40 | updatedAliases = context.aliases 41 | 42 | var foundComment = true 43 | 44 | while (foundComment) { 45 | var lastString: String = "" 46 | var newEntries = [Yaml.TokenMatch]() 47 | var i = 0 48 | var lastStringIndex = 0 49 | var commentIndex = 0 50 | 51 | foundComment = false 52 | 53 | for token in updatedTokens { 54 | if case let (type: type, match: comment) = token, type == Yaml.TokenType.comment, let unwrappedCommentText = Context.getCommentText(comment) { 55 | newEntries.append( 56 | contentsOf: [ 57 | (type: Yaml.TokenType.string, match: "\(Yaml.commentPrefix)\(lastString)"), 58 | (type: Yaml.TokenType.colon, match: ":"), 59 | (type: Yaml.TokenType.indent, match: ""), 60 | (type: Yaml.TokenType.space, match: " "), 61 | (type: Yaml.TokenType.string, match: unwrappedCommentText), 62 | (type: Yaml.TokenType.dedent, match: ""), 63 | (type: Yaml.TokenType.newLine, match: "\n ") 64 | ] 65 | ) 66 | commentIndex = i 67 | foundComment = true 68 | break 69 | } else if case let (type: type, match: comment) = token, type == Yaml.TokenType.string { 70 | lastString = comment 71 | lastStringIndex = i 72 | } 73 | i += 1 74 | } 75 | 76 | if (foundComment) { 77 | updatedTokens.remove(at: commentIndex) 78 | updatedTokens.insert(contentsOf: newEntries, at: lastStringIndex) 79 | } 80 | 81 | } 82 | 83 | } 84 | 85 | let cv = .value(Context(updatedTokens, updatedAliases)) >>=- parse 86 | let v = cv >>- getValue 87 | return cv 88 | >>- getContext 89 | >>- ignoreDocEnd 90 | >>=- expect(Yaml.TokenType.end, message: "expected end") 91 | >>| v 92 | } 93 | 94 | let cv = header >>=- parse 95 | let v = cv >>- getValue 96 | return cv 97 | >>- getContext 98 | >>- ignoreDocEnd 99 | >>=- expect(Yaml.TokenType.end, message: "expected end") 100 | >>| v 101 | } 102 | 103 | return parseDoc 104 | } 105 | 106 | static func parseDocs (_ tokens: [Yaml.TokenMatch]) -> YAMLResult<[Yaml]> { 107 | return parseDocs([])(Context(tokens)) 108 | } 109 | 110 | static func parseDocs (_ acc: [Yaml]) -> (Context) -> YAMLResult<[Yaml]> { 111 | return { context in 112 | if peekType(context) == .end { 113 | return Resulter.lift(acc) 114 | } 115 | let cv = Resulter.lift(context) 116 | >>=- parseHeader 117 | >>=- parse 118 | let v = cv 119 | >>- getValue 120 | let c = cv 121 | >>- getContext 122 | >>- ignoreDocEnd 123 | let a = appendToArray(acc) <^> v 124 | return parseDocs <^> a <*> c |> Resulter.join 125 | } 126 | } 127 | 128 | static func error (_ message: String) -> (Context) -> String { 129 | return { context in 130 | let text = recreateText("", context: context) |> Yaml.escapeErrorContext 131 | return "\(message), \(text)" 132 | } 133 | } 134 | 135 | 136 | 137 | } 138 | 139 | } 140 | 141 | private typealias Context = Yaml.Context 142 | 143 | private var error = Yaml.Context.error 144 | 145 | private typealias ContextValue = (context: Context, value: Yaml) 146 | 147 | private func createContextValue (_ context: Context) -> (Yaml) -> ContextValue { 148 | return { value in (context, value) } 149 | } 150 | 151 | private func getContext (_ cv: ContextValue) -> Context { 152 | return cv.context 153 | } 154 | 155 | private func getValue (_ cv: ContextValue) -> Yaml { 156 | return cv.value 157 | } 158 | 159 | 160 | private func peekType (_ context: Context) -> Yaml.TokenType { 161 | return context.tokens[0].type 162 | } 163 | 164 | 165 | private func peekMatch (_ context: Context) -> String { 166 | return context.tokens[0].match 167 | } 168 | 169 | 170 | private func advance (_ context: Context) -> Context { 171 | var tokens = context.tokens 172 | tokens.remove(at: 0) 173 | return Context(tokens, context.aliases) 174 | } 175 | 176 | private func ignoreSpace (_ context: Context) -> Context { 177 | // print("||||||||||||", context) 178 | if ![.comment, .space, .newLine].contains(peekType(context)) { 179 | // if ![.space, .newLine].contains(peekType(context)) { 180 | return context 181 | } 182 | return ignoreSpace(advance(context)) 183 | } 184 | 185 | private func ignoreDocEnd (_ context: Context) -> Context { 186 | if ![.comment, .space, .newLine, .docend].contains(peekType(context)) { 187 | return context 188 | } 189 | return ignoreDocEnd(advance(context)) 190 | } 191 | 192 | private func expect (_ type: Yaml.TokenType, message: String) -> (Context) -> YAMLResult { 193 | return { context in 194 | let check = peekType(context) == type 195 | return Resulter.`guard`(error(message)(context), check: check) 196 | >>| Resulter.lift(advance(context)) 197 | } 198 | } 199 | 200 | private func expectVersion (_ context: Context) -> YAMLResult { 201 | let version = peekMatch(context) 202 | let check = ["1.1", "1.2"].contains(version) 203 | return Resulter.`guard`(error("invalid yaml version")(context), check: check) 204 | >>| Resulter.lift(advance(context)) 205 | } 206 | 207 | 208 | private func recreateText (_ string: String, context: Context) -> String { 209 | if string.count >= 50 || peekType(context) == .end { 210 | return string 211 | } 212 | return recreateText(string + peekMatch(context), context: advance(context)) 213 | } 214 | 215 | private func parseHeader (_ context: Context) -> YAMLResult { 216 | return parseHeader(true)(Context(context.tokens, [:])) 217 | } 218 | 219 | private func parseHeader (_ yamlAllowed: Bool) -> (Context) -> YAMLResult { 220 | return { context in 221 | switch peekType(context) { 222 | 223 | case .comment, .space, .newLine: 224 | return Resulter.lift(context) 225 | >>- advance 226 | >>=- parseHeader(yamlAllowed) 227 | 228 | case .yamlDirective: 229 | let err = "duplicate yaml directive" 230 | return Resulter.`guard`(error(err)(context), check: yamlAllowed) 231 | >>| Resulter.lift(context) 232 | >>- advance 233 | >>=- expect(Yaml.TokenType.space, message: "expected space") 234 | >>=- expectVersion 235 | >>=- parseHeader(false) 236 | 237 | case .docStart: 238 | return Resulter.lift(advance(context)) 239 | 240 | default: 241 | return Resulter.`guard`(error("expected ---")(context), check: yamlAllowed) 242 | >>| Resulter.lift(context) 243 | } 244 | } 245 | } 246 | 247 | private func parse (_ context: Context) -> YAMLResult { 248 | // print(context) 249 | // print(peekType(context), peekMatch(context)) 250 | switch peekType(context) { 251 | 252 | case .comment, .space, .newLine: 253 | // case .space, .newLine: 254 | return parse(ignoreSpace(context)) 255 | 256 | case .null: 257 | return Resulter.lift((advance(context), nil)) 258 | 259 | case ._true: 260 | return Resulter.lift((advance(context), true)) 261 | 262 | case ._false: 263 | return Resulter.lift((advance(context), false)) 264 | 265 | case .int: 266 | let m = peekMatch(context) 267 | // will throw runtime error if overflows 268 | let v = Yaml.int(parseInt(m, radix: 10)) 269 | return Resulter.lift((advance(context), v)) 270 | 271 | // case .comment: 272 | // print("------------------------------") 273 | // print(peekMatch(context)) 274 | // // return parse(ignoreSpace(context)) 275 | // let m = peekMatch(context) 276 | // // will throw runtime error if overflows 277 | // return Resulter.lift((advance(context), Yaml.string(m))) 278 | 279 | case .intOct: 280 | let m = peekMatch(context) |> Yaml.Regex.replace(Yaml.Regex.regex("0o"), template: "") 281 | // will throw runtime error if overflows 282 | let v = Yaml.int(parseInt(m, radix: 8)) 283 | return Resulter.lift((advance(context), v)) 284 | 285 | case .intHex: 286 | let m = peekMatch(context) |> Yaml.Regex.replace(Yaml.Regex.regex("0x"), template: "") 287 | // will throw runtime error if overflows 288 | let v = Yaml.int(parseInt(m, radix: 16)) 289 | return Resulter.lift((advance(context), v)) 290 | 291 | case .intSex: 292 | let m = peekMatch(context) 293 | let v = Yaml.int(parseInt(m, radix: 60)) 294 | return Resulter.lift((advance(context), v)) 295 | 296 | case .infinityP: 297 | return Resulter.lift((advance(context), .double(Double.infinity))) 298 | 299 | case .infinityN: 300 | return Resulter.lift((advance(context), .double(-Double.infinity))) 301 | 302 | case .nan: 303 | return Resulter.lift((advance(context), .double(Double.nan))) 304 | 305 | case .double: 306 | let m = NSString(string: peekMatch(context)) 307 | return Resulter.lift((advance(context), .double(m.doubleValue))) 308 | 309 | case .dash: 310 | return parseBlockSeq(context) 311 | 312 | case .openSB: 313 | return parseFlowSeq(context) 314 | 315 | case .openCB: 316 | return parseFlowMap(context) 317 | 318 | case .questionMark: 319 | return parseBlockMap(context) 320 | 321 | case .stringDQ, .stringSQ, .string: 322 | return parseBlockMapOrString(context) 323 | 324 | case .literal: 325 | return parseliteral(context) 326 | 327 | case .folded: 328 | let cv = parseliteral(context) 329 | let c = cv >>- getContext 330 | let v = cv 331 | >>- getValue 332 | >>- { value in Yaml.string(foldBlock(value.string ?? "")) } 333 | return createContextValue <^> c <*> v 334 | 335 | case .indent: 336 | let advancedContext = advance(context) 337 | // print(">>", advancedContext) 338 | let cv = parse(advancedContext) 339 | // print("--", context) 340 | // print(cv) 341 | // print() 342 | let v = cv >>- getValue 343 | let c_ = cv 344 | >>- getContext 345 | // print(c_) 346 | let c = c_ 347 | >>- ignoreSpace 348 | >>=- expect(Yaml.TokenType.dedent, message: "expected dedent") 349 | return createContextValue <^> c <*> v 350 | 351 | case .anchor: 352 | let m = peekMatch(context) 353 | let name = m[m.index(after: m.startIndex)...] 354 | let cv = parse(advance(context)) 355 | let v = cv >>- getValue 356 | let c = addAlias(name) <^> v <*> (cv >>- getContext) 357 | return createContextValue <^> c <*> v 358 | 359 | case .alias: 360 | let m = peekMatch(context) 361 | let name = m[m.index(after: m.startIndex)...] 362 | let value = context.aliases[name] 363 | let err = "unknown alias \(name)" 364 | return Resulter.`guard`(error(err)(context), check: value != nil) 365 | >>| Resulter.lift((advance(context), value ?? nil)) 366 | 367 | case .end, .dedent: 368 | return Resulter.lift((context, nil)) 369 | 370 | default: 371 | return Resulter.fail(error("unexpected type \(peekType(context))")(context)) 372 | 373 | } 374 | } 375 | 376 | private func addAlias (_ name: String.SubSequence) -> (Yaml) -> (Context) -> Context { 377 | return { value in 378 | return { context in 379 | var aliases = context.aliases 380 | aliases[name] = value 381 | return Context(context.tokens, aliases) 382 | } 383 | } 384 | } 385 | 386 | private func appendToArray (_ array: [Yaml]) -> (Yaml) -> [Yaml] { 387 | return { value in 388 | return array + [value] 389 | } 390 | } 391 | 392 | private func putToMap (_ map: [Yaml: Yaml]) -> (Yaml) -> (Yaml) -> [Yaml: Yaml] { 393 | return { key in 394 | return { value in 395 | var map = map 396 | map[key] = value 397 | return map 398 | } 399 | } 400 | } 401 | 402 | private func checkKeyUniqueness (_ acc: [Yaml: Yaml]) -> (_ context: Context, _ key: Yaml) 403 | -> YAMLResult { 404 | return { (context, key) in 405 | let err = "duplicate key \(key)" 406 | return Resulter.`guard`(error(err)(context), check: !acc.keys.contains(key)) 407 | >>| Resulter.lift((context, key)) 408 | } 409 | } 410 | 411 | private func parseFlowSeq (_ context: Context) -> YAMLResult { 412 | return Resulter.lift(context) 413 | >>=- expect(Yaml.TokenType.openSB, message: "expected [") 414 | >>=- parseFlowSeq([]) 415 | } 416 | 417 | private func parseFlowSeq (_ acc: [Yaml]) -> (Context) -> YAMLResult { 418 | return { context in 419 | if peekType(context) == .closeSB { 420 | return Resulter.lift((advance(context), .array(acc))) 421 | } 422 | let cv = Resulter.lift(context) 423 | >>- ignoreSpace 424 | >>=- (acc.count == 0 ? Resulter.lift : expect(Yaml.TokenType.comma, message: "expected comma")) 425 | >>- ignoreSpace 426 | >>=- parse 427 | let v = cv >>- getValue 428 | let c = cv 429 | >>- getContext 430 | >>- ignoreSpace 431 | let a = appendToArray(acc) <^> v 432 | return parseFlowSeq <^> a <*> c |> Resulter.join 433 | } 434 | } 435 | 436 | 437 | private func parseFlowMap (_ context: Context) -> YAMLResult { 438 | return Resulter.lift(context) 439 | >>=- expect(Yaml.TokenType.openCB, message: "expected {") 440 | >>=- parseFlowMap([:]) 441 | } 442 | 443 | private func parseFlowMap (_ acc: [Yaml: Yaml]) -> (Context) -> YAMLResult { 444 | return { context in 445 | if peekType(context) == .closeCB { 446 | return Resulter.lift((advance(context), .dictionary(acc))) 447 | } 448 | let ck = Resulter.lift(context) 449 | >>- ignoreSpace 450 | >>=- (acc.count == 0 ? Resulter.lift : expect(Yaml.TokenType.comma, message: "expected comma")) 451 | >>- ignoreSpace 452 | >>=- parseString 453 | >>=- checkKeyUniqueness(acc) 454 | let k = ck >>- getValue 455 | let cv = ck 456 | >>- getContext 457 | >>=- expect(Yaml.TokenType.colon, message: "expected colon") 458 | >>=- parse 459 | let v = cv >>- getValue 460 | let c = cv 461 | >>- getContext 462 | >>- ignoreSpace 463 | let a = putToMap(acc) <^> k <*> v 464 | return parseFlowMap <^> a <*> c |> Resulter.join 465 | } 466 | } 467 | 468 | private func parseBlockSeq (_ context: Context) -> YAMLResult { 469 | return parseBlockSeq([])(context) 470 | } 471 | 472 | private func parseBlockSeq (_ acc: [Yaml]) -> (Context) -> YAMLResult { 473 | return { context in 474 | if peekType(context) != .dash { 475 | return Resulter.lift((context, .array(acc))) 476 | } 477 | let cv = Resulter.lift(context) 478 | >>- advance 479 | >>=- expect(Yaml.TokenType.indent, message: "expected indent after dash") 480 | >>- ignoreSpace 481 | >>=- parse 482 | let v = cv >>- getValue 483 | let c = cv 484 | >>- getContext 485 | >>- ignoreSpace 486 | >>=- expect(Yaml.TokenType.dedent, message: "expected dedent after dash indent") 487 | >>- ignoreSpace 488 | let a = appendToArray(acc) <^> v 489 | return parseBlockSeq <^> a <*> c |> Resulter.join 490 | } 491 | } 492 | 493 | private func parseBlockMap (_ context: Context) -> YAMLResult { 494 | return parseBlockMap([:])(context) 495 | } 496 | 497 | private func parseBlockMap (_ acc: [Yaml: Yaml]) -> (Context) -> YAMLResult { 498 | return { context in 499 | switch peekType(context) { 500 | 501 | case .questionMark: 502 | return parseQuestionMarkkeyValue(acc)(context) 503 | 504 | case .string, .stringDQ, .stringSQ: 505 | return parseStringKeyValue(acc)(context) 506 | 507 | default: 508 | return Resulter.lift((context, .dictionary(acc))) 509 | } 510 | } 511 | } 512 | 513 | private func parseQuestionMarkkeyValue (_ acc: [Yaml: Yaml]) -> (Context) -> YAMLResult { 514 | return { context in 515 | let ck = Resulter.lift(context) 516 | >>=- expect(Yaml.TokenType.questionMark, message: "expected ?") 517 | >>=- parse 518 | >>=- checkKeyUniqueness(acc) 519 | let k = ck >>- getValue 520 | let cv = ck 521 | >>- getContext 522 | >>- ignoreSpace 523 | >>=- parseColonValueOrNil 524 | let v = cv >>- getValue 525 | let c = cv 526 | >>- getContext 527 | >>- ignoreSpace 528 | let a = putToMap(acc) <^> k <*> v 529 | return parseBlockMap <^> a <*> c |> Resulter.join 530 | } 531 | } 532 | 533 | private func parseColonValueOrNil (_ context: Context) -> YAMLResult { 534 | if peekType(context) != .colon { 535 | return Resulter.lift((context, nil)) 536 | } 537 | return parseColonValue(context) 538 | } 539 | 540 | private func parseColonValue (_ context: Context) -> YAMLResult { 541 | return Resulter.lift(context) 542 | >>=- expect(Yaml.TokenType.colon, message: "expected colon") 543 | >>- ignoreSpace 544 | >>=- parse 545 | } 546 | 547 | private func parseStringKeyValue (_ acc: [Yaml: Yaml]) -> (Context) -> YAMLResult { 548 | return { context in 549 | let ck = Resulter.lift(context) 550 | >>=- parseString 551 | >>=- checkKeyUniqueness(acc) 552 | let k = ck >>- getValue 553 | let cv = ck 554 | >>- getContext 555 | >>- ignoreSpace 556 | >>=- parseColonValue 557 | let v = cv >>- getValue 558 | let c = cv 559 | >>- getContext 560 | >>- ignoreSpace 561 | let a = putToMap(acc) <^> k <*> v 562 | return parseBlockMap <^> a <*> c |> Resulter.join 563 | } 564 | } 565 | 566 | private func parseString (_ context: Context) -> YAMLResult { 567 | switch peekType(context) { 568 | 569 | case .string: 570 | let m = normalizeBreaks(peekMatch(context)) 571 | let folded = m |> Yaml.Regex.replace(Yaml.Regex.regex("^[ \\t\\n]+|[ \\t\\n]+$"), template: "") |> foldFlow 572 | return Resulter.lift((advance(context), .string(folded))) 573 | 574 | case .stringDQ: 575 | let m = unwrapQuotedString(normalizeBreaks(peekMatch(context))) 576 | return Resulter.lift((advance(context), .string(unescapeDoubleQuotes(foldFlow(m))))) 577 | 578 | case .stringSQ: 579 | let m = unwrapQuotedString(normalizeBreaks(peekMatch(context))) 580 | return Resulter.lift((advance(context), .string(unescapeSingleQuotes(foldFlow(m))))) 581 | 582 | default: 583 | return Resulter.fail(error("expected string")(context)) 584 | } 585 | } 586 | 587 | 588 | private func parseBlockMapOrString (_ context: Context) -> YAMLResult { 589 | let match = peekMatch(context) 590 | // should spaces before colon be ignored? 591 | return context.tokens[1].type != .colon || Yaml.Regex.matches(match, regex: Yaml.Regex.regex("\n")) 592 | ? parseString(context) 593 | : parseBlockMap(context) 594 | } 595 | 596 | private func foldBlock (_ block: String) -> String { 597 | let (body, trail) = block |> Yaml.Regex.splitTrail(Yaml.Regex.regex("\\n*$")) 598 | return (body 599 | |> Yaml.Regex.replace(Yaml.Regex.regex("^([^ \\t\\n].*)\\n(?=[^ \\t\\n])", options: "m"), template: "$1 ") 600 | |> Yaml.Regex.replace( 601 | Yaml.Regex.regex("^([^ \\t\\n].*)\\n(\\n+)(?![ \\t])", options: "m"), template: "$1$2") 602 | ) + trail 603 | } 604 | 605 | private func foldFlow (_ flow: String) -> String { 606 | let (lead, rest) = flow |> Yaml.Regex.splitLead(Yaml.Regex.regex("^[ \\t]+")) 607 | let (body, trail) = rest |> Yaml.Regex.splitTrail(Yaml.Regex.regex("[ \\t]+$")) 608 | let folded = body 609 | |> Yaml.Regex.replace(Yaml.Regex.regex("^[ \\t]+|[ \\t]+$|\\\\\\n", options: "m"), template: "") 610 | |> Yaml.Regex.replace(Yaml.Regex.regex("(^|.)\\n(?=.|$)"), template: "$1 ") 611 | |> Yaml.Regex.replace(Yaml.Regex.regex("(.)\\n(\\n+)"), template: "$1$2") 612 | return lead + folded + trail 613 | } 614 | 615 | private func count(string: String) -> Int { 616 | return string.count 617 | } 618 | 619 | private func parseliteral (_ context: Context) -> YAMLResult { 620 | let literal = peekMatch(context) 621 | let blockContext = advance(context) 622 | let chomps = ["-": -1, "+": 1] 623 | let chomp = chomps[literal |> Yaml.Regex.replace(Yaml.Regex.regex("[^-+]"), template: "")] ?? 0 624 | let indent = parseInt(literal |> Yaml.Regex.replace(Yaml.Regex.regex("[^1-9]"), template: ""), radix: 10) 625 | let headerPattern = Yaml.Regex.regex("^(\\||>)([1-9][-+]|[-+]?[1-9]?)( |$)") 626 | let error0 = "invalid chomp or indent header" 627 | let c = Resulter.`guard`(error(error0)(context), 628 | check: Yaml.Regex.matches(literal, regex: headerPattern!)) 629 | >>| Resulter.lift(blockContext) 630 | >>=- expect(Yaml.TokenType.string, message: "expected scalar block") 631 | let block = peekMatch(blockContext) 632 | |> normalizeBreaks 633 | let (lead, _) = block 634 | |> Yaml.Regex.splitLead(Yaml.Regex.regex("^( *\\n)* {1,}(?! |\\n|$)")) 635 | let foundindent = lead 636 | |> Yaml.Regex.replace(Yaml.Regex.regex("^( *\\n)*"), template: "") 637 | |> count 638 | let effectiveindent = indent > 0 ? indent : foundindent 639 | let invalidPattern = 640 | Yaml.Regex.regex("^( {0,\(effectiveindent)}\\n)* {\(effectiveindent + 1),}\\n") 641 | let check1 = Yaml.Regex.matches(block, regex: invalidPattern!) 642 | let check2 = indent > 0 && foundindent < indent 643 | let trimmed = block 644 | |> Yaml.Regex.replace(Yaml.Regex.regex("^ {0,\(effectiveindent)}"), template: "") 645 | |> Yaml.Regex.replace(Yaml.Regex.regex("\\n {0,\(effectiveindent)}"), template: "\n") 646 | |> (chomp == -1 647 | ? Yaml.Regex.replace(Yaml.Regex.regex("(\\n *)*$"), template: "") 648 | : chomp == 0 649 | ? Yaml.Regex.replace(Yaml.Regex.regex("(?=[^ ])(\\n *)*$"), template: "\n") 650 | : { s in s } 651 | ) 652 | let error1 = "leading all-space line must not have too many spaces" 653 | let error2 = "less indented block scalar than the indicated level" 654 | return c 655 | >>| Resulter.`guard`(error(error1)(blockContext), check: !check1) 656 | >>| Resulter.`guard`(error(error2)(blockContext), check: !check2) 657 | >>| c 658 | >>- { context in (context, .string(trimmed))} 659 | } 660 | 661 | 662 | private func parseInt (_ string: String, radix: Int) -> Int { 663 | let (sign, str) = Yaml.Regex.splitLead(Yaml.Regex.regex("^[-+]"))(string) 664 | let multiplier = (sign == "-" ? -1 : 1) 665 | let ints = radix == 60 666 | ? toSexints(str) 667 | : toints(str) 668 | return multiplier * ints.reduce(0, { acc, i in acc * radix + i }) 669 | } 670 | 671 | private func toSexints (_ string: String) -> [Int] { 672 | return string.components(separatedBy: ":").map { 673 | c in Int(c) ?? 0 674 | } 675 | } 676 | 677 | private func toints (_ string: String) -> [Int] { 678 | return string.unicodeScalars.map { 679 | c in 680 | switch c { 681 | case "0"..."9": return Int(c.value) - Int(("0" as UnicodeScalar).value) 682 | case "a"..."z": return Int(c.value) - Int(("a" as UnicodeScalar).value) + 10 683 | case "A"..."Z": return Int(c.value) - Int(("A" as UnicodeScalar).value) + 10 684 | default: fatalError("invalid digit \(c)") 685 | } 686 | } 687 | } 688 | 689 | private func normalizeBreaks (_ s: String) -> String { 690 | return Yaml.Regex.replace(Yaml.Regex.regex("\\r\\n|\\r"), template: "\n")(s) 691 | } 692 | 693 | private func unwrapQuotedString (_ s: String) -> String { 694 | return String(s[s.index(after: s.startIndex).. String { 698 | return Yaml.Regex.replace(Yaml.Regex.regex("''"), template: "'")(s) 699 | } 700 | 701 | private func unescapeDoubleQuotes (_ input: String) -> String { 702 | return input 703 | |> Yaml.Regex.replace(Yaml.Regex.regex("\\\\([0abtnvfre \"\\/N_LP])")) 704 | { escapeCharacters[$0[1]] ?? "" } 705 | |> Yaml.Regex.replace(Yaml.Regex.regex("\\\\x([0-9A-Fa-f]{2})")) 706 | { String(describing: UnicodeScalar(parseInt($0[1], radix: 16))) } 707 | |> Yaml.Regex.replace(Yaml.Regex.regex("\\\\u([0-9A-Fa-f]{4})")) 708 | { String(describing: UnicodeScalar(parseInt($0[1], radix: 16))) } 709 | |> Yaml.Regex.replace(Yaml.Regex.regex("\\\\U([0-9A-Fa-f]{8})")) 710 | { String(describing: UnicodeScalar(parseInt($0[1], radix: 16))) } 711 | } 712 | 713 | private let escapeCharacters = [ 714 | "0": "\0", 715 | "a": "\u{7}", 716 | "b": "\u{8}", 717 | "t": "\t", 718 | "n": "\n", 719 | "v": "\u{B}", 720 | "f": "\u{C}", 721 | "r": "\r", 722 | "e": "\u{1B}", 723 | " ": " ", 724 | "\"": "\"", 725 | "\\": "\\", 726 | "/": "/", 727 | "N": "\u{85}", 728 | "_": "\u{A0}", 729 | "L": "\u{2028}", 730 | "P": "\u{2029}" 731 | ] 732 | -------------------------------------------------------------------------------- /Sources/Yaml/YAMLRegex.swift: -------------------------------------------------------------------------------- 1 | import Foundation 2 | 3 | 4 | private let invalidOptionsPattern = 5 | try! NSRegularExpression(pattern: "[^ixsm]", options: []) 6 | 7 | private let regexOptions: [Character: NSRegularExpression.Options] = [ 8 | "i": .caseInsensitive, 9 | "x": .allowCommentsAndWhitespace, 10 | "s": .dotMatchesLineSeparators, 11 | "m": .anchorsMatchLines 12 | ] 13 | 14 | extension Yaml { 15 | struct Regex { 16 | 17 | static func matchRange (_ string: String, regex: NSRegularExpression) -> NSRange { 18 | let sr = NSMakeRange(0, string.utf16.count) 19 | return regex.rangeOfFirstMatch(in: string, options: [], range: sr) 20 | } 21 | 22 | static func matches (_ string: String, regex: NSRegularExpression) -> Bool { 23 | return matchRange(string, regex: regex).location != NSNotFound 24 | } 25 | 26 | static func regex (_ pattern: String, options: String = "") -> NSRegularExpression! { 27 | if matches(options, regex: invalidOptionsPattern) { 28 | return nil 29 | } 30 | 31 | let opts = options.reduce(NSRegularExpression.Options()) { (acc, opt) -> NSRegularExpression.Options in 32 | return NSRegularExpression.Options(rawValue:acc.rawValue | (regexOptions[opt] ?? NSRegularExpression.Options()).rawValue) 33 | } 34 | return try? NSRegularExpression(pattern: pattern, options: opts) 35 | } 36 | 37 | 38 | 39 | 40 | 41 | static func replace (_ regex: NSRegularExpression, template: String) -> (String) 42 | -> String { 43 | return { string in 44 | let s = NSMutableString(string: string) 45 | let range = NSMakeRange(0, string.utf16.count) 46 | _ = regex.replaceMatches(in: s, options: [], range: range, 47 | withTemplate: template) 48 | #if os(Linux) 49 | return s._bridgeToSwift() 50 | #else 51 | return s as String 52 | #endif 53 | } 54 | } 55 | 56 | static func replace (_ regex: NSRegularExpression, block: @escaping ([String]) -> String) 57 | -> (String) -> String { 58 | return { string in 59 | let s = NSMutableString(string: string) 60 | let range = NSMakeRange(0, string.utf16.count) 61 | var offset = 0 62 | regex.enumerateMatches(in: string, options: [], range: range) { 63 | result, _, _ in 64 | if let result = result { 65 | var captures = [String](repeating: "", count: result.numberOfRanges) 66 | for i in 0.. (String) 87 | -> (String, String) { 88 | return { string in 89 | let r = matchRange(string, regex: regex) 90 | if r.location == NSNotFound { 91 | return ("", string) 92 | } else { 93 | let s = NSString(string: string) 94 | let i = r.location + r.length 95 | return (s.substring(to: i), s.substring(from: i)) 96 | } 97 | } 98 | } 99 | 100 | static func splitTrail (_ regex: NSRegularExpression) -> (String) 101 | -> (String, String) { 102 | return { string in 103 | let r = matchRange(string, regex: regex) 104 | if r.location == NSNotFound { 105 | return (string, "") 106 | } else { 107 | let s = NSString(string: string) 108 | let i = r.location 109 | return (s.substring(to: i), s.substring(from: i)) 110 | } 111 | } 112 | } 113 | 114 | static func substring (_ range: NSRange, _ string : String ) -> String { 115 | return NSString(string: string).substring(with: range) 116 | } 117 | 118 | static func substring (_ index: Int, _ string: String ) -> String { 119 | return NSString(string: string).substring(from: index) 120 | } 121 | } 122 | 123 | } 124 | -------------------------------------------------------------------------------- /Sources/Yaml/YAMLResult.swift: -------------------------------------------------------------------------------- 1 | internal enum YAMLResult { 2 | case error(String) 3 | case value(T) 4 | 5 | public var error: String? { 6 | switch self { 7 | case .error(let e): return e 8 | case .value: return nil 9 | } 10 | } 11 | 12 | public var value: T? { 13 | switch self { 14 | case .error: return nil 15 | case .value(let v): return v 16 | } 17 | } 18 | 19 | public func map (f: (T) -> U) -> YAMLResult { 20 | switch self { 21 | case .error(let e): return .error(e) 22 | case .value(let v): return .value(f(v)) 23 | } 24 | } 25 | 26 | public func flatMap (f: (T) -> YAMLResult) -> YAMLResult { 27 | switch self { 28 | case .error(let e): return .error(e) 29 | case .value(let v): return f(v) 30 | } 31 | } 32 | } 33 | 34 | 35 | precedencegroup Functional { 36 | associativity: left 37 | higherThan: DefaultPrecedence 38 | } 39 | 40 | infix operator <*>: Functional 41 | func <*> (f: YAMLResult<(T) -> U>, x: YAMLResult) -> YAMLResult { 42 | switch (x, f) { 43 | case (.error(let e), _): return .error(e) 44 | case (.value, .error(let e)): return .error(e) 45 | case (.value(let x), .value(let f)): return . value(f(x)) 46 | } 47 | } 48 | 49 | infix operator <^>: Functional 50 | func <^> (f: (T) -> U, x: YAMLResult) -> YAMLResult { 51 | return x.map(f: f) 52 | } 53 | 54 | infix operator >>-: Functional 55 | func >>- (x: YAMLResult, f: (T) -> U) -> YAMLResult { 56 | return x.map(f: f) 57 | } 58 | 59 | infix operator >>=-: Functional 60 | func >>=- (x: YAMLResult, f: (T) -> YAMLResult) -> YAMLResult { 61 | return x.flatMap(f: f) 62 | } 63 | 64 | infix operator >>|: Functional 65 | func >>| (x: YAMLResult, y: YAMLResult) -> YAMLResult { 66 | return x.flatMap { _ in y } 67 | } 68 | 69 | extension Yaml { 70 | static func lift (_ v: V) -> YAMLResult { 71 | return .value(v) 72 | } 73 | 74 | static func fail (_ e: String) -> YAMLResult { 75 | return .error(e) 76 | } 77 | 78 | static func join (_ x: YAMLResult>) -> YAMLResult { 79 | return x >>=- { i in i } 80 | } 81 | 82 | static func `guard` (_ error: @autoclosure() -> String, check: Bool) -> YAMLResult<()> { 83 | return check ? lift(()) : .error(error()) 84 | } 85 | 86 | } 87 | -------------------------------------------------------------------------------- /Sources/Yaml/YAMLTokenizer.swift: -------------------------------------------------------------------------------- 1 | import Foundation 2 | 3 | 4 | extension Yaml { 5 | enum TokenType: String { 6 | case yamlDirective = "%YAML" 7 | case docStart = "doc-start" 8 | case docend = "doc-end" 9 | case comment = "comment" 10 | case space = "space" 11 | case newLine = "newline" 12 | case indent = "indent" 13 | case dedent = "dedent" 14 | case null = "null" 15 | case _true = "true" 16 | case _false = "false" 17 | case infinityP = "+infinity" 18 | case infinityN = "-infinity" 19 | case nan = "nan" 20 | case double = "double" 21 | case int = "int" 22 | case intOct = "int-oct" 23 | case intHex = "int-hex" 24 | case intSex = "int-sex" 25 | case anchor = "&" 26 | case alias = "*" 27 | case comma = "," 28 | case openSB = "[" 29 | case closeSB = "]" 30 | case dash = "-" 31 | case openCB = "{" 32 | case closeCB = "}" 33 | case key = "key" 34 | case keyDQ = "key-dq" 35 | case keySQ = "key-sq" 36 | case questionMark = "?" 37 | case colonFO = ":-flow-out" 38 | case colonFI = ":-flow-in" 39 | case colon = ":" 40 | case literal = "|" 41 | case folded = ">" 42 | case reserved = "reserved" 43 | case stringDQ = "string-dq" 44 | case stringSQ = "string-sq" 45 | case stringFI = "string-flow-in" 46 | case stringFO = "string-flow-out" 47 | case string = "string" 48 | case end = "end" 49 | } 50 | } 51 | 52 | private typealias TokenPattern = (type: Yaml.TokenType, pattern: NSRegularExpression) 53 | 54 | extension Yaml { 55 | typealias TokenMatch = (type: Yaml.TokenType, match: String) 56 | } 57 | 58 | private let bBreak = "(?:\\r\\n|\\r|\\n)" 59 | 60 | // printable non-space chars, 61 | // except `:`(3a), `#`(23), `,`(2c), `[`(5b), `]`(5d), `{`(7b), `}`(7d) 62 | private let safeIn = "\\x21\\x22\\x24-\\x2b\\x2d-\\x39\\x3b-\\x5a\\x5c\\x5e-\\x7a" + 63 | "\\x7c\\x7e\\x85\\xa0-\\ud7ff\\ue000-\\ufefe\\uff00\\ufffd" + 64 | "\\U00010000-\\U0010ffff" 65 | // with flow indicators: `,`, `[`, `]`, `{`, `}` 66 | private let safeOut = "\\x2c\\x5b\\x5d\\x7b\\x7d" + safeIn 67 | private let plainOutPattern = 68 | "([\(safeOut)]#|:(?![ \\t]|\(bBreak))|[\(safeOut)]|[ \\t])+" 69 | private let plainInPattern = 70 | "([\(safeIn)]#|:(?![ \\t]|\(bBreak))|[\(safeIn)]|[ \\t]|\(bBreak))+" 71 | private let dashPattern = Yaml.Regex.regex("^-([ \\t]+(?!#|\(bBreak))|(?=[ \\t\\n]))") 72 | private let finish = "(?= *(,|\\]|\\}|( #.*)?(\(bBreak)|$)))" 73 | 74 | private let tokenPatterns: [TokenPattern] = [ 75 | (.yamlDirective, Yaml.Regex.regex("^%YAML(?= )")), 76 | (.docStart, Yaml.Regex.regex("^---")), 77 | (.docend, Yaml.Regex.regex("^\\.\\.\\.")), 78 | (.comment, Yaml.Regex.regex("^#.*|^\(bBreak) *(#.*)?(?=\(bBreak)|$)")), 79 | (.space, Yaml.Regex.regex("^ +")), 80 | (.newLine, Yaml.Regex.regex("^\(bBreak) *")), 81 | (.dash, dashPattern!), 82 | (.null, Yaml.Regex.regex("^(null|Null|NULL|~)\(finish)")), 83 | (._true, Yaml.Regex.regex("^(true|True|TRUE)\(finish)")), 84 | (._false, Yaml.Regex.regex("^(false|False|FALSE)\(finish)")), 85 | (.infinityP, Yaml.Regex.regex("^\\+?\\.(inf|Inf|INF)\(finish)")), 86 | (.infinityN, Yaml.Regex.regex("^-\\.(inf|Inf|INF)\(finish)")), 87 | (.nan, Yaml.Regex.regex("^\\.(nan|NaN|NAN)\(finish)")), 88 | (.int, Yaml.Regex.regex("^[-+]?[0-9]+\(finish)")), 89 | (.intOct, Yaml.Regex.regex("^0o[0-7]+\(finish)")), 90 | (.intHex, Yaml.Regex.regex("^0x[0-9a-fA-F]+\(finish)")), 91 | (.intSex, Yaml.Regex.regex("^[0-9]{2}(:[0-9]{2})+\(finish)")), 92 | (.double, Yaml.Regex.regex("^[-+]?(\\.[0-9]+|[0-9]+(\\.[0-9]*)?)([eE][-+]?[0-9]+)?\(finish)")), 93 | (.anchor, Yaml.Regex.regex("^&\\w+")), 94 | (.alias, Yaml.Regex.regex("^\\*\\w+")), 95 | (.comma, Yaml.Regex.regex("^,")), 96 | (.openSB, Yaml.Regex.regex("^\\[")), 97 | (.closeSB, Yaml.Regex.regex("^\\]")), 98 | (.openCB, Yaml.Regex.regex("^\\{")), 99 | (.closeCB, Yaml.Regex.regex("^\\}")), 100 | (.questionMark, Yaml.Regex.regex("^\\?( +|(?=\(bBreak)))")), 101 | (.colonFO, Yaml.Regex.regex("^:(?!:)")), 102 | (.colonFI, Yaml.Regex.regex("^:(?!:)")), 103 | (.literal, Yaml.Regex.regex("^\\|.*")), 104 | (.folded, Yaml.Regex.regex("^>.*")), 105 | (.reserved, Yaml.Regex.regex("^[@`]")), 106 | (.stringDQ, Yaml.Regex.regex("^\"([^\\\\\"]|\\\\(.|\(bBreak)))*\"")), 107 | (.stringSQ, Yaml.Regex.regex("^'([^']|'')*'")), 108 | (.stringFO, Yaml.Regex.regex("^\(plainOutPattern)(?=:([ \\t]|\(bBreak))|\(bBreak)|$)")), 109 | (.stringFI, Yaml.Regex.regex("^\(plainInPattern)")), 110 | ] 111 | 112 | extension Yaml { 113 | static func escapeErrorContext (_ text: String) -> String { 114 | let endIndex = text.index(text.startIndex, offsetBy: 50, limitedBy: text.endIndex) ?? text.endIndex 115 | let escaped = String(text[.. Yaml.Regex.replace(Yaml.Regex.regex("\\r"), template: "\\\\r") 117 | |> Yaml.Regex.replace(Yaml.Regex.regex("\\n"), template: "\\\\n") 118 | |> Yaml.Regex.replace(Yaml.Regex.regex("\""), template: "\\\\\"") 119 | return "near \"\(escaped)\"" 120 | } 121 | 122 | 123 | static func tokenize (_ text: String) -> YAMLResult<[TokenMatch]> { 124 | var text = text 125 | var matchList: [TokenMatch] = [] 126 | var indents = [0] 127 | var insideFlow = 0 128 | next: 129 | while text.endIndex > text.startIndex { 130 | for tokenPattern in tokenPatterns { 131 | let range = Yaml.Regex.matchRange(text, regex: tokenPattern.pattern) 132 | if range.location != NSNotFound { 133 | let rangeEnd = range.location + range.length 134 | switch tokenPattern.type { 135 | 136 | case .newLine: 137 | let match = (range, text) |> Yaml.Regex.substring 138 | let lastindent = indents.last ?? 0 139 | let rest = match[match.index(after: match.startIndex)...] 140 | let spaces = rest.count 141 | let nestedBlockSequence = 142 | Yaml.Regex.matches((rangeEnd, text) |> Yaml.Regex.substring, regex: dashPattern!) 143 | if spaces == lastindent { 144 | matchList.append(TokenMatch(.newLine, match)) 145 | } else if spaces > lastindent { 146 | if insideFlow == 0 { 147 | if matchList.last != nil && 148 | matchList[matchList.endIndex - 1].type == .indent { 149 | indents[indents.endIndex - 1] = spaces 150 | matchList[matchList.endIndex - 1] = TokenMatch(.indent, match) 151 | } else { 152 | indents.append(spaces) 153 | matchList.append(TokenMatch(.indent, match)) 154 | } 155 | } 156 | } else if nestedBlockSequence && spaces == lastindent - 1 { 157 | matchList.append(TokenMatch(.newLine, match)) 158 | } else { 159 | while nestedBlockSequence && spaces < (indents.last ?? 0) - 1 160 | || !nestedBlockSequence && spaces < indents.last ?? 0 { 161 | indents.removeLast() 162 | matchList.append(TokenMatch(.dedent, "")) 163 | } 164 | matchList.append(TokenMatch(.newLine, match)) 165 | } 166 | 167 | case .dash, .questionMark: 168 | let match = (range, text) |> Yaml.Regex.substring 169 | let index = match.index(after: match.startIndex) 170 | let indent = match.count 171 | indents.append((indents.last ?? 0) + indent) 172 | matchList.append( 173 | TokenMatch(tokenPattern.type, String(match[.. 0 { 178 | continue 179 | } 180 | fallthrough 181 | 182 | case .colonFI: 183 | let match = (range, text) |> Yaml.Regex.substring 184 | matchList.append(TokenMatch(.colon, match)) 185 | if insideFlow == 0 { 186 | indents.append((indents.last ?? 0) + 1) 187 | matchList.append(TokenMatch(.indent, "")) 188 | } 189 | 190 | case .openSB, .openCB: 191 | insideFlow += 1 192 | matchList.append(TokenMatch(tokenPattern.type, (range, text) |> Yaml.Regex.substring)) 193 | 194 | case .closeSB, .closeCB: 195 | insideFlow -= 1 196 | matchList.append(TokenMatch(tokenPattern.type, (range, text) |> Yaml.Regex.substring)) 197 | 198 | case .literal, .folded: 199 | matchList.append(TokenMatch(tokenPattern.type, (range, text) |> Yaml.Regex.substring)) 200 | text = (rangeEnd, text) |> Yaml.Regex.substring 201 | let lastindent = indents.last ?? 0 202 | let minindent = 1 + lastindent 203 | let blockPattern = Yaml.Regex.regex(("^(\(bBreak) *)*(\(bBreak)" + 204 | "( {\(minindent),})[^ ].*(\(bBreak)( *|\\3.*))*)(?=\(bBreak)|$)")) 205 | let (lead, rest) = text |> Yaml.Regex.splitLead(blockPattern!) 206 | text = rest 207 | let block = (lead 208 | |> Yaml.Regex.replace(Yaml.Regex.regex("^\(bBreak)"), template: "") 209 | |> Yaml.Regex.replace(Yaml.Regex.regex("^ {0,\(lastindent)}"), template: "") 210 | |> Yaml.Regex.replace(Yaml.Regex.regex("\(bBreak) {0,\(lastindent)}"), template: "\n") 211 | ) + (Yaml.Regex.matches(text, regex: Yaml.Regex.regex("^\(bBreak)")) && lead.endIndex > lead.startIndex 212 | ? "\n" : "") 213 | matchList.append(TokenMatch(.string, block)) 214 | continue next 215 | 216 | case .stringFO: 217 | if insideFlow > 0 { 218 | continue 219 | } 220 | let indent = (indents.last ?? 0) 221 | let blockPattern = Yaml.Regex.regex(("^\(bBreak)( *| {\(indent),}" + 222 | "\(plainOutPattern))(?=\(bBreak)|$)")) 223 | var block = (range, text) 224 | |> Yaml.Regex.substring 225 | |> Yaml.Regex.replace(Yaml.Regex.regex("^[ \\t]+|[ \\t]+$"), template: "") 226 | text = (rangeEnd, text) |> Yaml.Regex.substring 227 | while true { 228 | let range = Yaml.Regex.matchRange(text, regex: blockPattern!) 229 | if range.location == NSNotFound { 230 | break 231 | } 232 | let s = (range, text) |> Yaml.Regex.substring 233 | block += "\n" + 234 | Yaml.Regex.replace(Yaml.Regex.regex("^\(bBreak)[ \\t]*|[ \\t]+$"), template: "")(s) 235 | text = (range.location + range.length, text) |> Yaml.Regex.substring 236 | } 237 | matchList.append(TokenMatch(.string, block)) 238 | continue next 239 | 240 | case .stringFI: 241 | let match = (range, text) 242 | |> Yaml.Regex.substring 243 | |> Yaml.Regex.replace(Yaml.Regex.regex("^[ \\t]|[ \\t]$"), template: "") 244 | matchList.append(TokenMatch(.string, match)) 245 | 246 | case .reserved: 247 | return fail(escapeErrorContext(text)) 248 | 249 | default: 250 | matchList.append(TokenMatch(tokenPattern.type, (range, text) |> Yaml.Regex.substring)) 251 | } 252 | text = (rangeEnd, text) |> Yaml.Regex.substring 253 | continue next 254 | } 255 | } 256 | return fail(escapeErrorContext(text)) 257 | } 258 | while indents.count > 1 { 259 | indents.removeLast() 260 | matchList.append((.dedent, "")) 261 | } 262 | matchList.append((.end, "")) 263 | return lift(matchList) 264 | } 265 | } 266 | -------------------------------------------------------------------------------- /Sources/Yaml/Yaml.swift: -------------------------------------------------------------------------------- 1 | import Foundation 2 | 3 | public enum Yaml: Hashable { 4 | case null 5 | case bool(Bool) 6 | case int(Int) 7 | case double(Double) 8 | case string(String) 9 | case array([Yaml]) 10 | case dictionary([Yaml: Yaml]) 11 | 12 | static public func == (lhs: Yaml, rhs: Yaml) -> Bool { 13 | switch (lhs, rhs) { 14 | case (.null, .null): 15 | return true 16 | case (.bool(let lv), .bool(let rv)): 17 | return lv == rv 18 | case (.int(let lv), .int(let rv)): 19 | return lv == rv 20 | case (.int(let lv), .double(let rv)): 21 | return Double(lv) == rv 22 | case (.double(let lv), .double(let rv)): 23 | return lv == rv 24 | case (.double(let lv), .int(let rv)): 25 | return lv == Double(rv) 26 | case (.string(let lv), .string(let rv)): 27 | return lv == rv 28 | case (.array(let lv), .array(let rv)): 29 | return lv == rv 30 | case (.dictionary(let lv), .dictionary(let rv)): 31 | return lv == rv 32 | default: 33 | return false 34 | } 35 | } 36 | 37 | // unary `-` operator 38 | static public prefix func - (value: Yaml) -> Yaml { 39 | switch value { 40 | case .int(let v): 41 | return .int(-v) 42 | case .double(let v): 43 | return .double(-v) 44 | default: 45 | fatalError("`-` operator may only be used on .int or .double Yaml values") 46 | } 47 | } 48 | 49 | public static let commentPrefix = "__comment__" 50 | 51 | public func getComment(forKey key: String) -> String? { 52 | switch self[.string("\(Yaml.commentPrefix)\(key)")] { 53 | case let .string(value): 54 | return value 55 | default: 56 | return nil 57 | } 58 | } 59 | } 60 | 61 | extension Yaml { 62 | public enum ResultError: Error { 63 | case message(String?) 64 | } 65 | } 66 | 67 | extension Yaml: ExpressibleByNilLiteral { 68 | public init(nilLiteral: ()) { 69 | self = .null 70 | } 71 | } 72 | 73 | extension Yaml: ExpressibleByBooleanLiteral { 74 | public init(booleanLiteral: BooleanLiteralType) { 75 | self = .bool(booleanLiteral) 76 | } 77 | } 78 | 79 | extension Yaml: ExpressibleByIntegerLiteral { 80 | public init(integerLiteral: IntegerLiteralType) { 81 | self = .int(integerLiteral) 82 | } 83 | } 84 | 85 | extension Yaml: ExpressibleByFloatLiteral { 86 | public init(floatLiteral: FloatLiteralType) { 87 | self = .double(floatLiteral) 88 | } 89 | } 90 | 91 | extension Yaml: ExpressibleByStringLiteral { 92 | public init(stringLiteral: StringLiteralType) { 93 | self = .string(stringLiteral) 94 | } 95 | 96 | public init(extendedGraphemeClusterLiteral: StringLiteralType) { 97 | self = .string(extendedGraphemeClusterLiteral) 98 | } 99 | 100 | public init(unicodeScalarLiteral: StringLiteralType) { 101 | self = .string(unicodeScalarLiteral) 102 | } 103 | } 104 | 105 | extension Yaml: ExpressibleByArrayLiteral { 106 | public init(arrayLiteral elements: Yaml...) { 107 | self = .array(elements) 108 | } 109 | } 110 | 111 | extension Yaml: ExpressibleByDictionaryLiteral { 112 | public init(dictionaryLiteral elements: (Yaml, Yaml)...) { 113 | var dictionary = [Yaml: Yaml]() 114 | for (k, v) in elements { 115 | dictionary[k] = v 116 | } 117 | self = .dictionary(dictionary) 118 | } 119 | } 120 | 121 | extension Yaml: CustomStringConvertible { 122 | public var description: String { 123 | switch self { 124 | case .null: 125 | return "Null" 126 | case .bool(let b): 127 | return "Bool(\(b))" 128 | case .int(let i): 129 | return "Int(\(i))" 130 | case .double(let f): 131 | return "Double(\(f))" 132 | case .string(let s): 133 | return "String(\(s))" 134 | case .array(let s): 135 | return "Array(\(s))" 136 | case .dictionary(let m): 137 | return "Dictionary(\(m))" 138 | } 139 | } 140 | } 141 | 142 | 143 | extension Yaml { 144 | 145 | public static func load (_ text: String, preserveComments: Bool = false) throws -> Yaml { 146 | let result = tokenize(text) >>=- Context.makeDocParser(preserveComments: preserveComments) 147 | if let value = result.value { return value } else { throw ResultError.message(result.error) } 148 | } 149 | 150 | public static func loadMultiple (_ text: String) throws -> [Yaml] { 151 | let result = tokenize(text) >>=- Context.parseDocs 152 | if let value = result.value { return value } else { throw ResultError.message(result.error) } 153 | 154 | } 155 | 156 | public static func debug (_ text: String) -> Yaml? { 157 | let result = tokenize(text) 158 | >>- { tokens in print("\n====== Tokens:\n\(tokens)"); return tokens } 159 | >>=- Context.makeDocParser() 160 | >>- { value -> Yaml in print("------ Doc:\n\(value)"); return value } 161 | if let error = result.error { 162 | print("~~~~~~\n\(error)") 163 | } 164 | return result.value 165 | } 166 | 167 | public static func debugMultiple (_ text: String) -> [Yaml]? { 168 | let result = tokenize(text) 169 | >>- { tokens in print("\n====== Tokens:\n\(tokens)"); return tokens } 170 | >>=- Context.parseDocs 171 | >>- { values -> [Yaml] in values.forEach { 172 | v in print("------ Doc:\n\(v)") 173 | }; return values } 174 | if let error = result.error { 175 | print("~~~~~~\n\(error)") 176 | } 177 | return result.value 178 | } 179 | } 180 | 181 | extension Yaml { 182 | public subscript(index: Int) -> Yaml { 183 | get { 184 | assert(index >= 0) 185 | switch self { 186 | case .array(let array): 187 | if array.indices.contains(index) { 188 | return array[index] 189 | } else { 190 | return .null 191 | } 192 | default: 193 | return .null 194 | } 195 | } 196 | set { 197 | assert(index >= 0) 198 | switch self { 199 | case .array(let array): 200 | let emptyCount = max(0, index + 1 - array.count) 201 | let empty = [Yaml](repeating: .null, count: emptyCount) 202 | var new = array 203 | new.append(contentsOf: empty) 204 | new[index] = newValue 205 | self = .array(new) 206 | default: 207 | var array = [Yaml](repeating: .null, count: index + 1) 208 | array[index] = newValue 209 | self = .array(array) 210 | } 211 | } 212 | } 213 | 214 | public subscript(key: Yaml) -> Yaml { 215 | get { 216 | switch self { 217 | case .dictionary(let dictionary): 218 | return dictionary[key] ?? .null 219 | default: 220 | return .null 221 | } 222 | } 223 | set { 224 | switch self { 225 | case .dictionary(let dictionary): 226 | var new = dictionary 227 | new[key] = newValue 228 | self = .dictionary(new) 229 | default: 230 | var dictionary = [Yaml: Yaml]() 231 | dictionary[key] = newValue 232 | self = .dictionary(dictionary) 233 | } 234 | } 235 | } 236 | } 237 | 238 | extension Yaml { 239 | public var bool: Bool? { 240 | switch self { 241 | case .bool(let b): 242 | return b 243 | default: 244 | return nil 245 | } 246 | } 247 | 248 | public var int: Int? { 249 | switch self { 250 | case .int(let i): 251 | return i 252 | case .double(let f): 253 | if Double(Int(f)) == f { 254 | return Int(f) 255 | } else { 256 | return nil 257 | } 258 | default: 259 | return nil 260 | } 261 | } 262 | 263 | public var double: Double? { 264 | switch self { 265 | case .double(let f): 266 | return f 267 | case .int(let i): 268 | return Double(i) 269 | default: 270 | return nil 271 | } 272 | } 273 | 274 | public var string: String? { 275 | switch self { 276 | case .string(let s): 277 | return s 278 | default: 279 | return nil 280 | } 281 | } 282 | 283 | public var array: [Yaml]? { 284 | switch self { 285 | case .array(let array): 286 | return array 287 | default: 288 | return nil 289 | } 290 | } 291 | 292 | public var dictionary: [Yaml: Yaml]? { 293 | switch self { 294 | case .dictionary(let dictionary): 295 | return dictionary 296 | default: 297 | return nil 298 | } 299 | } 300 | 301 | public var count: Int? { 302 | switch self { 303 | case .array(let array): 304 | return array.count 305 | case .dictionary(let dictionary): 306 | return dictionary.count 307 | default: 308 | return nil 309 | } 310 | } 311 | } 312 | 313 | -------------------------------------------------------------------------------- /Tests/Info.plist: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | CFBundleDevelopmentRegion 6 | en 7 | CFBundleExecutable 8 | $(EXECUTABLE_NAME) 9 | CFBundleIdentifier 10 | $(PRODUCT_BUNDLE_IDENTIFIER) 11 | CFBundleInfoDictionaryVersion 12 | 6.0 13 | CFBundleName 14 | $(PRODUCT_NAME) 15 | CFBundlePackageType 16 | BNDL 17 | CFBundleShortVersionString 18 | 1.0 19 | CFBundleSignature 20 | ???? 21 | CFBundleVersion 22 | 3.4.3 23 | 24 | 25 | -------------------------------------------------------------------------------- /Tests/LinuxMain.swift: -------------------------------------------------------------------------------- 1 | import XCTest 2 | 3 | @testable import YamlTests 4 | 5 | XCTMain([ 6 | testCase(ExampleTests.allTests), 7 | testCase(YamlTests.allTests), 8 | ]) 9 | -------------------------------------------------------------------------------- /Tests/YamlTests/ExampleTests.swift: -------------------------------------------------------------------------------- 1 | import Yaml 2 | import XCTest 3 | 4 | class ExampleTests: XCTestCase { 5 | 6 | func testExample0 () { 7 | var value = try! Yaml.load( 8 | "- just: write some\n" + 9 | "- yaml: \n" + 10 | " - [here, and]\n" + 11 | " - {it: updates, in: real-time}\n" 12 | ) 13 | XCTAssert(value.count == 2) 14 | XCTAssert(value[0]["just"] == "write some") 15 | XCTAssert(value[1]["yaml"][0][1] == "and") 16 | XCTAssert(value[1]["yaml"][1]["in"] == "real-time") 17 | 18 | value[0]["just"] = .string("replaced string") 19 | XCTAssert(value[0]["just"] == "replaced string") 20 | value[0]["another"] = .int(2) 21 | XCTAssert(value[0]["another"] == 2) 22 | value[0]["new"]["key"][10]["key"] = .string("Ten") 23 | XCTAssert(value[0]["new"]["key"][10]["key"] == "Ten") 24 | value[0]["new"]["key"][5]["key"] = .string("Five") 25 | XCTAssert(value[0]["new"]["key"][5]["key"] == "Five") 26 | value[0]["new"]["key"][15]["key"] = .string("Fifteen") 27 | XCTAssert(value[0]["new"]["key"][15]["key"] == "Fifteen") 28 | value[2] = .double(2) 29 | XCTAssert(value[2] == 2) 30 | value = nil 31 | XCTAssert(value == nil) 32 | } 33 | 34 | func testExample1 () { 35 | let value = try! Yaml.load( 36 | "- Mark McGwire\n" + 37 | "- Sammy Sosa\n" + 38 | "- Ken Griffey\n" 39 | ) 40 | XCTAssert(value.count == 3) 41 | XCTAssert(value[1] == "Sammy Sosa") 42 | } 43 | 44 | func testExample2 () { 45 | let value = try! Yaml.load( 46 | "hr: 65 # Home runs\n" + 47 | "avg: 0.278 # Batting average\n" + 48 | "rbi: 147 # Runs Batted In\n" 49 | ) 50 | XCTAssert(value.count == 3) 51 | XCTAssert(value["avg"] == 0.278) 52 | } 53 | 54 | func testComment() { 55 | let value = try! Yaml.load( 56 | """ 57 | foo: 58 | bar: # quux 59 | - baz 60 | - qux 61 | """, 62 | preserveComments: true 63 | ) 64 | 65 | XCTAssertEqual(value["foo"].getComment(forKey: "bar"), "quux") 66 | } 67 | 68 | func testExample3 () { 69 | let value = try! Yaml.load( 70 | "american:\n" + 71 | " - Boston Red Sox\n" + 72 | " - Detroit Tigers\n" + 73 | " - New York Yankees\n" + 74 | "national:\n" + 75 | " - New York Mets\n" + 76 | " - Chicago Cubs\n" + 77 | " - Atlanta Braves\n" 78 | ) 79 | XCTAssert(value.count == 2) 80 | XCTAssert(value["national"].count == 3) 81 | XCTAssert(value["national"][2] == "Atlanta Braves") 82 | } 83 | 84 | func testExample4 () { 85 | let value = try! Yaml.load( 86 | "-\n" + 87 | " name: Mark McGwire\n" + 88 | " hr: 65\n" + 89 | " avg: 0.278\n" + 90 | "-\n" + 91 | " name: Sammy Sosa\n" + 92 | " hr: 63\n" + 93 | " avg: 0.288\n" 94 | ) 95 | XCTAssert(value.count == 2) 96 | XCTAssertEqual(value[1]["avg"].double!, 0.288, accuracy: 0.00001) 97 | } 98 | 99 | func testExample5 () { 100 | let value = try! Yaml.load( 101 | "- [name , hr, avg ]\n" + 102 | "- [Mark McGwire, 65, 0.278]\n" + 103 | "- [Sammy Sosa , 63, 0.288]\n" 104 | ) 105 | XCTAssert(value.count == 3) 106 | XCTAssert(value[2].count == 3) 107 | XCTAssertEqual(value[2][2].double!, 0.288, accuracy: 0.00001) 108 | } 109 | 110 | func testExample6 () { 111 | let value = try! Yaml.load( 112 | "Mark McGwire: {hr: 65, avg: 0.278}\n" + 113 | "Sammy Sosa: {\n" + 114 | " hr: 63,\n" + 115 | " avg: 0.288\n" + 116 | " }\n" 117 | ) 118 | XCTAssert(value["Mark McGwire"]["hr"] == 65) 119 | XCTAssert(value["Sammy Sosa"]["hr"] == 63) 120 | } 121 | 122 | func testExample7 () { 123 | let value = try! Yaml.loadMultiple( 124 | "# Ranking of 1998 home runs\n" + 125 | "---\n" + 126 | "- Mark McGwire\n" + 127 | "- Sammy Sosa\n" + 128 | "- Ken Griffey\n" + 129 | "\n" + 130 | "# Team ranking\n" + 131 | "---\n" + 132 | "- Chicago Cubs\n" + 133 | "- St Louis Cardinals\n" 134 | ) 135 | XCTAssert(value.count == 2) 136 | XCTAssert(value[0].count == 3) 137 | XCTAssert(value[0][1] == "Sammy Sosa") 138 | XCTAssert(value[1].count == 2) 139 | XCTAssert(value[1][1] == "St Louis Cardinals") 140 | } 141 | 142 | func testExample8 () { 143 | let value = try! Yaml.loadMultiple( 144 | "---\n" + 145 | "time: 20:03:20\n" + 146 | "player: Sammy Sosa\n" + 147 | "action: strike (miss)\n" + 148 | "...\n" + 149 | "---\n" + 150 | "time: 20:03:47\n" + 151 | "player: Sammy Sosa\n" + 152 | "action: grand slam\n" + 153 | "...\n" 154 | ) 155 | XCTAssert(value.count == 2) 156 | XCTAssert(value[0]["player"] == "Sammy Sosa") 157 | XCTAssert(value[0]["time"] == 72200) 158 | XCTAssert(value[1]["player"] == "Sammy Sosa") 159 | XCTAssert(value[1]["time"] == 72227) 160 | } 161 | 162 | func testExample9 () { 163 | let value = try! Yaml.load( 164 | "---\n" + 165 | "hr: # 1998 hr ranking\n" + 166 | " - Mark McGwire\n" + 167 | " - Sammy Sosa\n" + 168 | "rbi:\n" + 169 | " # 1998 rbi ranking\n" + 170 | " - Sammy Sosa\n" + 171 | " - Ken Griffey\n" 172 | ) 173 | XCTAssert(value["hr"][1] == "Sammy Sosa") 174 | XCTAssert(value["rbi"][1] == "Ken Griffey") 175 | } 176 | 177 | func testExample10 () { 178 | let value = try! Yaml.load( 179 | "---\n" + 180 | "hr:\n" + 181 | " - Mark McGwire\n" + 182 | " # Following node labeled SS\n" + 183 | " - &SS Sammy Sosa\n" + 184 | "rbi:\n" + 185 | " - *SS # Subsequent occurrence\n" + 186 | " - Ken Griffey\n" 187 | ) 188 | XCTAssert(value["hr"].count == 2) 189 | XCTAssert(value["hr"][1] == "Sammy Sosa") 190 | XCTAssert(value["rbi"].count == 2) 191 | XCTAssert(value["rbi"][0] == "Sammy Sosa") 192 | } 193 | 194 | func testExample11 () { 195 | let value = try! Yaml.load( 196 | "? - Detroit Tigers\n" + 197 | " - Chicago cubs\n" + 198 | ":\n" + 199 | " - 2001-07-23\n" + 200 | "\n" + 201 | "? [ New York Yankees,\n" + 202 | " Atlanta Braves ]\n" + 203 | ": [ 2001-07-02, 2001-08-12,\n" + 204 | " 2001-08-14 ]\n" 205 | ) 206 | let key1 = try! Yaml.load("- Detroit Tigers\n- Chicago cubs\n") 207 | let key2 = try! Yaml.load("- New York Yankees\n- Atlanta Braves") 208 | XCTAssert(value.count == 2) 209 | XCTAssert(value[key1].count == 1) 210 | XCTAssert(value[key2].count == 3) 211 | XCTAssert(value[key2][2] == "2001-08-14") 212 | } 213 | 214 | func testExample12 () { 215 | let value = try! Yaml.load( 216 | "---\n" + 217 | "# Products purchased\n" + 218 | "- item : Super Hoop\n" + 219 | " quantity: 1\n" + 220 | "- item : Basketball\n" + 221 | " quantity: 4\n" + 222 | "- item : Big Shoes\n" + 223 | " quantity: 1\n" 224 | ) 225 | XCTAssert(value.count == 3) 226 | XCTAssert(value[1].count == 2) 227 | XCTAssert(value[1]["item"] == "Basketball") 228 | XCTAssert(value[1]["quantity"] == 4) 229 | let key = try! Yaml.load("quantity") 230 | XCTAssert(value[2][key] == 1) 231 | } 232 | 233 | func testExample13 () { 234 | let value = try! Yaml.load( 235 | "# ASCII Art\n" + 236 | "--- |\n" + 237 | " \\//||\\/||\n" + 238 | " // || ||__\n" 239 | ) 240 | XCTAssert(value == "\\//||\\/||\n// || ||__\n") 241 | } 242 | 243 | func testExample14 () { 244 | let value = try! Yaml.load( 245 | "--- >\n" + 246 | " Mark McGwire's\n" + 247 | " year was crippled\n" + 248 | " by a knee injury.\n" 249 | ) 250 | XCTAssert(value == "Mark McGwire's year was crippled by a knee injury.\n") 251 | } 252 | 253 | func testExample15 () { 254 | let value = try! Yaml.load( 255 | ">\n" + 256 | " Sammy Sosa completed another\n" + 257 | " fine season with great stats.\n" + 258 | "\n" + 259 | " 63 Home Runs\n" + 260 | " 0.288 Batting Average\n" + 261 | "\n" + 262 | " What a year!\n" 263 | ) 264 | XCTAssert(value == 265 | .string("Sammy Sosa completed another fine season with great stats.\n\n" + 266 | " 63 Home Runs\n 0.288 Batting Average\n\nWhat a year!\n")) 267 | } 268 | 269 | func testExample16 () { 270 | let value = try! Yaml.load( 271 | "name: Mark McGwire\n" + 272 | "accomplishment: >\n" + 273 | " Mark set a major league\n" + 274 | " home run record in 1998.\n" + 275 | "stats: |\n" + 276 | " 65 Home Runs\n" + 277 | " 0.278 Batting Average\n" 278 | ) 279 | XCTAssert(value["accomplishment"] == 280 | "Mark set a major league home run record in 1998.\n") 281 | XCTAssert(value["stats"] == "65 Home Runs\n0.278 Batting Average\n") 282 | } 283 | 284 | func testExample17 () { 285 | let value = try! Yaml.load( 286 | "unicode: \"Sosa did fine.\\u263A\"\n" + 287 | "control: \"\\b1998\\t1999\\t2000\\n\"\n" + 288 | "hex esc: \"\\x0d\\x0a is \\r\\n\"\n" + 289 | "\n" + 290 | "single: '\"Howdy!\" he cried.'\n" + 291 | "quoted: ' # Not a ''comment''.'\n" + 292 | "tie-fighter: '|\\-*-/|'\n" 293 | ) 294 | // FIXME: Failing with Xcode8b6 295 | // XCTAssert(value["unicode"] == "Sosa did fine.\u{263A}") 296 | XCTAssert(value["control"] == "\u{8}1998\t1999\t2000\n") 297 | // FIXME: Failing with Xcode8b6 298 | // XCTAssert(value["hex esc"] == "\u{d}\u{a} is \r\n") 299 | XCTAssert(value["single"] == "\"Howdy!\" he cried.") 300 | XCTAssert(value["quoted"] == " # Not a 'comment'.") 301 | XCTAssert(value["tie-fighter"] == "|\\-*-/|") 302 | } 303 | 304 | func testExample18 () { 305 | let value = try! Yaml.load( 306 | "plain:\n" + 307 | " This unquoted scalar\n" + 308 | " spans many lines.\n" + 309 | "\n" + 310 | "quoted: \"So does this\n" + 311 | " quoted scalar.\\n\"\n" 312 | ) 313 | XCTAssert(value.count == 2) 314 | XCTAssert(value["plain"] == "This unquoted scalar spans many lines.") 315 | XCTAssert(value["quoted"] == "So does this quoted scalar.\n") 316 | } 317 | 318 | func testExample19 () { 319 | let value = try! Yaml.load( 320 | "canonical: 12345\n" + 321 | "decimal: +12345\n" + 322 | "octal: 0o14\n" + 323 | "hexadecimal: 0xC\n" 324 | ) 325 | XCTAssert(value.count == 4) 326 | XCTAssert(value["canonical"] == 12345) 327 | XCTAssert(value["decimal"] == 12345) 328 | XCTAssert(value["octal"] == 12) 329 | XCTAssert(value["hexadecimal"] == 12) 330 | } 331 | 332 | func testExample20 () { 333 | let value = try! Yaml.load( 334 | "canonical: 1.23015e+3\n" + 335 | "exponential: 12.3015e+02\n" + 336 | "fixed: 1230.15\n" + 337 | "negative infinity: -.inf\n" + 338 | "not a number: .NaN\n" 339 | ) 340 | XCTAssert(value.count == 5) 341 | /* Disabled for Linux */ 342 | #if !os(Linux) 343 | XCTAssert(value["canonical"] == 1.23015e+3) 344 | XCTAssert(value["exponential"] == 1.23015e+3) 345 | XCTAssert(value["fixed"] == 1.23015e+3) 346 | #endif 347 | XCTAssert(value["negative infinity"] == .double(-Double.infinity)) 348 | XCTAssert(value["not a number"].double?.isNaN == true) 349 | } 350 | 351 | func testExample21 () { 352 | let value = try! Yaml.load( 353 | "null:\n" + 354 | "booleans: [ true, false ]\n" + 355 | "string: '012345'\n" 356 | ) 357 | XCTAssert(value.count == 3) 358 | XCTAssert(value["null"] == nil) 359 | XCTAssert(value["booleans"] == [true, false]) 360 | XCTAssert(value["string"] == "012345") 361 | } 362 | 363 | func testExample22 () { 364 | let value = try! Yaml.load( 365 | "canonical: 2001-12-15T02:59:43.1Z\n" + 366 | "iso8601: 2001-12-14t21:59:43.10-05:00\n" + 367 | "spaced: 2001-12-14 21:59:43.10 -5\n" + 368 | "date: 2002-12-14\n" 369 | ) 370 | XCTAssert(value.count == 4) 371 | XCTAssert(value["canonical"] == "2001-12-15T02:59:43.1Z") 372 | XCTAssert(value["iso8601"] == "2001-12-14t21:59:43.10-05:00") 373 | XCTAssert(value["spaced"] == "2001-12-14 21:59:43.10 -5") 374 | XCTAssert(value["date"] == "2002-12-14") 375 | } 376 | 377 | let exampleYaml = 378 | "%YAML 1.2\n" + 379 | "---\n" + 380 | "YAML: YAML Ain't Markup Language\n" + 381 | "\n" + 382 | "What It Is: YAML is a human friendly data serialization\n" + 383 | " standard for all programming languages.\n" + 384 | "\n" + 385 | "YAML Resources:\n" + 386 | " YAML 1.2 (3rd Edition): http://yaml.org/spec/1.2/spec.html\n" + 387 | " YAML 1.1 (2nd Edition): http://yaml.org/spec/1.1/\n" + 388 | " YAML 1.0 (1st Edition): http://yaml.org/spec/1.0/\n" + 389 | " YAML Issues Page: https://github.com/yaml/yaml/issues\n" + 390 | " YAML Mailing List: yaml-core@lists.sourceforge.net\n" + 391 | " YAML IRC Channel: \"#yaml on irc.freenode.net\"\n" + 392 | " YAML Cookbook (Ruby): http://yaml4r.sourceforge.net/cookbook/\n" + 393 | " YAML Reference Parser: http://yaml.org/ypaste/\n" + 394 | "\n" + 395 | "Projects:\n" + 396 | " C/C++ Libraries:\n" + 397 | " - libyaml # \"C\" Fast YAML 1.1\n" + 398 | " - Syck # (dated) \"C\" YAML 1.0\n" + 399 | " - yaml-cpp # C++ YAML 1.2 implementation\n" + 400 | " Ruby:\n" + 401 | " - psych # libyaml wrapper (in Ruby core for 1.9.2)\n" + 402 | " - RbYaml # YAML 1.1 (PyYaml Port)\n" + 403 | " - yaml4r # YAML 1.0, standard library syck binding\n" + 404 | " Python:\n" + 405 | " - PyYaml # YAML 1.1, pure python and libyaml binding\n" + 406 | " - PySyck # YAML 1.0, syck binding\n" + 407 | " Java:\n" + 408 | " - JvYaml # Java port of RbYaml\n" + 409 | " - SnakeYAML # Java 5 / YAML 1.1\n" + 410 | " - YamlBeans # To/from JavaBeans\n" + 411 | " - JYaml # Original Java Implementation\n" + 412 | " Perl Modules:\n" + 413 | " - YAML # Pure Perl YAML Module\n" + 414 | " - YAML::XS # Binding to libyaml\n" + 415 | " - YAML::Syck # Binding to libsyck\n" + 416 | " - YAML::Tiny # A small YAML subset module\n" + 417 | " - PlYaml # Perl port of PyYaml\n" + 418 | " C#/.NET:\n" + 419 | " - yaml-net # YAML 1.1 library\n" + 420 | " - yatools.net # (in-progress) YAML 1.1 implementation\n" + 421 | " PHP:\n" + 422 | " - php-yaml # libyaml bindings (YAML 1.1)\n" + 423 | " - syck # syck bindings (YAML 1.0)\n" + 424 | " - spyc # yaml loader/dumper (YAML 1.?)\n" + 425 | " OCaml:\n" + 426 | " - ocaml-syck # YAML 1.0 via syck bindings\n" + 427 | " Javascript:\n" + 428 | " - JS-YAML # Native PyYAML port to JavaScript.\n" + 429 | " - JS-YAML Online# Browserified JS-YAML demo, to play with YAML.\n" + 430 | " Actionscript:\n" + 431 | " - as3yaml # port of JvYAML (1.1)\n" + 432 | " Haskell:\n" + 433 | " - YamlReference # Haskell 1.2 reference parser\n" + 434 | " Others:\n" + 435 | " - yamlvim (src) # YAML dumper/emitter in pure vimscript\n" + 436 | "\n" + 437 | "Related Projects:\n" + 438 | " - Rx # Multi-Language Schemata Tool for JSON/YAML\n" + 439 | " - Kwalify # Ruby Schemata Tool for JSON/YAML\n" + 440 | " - yaml_vim # vim syntax files for YAML\n" + 441 | " - yatools.net # Visual Studio editor for YAML\n" + 442 | " - JSON # Official JSON Website\n" + 443 | " - Pygments # Python language Syntax Colorizer /w YAML support\n" + 444 | "\n" + 445 | "News:\n" + 446 | " - 20-NOV-2011 -- JS-YAML, a JavaScript YAML parser.\n" + 447 | " - 18-AUG-2010 -- Ruby 1.9.2 includes psych, a libyaml wrapper.\n" + 448 | "# Maintained by Clark C. Evans\n" + 449 | "...\n" 450 | 451 | func testYamlHomepage () { 452 | let value = try! Yaml.load(exampleYaml) 453 | XCTAssert(value.count == 6) 454 | XCTAssert(value["YAML"] == "YAML Ain't Markup Language") 455 | XCTAssert(value["What It Is"] == .string("YAML is a human friendly data" + 456 | " serialization standard for all programming languages.")) 457 | XCTAssert(value["YAML Resources"].count == 8) 458 | XCTAssert(value["YAML Resources"]["YAML 1.2 (3rd Edition)"] == 459 | "http://yaml.org/spec/1.2/spec.html") 460 | XCTAssert(value["YAML Resources"]["YAML IRC Channel"] == 461 | "#yaml on irc.freenode.net") 462 | XCTAssert(value["Projects"].count == 12) 463 | XCTAssert(value["Projects"]["C/C++ Libraries"][2] == "yaml-cpp") 464 | XCTAssert(value["Projects"]["Perl Modules"].count == 5) 465 | XCTAssert(value["Projects"]["Perl Modules"][0] == "YAML") 466 | XCTAssert(value["Projects"]["Perl Modules"][1] == "YAML::XS") 467 | XCTAssert(value["Related Projects"].count == 6) 468 | XCTAssert(value["News"].count == 2) 469 | } 470 | 471 | func testPerformanceExample() { 472 | self.measure() { 473 | _ = try! Yaml.load(self.exampleYaml) 474 | } 475 | } 476 | 477 | } 478 | 479 | #if os(Linux) 480 | 481 | extension ExampleTests { 482 | static var allTests: [(String, (ExampleTests) -> () throws -> Void)] { 483 | return [ 484 | ("testExample0", testExample0), 485 | ("testExample1", testExample1), 486 | ("testExample2", testExample2), 487 | ("testExample3", testExample3), 488 | ("testExample4", testExample4), 489 | ("testExample5", testExample5), 490 | ("testExample6", testExample6), 491 | ("testExample7", testExample7), 492 | ("testExample8", testExample8), 493 | ("testExample9", testExample9), 494 | ("testExample10", testExample10), 495 | ("testExample11", testExample11), 496 | ("testExample12", testExample12), 497 | ("testExample13", testExample13), 498 | ("testExample14", testExample14), 499 | ("testExample15", testExample15), 500 | ("testExample16", testExample16), 501 | ("testExample17", testExample17), 502 | ("testExample18", testExample18), 503 | ("testExample19", testExample19), 504 | ("testExample20", testExample20), 505 | ("testExample21", testExample21), 506 | ("testExample22", testExample22), 507 | ("testComment", testComment), 508 | ("testYamlHomepage", testYamlHomepage), 509 | ("testPerformanceExample", testPerformanceExample), 510 | ] 511 | } 512 | } 513 | 514 | #endif 515 | -------------------------------------------------------------------------------- /Tests/YamlTests/YamlTests.swift: -------------------------------------------------------------------------------- 1 | @testable import Yaml 2 | import XCTest 3 | 4 | class YamlTests: XCTestCase { 5 | 6 | func testNull() { 7 | XCTAssert(try! Yaml.load("# comment line") == .null) 8 | XCTAssert(try! Yaml.load("") == .null) 9 | XCTAssert(try! Yaml.load("null") == .null) 10 | XCTAssert(try! Yaml.load("Null") == nil) 11 | XCTAssert(try! Yaml.load("NULL") == nil) 12 | XCTAssert(try! Yaml.load("~") == nil) 13 | XCTAssert(try! Yaml.load("NuLL") == "NuLL") 14 | XCTAssert(try! Yaml.load("null#") == "null#") 15 | XCTAssert(try! Yaml.load("null#string") == "null#string") 16 | XCTAssert(try! Yaml.load("null #comment") == nil) 17 | 18 | let value: Yaml = nil 19 | XCTAssert(value == nil) 20 | } 21 | 22 | func testBool() { 23 | XCTAssert(try! Yaml.load("true") == .bool(true)) 24 | XCTAssert(try! Yaml.load("True").bool == true) 25 | XCTAssert(try! Yaml.load("TRUE") == true) 26 | XCTAssert(try! Yaml.load("trUE") == "trUE") 27 | XCTAssert(try! Yaml.load("true#") == "true#") 28 | XCTAssert(try! Yaml.load("true#string") == "true#string") 29 | XCTAssert(try! Yaml.load("true #comment") == true) 30 | XCTAssert(try! Yaml.load("true #") == true) 31 | XCTAssert(try! Yaml.load("true ") == true) 32 | XCTAssert(try! Yaml.load("true\n") == true) 33 | XCTAssert(try! Yaml.load("true \n") == true) 34 | XCTAssert(true == (try! Yaml.load("\ntrue \n"))) 35 | 36 | XCTAssert(try! Yaml.load("false") == .bool(false)) 37 | XCTAssert(try! Yaml.load("False").bool == false) 38 | XCTAssert(try! Yaml.load("FALSE") == false) 39 | XCTAssert(try! Yaml.load("faLSE") == "faLSE") 40 | XCTAssert(try! Yaml.load("false#") == "false#") 41 | XCTAssert(try! Yaml.load("false#string") == "false#string") 42 | XCTAssert(try! Yaml.load("false #comment") == false) 43 | XCTAssert(try! Yaml.load("false #") == false) 44 | XCTAssert(try! Yaml.load("false ") == false) 45 | XCTAssert(try! Yaml.load("false\n") == false) 46 | XCTAssert(try! Yaml.load("false \n") == false) 47 | XCTAssert(false == (try! Yaml.load("\nfalse \n"))) 48 | 49 | let value: Yaml = true 50 | XCTAssert(value == true) 51 | XCTAssert(value.bool == true) 52 | } 53 | 54 | func testInt() { 55 | XCTAssert(try! Yaml.load("0") == .int(0)) 56 | XCTAssert(try! Yaml.load("+0").int == 0) 57 | XCTAssert(try! Yaml.load("-0") == 0) 58 | XCTAssert(try! Yaml.load("2") == 2) 59 | XCTAssert(try! Yaml.load("+2") == 2) 60 | XCTAssert(try! Yaml.load("-2") == -2) 61 | XCTAssert(try! Yaml.load("00123") == 123) 62 | XCTAssert(try! Yaml.load("+00123") == 123) 63 | XCTAssert(try! Yaml.load("-00123") == -123) 64 | XCTAssert(try! Yaml.load("0o10") == 8) 65 | XCTAssert(try! Yaml.load("0o010") == 8) 66 | XCTAssert(try! Yaml.load("0o0010") == 8) 67 | XCTAssert(try! Yaml.load("0x10") == 16) 68 | XCTAssert(try! Yaml.load("0x1a") == 26) 69 | XCTAssert(try! Yaml.load("0x01a") == 26) 70 | XCTAssert(try! Yaml.load("0x001a") == 26) 71 | XCTAssert(try! Yaml.load("10:10") == 610) 72 | XCTAssert(try! Yaml.load("10:10:10") == 36610) 73 | 74 | XCTAssert(try! Yaml.load("2") == 2) 75 | XCTAssert(try! Yaml.load("2.0") == 2) 76 | XCTAssert(try! Yaml.load("2.5") != 2) 77 | XCTAssert(try! Yaml.load("2.5").int == nil) 78 | 79 | let value1: Yaml = 2 80 | XCTAssert(value1 == 2) 81 | XCTAssert(value1.int == 2) 82 | let value2: Yaml = -2 83 | XCTAssert(value2 == -2) 84 | XCTAssert(-value2 == 2) 85 | XCTAssert(-value2 == value1) 86 | } 87 | 88 | func testDouble() { 89 | XCTAssert(try! Yaml.load(".inf") == .double(Double.infinity)) 90 | XCTAssert(try! Yaml.load(".Inf").double == Double.infinity) 91 | XCTAssert(try! Yaml.load(".INF").double == Double.infinity) 92 | XCTAssert(try! Yaml.load(".iNf") == ".iNf") 93 | XCTAssert(try! Yaml.load(".inf#") == ".inf#") 94 | XCTAssert(try! Yaml.load(".inf# string") == ".inf# string") 95 | XCTAssert(try! Yaml.load(".inf # comment").double == Double.infinity) 96 | XCTAssert(try! Yaml.load(".inf .inf") == ".inf .inf") 97 | XCTAssert(try! Yaml.load("+.inf # comment").double == Double.infinity) 98 | 99 | XCTAssert(try! Yaml.load("-.inf") == .double(-Double.infinity)) 100 | XCTAssert(try! Yaml.load("-.Inf").double == -Double.infinity) 101 | XCTAssert(try! Yaml.load("-.INF").double == -Double.infinity) 102 | XCTAssert(try! Yaml.load("-.iNf") == "-.iNf") 103 | XCTAssert(try! Yaml.load("-.inf#") == "-.inf#") 104 | XCTAssert(try! Yaml.load("-.inf# string") == "-.inf# string") 105 | XCTAssert(try! Yaml.load("-.inf # comment").double == -Double.infinity) 106 | XCTAssert(try! Yaml.load("-.inf -.inf") == "-.inf -.inf") 107 | 108 | XCTAssert(try! Yaml.load(".nan") != .double(Double.nan)) 109 | XCTAssert(try! Yaml.load(".nan").double!.isNaN) 110 | //TODO: Causes exception 111 | // XCTAssert(try! Yaml.load(".NaN").double!.isNaN) 112 | XCTAssert(try! Yaml.load(".NAN").double!.isNaN) 113 | XCTAssert(try! Yaml.load(".Nan").double == nil) 114 | XCTAssert(try! Yaml.load(".nan#") == ".nan#") 115 | XCTAssert(try! Yaml.load(".nan# string") == ".nan# string") 116 | XCTAssert(try! Yaml.load(".nan # comment").double!.isNaN) 117 | XCTAssert(try! Yaml.load(".nan .nan") == ".nan .nan") 118 | 119 | XCTAssert(try! Yaml.load("0.") == .double(0)) 120 | XCTAssert(try! Yaml.load(".0").double == 0) 121 | XCTAssert(try! Yaml.load("+0.") == 0) 122 | XCTAssert(try! Yaml.load("+.0") == 0) 123 | XCTAssert(try! Yaml.load("+.") != 0) 124 | XCTAssert(try! Yaml.load("-0.") == 0) 125 | XCTAssert(try! Yaml.load("-.0") == 0) 126 | XCTAssert(try! Yaml.load("-.") != 0) 127 | XCTAssert(try! Yaml.load("2.") == 2) 128 | /* Disabled for Linux */ 129 | #if !os(Linux) 130 | XCTAssert(try! Yaml.load(".2") == 0.2) 131 | XCTAssert(try! Yaml.load("+2.") == 2) 132 | XCTAssert(try! Yaml.load("+.2") == 0.2) 133 | XCTAssert(try! Yaml.load("-2.") == -2) 134 | XCTAssert(try! Yaml.load("-.2") == -0.2) 135 | XCTAssert(try! Yaml.load("1.23015e+3") == 1.23015e+3) 136 | XCTAssert(try! Yaml.load("12.3015e+02") == 12.3015e+02) 137 | XCTAssert(try! Yaml.load("1230.15") == 1230.15) 138 | XCTAssert(try! Yaml.load("+1.23015e+3") == 1.23015e+3) 139 | XCTAssert(try! Yaml.load("+12.3015e+02") == 12.3015e+02) 140 | XCTAssert(try! Yaml.load("+1230.15") == 1230.15) 141 | XCTAssert(try! Yaml.load("-1.23015e+3") == -1.23015e+3) 142 | XCTAssert(try! Yaml.load("-12.3015e+02") == -12.3015e+02) 143 | XCTAssert(try! Yaml.load("-1230.15") == -1230.15) 144 | XCTAssert(try! Yaml.load("-01230.15") == -1230.15) 145 | XCTAssert(try! Yaml.load("-12.3015e02") == -12.3015e+02) 146 | #endif 147 | 148 | XCTAssert(try! Yaml.load("2") == 2.0) 149 | XCTAssert(try! Yaml.load("2.0") == 2.0) 150 | XCTAssert(try! Yaml.load("2.5") == 2.5) 151 | XCTAssert(try! Yaml.load("2.5").int == nil) 152 | 153 | let value1: Yaml = 0.2 154 | XCTAssert(value1 == 0.2) 155 | XCTAssert(value1.double == 0.2) 156 | let value2: Yaml = -0.2 157 | XCTAssert(value2 == -0.2) 158 | XCTAssert(-value2 == 0.2) 159 | XCTAssert(-value2 == value1) 160 | } 161 | 162 | func testString () { 163 | XCTAssert(try! Yaml.load("Behrang") == .string("Behrang")) 164 | XCTAssert(try! Yaml.load("\"Behrang\"") == .string("Behrang")) 165 | XCTAssert(try! Yaml.load("\"B\\\"ehran\\\"g\"") == .string("B\"ehran\"g")) 166 | XCTAssert(try! Yaml.load("Behrang Noruzi Niya").string == 167 | "Behrang Noruzi Niya") 168 | XCTAssert(try! Yaml.load("Radin Noruzi Niya") == "Radin Noruzi Niya") 169 | XCTAssert(try! Yaml.load("|") == "") 170 | XCTAssert(try! Yaml.load("| ") == "") 171 | XCTAssert(try! Yaml.load("| # comment") == "") 172 | XCTAssert(try! Yaml.load("| # comment\n") == "") 173 | 174 | XCTAssertThrowsError(try Yaml.load("|\nRadin")) 175 | XCTAssert(try! Yaml.load("|\n Radin") == "Radin") 176 | XCTAssert(try! Yaml.load("| \n Radin") == "Radin") 177 | XCTAssert(try! Yaml.load("| # comment\n Radin") == "Radin") 178 | XCTAssert(try! Yaml.load("|\n Radin") == "Radin") 179 | XCTAssert(try! Yaml.load("|2\n Radin") == "Radin") 180 | XCTAssert(try! Yaml.load("|1\n Radin") == " Radin") 181 | XCTAssert(try! Yaml.load("|1\n\n Radin") == "\n Radin") 182 | XCTAssert(try! Yaml.load("|\n\n Radin") == "\nRadin") 183 | XCTAssertNil(try? Yaml.load("|3\n\n Radin")) 184 | XCTAssertNil(try? Yaml.load("|3\n \n Radin")) 185 | XCTAssert(try! Yaml.load("|3\n \n Radin") == "\nRadin") 186 | XCTAssert(try! Yaml.load("|\n \n\n \n Radin\n\n \n\n Noruzi Niya") == 187 | "\n\n\nRadin\n\n\n\nNoruzi Niya") 188 | XCTAssert(try! Yaml.load("|\n \n\n \n Radin\n\n \n\n Noruzi Niya\n #1") == 189 | "\n\n\nRadin\n\n\n\nNoruzi Niya\n#1") 190 | XCTAssert(try! Yaml.load("|\n \n\n \n Radin\n\n \n\n Noruzi Niya\n #1" + 191 | "\n # Comment") == "\n\n\nRadin\n\n\n\nNoruzi Niya\n#1\n") 192 | XCTAssert(try! Yaml.load("|\n Radin\n") == "Radin\n") 193 | XCTAssert(try! Yaml.load("|\n Radin\n\n") == "Radin\n") 194 | XCTAssert(try! Yaml.load("|\n Radin\n \n ") == "Radin\n") 195 | XCTAssert(try! Yaml.load("|\n Radin\n \n ") == "Radin\n") 196 | XCTAssert(try! Yaml.load("|-\n Radin\n \n ") == "Radin") 197 | XCTAssert(try! Yaml.load("|+\n Radin\n") == "Radin\n") 198 | XCTAssert(try! Yaml.load("|+\n Radin\n\n") == "Radin\n\n") 199 | XCTAssert(try! Yaml.load("|+\n Radin\n \n ") == "Radin\n\n") 200 | XCTAssert(try! Yaml.load("|+\n Radin\n \n ") == "Radin\n \n ") 201 | XCTAssert(try! Yaml.load("|2+\n Radin\n \n ") == "Radin\n\n") 202 | XCTAssert(try! Yaml.load("|+2\n Radin\n \n ") == "Radin\n\n") 203 | XCTAssert(try! Yaml.load("|-2\n Radin\n \n ") == "Radin") 204 | XCTAssert(try! Yaml.load("|2-\n Radin\n \n ") == "Radin") 205 | XCTAssertThrowsError(try Yaml.load("|22\n Radin\n \n ")) 206 | XCTAssertThrowsError(try Yaml.load("|--\n Radin\n \n ")) 207 | XCTAssert(try! Yaml.load(">+\n trimmed\n \n \n\n as\n space\n\n \n") == 208 | "trimmed\n\n\nas space\n\n \n") 209 | XCTAssert(try! Yaml.load(">-\n trimmed\n \n \n\n as\n space") == 210 | "trimmed\n\n\nas space") 211 | XCTAssert(try! Yaml.load(">\n foo \n \n \t bar\n\n baz\n") == 212 | "foo \n\n\t bar\n\nbaz\n") 213 | 214 | XCTAssertThrowsError(try Yaml.load(">\n \n Behrang")) 215 | XCTAssert(try! Yaml.load(">\n \n Behrang") == "\nBehrang") 216 | XCTAssert(try! Yaml.load(">\n\n folded\n line\n\n next\n line\n * bullet\n\n" + 217 | " * list\n * lines\n\n last\n line\n\n# Comment") == 218 | .string("\nfolded line\nnext line\n * bullet\n\n * list\n * lines" + 219 | "\n\nlast line\n")) 220 | 221 | XCTAssert(try! Yaml.load("\"\n foo \n \n \t bar\n\n baz\n\"") == 222 | " foo\nbar\nbaz ") 223 | XCTAssert(try! Yaml.load("\"folded \nto a space,\t\n \nto a line feed," + 224 | " or \t\\\n \\ \tnon-content\"") == 225 | "folded to a space,\nto a line feed, or \t \tnon-content") 226 | XCTAssert(try! Yaml.load("\" 1st non-empty\n\n 2nd non-empty" + 227 | " \n\t3rd non-empty \"") == 228 | " 1st non-empty\n2nd non-empty 3rd non-empty ") 229 | 230 | XCTAssert(try! Yaml.load("'here''s to \"quotes\"'") == "here's to \"quotes\"") 231 | XCTAssert(try! Yaml.load("' 1st non-empty\n\n 2nd non-empty" + 232 | " \n\t3rd non-empty '") == 233 | " 1st non-empty\n2nd non-empty 3rd non-empty ") 234 | 235 | XCTAssert(try! Yaml.load("x\n y\nz") == "x y z") 236 | XCTAssert(try! Yaml.load(" x\ny\n z") == "x y z") 237 | XCTAssert(try! Yaml.load("a: x\n y\n z") == ["a": "x y z"]) 238 | XCTAssertThrowsError(try Yaml.load("a: x\ny\n z")) 239 | XCTAssert(try! Yaml.load("- a: x\n y\n z") == [["a": "x y z"]]) 240 | XCTAssert(try! Yaml.load("- a:\n x\n y\n z") == [["a": "x y z"]]) 241 | XCTAssert(try! Yaml.load("- a: \n x\n y\n z") == [["a": "x y z"]]) 242 | XCTAssert(try! Yaml.load("- a: # comment\n x\n y\n z") == 243 | [["a": "x y z"]]) 244 | 245 | let value1: Yaml = "Radin" 246 | XCTAssert(value1 == "Radin") 247 | XCTAssert(value1.string == "Radin") 248 | 249 | let value2 = try! Yaml.load( 250 | "# Outside flow collection:\n" + 251 | "- ::vector\n" + 252 | "- \": - ()\"\n" + 253 | "- Up, up, and away!\n" + 254 | "- -123\n" + 255 | "- http://example.com/foo#bar\n" + 256 | "# Inside flow collection:\n" + 257 | "- [ ::vector,\n" + 258 | " \": - ()\",\n" + 259 | " \"Up, up and away!\",\n" + 260 | " -123,\n" + 261 | " http://example.com/foo#bar ]\n" 262 | ) 263 | XCTAssert(value2.count == 6) 264 | XCTAssert(value2[0] == "::vector") 265 | XCTAssert(value2[5][0] == "::vector") 266 | XCTAssert(value2[5][4] == "http://example.com/foo#bar") 267 | } 268 | 269 | func testFlowSeq () { 270 | XCTAssert(try! Yaml.load("[]") == .array([])) 271 | XCTAssert(try! Yaml.load("[]").count == 0) 272 | XCTAssert(try! Yaml.load("[ true ]") == [Yaml.bool(true)]) 273 | XCTAssert(try! Yaml.load("[ true ]") == .array([true])) 274 | XCTAssert(try! Yaml.load("[ true ]") == [true]) 275 | XCTAssert(try! Yaml.load("[ true ]")[0] == true) 276 | XCTAssert(try! Yaml.load("[true, false, true]") == [true, false, true]) 277 | XCTAssert(try! Yaml.load("[Behrang, Radin]") == ["Behrang", "Radin"]) 278 | XCTAssert(try! Yaml.load("[true, [false, true]]") == [true, [false, true]]) 279 | XCTAssert(try! Yaml.load("[true, true ,false, false , false]") == 280 | [true, true, false, false, false]) 281 | XCTAssert(try! Yaml.load("[true, .NaN]") != [true, .double(Double.nan)]) 282 | XCTAssert(try! Yaml.load("[~, null, TRUE, False, .INF, -.inf, 0, 123, -456" + 283 | ", 0o74, 0xFf, 1.23, -4.5]") == 284 | [nil, nil, true, false, 285 | .double(Double.infinity), .double(-Double.infinity), 286 | 0, 123, -456, 60, 255, 1.23, -4.5]) 287 | XCTAssertThrowsError(try Yaml.load("x:\n y:\n z: [\n1]")) 288 | XCTAssertThrowsError(try Yaml.load("x:\n y:\n z: [\n 1]")) 289 | XCTAssert(try! Yaml.load("x:\n y:\n z: [\n 1]") == ["x": ["y": ["z": [1]]]]) 290 | } 291 | 292 | func testBlockSeq () { 293 | XCTAssert(try! Yaml.load("- 1\n- 2") == [1, 2]) 294 | XCTAssert(try! Yaml.load("- 1\n- 2")[1] == 2) 295 | XCTAssert(try! Yaml.load("- x: 1") == [["x": 1]]) 296 | XCTAssert(try! Yaml.load("- x: 1\n y: 2")[0] == ["x": 1, "y": 2]) 297 | XCTAssert(try! Yaml.load("- 1\n \n- x: 1\n y: 2") == [1, ["x": 1, "y": 2]]) 298 | XCTAssert(try! Yaml.load("- x:\n - y: 1") == [["x": [["y": 1]]]]) 299 | } 300 | 301 | func testFlowMap () { 302 | XCTAssert(try! Yaml.load("{}") == [:]) 303 | XCTAssert(try! Yaml.load("{x: 1}") == ["x": 1]) 304 | XCTAssertThrowsError(try Yaml.load("{x: 1, x: 2}")) 305 | XCTAssert(try! Yaml.load("{x: 1}")["x"] == 1) 306 | XCTAssertThrowsError(try Yaml.load("{x:1}")) 307 | XCTAssert(try! Yaml.load("{\"x\":1}")["x"] == 1) 308 | XCTAssert(try! Yaml.load("{\"x\":1, 'y': true}")["y"] == true) 309 | XCTAssert(try! Yaml.load("{\"x\":1, 'y': true, z: null}")["z"] == nil) 310 | XCTAssert(try! Yaml.load("{first name: \"Behrang\"," + 311 | " last name: 'Noruzi Niya'}") == 312 | ["first name": "Behrang", "last name": "Noruzi Niya"]) 313 | XCTAssert(try! Yaml.load("{fn: Behrang, ln: Noruzi Niya}")["ln"] == 314 | "Noruzi Niya") 315 | XCTAssert(try! Yaml.load("{fn: Behrang\n ,\nln: Noruzi Niya}")["ln"] == 316 | "Noruzi Niya") 317 | } 318 | 319 | func testBlockMap () { 320 | XCTAssert(try! Yaml.load("x: 1\ny: 2") == 321 | .dictionary([.string("x"): .int(1), .string("y"): .int(2)])) 322 | XCTAssertThrowsError(try Yaml.load("x: 1\nx: 2")) 323 | XCTAssert(try! Yaml.load("x: 1\n? y\n: 2") == ["x": 1, "y": 2]) 324 | XCTAssertThrowsError(try Yaml.load("x: 1\n? x\n: 2")) 325 | XCTAssertThrowsError(try Yaml.load("x: 1\n? y\n:\n2")) 326 | XCTAssert(try! Yaml.load("x: 1\n? y\n:\n 2") == ["x": 1, "y": 2]) 327 | XCTAssert(try! Yaml.load("x: 1\n? y") == ["x": 1, "y": nil]) 328 | XCTAssert(try! Yaml.load("? y") == ["y": nil]) 329 | XCTAssert(try! Yaml.load(" \n \n \n \n\nx: 1 \n \ny: 2" + 330 | "\n \n \n ")["y"] == 2) 331 | XCTAssert(try! Yaml.load("x:\n a: 1 # comment \n b: 2\ny: " + 332 | "\n c: 3\n ")["y"]["c"] == 3) 333 | XCTAssert(try! Yaml.load("# comment \n\n # x\n # y \n \n x: 1" + 334 | " \n y: 2") == ["x": 1, "y": 2]) 335 | } 336 | 337 | func testDirectives () { 338 | XCTAssertThrowsError(try Yaml.load("%YAML 1.2\n1")) 339 | XCTAssert(try Yaml.load("%YAML 1.2\n---1") == 1) 340 | XCTAssert(try Yaml.load("%YAML 1.2 #\n---1") == 1) 341 | XCTAssertThrowsError(try Yaml.load("%YAML 1.2\n%YAML 1.2\n---1")) 342 | XCTAssertThrowsError(try Yaml.load("%YAML 1.0\n---1")) 343 | XCTAssertThrowsError(try Yaml.load("%YAML 1\n---1")) 344 | XCTAssertThrowsError(try Yaml.load("%YAML 1.3\n---1")) 345 | XCTAssertThrowsError(try Yaml.load("%YAML \n---1")) 346 | } 347 | 348 | func testReserves () { 349 | XCTAssertThrowsError(try Yaml.load("`reserved")) 350 | XCTAssertThrowsError(try Yaml.load("@behrangn")) 351 | XCTAssertThrowsError(try Yaml.load("twitter handle: @behrangn")) 352 | } 353 | 354 | func testAliases () { 355 | XCTAssert(try! Yaml.load("x: &a 1\ny: *a") == ["x": 1, "y": 1]) 356 | XCTAssertThrowsError(try Yaml.loadMultiple("x: &a 1\ny: *a\n---\nx: *a")) 357 | XCTAssertThrowsError(try Yaml.load("x: *a")) 358 | } 359 | 360 | func testUnicodeSurrogates() { 361 | XCTAssert(try! Yaml.load("x: Dog‼🐶\ny: 𝒂𝑡") == ["x": "Dog‼🐶", "y": "𝒂𝑡"]) 362 | } 363 | 364 | } 365 | 366 | #if os(Linux) 367 | 368 | extension YamlTests { 369 | static var allTests: [(String, (YamlTests) -> () throws -> Void)] { 370 | return [ 371 | ("testNull", testNull), 372 | ("testBool", testBool), 373 | ("testInt", testInt), 374 | ("testDouble", testDouble), 375 | ("testString", testString), 376 | ("testFlowSeq", testFlowSeq), 377 | ("testBlockSeq", testBlockSeq), 378 | ("testFlowMap", testFlowMap), 379 | ("testBlockMap", testBlockMap), 380 | ("testDirectives", testDirectives), 381 | ("testReserves", testReserves), 382 | ("testAliases", testAliases), 383 | ("testUnicodeSurrogates", testUnicodeSurrogates), 384 | ] 385 | } 386 | } 387 | 388 | #endif 389 | -------------------------------------------------------------------------------- /Yaml.podspec: -------------------------------------------------------------------------------- 1 | Pod::Spec.new do |s| 2 | 3 | # ――― Spec Metadata ―――――――――――――――――――――――――――――――――――――――――――――――――――――――――― # 4 | s.name = "Yaml" 5 | s.version = "3.4.4" 6 | s.summary = "Load YAML and JSON documents using Swift" 7 | s.description = <<-DESC 8 | YamlSwift parses a string of YAML document(s) (or a JSON document) 9 | and returns a Yaml enum value representing that string. 10 | DESC 11 | s.homepage = "https://github.com/behrang/YamlSwift" 12 | s.swift_version = "5.0" 13 | 14 | # ――― Spec License ――――――――――――――――――――――――――――――――――――――――――――――――――――――――――― # 15 | s.license = "MIT" 16 | 17 | # ――― Author Metadata ――――――――――――――――――――――――――――――――――――――――――――――――――――――――― # 18 | s.author = { "behrang" => "behrangn@gmail.com" } 19 | 20 | # ――― Platform Specifics ――――――――――――――――――――――――――――――――――――――――――――――――――――――― # 21 | s.ios.deployment_target = "8.0" 22 | s.osx.deployment_target = "10.9" 23 | s.tvos.deployment_target = "9.0" 24 | 25 | # ――― Source Location ―――――――――――――――――――――――――――――――――――――――――――――――――――――――――― # 26 | s.source = { :git => "https://github.com/behrang/YamlSwift.git", :tag => s.version } 27 | 28 | # ――― Source Code ―――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――― # 29 | s.source_files = "Sources/Yaml/*.swift" 30 | 31 | # --- Target xcconfig ―――――――――――――――――――――――――――――――――――――――――――――――――――――――――― # 32 | s.pod_target_xcconfig = { 33 | 'SWIFT_VERSION' => '5.0', 34 | 'APPLICATION_EXTENSION_API_ONLY' => 'YES', 35 | } 36 | 37 | end 38 | -------------------------------------------------------------------------------- /Yaml.xcodeproj/.gitignore: -------------------------------------------------------------------------------- 1 | project.xcworkspace 2 | -------------------------------------------------------------------------------- /Yaml.xcodeproj/project.pbxproj: -------------------------------------------------------------------------------- 1 | // !$*UTF8*$! 2 | { 3 | archiveVersion = 1; 4 | classes = { 5 | }; 6 | objectVersion = 46; 7 | objects = { 8 | 9 | /* Begin PBXBuildFile section */ 10 | 228450C01DB0E51C00EACD31 /* Yaml.swift in Sources */ = {isa = PBXBuildFile; fileRef = 228450B61DB0E51C00EACD31 /* Yaml.swift */; }; 11 | 228450C11DB0E51C00EACD31 /* Yaml.swift in Sources */ = {isa = PBXBuildFile; fileRef = 228450B61DB0E51C00EACD31 /* Yaml.swift */; }; 12 | 228450C21DB0E51C00EACD31 /* Yaml.swift in Sources */ = {isa = PBXBuildFile; fileRef = 228450B61DB0E51C00EACD31 /* Yaml.swift */; }; 13 | 228450C31DB0E51C00EACD31 /* YAMLOperators.swift in Sources */ = {isa = PBXBuildFile; fileRef = 228450B71DB0E51C00EACD31 /* YAMLOperators.swift */; }; 14 | 228450C41DB0E51C00EACD31 /* YAMLOperators.swift in Sources */ = {isa = PBXBuildFile; fileRef = 228450B71DB0E51C00EACD31 /* YAMLOperators.swift */; }; 15 | 228450C51DB0E51C00EACD31 /* YAMLOperators.swift in Sources */ = {isa = PBXBuildFile; fileRef = 228450B71DB0E51C00EACD31 /* YAMLOperators.swift */; }; 16 | 228450C61DB0E51C00EACD31 /* YAMLParser.swift in Sources */ = {isa = PBXBuildFile; fileRef = 228450B81DB0E51C00EACD31 /* YAMLParser.swift */; }; 17 | 228450C71DB0E51C00EACD31 /* YAMLParser.swift in Sources */ = {isa = PBXBuildFile; fileRef = 228450B81DB0E51C00EACD31 /* YAMLParser.swift */; }; 18 | 228450C81DB0E51C00EACD31 /* YAMLParser.swift in Sources */ = {isa = PBXBuildFile; fileRef = 228450B81DB0E51C00EACD31 /* YAMLParser.swift */; }; 19 | 228450C91DB0E51C00EACD31 /* YAMLRegex.swift in Sources */ = {isa = PBXBuildFile; fileRef = 228450B91DB0E51C00EACD31 /* YAMLRegex.swift */; }; 20 | 228450CA1DB0E51C00EACD31 /* YAMLRegex.swift in Sources */ = {isa = PBXBuildFile; fileRef = 228450B91DB0E51C00EACD31 /* YAMLRegex.swift */; }; 21 | 228450CB1DB0E51C00EACD31 /* YAMLRegex.swift in Sources */ = {isa = PBXBuildFile; fileRef = 228450B91DB0E51C00EACD31 /* YAMLRegex.swift */; }; 22 | 228450CC1DB0E51C00EACD31 /* YAMLResult.swift in Sources */ = {isa = PBXBuildFile; fileRef = 228450BA1DB0E51C00EACD31 /* YAMLResult.swift */; }; 23 | 228450CD1DB0E51C00EACD31 /* YAMLResult.swift in Sources */ = {isa = PBXBuildFile; fileRef = 228450BA1DB0E51C00EACD31 /* YAMLResult.swift */; }; 24 | 228450CE1DB0E51C00EACD31 /* YAMLResult.swift in Sources */ = {isa = PBXBuildFile; fileRef = 228450BA1DB0E51C00EACD31 /* YAMLResult.swift */; }; 25 | 228450CF1DB0E51C00EACD31 /* YAMLTokenizer.swift in Sources */ = {isa = PBXBuildFile; fileRef = 228450BB1DB0E51C00EACD31 /* YAMLTokenizer.swift */; }; 26 | 228450D01DB0E51C00EACD31 /* YAMLTokenizer.swift in Sources */ = {isa = PBXBuildFile; fileRef = 228450BB1DB0E51C00EACD31 /* YAMLTokenizer.swift */; }; 27 | 228450D11DB0E51C00EACD31 /* YAMLTokenizer.swift in Sources */ = {isa = PBXBuildFile; fileRef = 228450BB1DB0E51C00EACD31 /* YAMLTokenizer.swift */; }; 28 | 228450D21DB0E51C00EACD31 /* Yaml.h in Headers */ = {isa = PBXBuildFile; fileRef = 228450BC1DB0E51C00EACD31 /* Yaml.h */; settings = {ATTRIBUTES = (Public, ); }; }; 29 | 228450D31DB0E51C00EACD31 /* Yaml.h in Headers */ = {isa = PBXBuildFile; fileRef = 228450BC1DB0E51C00EACD31 /* Yaml.h */; settings = {ATTRIBUTES = (Public, ); }; }; 30 | 228450D41DB0E51C00EACD31 /* Yaml.h in Headers */ = {isa = PBXBuildFile; fileRef = 228450BC1DB0E51C00EACD31 /* Yaml.h */; settings = {ATTRIBUTES = (Public, ); }; }; 31 | 8313C4331C8DC2CB00DEF215 /* Yaml.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 8313C4291C8DC2CB00DEF215 /* Yaml.framework */; }; 32 | 8313C4401C8DC4AD00DEF215 /* YamlTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = F3894BCB1B7312E000286880 /* YamlTests.swift */; }; 33 | 8313C4411C8DC4B000DEF215 /* ExampleTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = F32DF24D1B7304750011046A /* ExampleTests.swift */; }; 34 | 8E1D762D1B258FEE0022C013 /* Yaml.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 8E1D76211B258FEE0022C013 /* Yaml.framework */; }; 35 | F32DF2501B7304750011046A /* ExampleTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = F32DF24D1B7304750011046A /* ExampleTests.swift */; }; 36 | F32DF2621B73054D0011046A /* Yaml.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = F32DF2581B73054C0011046A /* Yaml.framework */; }; 37 | F32DF27B1B7305700011046A /* ExampleTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = F32DF24D1B7304750011046A /* ExampleTests.swift */; }; 38 | F3894BCC1B7312E000286880 /* YamlTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = F3894BCB1B7312E000286880 /* YamlTests.swift */; }; 39 | F3894BCD1B7312E000286880 /* YamlTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = F3894BCB1B7312E000286880 /* YamlTests.swift */; }; 40 | /* End PBXBuildFile section */ 41 | 42 | /* Begin PBXContainerItemProxy section */ 43 | 8313C4341C8DC2CB00DEF215 /* PBXContainerItemProxy */ = { 44 | isa = PBXContainerItemProxy; 45 | containerPortal = 8EF2541A1B258FB4001BCEBE /* Project object */; 46 | proxyType = 1; 47 | remoteGlobalIDString = 8313C4281C8DC2CB00DEF215; 48 | remoteInfo = Yaml; 49 | }; 50 | 8E1D762E1B258FEE0022C013 /* PBXContainerItemProxy */ = { 51 | isa = PBXContainerItemProxy; 52 | containerPortal = 8EF2541A1B258FB4001BCEBE /* Project object */; 53 | proxyType = 1; 54 | remoteGlobalIDString = 8E1D76201B258FEE0022C013; 55 | remoteInfo = Yaml; 56 | }; 57 | F32DF2631B73054D0011046A /* PBXContainerItemProxy */ = { 58 | isa = PBXContainerItemProxy; 59 | containerPortal = 8EF2541A1B258FB4001BCEBE /* Project object */; 60 | proxyType = 1; 61 | remoteGlobalIDString = F32DF2571B73054C0011046A; 62 | remoteInfo = Yaml; 63 | }; 64 | /* End PBXContainerItemProxy section */ 65 | 66 | /* Begin PBXFileReference section */ 67 | 228450B41DB0E51C00EACD31 /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = ""; }; 68 | 228450B61DB0E51C00EACD31 /* Yaml.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Yaml.swift; sourceTree = ""; }; 69 | 228450B71DB0E51C00EACD31 /* YAMLOperators.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = YAMLOperators.swift; sourceTree = ""; }; 70 | 228450B81DB0E51C00EACD31 /* YAMLParser.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = YAMLParser.swift; sourceTree = ""; }; 71 | 228450B91DB0E51C00EACD31 /* YAMLRegex.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = YAMLRegex.swift; sourceTree = ""; }; 72 | 228450BA1DB0E51C00EACD31 /* YAMLResult.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = YAMLResult.swift; sourceTree = ""; }; 73 | 228450BB1DB0E51C00EACD31 /* YAMLTokenizer.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = YAMLTokenizer.swift; sourceTree = ""; }; 74 | 228450BC1DB0E51C00EACD31 /* Yaml.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Yaml.h; sourceTree = ""; }; 75 | 8313C4291C8DC2CB00DEF215 /* Yaml.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = Yaml.framework; sourceTree = BUILT_PRODUCTS_DIR; }; 76 | 8313C4321C8DC2CB00DEF215 /* Tests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = Tests.xctest; sourceTree = BUILT_PRODUCTS_DIR; }; 77 | 8E1D76211B258FEE0022C013 /* Yaml.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = Yaml.framework; sourceTree = BUILT_PRODUCTS_DIR; }; 78 | 8E1D762C1B258FEE0022C013 /* Tests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = Tests.xctest; sourceTree = BUILT_PRODUCTS_DIR; }; 79 | 8E1D76321B258FEE0022C013 /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; name = Info.plist; path = ../Info.plist; sourceTree = ""; }; 80 | 8E1D763B1B2591330022C013 /* Readme.md */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = net.daringfireball.markdown; path = Readme.md; sourceTree = ""; }; 81 | F32DF24D1B7304750011046A /* ExampleTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = ExampleTests.swift; sourceTree = ""; }; 82 | F32DF2581B73054C0011046A /* Yaml.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = Yaml.framework; sourceTree = BUILT_PRODUCTS_DIR; }; 83 | F32DF2611B73054C0011046A /* Tests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = Tests.xctest; sourceTree = BUILT_PRODUCTS_DIR; }; 84 | F3894BCB1B7312E000286880 /* YamlTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = YamlTests.swift; sourceTree = ""; }; 85 | /* End PBXFileReference section */ 86 | 87 | /* Begin PBXFrameworksBuildPhase section */ 88 | 8313C4251C8DC2CB00DEF215 /* Frameworks */ = { 89 | isa = PBXFrameworksBuildPhase; 90 | buildActionMask = 2147483647; 91 | files = ( 92 | ); 93 | runOnlyForDeploymentPostprocessing = 0; 94 | }; 95 | 8313C42F1C8DC2CB00DEF215 /* Frameworks */ = { 96 | isa = PBXFrameworksBuildPhase; 97 | buildActionMask = 2147483647; 98 | files = ( 99 | 8313C4331C8DC2CB00DEF215 /* Yaml.framework in Frameworks */, 100 | ); 101 | runOnlyForDeploymentPostprocessing = 0; 102 | }; 103 | 8E1D761D1B258FEE0022C013 /* Frameworks */ = { 104 | isa = PBXFrameworksBuildPhase; 105 | buildActionMask = 2147483647; 106 | files = ( 107 | ); 108 | runOnlyForDeploymentPostprocessing = 0; 109 | }; 110 | 8E1D76291B258FEE0022C013 /* Frameworks */ = { 111 | isa = PBXFrameworksBuildPhase; 112 | buildActionMask = 2147483647; 113 | files = ( 114 | 8E1D762D1B258FEE0022C013 /* Yaml.framework in Frameworks */, 115 | ); 116 | runOnlyForDeploymentPostprocessing = 0; 117 | }; 118 | F32DF2541B73054C0011046A /* Frameworks */ = { 119 | isa = PBXFrameworksBuildPhase; 120 | buildActionMask = 2147483647; 121 | files = ( 122 | ); 123 | runOnlyForDeploymentPostprocessing = 0; 124 | }; 125 | F32DF25E1B73054C0011046A /* Frameworks */ = { 126 | isa = PBXFrameworksBuildPhase; 127 | buildActionMask = 2147483647; 128 | files = ( 129 | F32DF2621B73054D0011046A /* Yaml.framework in Frameworks */, 130 | ); 131 | runOnlyForDeploymentPostprocessing = 0; 132 | }; 133 | /* End PBXFrameworksBuildPhase section */ 134 | 135 | /* Begin PBXGroup section */ 136 | 228450B31DB0E51C00EACD31 /* Sources */ = { 137 | isa = PBXGroup; 138 | children = ( 139 | 228450B41DB0E51C00EACD31 /* Info.plist */, 140 | 228450B51DB0E51C00EACD31 /* YAML */, 141 | 228450BC1DB0E51C00EACD31 /* Yaml.h */, 142 | ); 143 | path = Sources; 144 | sourceTree = ""; 145 | }; 146 | 228450B51DB0E51C00EACD31 /* YAML */ = { 147 | isa = PBXGroup; 148 | children = ( 149 | 228450B61DB0E51C00EACD31 /* Yaml.swift */, 150 | 228450B71DB0E51C00EACD31 /* YAMLOperators.swift */, 151 | 228450B81DB0E51C00EACD31 /* YAMLParser.swift */, 152 | 228450B91DB0E51C00EACD31 /* YAMLRegex.swift */, 153 | 228450BA1DB0E51C00EACD31 /* YAMLResult.swift */, 154 | 228450BB1DB0E51C00EACD31 /* YAMLTokenizer.swift */, 155 | ); 156 | name = YAML; 157 | path = Yaml; 158 | sourceTree = ""; 159 | }; 160 | 8E1D76221B258FEE0022C013 /* Products */ = { 161 | isa = PBXGroup; 162 | children = ( 163 | 8E1D76211B258FEE0022C013 /* Yaml.framework */, 164 | 8E1D762C1B258FEE0022C013 /* Tests.xctest */, 165 | F32DF2581B73054C0011046A /* Yaml.framework */, 166 | F32DF2611B73054C0011046A /* Tests.xctest */, 167 | 8313C4291C8DC2CB00DEF215 /* Yaml.framework */, 168 | 8313C4321C8DC2CB00DEF215 /* Tests.xctest */, 169 | ); 170 | name = Products; 171 | sourceTree = ""; 172 | }; 173 | 8E1D76301B258FEE0022C013 /* Tests */ = { 174 | isa = PBXGroup; 175 | children = ( 176 | F32DF24D1B7304750011046A /* ExampleTests.swift */, 177 | F3894BCB1B7312E000286880 /* YamlTests.swift */, 178 | 8E1D76311B258FEE0022C013 /* Supporting Files */, 179 | ); 180 | name = Tests; 181 | path = Tests/YamlTests; 182 | sourceTree = ""; 183 | }; 184 | 8E1D76311B258FEE0022C013 /* Supporting Files */ = { 185 | isa = PBXGroup; 186 | children = ( 187 | 8E1D76321B258FEE0022C013 /* Info.plist */, 188 | ); 189 | name = "Supporting Files"; 190 | sourceTree = ""; 191 | }; 192 | 8EF254191B258FB4001BCEBE = { 193 | isa = PBXGroup; 194 | children = ( 195 | 228450B31DB0E51C00EACD31 /* Sources */, 196 | 8E1D763B1B2591330022C013 /* Readme.md */, 197 | 8E1D76301B258FEE0022C013 /* Tests */, 198 | 8E1D76221B258FEE0022C013 /* Products */, 199 | ); 200 | sourceTree = ""; 201 | }; 202 | /* End PBXGroup section */ 203 | 204 | /* Begin PBXHeadersBuildPhase section */ 205 | 8313C4261C8DC2CB00DEF215 /* Headers */ = { 206 | isa = PBXHeadersBuildPhase; 207 | buildActionMask = 2147483647; 208 | files = ( 209 | 228450D41DB0E51C00EACD31 /* Yaml.h in Headers */, 210 | ); 211 | runOnlyForDeploymentPostprocessing = 0; 212 | }; 213 | 8E1D761E1B258FEE0022C013 /* Headers */ = { 214 | isa = PBXHeadersBuildPhase; 215 | buildActionMask = 2147483647; 216 | files = ( 217 | 228450D21DB0E51C00EACD31 /* Yaml.h in Headers */, 218 | ); 219 | runOnlyForDeploymentPostprocessing = 0; 220 | }; 221 | F32DF2551B73054C0011046A /* Headers */ = { 222 | isa = PBXHeadersBuildPhase; 223 | buildActionMask = 2147483647; 224 | files = ( 225 | 228450D31DB0E51C00EACD31 /* Yaml.h in Headers */, 226 | ); 227 | runOnlyForDeploymentPostprocessing = 0; 228 | }; 229 | /* End PBXHeadersBuildPhase section */ 230 | 231 | /* Begin PBXNativeTarget section */ 232 | 8313C4281C8DC2CB00DEF215 /* Yaml tvOS */ = { 233 | isa = PBXNativeTarget; 234 | buildConfigurationList = 8313C43E1C8DC2CB00DEF215 /* Build configuration list for PBXNativeTarget "Yaml tvOS" */; 235 | buildPhases = ( 236 | 8313C4241C8DC2CB00DEF215 /* Sources */, 237 | 8313C4251C8DC2CB00DEF215 /* Frameworks */, 238 | 8313C4261C8DC2CB00DEF215 /* Headers */, 239 | 8313C4271C8DC2CB00DEF215 /* Resources */, 240 | ); 241 | buildRules = ( 242 | ); 243 | dependencies = ( 244 | ); 245 | name = "Yaml tvOS"; 246 | productName = Yaml; 247 | productReference = 8313C4291C8DC2CB00DEF215 /* Yaml.framework */; 248 | productType = "com.apple.product-type.framework"; 249 | }; 250 | 8313C4311C8DC2CB00DEF215 /* Tests tvOS */ = { 251 | isa = PBXNativeTarget; 252 | buildConfigurationList = 8313C43F1C8DC2CB00DEF215 /* Build configuration list for PBXNativeTarget "Tests tvOS" */; 253 | buildPhases = ( 254 | 8313C42E1C8DC2CB00DEF215 /* Sources */, 255 | 8313C42F1C8DC2CB00DEF215 /* Frameworks */, 256 | 8313C4301C8DC2CB00DEF215 /* Resources */, 257 | ); 258 | buildRules = ( 259 | ); 260 | dependencies = ( 261 | 8313C4351C8DC2CB00DEF215 /* PBXTargetDependency */, 262 | ); 263 | name = "Tests tvOS"; 264 | productName = YamlTests; 265 | productReference = 8313C4321C8DC2CB00DEF215 /* Tests.xctest */; 266 | productType = "com.apple.product-type.bundle.unit-test"; 267 | }; 268 | 8E1D76201B258FEE0022C013 /* Yaml OSX */ = { 269 | isa = PBXNativeTarget; 270 | buildConfigurationList = 8E1D76391B258FEE0022C013 /* Build configuration list for PBXNativeTarget "Yaml OSX" */; 271 | buildPhases = ( 272 | 8E1D761C1B258FEE0022C013 /* Sources */, 273 | 8E1D761D1B258FEE0022C013 /* Frameworks */, 274 | 8E1D761E1B258FEE0022C013 /* Headers */, 275 | 8E1D761F1B258FEE0022C013 /* Resources */, 276 | ); 277 | buildRules = ( 278 | ); 279 | dependencies = ( 280 | ); 281 | name = "Yaml OSX"; 282 | productName = Yaml; 283 | productReference = 8E1D76211B258FEE0022C013 /* Yaml.framework */; 284 | productType = "com.apple.product-type.framework"; 285 | }; 286 | 8E1D762B1B258FEE0022C013 /* Tests OSX */ = { 287 | isa = PBXNativeTarget; 288 | buildConfigurationList = 8E1D763A1B258FEE0022C013 /* Build configuration list for PBXNativeTarget "Tests OSX" */; 289 | buildPhases = ( 290 | 8E1D76281B258FEE0022C013 /* Sources */, 291 | 8E1D76291B258FEE0022C013 /* Frameworks */, 292 | 8E1D762A1B258FEE0022C013 /* Resources */, 293 | ); 294 | buildRules = ( 295 | ); 296 | dependencies = ( 297 | 8E1D762F1B258FEE0022C013 /* PBXTargetDependency */, 298 | ); 299 | name = "Tests OSX"; 300 | productName = Tests; 301 | productReference = 8E1D762C1B258FEE0022C013 /* Tests.xctest */; 302 | productType = "com.apple.product-type.bundle.unit-test"; 303 | }; 304 | F32DF2571B73054C0011046A /* Yaml iOS */ = { 305 | isa = PBXNativeTarget; 306 | buildConfigurationList = F32DF2691B73054D0011046A /* Build configuration list for PBXNativeTarget "Yaml iOS" */; 307 | buildPhases = ( 308 | F32DF2531B73054C0011046A /* Sources */, 309 | F32DF2541B73054C0011046A /* Frameworks */, 310 | F32DF2551B73054C0011046A /* Headers */, 311 | F32DF2561B73054C0011046A /* Resources */, 312 | ); 313 | buildRules = ( 314 | ); 315 | dependencies = ( 316 | ); 317 | name = "Yaml iOS"; 318 | productName = Yaml; 319 | productReference = F32DF2581B73054C0011046A /* Yaml.framework */; 320 | productType = "com.apple.product-type.framework"; 321 | }; 322 | F32DF2601B73054C0011046A /* Tests iOS */ = { 323 | isa = PBXNativeTarget; 324 | buildConfigurationList = F32DF26C1B73054D0011046A /* Build configuration list for PBXNativeTarget "Tests iOS" */; 325 | buildPhases = ( 326 | F32DF25D1B73054C0011046A /* Sources */, 327 | F32DF25E1B73054C0011046A /* Frameworks */, 328 | F32DF25F1B73054C0011046A /* Resources */, 329 | ); 330 | buildRules = ( 331 | ); 332 | dependencies = ( 333 | F32DF2641B73054D0011046A /* PBXTargetDependency */, 334 | ); 335 | name = "Tests iOS"; 336 | productName = Tests; 337 | productReference = F32DF2611B73054C0011046A /* Tests.xctest */; 338 | productType = "com.apple.product-type.bundle.unit-test"; 339 | }; 340 | /* End PBXNativeTarget section */ 341 | 342 | /* Begin PBXProject section */ 343 | 8EF2541A1B258FB4001BCEBE /* Project object */ = { 344 | isa = PBXProject; 345 | attributes = { 346 | LastSwiftUpdateCheck = 0720; 347 | LastUpgradeCheck = 1020; 348 | TargetAttributes = { 349 | 8313C4281C8DC2CB00DEF215 = { 350 | CreatedOnToolsVersion = 7.2.1; 351 | LastSwiftMigration = 0800; 352 | }; 353 | 8313C4311C8DC2CB00DEF215 = { 354 | CreatedOnToolsVersion = 7.2.1; 355 | LastSwiftMigration = 0800; 356 | }; 357 | 8E1D76201B258FEE0022C013 = { 358 | CreatedOnToolsVersion = 6.3.2; 359 | LastSwiftMigration = 0800; 360 | }; 361 | 8E1D762B1B258FEE0022C013 = { 362 | CreatedOnToolsVersion = 6.3.2; 363 | LastSwiftMigration = 0800; 364 | }; 365 | F32DF2571B73054C0011046A = { 366 | CreatedOnToolsVersion = 7.0; 367 | LastSwiftMigration = 1020; 368 | }; 369 | F32DF2601B73054C0011046A = { 370 | CreatedOnToolsVersion = 7.0; 371 | LastSwiftMigration = 1020; 372 | }; 373 | }; 374 | }; 375 | buildConfigurationList = 8EF2541D1B258FB4001BCEBE /* Build configuration list for PBXProject "Yaml" */; 376 | compatibilityVersion = "Xcode 3.2"; 377 | developmentRegion = en; 378 | hasScannedForEncodings = 0; 379 | knownRegions = ( 380 | en, 381 | Base, 382 | ); 383 | mainGroup = 8EF254191B258FB4001BCEBE; 384 | productRefGroup = 8E1D76221B258FEE0022C013 /* Products */; 385 | projectDirPath = ""; 386 | projectRoot = ""; 387 | targets = ( 388 | 8E1D76201B258FEE0022C013 /* Yaml OSX */, 389 | 8E1D762B1B258FEE0022C013 /* Tests OSX */, 390 | F32DF2571B73054C0011046A /* Yaml iOS */, 391 | F32DF2601B73054C0011046A /* Tests iOS */, 392 | 8313C4281C8DC2CB00DEF215 /* Yaml tvOS */, 393 | 8313C4311C8DC2CB00DEF215 /* Tests tvOS */, 394 | ); 395 | }; 396 | /* End PBXProject section */ 397 | 398 | /* Begin PBXResourcesBuildPhase section */ 399 | 8313C4271C8DC2CB00DEF215 /* Resources */ = { 400 | isa = PBXResourcesBuildPhase; 401 | buildActionMask = 2147483647; 402 | files = ( 403 | ); 404 | runOnlyForDeploymentPostprocessing = 0; 405 | }; 406 | 8313C4301C8DC2CB00DEF215 /* Resources */ = { 407 | isa = PBXResourcesBuildPhase; 408 | buildActionMask = 2147483647; 409 | files = ( 410 | ); 411 | runOnlyForDeploymentPostprocessing = 0; 412 | }; 413 | 8E1D761F1B258FEE0022C013 /* Resources */ = { 414 | isa = PBXResourcesBuildPhase; 415 | buildActionMask = 2147483647; 416 | files = ( 417 | ); 418 | runOnlyForDeploymentPostprocessing = 0; 419 | }; 420 | 8E1D762A1B258FEE0022C013 /* Resources */ = { 421 | isa = PBXResourcesBuildPhase; 422 | buildActionMask = 2147483647; 423 | files = ( 424 | ); 425 | runOnlyForDeploymentPostprocessing = 0; 426 | }; 427 | F32DF2561B73054C0011046A /* Resources */ = { 428 | isa = PBXResourcesBuildPhase; 429 | buildActionMask = 2147483647; 430 | files = ( 431 | ); 432 | runOnlyForDeploymentPostprocessing = 0; 433 | }; 434 | F32DF25F1B73054C0011046A /* Resources */ = { 435 | isa = PBXResourcesBuildPhase; 436 | buildActionMask = 2147483647; 437 | files = ( 438 | ); 439 | runOnlyForDeploymentPostprocessing = 0; 440 | }; 441 | /* End PBXResourcesBuildPhase section */ 442 | 443 | /* Begin PBXSourcesBuildPhase section */ 444 | 8313C4241C8DC2CB00DEF215 /* Sources */ = { 445 | isa = PBXSourcesBuildPhase; 446 | buildActionMask = 2147483647; 447 | files = ( 448 | 228450D11DB0E51C00EACD31 /* YAMLTokenizer.swift in Sources */, 449 | 228450CE1DB0E51C00EACD31 /* YAMLResult.swift in Sources */, 450 | 228450CB1DB0E51C00EACD31 /* YAMLRegex.swift in Sources */, 451 | 228450C51DB0E51C00EACD31 /* YAMLOperators.swift in Sources */, 452 | 228450C21DB0E51C00EACD31 /* Yaml.swift in Sources */, 453 | 228450C81DB0E51C00EACD31 /* YAMLParser.swift in Sources */, 454 | ); 455 | runOnlyForDeploymentPostprocessing = 0; 456 | }; 457 | 8313C42E1C8DC2CB00DEF215 /* Sources */ = { 458 | isa = PBXSourcesBuildPhase; 459 | buildActionMask = 2147483647; 460 | files = ( 461 | 8313C4411C8DC4B000DEF215 /* ExampleTests.swift in Sources */, 462 | 8313C4401C8DC4AD00DEF215 /* YamlTests.swift in Sources */, 463 | ); 464 | runOnlyForDeploymentPostprocessing = 0; 465 | }; 466 | 8E1D761C1B258FEE0022C013 /* Sources */ = { 467 | isa = PBXSourcesBuildPhase; 468 | buildActionMask = 2147483647; 469 | files = ( 470 | 228450CF1DB0E51C00EACD31 /* YAMLTokenizer.swift in Sources */, 471 | 228450CC1DB0E51C00EACD31 /* YAMLResult.swift in Sources */, 472 | 228450C91DB0E51C00EACD31 /* YAMLRegex.swift in Sources */, 473 | 228450C31DB0E51C00EACD31 /* YAMLOperators.swift in Sources */, 474 | 228450C01DB0E51C00EACD31 /* Yaml.swift in Sources */, 475 | 228450C61DB0E51C00EACD31 /* YAMLParser.swift in Sources */, 476 | ); 477 | runOnlyForDeploymentPostprocessing = 0; 478 | }; 479 | 8E1D76281B258FEE0022C013 /* Sources */ = { 480 | isa = PBXSourcesBuildPhase; 481 | buildActionMask = 2147483647; 482 | files = ( 483 | F3894BCC1B7312E000286880 /* YamlTests.swift in Sources */, 484 | F32DF2501B7304750011046A /* ExampleTests.swift in Sources */, 485 | ); 486 | runOnlyForDeploymentPostprocessing = 0; 487 | }; 488 | F32DF2531B73054C0011046A /* Sources */ = { 489 | isa = PBXSourcesBuildPhase; 490 | buildActionMask = 2147483647; 491 | files = ( 492 | 228450D01DB0E51C00EACD31 /* YAMLTokenizer.swift in Sources */, 493 | 228450CD1DB0E51C00EACD31 /* YAMLResult.swift in Sources */, 494 | 228450CA1DB0E51C00EACD31 /* YAMLRegex.swift in Sources */, 495 | 228450C41DB0E51C00EACD31 /* YAMLOperators.swift in Sources */, 496 | 228450C11DB0E51C00EACD31 /* Yaml.swift in Sources */, 497 | 228450C71DB0E51C00EACD31 /* YAMLParser.swift in Sources */, 498 | ); 499 | runOnlyForDeploymentPostprocessing = 0; 500 | }; 501 | F32DF25D1B73054C0011046A /* Sources */ = { 502 | isa = PBXSourcesBuildPhase; 503 | buildActionMask = 2147483647; 504 | files = ( 505 | F3894BCD1B7312E000286880 /* YamlTests.swift in Sources */, 506 | F32DF27B1B7305700011046A /* ExampleTests.swift in Sources */, 507 | ); 508 | runOnlyForDeploymentPostprocessing = 0; 509 | }; 510 | /* End PBXSourcesBuildPhase section */ 511 | 512 | /* Begin PBXTargetDependency section */ 513 | 8313C4351C8DC2CB00DEF215 /* PBXTargetDependency */ = { 514 | isa = PBXTargetDependency; 515 | target = 8313C4281C8DC2CB00DEF215 /* Yaml tvOS */; 516 | targetProxy = 8313C4341C8DC2CB00DEF215 /* PBXContainerItemProxy */; 517 | }; 518 | 8E1D762F1B258FEE0022C013 /* PBXTargetDependency */ = { 519 | isa = PBXTargetDependency; 520 | target = 8E1D76201B258FEE0022C013 /* Yaml OSX */; 521 | targetProxy = 8E1D762E1B258FEE0022C013 /* PBXContainerItemProxy */; 522 | }; 523 | F32DF2641B73054D0011046A /* PBXTargetDependency */ = { 524 | isa = PBXTargetDependency; 525 | target = F32DF2571B73054C0011046A /* Yaml iOS */; 526 | targetProxy = F32DF2631B73054D0011046A /* PBXContainerItemProxy */; 527 | }; 528 | /* End PBXTargetDependency section */ 529 | 530 | /* Begin XCBuildConfiguration section */ 531 | 8313C43A1C8DC2CB00DEF215 /* Debug */ = { 532 | isa = XCBuildConfiguration; 533 | buildSettings = { 534 | ALWAYS_SEARCH_USER_PATHS = NO; 535 | APPLICATION_EXTENSION_API_ONLY = YES; 536 | CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; 537 | CLANG_CXX_LIBRARY = "libc++"; 538 | CLANG_ENABLE_MODULES = YES; 539 | CLANG_ENABLE_OBJC_ARC = YES; 540 | CLANG_WARN_BOOL_CONVERSION = YES; 541 | CLANG_WARN_CONSTANT_CONVERSION = YES; 542 | CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; 543 | CLANG_WARN_EMPTY_BODY = YES; 544 | CLANG_WARN_ENUM_CONVERSION = YES; 545 | CLANG_WARN_INT_CONVERSION = YES; 546 | CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; 547 | CLANG_WARN_UNREACHABLE_CODE = YES; 548 | CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; 549 | "CODE_SIGN_IDENTITY[sdk=appletvos*]" = ""; 550 | COPY_PHASE_STRIP = NO; 551 | CURRENT_PROJECT_VERSION = 3.4.3; 552 | DEBUG_INFORMATION_FORMAT = dwarf; 553 | DEFINES_MODULE = YES; 554 | DYLIB_COMPATIBILITY_VERSION = 1; 555 | DYLIB_CURRENT_VERSION = 3.4.3; 556 | DYLIB_INSTALL_NAME_BASE = "@rpath"; 557 | ENABLE_STRICT_OBJC_MSGSEND = YES; 558 | GCC_C_LANGUAGE_STANDARD = gnu99; 559 | GCC_DYNAMIC_NO_PIC = NO; 560 | GCC_NO_COMMON_BLOCKS = YES; 561 | GCC_OPTIMIZATION_LEVEL = 0; 562 | GCC_PREPROCESSOR_DEFINITIONS = ( 563 | "DEBUG=1", 564 | "$(inherited)", 565 | ); 566 | GCC_WARN_64_TO_32_BIT_CONVERSION = YES; 567 | GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; 568 | GCC_WARN_UNDECLARED_SELECTOR = YES; 569 | GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; 570 | GCC_WARN_UNUSED_FUNCTION = YES; 571 | GCC_WARN_UNUSED_VARIABLE = YES; 572 | INFOPLIST_FILE = "$(SRCROOT)/Sources/Info.plist"; 573 | INSTALL_PATH = "$(LOCAL_LIBRARY_DIR)/Frameworks"; 574 | LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks @loader_path/Frameworks"; 575 | MTL_ENABLE_DEBUG_INFO = YES; 576 | SDKROOT = appletvos; 577 | SKIP_INSTALL = YES; 578 | SWIFT_OPTIMIZATION_LEVEL = "-Onone"; 579 | SWIFT_VERSION = 5.0; 580 | TARGETED_DEVICE_FAMILY = 3; 581 | TVOS_DEPLOYMENT_TARGET = 9.1; 582 | VERSIONING_SYSTEM = "apple-generic"; 583 | VERSION_INFO_PREFIX = ""; 584 | }; 585 | name = Debug; 586 | }; 587 | 8313C43B1C8DC2CB00DEF215 /* Release */ = { 588 | isa = XCBuildConfiguration; 589 | buildSettings = { 590 | ALWAYS_SEARCH_USER_PATHS = NO; 591 | APPLICATION_EXTENSION_API_ONLY = YES; 592 | CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; 593 | CLANG_CXX_LIBRARY = "libc++"; 594 | CLANG_ENABLE_MODULES = YES; 595 | CLANG_ENABLE_OBJC_ARC = YES; 596 | CLANG_WARN_BOOL_CONVERSION = YES; 597 | CLANG_WARN_CONSTANT_CONVERSION = YES; 598 | CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; 599 | CLANG_WARN_EMPTY_BODY = YES; 600 | CLANG_WARN_ENUM_CONVERSION = YES; 601 | CLANG_WARN_INT_CONVERSION = YES; 602 | CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; 603 | CLANG_WARN_UNREACHABLE_CODE = YES; 604 | CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; 605 | "CODE_SIGN_IDENTITY[sdk=appletvos*]" = ""; 606 | COPY_PHASE_STRIP = NO; 607 | CURRENT_PROJECT_VERSION = 3.4.3; 608 | DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; 609 | DEFINES_MODULE = YES; 610 | DYLIB_COMPATIBILITY_VERSION = 1; 611 | DYLIB_CURRENT_VERSION = 3.4.3; 612 | DYLIB_INSTALL_NAME_BASE = "@rpath"; 613 | ENABLE_NS_ASSERTIONS = NO; 614 | ENABLE_STRICT_OBJC_MSGSEND = YES; 615 | GCC_C_LANGUAGE_STANDARD = gnu99; 616 | GCC_NO_COMMON_BLOCKS = YES; 617 | GCC_WARN_64_TO_32_BIT_CONVERSION = YES; 618 | GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; 619 | GCC_WARN_UNDECLARED_SELECTOR = YES; 620 | GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; 621 | GCC_WARN_UNUSED_FUNCTION = YES; 622 | GCC_WARN_UNUSED_VARIABLE = YES; 623 | INFOPLIST_FILE = "$(SRCROOT)/Sources/Info.plist"; 624 | INSTALL_PATH = "$(LOCAL_LIBRARY_DIR)/Frameworks"; 625 | LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks @loader_path/Frameworks"; 626 | MTL_ENABLE_DEBUG_INFO = NO; 627 | SDKROOT = appletvos; 628 | SKIP_INSTALL = YES; 629 | SWIFT_OPTIMIZATION_LEVEL = "-Owholemodule"; 630 | SWIFT_VERSION = 5.0; 631 | TARGETED_DEVICE_FAMILY = 3; 632 | TVOS_DEPLOYMENT_TARGET = 9.1; 633 | VALIDATE_PRODUCT = YES; 634 | VERSIONING_SYSTEM = "apple-generic"; 635 | VERSION_INFO_PREFIX = ""; 636 | }; 637 | name = Release; 638 | }; 639 | 8313C43C1C8DC2CB00DEF215 /* Debug */ = { 640 | isa = XCBuildConfiguration; 641 | buildSettings = { 642 | ALWAYS_EMBED_SWIFT_STANDARD_LIBRARIES = YES; 643 | ALWAYS_SEARCH_USER_PATHS = NO; 644 | CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; 645 | CLANG_CXX_LIBRARY = "libc++"; 646 | CLANG_ENABLE_MODULES = YES; 647 | CLANG_ENABLE_OBJC_ARC = YES; 648 | CLANG_WARN_BOOL_CONVERSION = YES; 649 | CLANG_WARN_CONSTANT_CONVERSION = YES; 650 | CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; 651 | CLANG_WARN_EMPTY_BODY = YES; 652 | CLANG_WARN_ENUM_CONVERSION = YES; 653 | CLANG_WARN_INT_CONVERSION = YES; 654 | CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; 655 | CLANG_WARN_UNREACHABLE_CODE = YES; 656 | CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; 657 | COPY_PHASE_STRIP = NO; 658 | DEBUG_INFORMATION_FORMAT = dwarf; 659 | ENABLE_STRICT_OBJC_MSGSEND = YES; 660 | GCC_C_LANGUAGE_STANDARD = gnu99; 661 | GCC_DYNAMIC_NO_PIC = NO; 662 | GCC_NO_COMMON_BLOCKS = YES; 663 | GCC_OPTIMIZATION_LEVEL = 0; 664 | GCC_PREPROCESSOR_DEFINITIONS = ( 665 | "DEBUG=1", 666 | "$(inherited)", 667 | ); 668 | GCC_WARN_64_TO_32_BIT_CONVERSION = YES; 669 | GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; 670 | GCC_WARN_UNDECLARED_SELECTOR = YES; 671 | GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; 672 | GCC_WARN_UNUSED_FUNCTION = YES; 673 | GCC_WARN_UNUSED_VARIABLE = YES; 674 | INFOPLIST_FILE = Tests/Info.plist; 675 | LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks @loader_path/Frameworks"; 676 | MTL_ENABLE_DEBUG_INFO = YES; 677 | PRODUCT_NAME = Tests; 678 | SDKROOT = appletvos; 679 | SWIFT_OPTIMIZATION_LEVEL = "-Onone"; 680 | SWIFT_VERSION = 5.0; 681 | TVOS_DEPLOYMENT_TARGET = 9.1; 682 | }; 683 | name = Debug; 684 | }; 685 | 8313C43D1C8DC2CB00DEF215 /* Release */ = { 686 | isa = XCBuildConfiguration; 687 | buildSettings = { 688 | ALWAYS_EMBED_SWIFT_STANDARD_LIBRARIES = YES; 689 | ALWAYS_SEARCH_USER_PATHS = NO; 690 | CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; 691 | CLANG_CXX_LIBRARY = "libc++"; 692 | CLANG_ENABLE_MODULES = YES; 693 | CLANG_ENABLE_OBJC_ARC = YES; 694 | CLANG_WARN_BOOL_CONVERSION = YES; 695 | CLANG_WARN_CONSTANT_CONVERSION = YES; 696 | CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; 697 | CLANG_WARN_EMPTY_BODY = YES; 698 | CLANG_WARN_ENUM_CONVERSION = YES; 699 | CLANG_WARN_INT_CONVERSION = YES; 700 | CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; 701 | CLANG_WARN_UNREACHABLE_CODE = YES; 702 | CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; 703 | COPY_PHASE_STRIP = NO; 704 | DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; 705 | ENABLE_NS_ASSERTIONS = NO; 706 | ENABLE_STRICT_OBJC_MSGSEND = YES; 707 | GCC_C_LANGUAGE_STANDARD = gnu99; 708 | GCC_NO_COMMON_BLOCKS = YES; 709 | GCC_WARN_64_TO_32_BIT_CONVERSION = YES; 710 | GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; 711 | GCC_WARN_UNDECLARED_SELECTOR = YES; 712 | GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; 713 | GCC_WARN_UNUSED_FUNCTION = YES; 714 | GCC_WARN_UNUSED_VARIABLE = YES; 715 | INFOPLIST_FILE = Tests/Info.plist; 716 | LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks @loader_path/Frameworks"; 717 | MTL_ENABLE_DEBUG_INFO = NO; 718 | PRODUCT_NAME = Tests; 719 | SDKROOT = appletvos; 720 | SWIFT_OPTIMIZATION_LEVEL = "-Owholemodule"; 721 | SWIFT_VERSION = 5.0; 722 | TVOS_DEPLOYMENT_TARGET = 9.1; 723 | VALIDATE_PRODUCT = YES; 724 | }; 725 | name = Release; 726 | }; 727 | 8E1D76351B258FEE0022C013 /* Debug */ = { 728 | isa = XCBuildConfiguration; 729 | buildSettings = { 730 | ALWAYS_SEARCH_USER_PATHS = NO; 731 | APPLICATION_EXTENSION_API_ONLY = YES; 732 | CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; 733 | CLANG_CXX_LIBRARY = "libc++"; 734 | CLANG_ENABLE_MODULES = YES; 735 | CLANG_ENABLE_OBJC_ARC = YES; 736 | CLANG_WARN_BOOL_CONVERSION = YES; 737 | CLANG_WARN_CONSTANT_CONVERSION = YES; 738 | CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; 739 | CLANG_WARN_EMPTY_BODY = YES; 740 | CLANG_WARN_ENUM_CONVERSION = YES; 741 | CLANG_WARN_INT_CONVERSION = YES; 742 | CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; 743 | CLANG_WARN_UNREACHABLE_CODE = YES; 744 | CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; 745 | COMBINE_HIDPI_IMAGES = YES; 746 | COPY_PHASE_STRIP = NO; 747 | CURRENT_PROJECT_VERSION = 3.4.3; 748 | DEBUG_INFORMATION_FORMAT = dwarf; 749 | DEFINES_MODULE = YES; 750 | DYLIB_COMPATIBILITY_VERSION = 1; 751 | DYLIB_CURRENT_VERSION = 3.4.3; 752 | DYLIB_INSTALL_NAME_BASE = "@rpath"; 753 | ENABLE_STRICT_OBJC_MSGSEND = YES; 754 | FRAMEWORK_VERSION = A; 755 | GCC_C_LANGUAGE_STANDARD = gnu99; 756 | GCC_DYNAMIC_NO_PIC = NO; 757 | GCC_NO_COMMON_BLOCKS = YES; 758 | GCC_OPTIMIZATION_LEVEL = 0; 759 | GCC_PREPROCESSOR_DEFINITIONS = ( 760 | "DEBUG=1", 761 | "$(inherited)", 762 | ); 763 | GCC_SYMBOLS_PRIVATE_EXTERN = NO; 764 | GCC_WARN_64_TO_32_BIT_CONVERSION = YES; 765 | GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; 766 | GCC_WARN_UNDECLARED_SELECTOR = YES; 767 | GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; 768 | GCC_WARN_UNUSED_FUNCTION = YES; 769 | GCC_WARN_UNUSED_VARIABLE = YES; 770 | INFOPLIST_FILE = "$(SRCROOT)/Sources/Info.plist"; 771 | INSTALL_PATH = "$(LOCAL_LIBRARY_DIR)/Frameworks"; 772 | LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/../Frameworks @loader_path/Frameworks"; 773 | MACOSX_DEPLOYMENT_TARGET = 10.9; 774 | MTL_ENABLE_DEBUG_INFO = YES; 775 | ONLY_ACTIVE_ARCH = YES; 776 | SDKROOT = macosx; 777 | SKIP_INSTALL = YES; 778 | SWIFT_OPTIMIZATION_LEVEL = "-Onone"; 779 | SWIFT_VERSION = 5.0; 780 | VERSIONING_SYSTEM = "apple-generic"; 781 | VERSION_INFO_PREFIX = ""; 782 | }; 783 | name = Debug; 784 | }; 785 | 8E1D76361B258FEE0022C013 /* Release */ = { 786 | isa = XCBuildConfiguration; 787 | buildSettings = { 788 | ALWAYS_SEARCH_USER_PATHS = NO; 789 | APPLICATION_EXTENSION_API_ONLY = YES; 790 | CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; 791 | CLANG_CXX_LIBRARY = "libc++"; 792 | CLANG_ENABLE_MODULES = YES; 793 | CLANG_ENABLE_OBJC_ARC = YES; 794 | CLANG_WARN_BOOL_CONVERSION = YES; 795 | CLANG_WARN_CONSTANT_CONVERSION = YES; 796 | CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; 797 | CLANG_WARN_EMPTY_BODY = YES; 798 | CLANG_WARN_ENUM_CONVERSION = YES; 799 | CLANG_WARN_INT_CONVERSION = YES; 800 | CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; 801 | CLANG_WARN_UNREACHABLE_CODE = YES; 802 | CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; 803 | COMBINE_HIDPI_IMAGES = YES; 804 | COPY_PHASE_STRIP = NO; 805 | CURRENT_PROJECT_VERSION = 3.4.3; 806 | DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; 807 | DEFINES_MODULE = YES; 808 | DYLIB_COMPATIBILITY_VERSION = 1; 809 | DYLIB_CURRENT_VERSION = 3.4.3; 810 | DYLIB_INSTALL_NAME_BASE = "@rpath"; 811 | ENABLE_NS_ASSERTIONS = NO; 812 | ENABLE_STRICT_OBJC_MSGSEND = YES; 813 | FRAMEWORK_VERSION = A; 814 | GCC_C_LANGUAGE_STANDARD = gnu99; 815 | GCC_NO_COMMON_BLOCKS = YES; 816 | GCC_WARN_64_TO_32_BIT_CONVERSION = YES; 817 | GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; 818 | GCC_WARN_UNDECLARED_SELECTOR = YES; 819 | GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; 820 | GCC_WARN_UNUSED_FUNCTION = YES; 821 | GCC_WARN_UNUSED_VARIABLE = YES; 822 | INFOPLIST_FILE = "$(SRCROOT)/Sources/Info.plist"; 823 | INSTALL_PATH = "$(LOCAL_LIBRARY_DIR)/Frameworks"; 824 | LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/../Frameworks @loader_path/Frameworks"; 825 | MACOSX_DEPLOYMENT_TARGET = 10.9; 826 | MTL_ENABLE_DEBUG_INFO = NO; 827 | SDKROOT = macosx; 828 | SKIP_INSTALL = YES; 829 | SWIFT_OPTIMIZATION_LEVEL = "-Owholemodule"; 830 | SWIFT_VERSION = 5.0; 831 | VERSIONING_SYSTEM = "apple-generic"; 832 | VERSION_INFO_PREFIX = ""; 833 | }; 834 | name = Release; 835 | }; 836 | 8E1D76371B258FEE0022C013 /* Debug */ = { 837 | isa = XCBuildConfiguration; 838 | buildSettings = { 839 | ALWAYS_EMBED_SWIFT_STANDARD_LIBRARIES = YES; 840 | ALWAYS_SEARCH_USER_PATHS = NO; 841 | CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; 842 | CLANG_CXX_LIBRARY = "libc++"; 843 | CLANG_ENABLE_MODULES = YES; 844 | CLANG_ENABLE_OBJC_ARC = YES; 845 | CLANG_WARN_BOOL_CONVERSION = YES; 846 | CLANG_WARN_CONSTANT_CONVERSION = YES; 847 | CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; 848 | CLANG_WARN_EMPTY_BODY = YES; 849 | CLANG_WARN_ENUM_CONVERSION = YES; 850 | CLANG_WARN_INT_CONVERSION = YES; 851 | CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; 852 | CLANG_WARN_UNREACHABLE_CODE = YES; 853 | CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; 854 | COMBINE_HIDPI_IMAGES = YES; 855 | COPY_PHASE_STRIP = NO; 856 | DEBUG_INFORMATION_FORMAT = dwarf; 857 | ENABLE_STRICT_OBJC_MSGSEND = YES; 858 | FRAMEWORK_SEARCH_PATHS = ( 859 | "$(DEVELOPER_FRAMEWORKS_DIR)", 860 | "$(inherited)", 861 | ); 862 | GCC_C_LANGUAGE_STANDARD = gnu99; 863 | GCC_DYNAMIC_NO_PIC = NO; 864 | GCC_NO_COMMON_BLOCKS = YES; 865 | GCC_OPTIMIZATION_LEVEL = 0; 866 | GCC_PREPROCESSOR_DEFINITIONS = ( 867 | "DEBUG=1", 868 | "$(inherited)", 869 | ); 870 | GCC_SYMBOLS_PRIVATE_EXTERN = NO; 871 | GCC_WARN_64_TO_32_BIT_CONVERSION = YES; 872 | GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; 873 | GCC_WARN_UNDECLARED_SELECTOR = YES; 874 | GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; 875 | GCC_WARN_UNUSED_FUNCTION = YES; 876 | GCC_WARN_UNUSED_VARIABLE = YES; 877 | INFOPLIST_FILE = Tests/Info.plist; 878 | LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/../Frameworks @loader_path/../Frameworks"; 879 | MACOSX_DEPLOYMENT_TARGET = 10.10; 880 | MTL_ENABLE_DEBUG_INFO = YES; 881 | ONLY_ACTIVE_ARCH = YES; 882 | PRODUCT_NAME = Tests; 883 | SDKROOT = macosx; 884 | SWIFT_OPTIMIZATION_LEVEL = "-Onone"; 885 | SWIFT_VERSION = 5.0; 886 | }; 887 | name = Debug; 888 | }; 889 | 8E1D76381B258FEE0022C013 /* Release */ = { 890 | isa = XCBuildConfiguration; 891 | buildSettings = { 892 | ALWAYS_EMBED_SWIFT_STANDARD_LIBRARIES = YES; 893 | ALWAYS_SEARCH_USER_PATHS = NO; 894 | CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; 895 | CLANG_CXX_LIBRARY = "libc++"; 896 | CLANG_ENABLE_MODULES = YES; 897 | CLANG_ENABLE_OBJC_ARC = YES; 898 | CLANG_WARN_BOOL_CONVERSION = YES; 899 | CLANG_WARN_CONSTANT_CONVERSION = YES; 900 | CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; 901 | CLANG_WARN_EMPTY_BODY = YES; 902 | CLANG_WARN_ENUM_CONVERSION = YES; 903 | CLANG_WARN_INT_CONVERSION = YES; 904 | CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; 905 | CLANG_WARN_UNREACHABLE_CODE = YES; 906 | CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; 907 | COMBINE_HIDPI_IMAGES = YES; 908 | COPY_PHASE_STRIP = NO; 909 | DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; 910 | ENABLE_NS_ASSERTIONS = NO; 911 | ENABLE_STRICT_OBJC_MSGSEND = YES; 912 | FRAMEWORK_SEARCH_PATHS = ( 913 | "$(DEVELOPER_FRAMEWORKS_DIR)", 914 | "$(inherited)", 915 | ); 916 | GCC_C_LANGUAGE_STANDARD = gnu99; 917 | GCC_NO_COMMON_BLOCKS = YES; 918 | GCC_WARN_64_TO_32_BIT_CONVERSION = YES; 919 | GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; 920 | GCC_WARN_UNDECLARED_SELECTOR = YES; 921 | GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; 922 | GCC_WARN_UNUSED_FUNCTION = YES; 923 | GCC_WARN_UNUSED_VARIABLE = YES; 924 | INFOPLIST_FILE = Tests/Info.plist; 925 | LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/../Frameworks @loader_path/../Frameworks"; 926 | MACOSX_DEPLOYMENT_TARGET = 10.10; 927 | MTL_ENABLE_DEBUG_INFO = NO; 928 | PRODUCT_NAME = Tests; 929 | SDKROOT = macosx; 930 | SWIFT_OPTIMIZATION_LEVEL = "-Owholemodule"; 931 | SWIFT_VERSION = 5.0; 932 | }; 933 | name = Release; 934 | }; 935 | 8EF2541E1B258FB4001BCEBE /* Debug */ = { 936 | isa = XCBuildConfiguration; 937 | buildSettings = { 938 | APPLICATION_EXTENSION_API_ONLY = YES; 939 | CLANG_ANALYZER_LOCALIZABILITY_NONLOCALIZED = YES; 940 | CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; 941 | CLANG_WARN_BOOL_CONVERSION = YES; 942 | CLANG_WARN_COMMA = YES; 943 | CLANG_WARN_CONSTANT_CONVERSION = YES; 944 | CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; 945 | CLANG_WARN_EMPTY_BODY = YES; 946 | CLANG_WARN_ENUM_CONVERSION = YES; 947 | CLANG_WARN_INFINITE_RECURSION = YES; 948 | CLANG_WARN_INT_CONVERSION = YES; 949 | CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; 950 | CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES; 951 | CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; 952 | CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; 953 | CLANG_WARN_STRICT_PROTOTYPES = YES; 954 | CLANG_WARN_SUSPICIOUS_MOVE = YES; 955 | CLANG_WARN_UNREACHABLE_CODE = YES; 956 | CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; 957 | ENABLE_STRICT_OBJC_MSGSEND = YES; 958 | ENABLE_TESTABILITY = YES; 959 | GCC_NO_COMMON_BLOCKS = YES; 960 | GCC_WARN_64_TO_32_BIT_CONVERSION = YES; 961 | GCC_WARN_ABOUT_RETURN_TYPE = YES; 962 | GCC_WARN_UNDECLARED_SELECTOR = YES; 963 | GCC_WARN_UNINITIALIZED_AUTOS = YES; 964 | GCC_WARN_UNUSED_FUNCTION = YES; 965 | GCC_WARN_UNUSED_VARIABLE = YES; 966 | ONLY_ACTIVE_ARCH = YES; 967 | PRODUCT_BUNDLE_IDENTIFIER = behrang.Yaml; 968 | PRODUCT_NAME = Yaml; 969 | SWIFT_VERSION = 5.0; 970 | }; 971 | name = Debug; 972 | }; 973 | 8EF2541F1B258FB4001BCEBE /* Release */ = { 974 | isa = XCBuildConfiguration; 975 | buildSettings = { 976 | APPLICATION_EXTENSION_API_ONLY = YES; 977 | CLANG_ANALYZER_LOCALIZABILITY_NONLOCALIZED = YES; 978 | CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; 979 | CLANG_WARN_BOOL_CONVERSION = YES; 980 | CLANG_WARN_COMMA = YES; 981 | CLANG_WARN_CONSTANT_CONVERSION = YES; 982 | CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; 983 | CLANG_WARN_EMPTY_BODY = YES; 984 | CLANG_WARN_ENUM_CONVERSION = YES; 985 | CLANG_WARN_INFINITE_RECURSION = YES; 986 | CLANG_WARN_INT_CONVERSION = YES; 987 | CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; 988 | CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES; 989 | CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; 990 | CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; 991 | CLANG_WARN_STRICT_PROTOTYPES = YES; 992 | CLANG_WARN_SUSPICIOUS_MOVE = YES; 993 | CLANG_WARN_UNREACHABLE_CODE = YES; 994 | CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; 995 | ENABLE_STRICT_OBJC_MSGSEND = YES; 996 | GCC_NO_COMMON_BLOCKS = YES; 997 | GCC_WARN_64_TO_32_BIT_CONVERSION = YES; 998 | GCC_WARN_ABOUT_RETURN_TYPE = YES; 999 | GCC_WARN_UNDECLARED_SELECTOR = YES; 1000 | GCC_WARN_UNINITIALIZED_AUTOS = YES; 1001 | GCC_WARN_UNUSED_FUNCTION = YES; 1002 | GCC_WARN_UNUSED_VARIABLE = YES; 1003 | PRODUCT_BUNDLE_IDENTIFIER = behrang.Yaml; 1004 | PRODUCT_NAME = Yaml; 1005 | SWIFT_VERSION = 5.0; 1006 | }; 1007 | name = Release; 1008 | }; 1009 | F32DF26A1B73054D0011046A /* Debug */ = { 1010 | isa = XCBuildConfiguration; 1011 | buildSettings = { 1012 | ALWAYS_SEARCH_USER_PATHS = NO; 1013 | APPLICATION_EXTENSION_API_ONLY = YES; 1014 | CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; 1015 | CLANG_CXX_LIBRARY = "libc++"; 1016 | CLANG_ENABLE_MODULES = YES; 1017 | CLANG_ENABLE_OBJC_ARC = YES; 1018 | CLANG_WARN_BOOL_CONVERSION = YES; 1019 | CLANG_WARN_CONSTANT_CONVERSION = YES; 1020 | CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; 1021 | CLANG_WARN_EMPTY_BODY = YES; 1022 | CLANG_WARN_ENUM_CONVERSION = YES; 1023 | CLANG_WARN_INT_CONVERSION = YES; 1024 | CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; 1025 | CLANG_WARN_UNREACHABLE_CODE = YES; 1026 | CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; 1027 | "CODE_SIGN_IDENTITY[sdk=iphoneos*]" = ""; 1028 | COPY_PHASE_STRIP = NO; 1029 | CURRENT_PROJECT_VERSION = 3.4.3; 1030 | DEBUG_INFORMATION_FORMAT = dwarf; 1031 | DEFINES_MODULE = YES; 1032 | DYLIB_COMPATIBILITY_VERSION = 1; 1033 | DYLIB_CURRENT_VERSION = 3.4.3; 1034 | DYLIB_INSTALL_NAME_BASE = "@rpath"; 1035 | ENABLE_STRICT_OBJC_MSGSEND = YES; 1036 | ENABLE_TESTABILITY = YES; 1037 | GCC_C_LANGUAGE_STANDARD = gnu99; 1038 | GCC_DYNAMIC_NO_PIC = NO; 1039 | GCC_NO_COMMON_BLOCKS = YES; 1040 | GCC_OPTIMIZATION_LEVEL = 0; 1041 | GCC_PREPROCESSOR_DEFINITIONS = ( 1042 | "DEBUG=1", 1043 | "$(inherited)", 1044 | ); 1045 | GCC_WARN_64_TO_32_BIT_CONVERSION = YES; 1046 | GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; 1047 | GCC_WARN_UNDECLARED_SELECTOR = YES; 1048 | GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; 1049 | GCC_WARN_UNUSED_FUNCTION = YES; 1050 | GCC_WARN_UNUSED_VARIABLE = YES; 1051 | INFOPLIST_FILE = "$(SRCROOT)/Sources/Info.plist"; 1052 | INSTALL_PATH = "$(LOCAL_LIBRARY_DIR)/Frameworks"; 1053 | IPHONEOS_DEPLOYMENT_TARGET = 8.0; 1054 | LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks @loader_path/Frameworks"; 1055 | MTL_ENABLE_DEBUG_INFO = YES; 1056 | ONLY_ACTIVE_ARCH = YES; 1057 | SDKROOT = iphoneos; 1058 | SKIP_INSTALL = YES; 1059 | SWIFT_OPTIMIZATION_LEVEL = "-Onone"; 1060 | SWIFT_VERSION = 5.0; 1061 | TARGETED_DEVICE_FAMILY = "1,2"; 1062 | VERSIONING_SYSTEM = "apple-generic"; 1063 | VERSION_INFO_PREFIX = ""; 1064 | }; 1065 | name = Debug; 1066 | }; 1067 | F32DF26B1B73054D0011046A /* Release */ = { 1068 | isa = XCBuildConfiguration; 1069 | buildSettings = { 1070 | ALWAYS_SEARCH_USER_PATHS = NO; 1071 | APPLICATION_EXTENSION_API_ONLY = YES; 1072 | CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; 1073 | CLANG_CXX_LIBRARY = "libc++"; 1074 | CLANG_ENABLE_MODULES = YES; 1075 | CLANG_ENABLE_OBJC_ARC = YES; 1076 | CLANG_WARN_BOOL_CONVERSION = YES; 1077 | CLANG_WARN_CONSTANT_CONVERSION = YES; 1078 | CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; 1079 | CLANG_WARN_EMPTY_BODY = YES; 1080 | CLANG_WARN_ENUM_CONVERSION = YES; 1081 | CLANG_WARN_INT_CONVERSION = YES; 1082 | CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; 1083 | CLANG_WARN_UNREACHABLE_CODE = YES; 1084 | CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; 1085 | "CODE_SIGN_IDENTITY[sdk=iphoneos*]" = ""; 1086 | COPY_PHASE_STRIP = NO; 1087 | CURRENT_PROJECT_VERSION = 3.4.3; 1088 | DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; 1089 | DEFINES_MODULE = YES; 1090 | DYLIB_COMPATIBILITY_VERSION = 1; 1091 | DYLIB_CURRENT_VERSION = 3.4.3; 1092 | DYLIB_INSTALL_NAME_BASE = "@rpath"; 1093 | ENABLE_NS_ASSERTIONS = NO; 1094 | ENABLE_STRICT_OBJC_MSGSEND = YES; 1095 | GCC_C_LANGUAGE_STANDARD = gnu99; 1096 | GCC_NO_COMMON_BLOCKS = YES; 1097 | GCC_WARN_64_TO_32_BIT_CONVERSION = YES; 1098 | GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; 1099 | GCC_WARN_UNDECLARED_SELECTOR = YES; 1100 | GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; 1101 | GCC_WARN_UNUSED_FUNCTION = YES; 1102 | GCC_WARN_UNUSED_VARIABLE = YES; 1103 | INFOPLIST_FILE = "$(SRCROOT)/Sources/Info.plist"; 1104 | INSTALL_PATH = "$(LOCAL_LIBRARY_DIR)/Frameworks"; 1105 | IPHONEOS_DEPLOYMENT_TARGET = 8.0; 1106 | LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks @loader_path/Frameworks"; 1107 | MTL_ENABLE_DEBUG_INFO = NO; 1108 | SDKROOT = iphoneos; 1109 | SKIP_INSTALL = YES; 1110 | SWIFT_OPTIMIZATION_LEVEL = "-Owholemodule"; 1111 | SWIFT_VERSION = 5.0; 1112 | TARGETED_DEVICE_FAMILY = "1,2"; 1113 | VALIDATE_PRODUCT = YES; 1114 | VERSIONING_SYSTEM = "apple-generic"; 1115 | VERSION_INFO_PREFIX = ""; 1116 | }; 1117 | name = Release; 1118 | }; 1119 | F32DF26D1B73054D0011046A /* Debug */ = { 1120 | isa = XCBuildConfiguration; 1121 | buildSettings = { 1122 | ALWAYS_EMBED_SWIFT_STANDARD_LIBRARIES = YES; 1123 | ALWAYS_SEARCH_USER_PATHS = NO; 1124 | CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; 1125 | CLANG_CXX_LIBRARY = "libc++"; 1126 | CLANG_ENABLE_MODULES = YES; 1127 | CLANG_ENABLE_OBJC_ARC = YES; 1128 | CLANG_WARN_BOOL_CONVERSION = YES; 1129 | CLANG_WARN_CONSTANT_CONVERSION = YES; 1130 | CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; 1131 | CLANG_WARN_EMPTY_BODY = YES; 1132 | CLANG_WARN_ENUM_CONVERSION = YES; 1133 | CLANG_WARN_INT_CONVERSION = YES; 1134 | CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; 1135 | CLANG_WARN_UNREACHABLE_CODE = YES; 1136 | CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; 1137 | "CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer"; 1138 | COPY_PHASE_STRIP = NO; 1139 | DEBUG_INFORMATION_FORMAT = dwarf; 1140 | ENABLE_STRICT_OBJC_MSGSEND = YES; 1141 | ENABLE_TESTABILITY = YES; 1142 | GCC_C_LANGUAGE_STANDARD = gnu99; 1143 | GCC_DYNAMIC_NO_PIC = NO; 1144 | GCC_NO_COMMON_BLOCKS = YES; 1145 | GCC_OPTIMIZATION_LEVEL = 0; 1146 | GCC_PREPROCESSOR_DEFINITIONS = ( 1147 | "DEBUG=1", 1148 | "$(inherited)", 1149 | ); 1150 | GCC_WARN_64_TO_32_BIT_CONVERSION = YES; 1151 | GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; 1152 | GCC_WARN_UNDECLARED_SELECTOR = YES; 1153 | GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; 1154 | GCC_WARN_UNUSED_FUNCTION = YES; 1155 | GCC_WARN_UNUSED_VARIABLE = YES; 1156 | INFOPLIST_FILE = Tests/Info.plist; 1157 | IPHONEOS_DEPLOYMENT_TARGET = 9.0; 1158 | LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks @loader_path/Frameworks"; 1159 | MTL_ENABLE_DEBUG_INFO = YES; 1160 | ONLY_ACTIVE_ARCH = YES; 1161 | PRODUCT_NAME = Tests; 1162 | SDKROOT = iphoneos; 1163 | SWIFT_OPTIMIZATION_LEVEL = "-Onone"; 1164 | SWIFT_VERSION = 5.0; 1165 | }; 1166 | name = Debug; 1167 | }; 1168 | F32DF26E1B73054D0011046A /* Release */ = { 1169 | isa = XCBuildConfiguration; 1170 | buildSettings = { 1171 | ALWAYS_EMBED_SWIFT_STANDARD_LIBRARIES = YES; 1172 | ALWAYS_SEARCH_USER_PATHS = NO; 1173 | CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; 1174 | CLANG_CXX_LIBRARY = "libc++"; 1175 | CLANG_ENABLE_MODULES = YES; 1176 | CLANG_ENABLE_OBJC_ARC = YES; 1177 | CLANG_WARN_BOOL_CONVERSION = YES; 1178 | CLANG_WARN_CONSTANT_CONVERSION = YES; 1179 | CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; 1180 | CLANG_WARN_EMPTY_BODY = YES; 1181 | CLANG_WARN_ENUM_CONVERSION = YES; 1182 | CLANG_WARN_INT_CONVERSION = YES; 1183 | CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; 1184 | CLANG_WARN_UNREACHABLE_CODE = YES; 1185 | CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; 1186 | "CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer"; 1187 | COPY_PHASE_STRIP = NO; 1188 | DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; 1189 | ENABLE_NS_ASSERTIONS = NO; 1190 | ENABLE_STRICT_OBJC_MSGSEND = YES; 1191 | GCC_C_LANGUAGE_STANDARD = gnu99; 1192 | GCC_NO_COMMON_BLOCKS = YES; 1193 | GCC_WARN_64_TO_32_BIT_CONVERSION = YES; 1194 | GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; 1195 | GCC_WARN_UNDECLARED_SELECTOR = YES; 1196 | GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; 1197 | GCC_WARN_UNUSED_FUNCTION = YES; 1198 | GCC_WARN_UNUSED_VARIABLE = YES; 1199 | INFOPLIST_FILE = Tests/Info.plist; 1200 | IPHONEOS_DEPLOYMENT_TARGET = 9.0; 1201 | LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks @loader_path/Frameworks"; 1202 | MTL_ENABLE_DEBUG_INFO = NO; 1203 | PRODUCT_NAME = Tests; 1204 | SDKROOT = iphoneos; 1205 | SWIFT_OPTIMIZATION_LEVEL = "-Owholemodule"; 1206 | SWIFT_VERSION = 5.0; 1207 | VALIDATE_PRODUCT = YES; 1208 | }; 1209 | name = Release; 1210 | }; 1211 | /* End XCBuildConfiguration section */ 1212 | 1213 | /* Begin XCConfigurationList section */ 1214 | 8313C43E1C8DC2CB00DEF215 /* Build configuration list for PBXNativeTarget "Yaml tvOS" */ = { 1215 | isa = XCConfigurationList; 1216 | buildConfigurations = ( 1217 | 8313C43A1C8DC2CB00DEF215 /* Debug */, 1218 | 8313C43B1C8DC2CB00DEF215 /* Release */, 1219 | ); 1220 | defaultConfigurationIsVisible = 0; 1221 | defaultConfigurationName = Release; 1222 | }; 1223 | 8313C43F1C8DC2CB00DEF215 /* Build configuration list for PBXNativeTarget "Tests tvOS" */ = { 1224 | isa = XCConfigurationList; 1225 | buildConfigurations = ( 1226 | 8313C43C1C8DC2CB00DEF215 /* Debug */, 1227 | 8313C43D1C8DC2CB00DEF215 /* Release */, 1228 | ); 1229 | defaultConfigurationIsVisible = 0; 1230 | defaultConfigurationName = Release; 1231 | }; 1232 | 8E1D76391B258FEE0022C013 /* Build configuration list for PBXNativeTarget "Yaml OSX" */ = { 1233 | isa = XCConfigurationList; 1234 | buildConfigurations = ( 1235 | 8E1D76351B258FEE0022C013 /* Debug */, 1236 | 8E1D76361B258FEE0022C013 /* Release */, 1237 | ); 1238 | defaultConfigurationIsVisible = 0; 1239 | defaultConfigurationName = Release; 1240 | }; 1241 | 8E1D763A1B258FEE0022C013 /* Build configuration list for PBXNativeTarget "Tests OSX" */ = { 1242 | isa = XCConfigurationList; 1243 | buildConfigurations = ( 1244 | 8E1D76371B258FEE0022C013 /* Debug */, 1245 | 8E1D76381B258FEE0022C013 /* Release */, 1246 | ); 1247 | defaultConfigurationIsVisible = 0; 1248 | defaultConfigurationName = Release; 1249 | }; 1250 | 8EF2541D1B258FB4001BCEBE /* Build configuration list for PBXProject "Yaml" */ = { 1251 | isa = XCConfigurationList; 1252 | buildConfigurations = ( 1253 | 8EF2541E1B258FB4001BCEBE /* Debug */, 1254 | 8EF2541F1B258FB4001BCEBE /* Release */, 1255 | ); 1256 | defaultConfigurationIsVisible = 0; 1257 | defaultConfigurationName = Release; 1258 | }; 1259 | F32DF2691B73054D0011046A /* Build configuration list for PBXNativeTarget "Yaml iOS" */ = { 1260 | isa = XCConfigurationList; 1261 | buildConfigurations = ( 1262 | F32DF26A1B73054D0011046A /* Debug */, 1263 | F32DF26B1B73054D0011046A /* Release */, 1264 | ); 1265 | defaultConfigurationIsVisible = 0; 1266 | defaultConfigurationName = Release; 1267 | }; 1268 | F32DF26C1B73054D0011046A /* Build configuration list for PBXNativeTarget "Tests iOS" */ = { 1269 | isa = XCConfigurationList; 1270 | buildConfigurations = ( 1271 | F32DF26D1B73054D0011046A /* Debug */, 1272 | F32DF26E1B73054D0011046A /* Release */, 1273 | ); 1274 | defaultConfigurationIsVisible = 0; 1275 | defaultConfigurationName = Release; 1276 | }; 1277 | /* End XCConfigurationList section */ 1278 | }; 1279 | rootObject = 8EF2541A1B258FB4001BCEBE /* Project object */; 1280 | } 1281 | -------------------------------------------------------------------------------- /Yaml.xcodeproj/xcshareddata/xcschemes/Yaml OSX.xcscheme: -------------------------------------------------------------------------------- 1 | 2 | 5 | 8 | 9 | 15 | 21 | 22 | 23 | 29 | 35 | 36 | 37 | 38 | 39 | 44 | 45 | 47 | 53 | 54 | 55 | 56 | 57 | 63 | 64 | 65 | 66 | 67 | 68 | 78 | 79 | 85 | 86 | 87 | 88 | 89 | 90 | 96 | 97 | 103 | 104 | 105 | 106 | 108 | 109 | 112 | 113 | 114 | -------------------------------------------------------------------------------- /Yaml.xcodeproj/xcshareddata/xcschemes/Yaml iOS.xcscheme: -------------------------------------------------------------------------------- 1 | 2 | 5 | 8 | 9 | 15 | 21 | 22 | 23 | 24 | 25 | 31 | 32 | 34 | 40 | 41 | 42 | 43 | 44 | 50 | 51 | 52 | 53 | 54 | 55 | 65 | 66 | 72 | 73 | 74 | 75 | 76 | 77 | 83 | 84 | 90 | 91 | 92 | 93 | 95 | 96 | 99 | 100 | 101 | -------------------------------------------------------------------------------- /Yaml.xcodeproj/xcshareddata/xcschemes/Yaml tvOS.xcscheme: -------------------------------------------------------------------------------- 1 | 2 | 5 | 8 | 9 | 15 | 21 | 22 | 23 | 24 | 25 | 30 | 31 | 33 | 39 | 40 | 41 | 42 | 43 | 49 | 50 | 51 | 52 | 53 | 54 | 64 | 65 | 71 | 72 | 73 | 74 | 75 | 76 | 82 | 83 | 89 | 90 | 91 | 92 | 94 | 95 | 98 | 99 | 100 | -------------------------------------------------------------------------------- /Yaml.xcodeproj/xcuserdata/behrang.xcuserdatad/xcschemes/xcschememanagement.plist: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | SchemeUserState 6 | 7 | Yaml.xcscheme_^#shared#^_ 8 | 9 | orderHint 10 | 0 11 | 12 | 13 | SuppressBuildableAutocreation 14 | 15 | 8313C4281C8DC2CB00DEF215 16 | 17 | primary 18 | 19 | 20 | 8313C4311C8DC2CB00DEF215 21 | 22 | primary 23 | 24 | 25 | 8E1D76201B258FEE0022C013 26 | 27 | primary 28 | 29 | 30 | 8E1D762B1B258FEE0022C013 31 | 32 | primary 33 | 34 | 35 | F32DF2571B73054C0011046A 36 | 37 | primary 38 | 39 | 40 | F32DF2601B73054C0011046A 41 | 42 | primary 43 | 44 | 45 | 46 | 47 | 48 | -------------------------------------------------------------------------------- /Yaml.xcworkspace/contents.xcworkspacedata: -------------------------------------------------------------------------------- 1 | 2 | 4 | 6 | 7 | 8 | --------------------------------------------------------------------------------