import AppKit
|
import ApplicationServices
|
import Foundation
|
|
struct MatchDescriptor {
|
let identifier: String
|
let rect: CGRect?
|
let hasParentWindow: Bool
|
}
|
|
enum AXReadFailure: Error {
|
case nonBenign(AXError)
|
}
|
|
func isBenignAbsence(_ error: AXError) -> Bool {
|
error == .noValue || error == .attributeUnsupported
|
}
|
|
func completeMatches(_ result: Result<[MatchDescriptor], AXReadFailure>) throws -> [MatchDescriptor] {
|
try result.get()
|
}
|
|
func validRect(_ rect: CGRect?) -> Bool {
|
guard let rect else { return false }
|
return [rect.origin.x, rect.origin.y, rect.width, rect.height].allSatisfy(\.isFinite)
|
&& rect.width > 0 && rect.height > 0
|
}
|
|
func postMutationReadbackExit(
|
_ readback: Result<Bool, AXReadFailure>,
|
validationFailure: Int32,
|
cleanupFailure: Int32,
|
rollback: () -> Bool
|
) -> Int32? {
|
if case .success(true) = readback { return nil }
|
return rollback() ? validationFailure : cleanupFailure
|
}
|
|
func uniqueMatch(_ matches: [MatchDescriptor], expected: String) -> MatchDescriptor? {
|
let exact = matches.filter { $0.identifier == expected }
|
guard exact.count == 1,
|
exact[0].hasParentWindow,
|
validRect(exact[0].rect) else { return nil }
|
return exact[0]
|
}
|
|
func selfTest() -> Int32 {
|
let good = MatchDescriptor(identifier: "fixture.excalidraw", rect: CGRect(x: 1, y: 2, width: 3, height: 4), hasParentWindow: true)
|
let traversalErrorRejected = (try? completeMatches(.failure(.nonBenign(.cannotComplete)))) == nil
|
let invalidParentRects: [CGRect] = [
|
CGRect(x: 0, y: 0, width: 0, height: 1),
|
CGRect(x: 0, y: 0, width: 1, height: 0),
|
CGRect(x: CGFloat.nan, y: 0, width: 1, height: 1),
|
CGRect(x: 0, y: CGFloat.infinity, width: 1, height: 1),
|
]
|
var rollbackCalled = 0
|
let readErrorCleanupSuccess = postMutationReadbackExit(
|
.failure(.nonBenign(.cannotComplete)), validationFailure: 69, cleanupFailure: 71
|
) { rollbackCalled += 1; return true }
|
let readErrorCleanupFailure = postMutationReadbackExit(
|
.failure(.nonBenign(.cannotComplete)), validationFailure: 69, cleanupFailure: 71
|
) { rollbackCalled += 1; return false }
|
guard uniqueMatch([good], expected: "fixture.excalidraw") != nil,
|
uniqueMatch([good], expected: "fixture") == nil,
|
uniqueMatch([good, good], expected: "fixture.excalidraw") == nil,
|
uniqueMatch([MatchDescriptor(identifier: good.identifier, rect: .zero, hasParentWindow: true)], expected: good.identifier) == nil,
|
uniqueMatch([MatchDescriptor(identifier: good.identifier, rect: good.rect, hasParentWindow: false)], expected: good.identifier) == nil,
|
traversalErrorRejected,
|
isBenignAbsence(.noValue), isBenignAbsence(.attributeUnsupported),
|
!isBenignAbsence(.cannotComplete), !isBenignAbsence(.invalidUIElement), !isBenignAbsence(.apiDisabled),
|
(invalidParentRects.allSatisfy { !validRect($0) }),
|
rollbackCalled == 2, readErrorCleanupSuccess == 69, readErrorCleanupFailure == 71,
|
postMutationReadbackExit(.success(true), validationFailure: 69, cleanupFailure: 71, rollback: { false }) == nil else { return 1 }
|
print("self_test=PASS explicit_exact_unique_source=true traversal_read_error_rejected=true parent_geometry_rejected=true post_mutation_read_error_rollback=true cleanup_status_distinct=true")
|
return 0
|
}
|
|
if CommandLine.arguments == [CommandLine.arguments[0], "--self-test"] { exit(selfTest()) }
|
guard CommandLine.arguments.count == 2, !CommandLine.arguments[1].isEmpty else {
|
fputs("usage: PlaceFinderSource exactSourceIdentifier\n", stderr)
|
exit(64)
|
}
|
let expected = CommandLine.arguments[1]
|
|
func attribute(_ element: AXUIElement, _ name: String) throws -> CFTypeRef? {
|
var value: CFTypeRef?
|
let error = AXUIElementCopyAttributeValue(element, name as CFString, &value)
|
if error == .success { return value }
|
if isBenignAbsence(error) { return nil }
|
throw AXReadFailure.nonBenign(error)
|
}
|
func stringValue(_ element: AXUIElement, _ name: String) throws -> String? {
|
guard let value = try attribute(element, name), CFGetTypeID(value) == CFStringGetTypeID() else { return nil }
|
return value as? String
|
}
|
func rect(_ element: AXUIElement) throws -> CGRect? {
|
guard let pv = try attribute(element, kAXPositionAttribute), CFGetTypeID(pv) == AXValueGetTypeID(),
|
let sv = try attribute(element, kAXSizeAttribute), CFGetTypeID(sv) == AXValueGetTypeID() else { return nil }
|
var point = CGPoint.zero
|
var size = CGSize.zero
|
guard AXValueGetValue(pv as! AXValue, .cgPoint, &point), AXValueGetValue(sv as! AXValue, .cgSize, &size) else { return nil }
|
return CGRect(origin: point, size: size)
|
}
|
func parentWindow(_ element: AXUIElement) throws -> AXUIElement? {
|
var current = element
|
for _ in 0..<16 {
|
if try stringValue(current, kAXRoleAttribute) == (kAXWindowRole as String) { return current }
|
guard let parent = try attribute(current, kAXParentAttribute), CFGetTypeID(parent) == AXUIElementGetTypeID() else { return nil }
|
current = parent as! AXUIElement
|
}
|
return nil
|
}
|
func collect(_ element: AXUIElement, depth: Int = 0, into result: inout [AXUIElement]) throws {
|
if try stringValue(element, kAXRoleAttribute) == (kAXTextFieldRole as String),
|
try stringValue(element, kAXValueAttribute) == expected { result.append(element) }
|
guard depth < 14, let children = try attribute(element, kAXChildrenAttribute) as? [AXUIElement] else { return }
|
for child in children { try collect(child, depth: depth + 1, into: &result) }
|
}
|
func setPoint(_ element: AXUIElement, _ value: CGPoint) -> AXError {
|
var value = value
|
return AXUIElementSetAttributeValue(element, kAXPositionAttribute as CFString, AXValueCreate(.cgPoint, &value)!)
|
}
|
func setSize(_ element: AXUIElement, _ value: CGSize) -> AXError {
|
var value = value
|
return AXUIElementSetAttributeValue(element, kAXSizeAttribute as CFString, AXValueCreate(.cgSize, &value)!)
|
}
|
|
guard let finder = NSRunningApplication.runningApplications(withBundleIdentifier: "com.apple.finder").first else { exit(66) }
|
let app = AXUIElementCreateApplication(finder.processIdentifier)
|
var matches: [AXUIElement] = []
|
try collect(app, into: &matches)
|
let descriptors = try completeMatches(.success(try matches.map { element in
|
MatchDescriptor(
|
identifier: try stringValue(element, kAXValueAttribute) ?? "",
|
rect: try rect(element),
|
hasParentWindow: try parentWindow(element) != nil
|
)
|
}))
|
guard matches.count == 1,
|
uniqueMatch(descriptors, expected: expected) != nil,
|
let window = try parentWindow(matches[0]),
|
let originalWindowRect = try rect(window), validRect(originalWindowRect),
|
let sourceRectBefore = try rect(matches[0]), validRect(sourceRectBefore) else {
|
fputs("exact unique source binding failed\n", stderr)
|
exit(67)
|
}
|
|
let desiredPosition = CGPoint(x: 10, y: 70)
|
let desiredSize = CGSize(width: 500, height: 320)
|
let positionError = setPoint(window, desiredPosition)
|
guard positionError == .success else { exit(70) }
|
let sizeError = setSize(window, desiredSize)
|
guard sizeError == .success else {
|
let rollback = setPoint(window, originalWindowRect.origin)
|
exit(rollback == .success ? 70 : 71)
|
}
|
let raiseError = AXUIElementPerformAction(window, kAXRaiseAction as CFString)
|
guard raiseError == .success else {
|
let sizeRollback = setSize(window, originalWindowRect.size)
|
let pointRollback = setPoint(window, originalWindowRect.origin)
|
exit(sizeRollback == .success && pointRollback == .success ? 70 : 71)
|
}
|
Thread.sleep(forTimeInterval: 0.6)
|
let readbackResult: Result<Bool, AXReadFailure>
|
var verifiedSourceRect: CGRect?
|
var verifiedWindowRect: CGRect?
|
do {
|
let sourceRect = try rect(matches[0])
|
let windowRect = try rect(window)
|
readbackResult = .success(validRect(sourceRect) && validRect(windowRect))
|
if validRect(sourceRect) && validRect(windowRect) {
|
verifiedSourceRect = sourceRect
|
verifiedWindowRect = windowRect
|
}
|
} catch let error as AXReadFailure {
|
readbackResult = .failure(error)
|
}
|
if let exitCode = postMutationReadbackExit(readbackResult, validationFailure: 69, cleanupFailure: 71, rollback: {
|
let sizeRollback = setSize(window, originalWindowRect.size)
|
let pointRollback = setPoint(window, originalWindowRect.origin)
|
return sizeRollback == .success && pointRollback == .success
|
}) {
|
exit(exitCode)
|
}
|
let sourceRect = verifiedSourceRect!
|
let windowRect = verifiedWindowRect!
|
print("source=<QA_SOURCE> parent_window=<QA_WINDOW> exact_unique=true")
|
print("window_rect=\(windowRect.origin.x),\(windowRect.origin.y),\(windowRect.width),\(windowRect.height)")
|
print("source_rect=\(sourceRect.origin.x),\(sourceRect.origin.y),\(sourceRect.width),\(sourceRect.height)")
|
print("source_center=\(sourceRect.midX),\(sourceRect.midY)")
|
