Migrate from TOMLKit to TOMLDecoder

TOMLDecoder supports TOML 1.1.0. TOML 1.1.0 finaly allows newlines in inline tables which is a much better syntax than
double square brackets.

I'd love to update the ./docs to prefer inline tables over double square brackets, but pygments color syntax highlighter
doesn't still support it (we use pygments to highlight TOML snippets in the docs)

We need to wait for this PR to land: pygments/pygments#3027
And then the Ruby library to be updated: https://github.com/pygments/pygments.rb

The other motivation is that TOMLDecoder source code seems to be more disciplined

_closes #975
_closes #1064

Author: nikitabobko

Package.resolved

@@ -19,7 +19,7 @@ let package = Package(
     dependencies: [
         .package(path: "./ShellParserGenerated"),
         .package(url: "https://github.com/InerziaSoft/ISSoundAdditions.git", exact: "2.0.1"),
-        .package(url: "https://github.com/LebJe/TOMLKit.git", exact: "0.5.5"),
+        .package(url: "https://github.com/dduan/TOMLDecoder", exact: "0.4.4"),
         .package(url: "https://github.com/apple/swift-collections.git", exact: "1.3.0"),
         .package(url: "https://github.com/soffes/HotKey.git", exact: "0.2.1"),
     ],
@@ -45,7 +45,7 @@ let package = Package(
                 .product(name: "HotKey", package: "HotKey"),
                 .product(name: "ISSoundAdditions", package: "ISSoundAdditions"),
                 .product(name: "ShellParserGenerated", package: "ShellParserGenerated"),
-                .product(name: "TOMLKit", package: "TOMLKit"),
+                .product(name: "TOMLDecoder", package: "TOMLDecoder"),
                 .target(name: "Common"),
                 .target(name: "PrivateApi"),
             ],

Package.swift

@@ -1,7 +1,7 @@
 import AppKit
 import Common
 import HotKey
-import TOMLKit
+import TOMLDecoder
 import OrderedCollections
 
 @MainActor
@@ -173,48 +173,31 @@ func parseCommandOrCommands(_ raw: Json) -> Parsed<[any Command]> {
     }
 }
 
-extension TOMLValueConvertible {
-    func toJsonRecursive(_ backtrace: ConfigBacktrace) -> ParsedConfig<Json> {
-        switch self.type {
-            // Vector
-            case .table: return table.orDie().tomlTableToJsonRecursive(backtrace).map(Json.dict)
-            case .array:
-                let array = array.orDie()
-                var json = Json.JsonArray()
-                for (index, tomlValue) in array.enumerated() {
-                    let jsonResultValue = tomlValue.toJsonRecursive(backtrace + .index(index))
-                    switch jsonResultValue {
-                        case .success(let jsonValue): json.append(jsonValue)
-                        case .failure(let fail): return .failure(fail)
-                    }
+func tomlAnyToParsedConfigRecursive(any: Any, _ backtrace: ConfigBacktrace) -> ParsedConfig<Json> {
+    switch any {
+        case let dict as [String: Any]:
+            var json = Json.JsonDict()
+            for (key, tomlValue) in dict {
+                let jsonResultValue = tomlAnyToParsedConfigRecursive(any: tomlValue, backtrace + .key(key))
+                switch jsonResultValue {
+                    case .success(let jsonValue): json[key] = jsonValue
+                    case .failure(let fail): return .failure(fail)
                 }
-                return .success(.array(json))
-
-            // Scalar
-            case .string: return .success(.string(string.orDie()))
-            case .int: return .success(.int(int.orDie()))
-            case .bool: return .success(.bool(bool.orDie()))
-
-            // Unsupported
-            case .double: return .failure(.semantic(backtrace, "TOML Double type is not supported"))
-            case .date: return .failure(.semantic(backtrace, "TOML Date type is not supported"))
-            case .time: return .failure(.semantic(backtrace, "TOML Time type is not supported"))
-            case .dateTime: return .failure(.semantic(backtrace, "TOML DateTime type is not supported"))
-        }
-    }
-}
-
-extension TOMLTable {
-    func tomlTableToJsonRecursive(_ backtrace: ConfigBacktrace) -> ParsedConfig<Json.JsonDict> {
-        var json = Json.JsonDict()
-        for (key, tomlValue) in self {
-            let jsonResultValue = tomlValue.toJsonRecursive(backtrace + .key(key))
-            switch jsonResultValue {
-                case .success(let jsonValue): json[key] = jsonValue
-                case .failure(let fail): return .failure(fail)
             }
-        }
-        return .success(json)
+            return .success(.dict(json))
+        case let array as [Any]:
+            var json = Json.JsonArray()
+            for (index, tomlValue) in array.enumerated() {
+                let jsonResultValue = tomlAnyToParsedConfigRecursive(any: tomlValue, backtrace + .index(index))
+                switch jsonResultValue {
+                    case .success(let jsonValue): json.append(jsonValue)
+                    case .failure(let fail): return .failure(fail)
+                }
+            }
+            return .success(.array(json))
+        default:
+            return Json.newScalarOrNil(any).map(Result.success)
+                ?? .failure(.semantic(backtrace, "Unsupported TOML type: \(type(of: any))"))
     }
 }
 
@@ -226,14 +209,14 @@ extension TOMLTable {
 @MainActor private func _parseConfig(_ rawToml: String) -> (config: Config, errors: [ConfigParseError]) { // todo change return value to Result
     let rawTable: Json.JsonDict
     do {
-        switch (try TOMLTable(string: rawToml)).tomlTableToJsonRecursive(.emptyRoot) {
-            case .success(let _rawTable): rawTable = _rawTable
+        let dict: [String: Any] = try .init(try TOMLTable(source: rawToml))
+        switch tomlAnyToParsedConfigRecursive(any: dict, .emptyRoot) {
+            case .success(.dict(let dict)): rawTable = dict
+            case .success: return (defaultConfig, [.syntax("Config parsing error: the top level type must be a TOML Table")])
             case .failure(let fail): return (defaultConfig, [fail])
         }
-    } catch let e as TOMLParseError {
-        return (defaultConfig, [.syntax(e.debugDescription)])
-    } catch let e {
-        return (defaultConfig, [.syntax(e.localizedDescription)])
+    } catch {
+        return (defaultConfig, [.syntax(error.description)])
     }
 
     var errors: [ConfigParseError] = []

Sources/AppBundle/config/parseConfig.swift

@@ -29,22 +29,24 @@ enum Json: Encodable, Equatable {
     }
 
     static func newOrDie(_ value: Any?) -> Json {
-        if let value = value as? [String: Any?] {
-            return .dict(value.mapValues(newOrDie))
-        } else if let value = value as? [Any?] {
-            return .array(value.map(newOrDie))
-        } else if let value = value as? Int {
-            return .int(value)
-        } else if let value = value as? UInt32 {
-            return .uint32(value)
-        } else if let value = value as? Bool {
-            return .bool(value)
-        } else if let value = value as? String {
-            return .string(value)
-        } else if value == nil || value is NSNull {
-            return .null
-        } else {
-            die("Can't parse \(String(describing: value)) (\(Swift.type(of: value))) to JSON")
+        switch value {
+            case let value as [String: Any?]: .dict(value.mapValues(newOrDie))
+            case let value as [Any?]: .array(value.map(newOrDie))
+            default:
+                newScalarOrNil(value)
+                    ?? dieT("Can't parse \(String(describing: value)) (\(Swift.type(of: value))) to JSON")
+        }
+    }
+
+    static func newScalarOrNil(_ value: Any?) -> Json? {
+        switch value {
+            case let value as Int: .int(value)
+            case let value as Int64: Int(exactly: value).map(Json.int)
+            case let value as UInt32: .uint32(value)
+            case let value as Bool: .bool(value)
+            case let value as String: .string(value)
+            case nil, is NSNull: .null
+            default: nil
         }
     }
 

Sources/AppBundle/model/Json.swift

@@ -184,10 +184,29 @@ final class ConfigTest: XCTestCase {
     }
 
     func testConfigParseError() {
-        let (_, errors) = parseConfig("true")
         assertEquals(
-            errors,
-            ["Error while parsing key-value pair: encountered end-of-file (at line 1, column 5)"],
+            parseConfig("true").errors,
+            ["(Line 1) Syntax error: missing =."],
+        )
+
+        assertEquals(
+            parseConfig("\n1").errors,
+            ["(Line 2) Syntax error: missing =."],
+        )
+
+        assertEquals(
+            parseConfig("foo: 1").errors,
+            ["(Line 1) Syntax error: missing =."],
+        )
+
+        assertEquals(
+            parseConfig("foo = 1.0").errors,
+            ["foo: Unsupported TOML type: Double"],
+        )
+
+        assertEquals(
+            parseConfig("foo.bar = 1979-05-27").errors,
+            ["foo.bar: Unsupported TOML type: LocalDate"],
         )
     }
 
@@ -331,6 +350,40 @@ final class ConfigTest: XCTestCase {
         ])
     }
 
+    func testParseInlineTables() {
+        let errors = parseConfig(
+            """
+            on-window-detected = [
+                {
+                    check-further-callbacks = true,
+                    run = ['layout floating', 'move-node-to-workspace W'],
+                },
+                {
+                    if.app-id = 'com.apple.systempreferences',
+                    run = [],
+                }
+            ]
+            """,
+        ).errors
+        assertEquals(errors, [])
+    }
+
+    func testTomlParser() {
+        // https://github.com/nikitabobko/AeroSpace/issues/1064
+        let errors = parseConfig(
+            """
+            [[[on-window-detected]]
+            if.app-id = 'com.apple.findmy'
+            run = 'layout floating'
+
+            [on-window-detected]]
+            if.app-id = 'com.openai.chat'
+            run = 'layout floating'
+            """,
+        ).errors
+        assertEquals(errors, ["(Line 1) Syntax error: invalid or missing key."])
+    }
+
     func testParseOnWindowDetectedRegex() {
         let (config, errors) = parseConfig(
             """

Sources/AppBundleTests/config/ConfigTest.swift

@@ -11,15 +11,10 @@ AeroSpace bundles the following dependencies and uses the following materials:
 [HotKey MIT license](./third-party-license/LICENSE-HotKey.txt).
 HotKey is used as a more convenient wrapper around macOS Carbon API to listen for global shortcuts.
 
-**TOMLKIT**.
-[TOMLKIT GitHub link](https://github.com/LebJe/TOMLKit).
-[TOMLKIT MIT license](./third-party-license/LICENSE-TOMLKIT.txt).
-TOMLKIT is used as a more convenient Swift wrapper around tomlplusplus C++ API.
-
-**tomlplusplus**.
-[tomlplusplus GitHub link](https://github.com/marzer/tomlplusplus).
-[tomlplusplus MIT license](./third-party-license/LICENSE-tomlplusplus.txt).
-tomlplusplus is used as TOML parser. tomlplusplus is used indirectly through TOMLKIT Swift API.
+**TOMLDecoder**.
+[TOMLDecoder GitHub link](https://github.com/LebJe/TOMLKit).
+[TOMLDecoder MIT license](./third-party-license/LICENSE-TOMLDecoder.txt).
+TOMLDecoder is used as TOML parsing library.
 
 **ANTLR v4**.
 [ANTLR v4 GitHub link](https://github.com/antlr/antlr4).

legal/README.md

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 TOMLDecoder contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.