Minimize usage of TOMLKit

Author: nikitabobko

Sources/AppBundle/command/parseCommand.swift

@@ -1,5 +1,4 @@
 import Common
-import TOMLKit
 
 func parseCommand(_ raw: String) -> ParsedCmd<any Command> {
     if raw.starts(with: "exec-and-forget") {
@@ -15,14 +14,14 @@ func parseCommand(_ args: [String]) -> ParsedCmd<any Command> {
     parseCmdArgs(args.slice).map { $0.toCommand() }
 }
 
-func expectedActualTypeError(expected: TOMLType, actual: TOMLType) -> String {
+func expectedActualTypeError(expected: TomlType, actual: TomlType) -> String {
     "Expected type is '\(expected)'. But actual type is '\(actual)'"
 }
 
-func expectedActualTypeError(expected: [TOMLType], actual: TOMLType) -> String {
+func expectedActualTypeError(expected: [TomlType], actual: TomlType) -> String {
     if let single = expected.singleOrNil() {
         return expectedActualTypeError(expected: single, actual: actual)
     } else {
-        return "Expected types are \(expected.map { "'\($0.description)'" }.joined(separator: " or ")). But actual type is '\(actual)'"
+        return "Expected types are \(expected.map { "'\($0)'" }.joined(separator: " or ")). But actual type is '\(actual)'"
     }
 }

Sources/AppBundle/config/DynamicConfigValue.swift

@@ -1,5 +1,4 @@
 import Common
-import TOMLKit
 
 struct PerMonitorValue<Value: Equatable>: Equatable {
     let description: MonitorDescription
@@ -33,15 +32,15 @@ extension DynamicConfigValue {
 }
 
 func parseDynamicValue<T>(
-    _ raw: TOMLValueConvertible,
+    _ raw: Json,
     _ valueType: T.Type,
     _ fallback: T,
     _ backtrace: ConfigBacktrace,
     _ errors: inout [ConfigParseError],
 ) -> DynamicConfigValue<T> {
     if let simpleValue = parseSimpleType(raw) as T? {
         return .constant(simpleValue)
-    } else if let array = raw.array {
+    } else if let array = raw.asArrayOrNil {
         if array.isEmpty {
             errors.append(.semantic(backtrace, "The array must not be empty"))
             return .constant(fallback)
@@ -57,17 +56,17 @@ func parseDynamicValue<T>(
             return .constant(fallback)
         }
 
-        let rules: [PerMonitorValue<T>] = parsePerMonitorValues(TOMLArray(array.dropLast()), backtrace, &errors)
+        let rules: [PerMonitorValue<T>] = parsePerMonitorValues(array.dropLast(), backtrace, &errors)
 
         return .perMonitor(rules, default: defaultValue)
     } else {
-        errors.append(.semantic(backtrace, "Unsupported type: \(raw.type), expected: \(valueType) or array"))
+        errors.append(.semantic(backtrace, "Unsupported type: \(raw.tomlType), expected: \(valueType) or array"))
         return .constant(fallback)
     }
 }
 
-func parsePerMonitorValues<T>(_ array: TOMLArray, _ backtrace: ConfigBacktrace, _ errors: inout [ConfigParseError]) -> [PerMonitorValue<T>] {
-    array.enumerated().compactMap { (index: Int, raw: TOMLValueConvertible) -> PerMonitorValue<T>? in
+func parsePerMonitorValues<T>(_ array: Json.JsonArray, _ backtrace: ConfigBacktrace, _ errors: inout [ConfigParseError]) -> [PerMonitorValue<T>] {
+    array.enumerated().compactMap { (index: Int, raw: Json) -> PerMonitorValue<T>? in
         var backtrace = backtrace + .index(index)
 
         guard let (key, value) = raw.unwrapTableWithSingleKey(expectedKey: "monitor", &backtrace)
@@ -77,12 +76,12 @@ func parsePerMonitorValues<T>(_ array: TOMLArray, _ backtrace: ConfigBacktrace,
             return nil
         }
 
-        let monitorDescriptionResult = parseMonitorDescription(key, backtrace)
+        let monitorDescriptionResult = parseMonitorDescription(.string(key), backtrace)
 
         guard let monitorDescription = monitorDescriptionResult.getOrNil(appendErrorTo: &errors) else { return nil }
 
         guard let value = parseSimpleType(value) as T? else {
-            errors.append(.semantic(backtrace, "Expected type is '\(T.self)'. But actual type is '\(value.type)'"))
+            errors.append(.semantic(backtrace, "Expected type is '\(T.self)'. But actual type is '\(value.tomlType)'"))
             return nil
         }
 

Sources/AppBundle/config/HotkeyBinding.swift

@@ -2,7 +2,6 @@ import AppKit
 import Common
 import Foundation
 import HotKey
-import TOMLKit
 
 @MainActor private var hotkeys: [String: HotKey] = [:]
 
@@ -90,13 +89,13 @@ struct HotkeyBinding: Equatable, Sendable {
     }
 }
 
-func parseBindings(_ raw: TOMLValueConvertible, _ backtrace: ConfigBacktrace, _ errors: inout [ConfigParseError], _ mapping: [String: Key]) -> [String: HotkeyBinding] {
-    guard let rawTable = raw.table else {
-        errors += [expectedActualTypeError(expected: .table, actual: raw.type, backtrace)]
+func parseBindings(_ raw: Json, _ backtrace: ConfigBacktrace, _ errors: inout [ConfigParseError], _ mapping: [String: Key]) -> [String: HotkeyBinding] {
+    guard let rawTable = raw.asDictOrNil else {
+        errors += [expectedActualTypeError(expected: .table, actual: raw.tomlType, backtrace)]
         return [:]
     }
     var result: [String: HotkeyBinding] = [:]
-    for (binding, rawCommand): (String, TOMLValueConvertible) in rawTable {
+    for (binding, rawCommand): (String, Json) in rawTable {
         let backtrace = backtrace + .key(binding)
         let binding = parseBinding(binding, backtrace, mapping)
             .flatMap { modifiers, key -> ParsedConfig<HotkeyBinding> in

Sources/AppBundle/config/Mode.swift

@@ -1,16 +1,15 @@
 import Common
 import HotKey
-import TOMLKit
 
 struct Mode: ConvenienceCopyable, Equatable, Sendable {
     var bindings: [String: HotkeyBinding]
 
     static let zero = Mode(bindings: [:])
 }
 
-func parseModes(_ raw: TOMLValueConvertible, _ backtrace: ConfigBacktrace, _ errors: inout [ConfigParseError], _ mapping: [String: Key]) -> [String: Mode] {
-    guard let rawTable = raw.table else {
-        errors += [expectedActualTypeError(expected: .table, actual: raw.type, backtrace)]
+func parseModes(_ raw: Json, _ backtrace: ConfigBacktrace, _ errors: inout [ConfigParseError], _ mapping: [String: Key]) -> [String: Mode] {
+    guard let rawTable = raw.asDictOrNil else {
+        errors += [expectedActualTypeError(expected: .table, actual: raw.tomlType, backtrace)]
         return [:]
     }
     var result: [String: Mode] = [:]
@@ -23,9 +22,9 @@ func parseModes(_ raw: TOMLValueConvertible, _ backtrace: ConfigBacktrace, _ err
     return result
 }
 
-func parseMode(_ raw: TOMLValueConvertible, _ backtrace: ConfigBacktrace, _ errors: inout [ConfigParseError], _ mapping: [String: Key]) -> Mode {
-    guard let rawTable: TOMLTable = raw.table else {
-        errors += [expectedActualTypeError(expected: .table, actual: raw.type, backtrace)]
+func parseMode(_ raw: Json, _ backtrace: ConfigBacktrace, _ errors: inout [ConfigParseError], _ mapping: [String: Key]) -> Mode {
+    guard let rawTable: Json.JsonDict = raw.asDictOrNil else {
+        errors += [expectedActualTypeError(expected: .table, actual: raw.tomlType, backtrace)]
         return .zero
     }