Add config options: persistentWorkspaces & configVersion

#999

Author: nikitabobko

Sources/AppBundle/config/Config.swift

@@ -1,6 +1,7 @@
 import AppKit
 import Common
 import HotKey
+import OrderedCollections
 
 func getDefaultConfigUrlFromProject() -> URL {
     var url = URL(filePath: #filePath)
@@ -32,6 +33,7 @@ var defaultConfigUrl: URL {
 @MainActor var configUrl: URL = defaultConfigUrl
 
 struct Config: ConvenienceCopyable {
+    var configVersion: Int = 1
     var afterLoginCommand: [any Command] = []
     var afterStartupCommand: [any Command] = []
     var _indentForNestedContainersWithTheSameOrientation: Void = ()
@@ -43,6 +45,7 @@ struct Config: ConvenienceCopyable {
     var automaticallyUnhideMacosHiddenApps: Bool = false
     var accordionPadding: Int = 30
     var enableNormalizationOppositeOrientationForNestedContainers: Bool = true
+    var persistentWorkspaces: OrderedSet<String> = []
     var execOnWorkspaceChange: [String] = [] // todo deprecate
     var keyMapping = KeyMapping()
     var execConfig: ExecConfig = ExecConfig()
@@ -56,8 +59,6 @@ struct Config: ConvenienceCopyable {
     var modes: [String: Mode] = [:]
     var onWindowDetected: [WindowDetectedCallback] = []
     var onModeChanged: [any Command] = []
-
-    var preservedWorkspaceNames: [String] = []
 }
 
 enum DefaultContainerOrientation: String {

Sources/AppBundle/config/parseConfig.swift

@@ -2,6 +2,7 @@ import AppKit
 import Common
 import HotKey
 import TOMLKit
+import OrderedCollections
 
 @MainActor
 func readConfig(forceConfigUrl: URL? = nil) -> Result<(Config, URL), String> {
@@ -83,11 +84,14 @@ struct Parser<S: ConvenienceCopyable, T>: ParserProtocol {
 
 private let keyMappingConfigRootKey = "key-mapping"
 private let modeConfigRootKey = "mode"
+private let persistentWorkspacesKey = "persistent-workspaces"
 
 // For every new config option you add, think:
 // 1. Does it make sense to have different value
 // 2. Prefer commands and commands flags over toml options if possible
 private let configParser: [String: any ParserProtocol<Config>] = [
+    "config-version": Parser(\.configVersion, parseConfigVersion),
+
     "after-login-command": Parser(\.afterLoginCommand, parseAfterLoginCommand),
     "after-startup-command": Parser(\.afterStartupCommand) { parseCommandOrCommands($0).toParsedToml($1) },
 
@@ -105,6 +109,7 @@ private let configParser: [String: any ParserProtocol<Config>] = [
     "start-at-login": Parser(\.startAtLogin, parseBool),
     "automatically-unhide-macos-hidden-apps": Parser(\.automaticallyUnhideMacosHiddenApps, parseBool),
     "accordion-padding": Parser(\.accordionPadding, parseInt),
+    persistentWorkspacesKey: Parser(\.persistentWorkspaces, parsePersistentWorkspaces),
     "exec-on-workspace-change": Parser(\.execOnWorkspaceChange, parseArrayOfStrings),
     "exec": Parser(\.execConfig, parseExecConfig),
 
@@ -181,17 +186,24 @@ func parseCommandOrCommands(_ raw: TOMLValueConvertible) -> Parsed<[any Command]
         config.keyMapping = mapping
     }
 
+    // Parse modeConfigRootKey after keyMappingConfigRootKey
     if let modes = rawTable[modeConfigRootKey].flatMap({ parseModes($0, .rootKey(modeConfigRootKey), &errors, config.keyMapping.resolve()) }) {
         config.modes = modes
     }
 
-    config.preservedWorkspaceNames = config.modes.values.lazy
-        .flatMap { (mode: Mode) -> [HotkeyBinding] in Array(mode.bindings.values) }
-        .flatMap { (binding: HotkeyBinding) -> [String] in
-            binding.commands.filterIsInstance(of: WorkspaceCommand.self).compactMap { $0.args.target.val.workspaceNameOrNil()?.raw } +
-                binding.commands.filterIsInstance(of: MoveNodeToWorkspaceCommand.self).compactMap { $0.args.target.val.workspaceNameOrNil()?.raw }
+    if config.configVersion <= 1 {
+        if rawTable.contains(key: persistentWorkspacesKey) {
+            errors += [.semantic(.rootKey(persistentWorkspacesKey), "This config option is only available since 'config-version = 2'")]
         }
-        + (config.workspaceToMonitorForceAssignment).keys
+        config.persistentWorkspaces = (config.modes.values.lazy
+            .flatMap { (mode: Mode) -> [HotkeyBinding] in Array(mode.bindings.values) }
+            .flatMap { (binding: HotkeyBinding) -> [String] in
+                binding.commands.filterIsInstance(of: WorkspaceCommand.self).compactMap { $0.args.target.val.workspaceNameOrNil()?.raw } +
+                    binding.commands.filterIsInstance(of: MoveNodeToWorkspaceCommand.self).compactMap { $0.args.target.val.workspaceNameOrNil()?.raw }
+            }
+            + (config.workspaceToMonitorForceAssignment).keys)
+            .toOrderedSet()
+    }
 
     if config.enableNormalizationFlattenContainers {
         let containsSplitCommand = config.modes.values.lazy.flatMap { $0.bindings.values }
@@ -222,6 +234,13 @@ func parseIndentForNestedContainersWithTheSameOrientation(
     return .failure(.semantic(backtrace, msg))
 }
 
+func parseConfigVersion(_ raw: TOMLValueConvertible, _ backtrace: TomlBacktrace) -> ParsedToml<Int> {
+    let min = 1
+    let max = 2
+    return parseInt(raw, backtrace)
+        .filter(.semantic(backtrace, "Must be in [\(min), \(max)] range")) { (min ... max).contains($0) }
+}
+
 func parseInt(_ raw: TOMLValueConvertible, _ backtrace: TomlBacktrace) -> ParsedToml<Int> {
     raw.int.orFailure(expectedActualTypeError(expected: .int, actual: raw.type, backtrace))
 }
@@ -289,6 +308,14 @@ private func skipParsing<T: Sendable>(_ value: T) -> @Sendable (_ raw: TOMLValue
     { _, _ in .success(value) }
 }
 
+private func parsePersistentWorkspaces(_ raw: TOMLValueConvertible, _ backtrace: TomlBacktrace) -> ParsedToml<OrderedSet<String>> {
+    parseArrayOfStrings(raw, backtrace)
+        .flatMap { arr in
+            let set = arr.toOrderedSet()
+            return set.count == arr.count ? .success(set) : .failure(.semantic(backtrace, "Contains duplicated workspace names"))
+        }
+}
+
 private func parseArrayOfStrings(_ raw: TOMLValueConvertible, _ backtrace: TomlBacktrace) -> ParsedToml<[String]> {
     parseTomlArray(raw, backtrace)
         .flatMap { arr in

Sources/AppBundle/tree/Workspace.swift

@@ -24,10 +24,9 @@ private func getStubWorkspace(forPoint point: CGPoint) -> Workspace {
     {
         return candidate
     }
-    let preservedNames = config.preservedWorkspaceNames.toSet()
     return (1 ... Int.max).lazy
         .map { Workspace.get(byName: String($0)) }
-        .first { $0.isEffectivelyEmpty && !$0.isVisible && !preservedNames.contains($0.name) && $0.forceAssignedMonitor == nil }
+        .first { $0.isEffectivelyEmpty && !$0.isVisible && !config.persistentWorkspaces.contains($0.name) && $0.forceAssignedMonitor == nil }
         .orDie("Can't create empty workspace")
 }
 
@@ -72,24 +71,22 @@ final class Workspace: TreeNode, NonLeafTreeNodeObject, Hashable, Comparable {
 
     @MainActor
     var description: String {
-        let preservedNames = config.preservedWorkspaceNames.toSet()
         let description = [
             ("name", name),
             ("isVisible", String(isVisible)),
             ("isEffectivelyEmpty", String(isEffectivelyEmpty)),
-            ("doKeepAlive", String(preservedNames.contains(name))),
+            ("doKeepAlive", String(config.persistentWorkspaces.contains(name))),
         ].map { "\($0.0): '\(String(describing: $0.1))'" }.joined(separator: ", ")
         return "Workspace(\(description))"
     }
 
     @MainActor
     static func garbageCollectUnusedWorkspaces() {
-        let preservedNames = config.preservedWorkspaceNames.toSet()
-        for name in preservedNames {
-            _ = get(byName: name) // Make sure that all preserved workspaces are "cached"
+        for name in config.persistentWorkspaces {
+            _ = get(byName: name) // Make sure that all persistent workspaces are "cached"
         }
         workspaceNameToWorkspace = workspaceNameToWorkspace.filter { (_, workspace: Workspace) in
-            preservedNames.contains(workspace.name) ||
+            config.persistentWorkspaces.contains(workspace.name) ||
                 !workspace.isEffectivelyEmpty ||
                 workspace.isVisible ||
                 workspace.name == focus.workspace.name

Sources/AppBundleTests/config/ConfigTest.swift

@@ -19,6 +19,15 @@ final class ConfigTest: XCTestCase {
         assertEquals(errors, [])
     }
 
+    func testConfigVersionOutOfBounds() {
+        let (_, errors) = parseConfig(
+            """
+            config-version = 0
+            """,
+        )
+        assertEquals(errors.descriptions, ["config-version: Must be in [1, 2] range"])
+    }
+
     func testExecOnWorkspaceChangeDifferentTypesError() {
         let (_, errors) = parseConfig(
             """
@@ -28,6 +37,25 @@ final class ConfigTest: XCTestCase {
         assertEquals(errors.descriptions, ["exec-on-workspace-change[1]: Expected type is \'string\'. But actual type is \'integer\'"])
     }
 
+    func testDuplicatedPersistentWorkspaces() {
+        let (_, errors) = parseConfig(
+            """
+            config-version = 2
+            persistent-workspaces = ['a', 'a']
+            """,
+        )
+        assertEquals(errors.descriptions, ["persistent-workspaces: Contains duplicated workspace names"])
+    }
+
+    func testPersistentWorkspacesAreAvailableOnlySinceVersion2() {
+        let (_, errors) = parseConfig(
+            """
+            persistent-workspaces = ['a']
+            """,
+        )
+        assertEquals(errors.descriptions, ["persistent-workspaces: This config option is only available since \'config-version = 2\'"])
+    }
+
     func testQueryCantBeUsedInConfig() {
         let (_, errors) = parseConfig(
             """
@@ -111,7 +139,7 @@ final class ConfigTest: XCTestCase {
             """,
         )
         assertEquals(errors.descriptions, [])
-        assertEquals(config.preservedWorkspaceNames.sorted(), ["1", "2", "3", "4"])
+        assertEquals(config.persistentWorkspaces.sorted(), ["1", "2", "3", "4"])
     }
 
     func testUnknownTopLevelKeyParseError() {

Sources/AppBundleTests/testUtil.swift

@@ -23,7 +23,7 @@ func setUpWorkspacesForTests() {
 
     // Don't create any bindings and workspaces for tests
     config.modes = [mainModeId: Mode(name: nil, bindings: [:])]
-    config.preservedWorkspaceNames = []
+    config.persistentWorkspaces = []
 
     for workspace in Workspace.all {
         for child in workspace.children {

Sources/Common/util/SequenceEx.swift

@@ -1,4 +1,5 @@
 import AppKit
+import OrderedCollections
 
 extension Sequence {
     public func filterNotNil<Unwrapped>() -> [Unwrapped] where Element == Unwrapped? {
@@ -118,4 +119,5 @@ extension Sequence where Self.Element: Comparable {
 
 extension Sequence where Element: Hashable {
     public func toSet() -> Set<Element> { Set(self) }
+    public func toOrderedSet() -> OrderedSet<Element> { OrderedSet(self) }
 }

docs/config-examples/default-config.toml

@@ -1,6 +1,10 @@
 # Place a copy of this config to ~/.aerospace.toml
 # After that, you can edit ~/.aerospace.toml to your liking
 
+# Config version for compatibility and deprecations
+# Fallback value (if you omit the key): config-version = 1
+config-version = 2
+
 # You can use it to add commands that run after AeroSpace startup.
 # Available commands : https://nikitabobko.github.io/AeroSpace/commands
 after-startup-command = []
@@ -37,6 +41,14 @@ on-focused-monitor-changed = ['move-mouse monitor-lazy-center']
 # Also see: https://nikitabobko.github.io/AeroSpace/goodies#disable-hide-app
 automatically-unhide-macos-hidden-apps = false
 
+# List of workspaces that should stay alive even when they contain no windows,
+# even when they are invisible.
+# This config version is only available since 'config-version = 2'
+# Fallback value (if you omit the key): persistent-workspaces = []
+persistent-workspaces = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C",
+                         "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O",
+                         "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"]
+
 # A callback that runs every time binding mode changes
 # See: https://nikitabobko.github.io/AeroSpace/guide#binding-modes
 # See: https://nikitabobko.github.io/AeroSpace/commands#mode

docs/config-examples/i3-like-config-example.toml

@@ -1,5 +1,10 @@
 # Reference: https://github.com/i3/i3/blob/next/etc/config
 
+config-version = 2
+
+# In i3, all workspaces are phantom
+persistent-workspaces = []
+
 # i3 doesn't have "normalizations" feature that why we disable them here.
 # But the feature is very helpful.
 # Normalizations eliminate all sorts of weird tree configurations that don't make sense.