aerospace fork
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285import OrderedCollections
private let workspace = "<workspace>"private let workspaces = "\(workspace)..."
public struct ListWindowsCmdArgs: CmdArgs { /*conforms*/ public var commonState: CmdArgsCommonState public static let parser: CmdParser<Self> = .init( kind: .listWindows, help: list_windows_help_generated, flags: [ "--all": trueBoolFlag(\.allAlias),
// Filtering flags "--focused": trueBoolFlag(\.filteringOptions.focused), "--monitor": ArgParser(\.filteringOptions.monitors, parseMonitorIds), "--workspace": ArgParser(\.filteringOptions.workspaces, parseWorkspaces), "--pid": singleValueSubArgParser(\.filteringOptions.pidFilter, "<pid>") { Int32($0).toResult("Can't convert to Int32") }, "--app-bundle-id": singleValueSubArgParser(\.filteringOptions.appIdFilter, "<app-bundle-id>", Result.success),
// Formatting flags "--format": formatParser(\._format, for: .window), "--count": trueBoolFlag(\.outputOnlyCount), "--json": trueBoolFlag(\.json), ], posArgs: [], conflictingOptions: [ ["--all", "--focused", "--workspace"], ["--all", "--focused", "--monitor"], ["--count", "--format"], ["--count", "--json"], ], )
fileprivate var allAlias: Bool = false
public var filteringOptions = FilteringOptions() public var _format: [InterToken<InterVar>] = [] public var outputOnlyCount: Bool = false public var json: Bool = false
public struct FilteringOptions: ConvenienceMutable, Equatable, Sendable { public var monitors: [MonitorId] = [] public var focused: Bool = false public var workspaces: [WorkspaceFilter] = [] public var pidFilter: Int32? public var appIdFilter: String? }}
extension ListWindowsCmdArgs { public var format: [InterToken<InterVar>] { _format.isEmpty ? [ .interVar(.formatVar(.window(.windowId))), .interVar(.plainInterVar(.rightPadding)), .literal(" | "), .interVar(.formatVar(.app(.appName))), .interVar(.plainInterVar(.rightPadding)), .literal(" | "), .interVar(.formatVar(.window(.windowTitle))), ] : _format }}
func parseListWindowsCmdArgs(_ args: StrArrSlice) -> ParsedCmd<ListWindowsCmdArgs> { let args = args.map { $0 == "--app-id" ? "--app-bundle-id" : $0 }.slice // Compatibility return parseSpecificCmdArgs(ListWindowsCmdArgs(commonState: .init(args)), args) .filter("Mandatory option is not specified (--focused|--all|--monitor|--workspace)") { raw in raw.filteringOptions.focused || raw.allAlias || !raw.filteringOptions.monitors.isEmpty || !raw.filteringOptions.workspaces.isEmpty } .filter("--all conflicts with \"filtering\" flags. Please use '--monitor all' instead of '--all' alias") { raw in raw.allAlias.implies(raw.filteringOptions == ListWindowsCmdArgs.FilteringOptions()) } .filter("--focused conflicts with other \"filtering\" flags") { raw in raw.filteringOptions.focused.implies(raw.filteringOptions.copy(\.focused, false) == ListWindowsCmdArgs.FilteringOptions()) } .map { raw in raw.allAlias ? raw.copy(\.filteringOptions.monitors, [.all]).copy(\.allAlias, false) : raw // Normalize alias } .flatMap { if $0.json, let msg = getErrorIfFormatIsIncompatibleWithJson($0._format) { .failure(msg) } else { .cmd($0) } }}
func formatParser<Root>( _ keyPath: SendableWritableKeyPath<Root, [InterToken<InterVar>]>, for kind: AeroObjKind,) -> SubArgParser<Root, [InterToken<InterVar>]> { return ArgParser(keyPath) { input in if let arg = input.nonFlagArgOrNil() { return switch arg.interpolationTokens(interpolationChar: "%", ofInterVarType: InterVar.self) { case .success(let tokens): .succ(tokens, advanceBy: 1) case .failure(let err): .fail("Failed to parse <output-format>. \(err)", advanceBy: 1) } } else { let values = getAvailableInterVars(for: kind).joined(separator: "\n").prependLines(" ") return .fail("<output-format> is mandatory. Possible values:\n\(values)", advanceBy: 0) } }}
private func parseWorkspaces(input: SubArgParserInput) -> ParsedCliArgs<[WorkspaceFilter]> { let args = input.nonFlagArgs() let possibleValues = "\(workspace) possible values: (<workspace-name>|focused|visible)" if args.isEmpty { return .fail("\(workspaces) is mandatory. \(possibleValues)", advanceBy: args.count) } var workspaces: [WorkspaceFilter] = [] var i = 0 for workspaceRaw in args { switch workspaceRaw { case "visible": workspaces.append(.visible) case "focused": workspaces.append(.focused) default: switch WorkspaceName.parse(workspaceRaw) { case .success(let unwrapped): workspaces.append(.name(unwrapped)) case .failure(let msg): return .fail(msg, advanceBy: i + 1) } } i += 1 } return .succ(workspaces, advanceBy: workspaces.count)}
public enum WorkspaceFilter: Equatable, Sendable { case focused case visible case name(WorkspaceName)}
public enum FormatVar: RawRepresentable, Equatable, CaseIterable, Sendable { case window(WindowFormatVar) case workspace(WorkspaceFormatVar) case app(AppFormatVar) case monitor(MonitorFormatVar)
// periphery:ignore private var kind: AeroObjKind { switch self { case .app: .app case .monitor: .monitor case .window: .window case .workspace: .workspace } }
public static var allCases: [FormatVar] { AeroObjKind.allCases.flatMap { switch $0 { case .app: AppFormatVar.allCases.map(FormatVar.app) case .monitor: MonitorFormatVar.allCases.map(FormatVar.monitor) case .window: WindowFormatVar.allCases.map(FormatVar.window) case .workspace: WorkspaceFormatVar.allCases.map(FormatVar.workspace) } } }
public init?(rawValue: String) { let value = AeroObjKind.allCases.map { kind in switch kind { case .app: AppFormatVar(rawValue: rawValue).map(FormatVar.app) case .monitor: MonitorFormatVar(rawValue: rawValue).map(FormatVar.monitor) case .window: WindowFormatVar(rawValue: rawValue).map(FormatVar.window) case .workspace: WorkspaceFormatVar(rawValue: rawValue).map(FormatVar.workspace) } }.filterNotNil() switch value.sequencePattern { case .empty: return nil case .one(let it): self = it default: die("FormatVar clash: \(value)") } }
public var rawValue: String { switch self { case .app(let it): it.rawValue case .monitor(let it): it.rawValue case .window(let it): it.rawValue case .workspace(let it): it.rawValue } }
public enum WindowFormatVar: String, Equatable, CaseIterable, Sendable { case windowId = "window-id" case windowIsFullscreen = "window-is-fullscreen" case windowTitle = "window-title" case windowLayout = "window-layout" // An alias for windowParentContainerLayout case windowParentContainerLayout = "window-parent-container-layout" }
public enum WorkspaceFormatVar: String, Equatable, CaseIterable, Sendable { case workspaceName = "workspace" case workspaceFocused = "workspace-is-focused" case workspaceVisible = "workspace-is-visible" case workspaceRootContainerLayout = "workspace-root-container-layout" }
public enum AppFormatVar: String, Equatable, CaseIterable, Sendable { case appBundleId = "app-bundle-id" case appName = "app-name" case appPid = "app-pid" case appExecPath = "app-exec-path" case appBundlePath = "app-bundle-path" }
public enum MonitorFormatVar: String, Equatable, CaseIterable, Sendable { case monitorId_oneBased = "monitor-id" case monitorAppKitNsScreenScreensId = "monitor-appkit-nsscreen-screens-id" case monitorName = "monitor-name" case monitorIsMain = "monitor-is-main" }}
public enum PlainInterVar: String, CaseIterable, Sendable, Equatable { case rightPadding = "right-padding" case newline = "newline" case tab = "tab"}
public enum InterVar: RawRepresentable, Equatable, CaseIterable, Sendable { case formatVar(FormatVar) case plainInterVar(PlainInterVar)
private enum Kind: CaseIterable, Equatable, Sendable { case formatVar case plainInterVar }
// periphery:ignore private var kind: Kind { switch self { case .formatVar: .formatVar case .plainInterVar: .plainInterVar } }
public static var allCases: [InterVar] { Kind.allCases.flatMap { kind in switch kind { case .formatVar: FormatVar.allCases.map(InterVar.formatVar) case .plainInterVar: PlainInterVar.allCases.map(InterVar.plainInterVar) } } }
public init?(rawValue: String) { let this: [Self] = Kind.allCases.map { kind in switch kind { case .formatVar: FormatVar(rawValue: rawValue).map(InterVar.formatVar) case .plainInterVar: PlainInterVar(rawValue: rawValue).map(InterVar.plainInterVar) } }.filterNotNil() switch this.sequencePattern { case .empty: return nil case .one(let it): self = it default: die("Clashed cases: \(this)") } }
public var rawValue: String { switch self { case .formatVar(let it): it.rawValue case .plainInterVar(let it): it.rawValue } }}
public enum AeroObjKind: CaseIterable, Sendable { case window, workspace, app, monitor}
public func getAvailableInterVars(for kind: AeroObjKind) -> [String] { _getAvailableInterVars(for: kind) + PlainInterVar.allCases.map(\.rawValue)}
private func _getAvailableInterVars(for kind: AeroObjKind) -> [String] { switch kind { case .app: FormatVar.AppFormatVar.allCases.map(\.rawValue) case .monitor: FormatVar.MonitorFormatVar.allCases.map(\.rawValue) case .workspace: FormatVar.WorkspaceFormatVar.allCases.map(\.rawValue) + _getAvailableInterVars(for: .monitor) case .window: FormatVar.WindowFormatVar.allCases.map(\.rawValue) + _getAvailableInterVars(for: .workspace) + _getAvailableInterVars(for: .app) }}