[AltStoreCore] Renames AsyncManaged.get() to perform()

Implies it can be used as alternative to managedObject.managedObjectContext.perform() and not just for retrieving values.

AltStore/Managing Apps/AppManager.swift

@@ -355,7 +355,7 @@ extension AppManager
     
     func add(@AsyncManaged _ source: Source, message: String? = nil, presentingViewController: UIViewController) async throws
     {
-        let (sourceName, sourceURL) = await $source.get { ($0.name, $0.sourceURL) }
+        let (sourceName, sourceURL) = await $source.perform { ($0.name, $0.sourceURL) }
         
         let context = DatabaseManager.shared.persistentContainer.newBackgroundContext()
         async let fetchedSource = try await self.fetchSource(sourceURL: sourceURL, managedObjectContext: context) // Fetch source async while showing alert.
@@ -375,7 +375,7 @@ extension AppManager
     
     func remove(@AsyncManaged _ source: Source, presentingViewController: UIViewController) async throws
     {
-        let (sourceName, sourceID) = await $source.get { ($0.name, $0.identifier) }
+        let (sourceName, sourceID) = await $source.perform { ($0.name, $0.identifier) }
         guard sourceID != Source.altStoreIdentifier else {
             throw OperationError.forbidden(failureReason: NSLocalizedString("The default AltStore source cannot be removed.", comment: ""))
         }

AltStoreCore/Types/AsyncManaged.swift

@@ -34,10 +34,11 @@ public struct AsyncManaged<ManagedObject>
     }
 }
 
+/// Run on managedObjectContext's queue.
 public extension AsyncManaged
 {
-    // Fetch multiple values.
+    // Non-throwing
-    func get<T>(_ closure: @escaping (ManagedObject) -> T) async -> T
+    func perform<T>(_ closure: @escaping (ManagedObject) -> T) async -> T
     {
         if let context = self.managedObjectContext
         {
@@ -50,33 +51,40 @@ public extension AsyncManaged
             return closure(self.wrappedValue)
         }
     }
+    
+    // Throwing
+    func perform<T>(_ closure: @escaping (ManagedObject) throws -> T) async throws -> T
+    {
+        if let context = self.managedObjectContext
+        {
+            return try await context.performAsync {
+                try closure(self.wrappedValue)
+            }
+        }
+        else
+        {
+            return try closure(self.wrappedValue)
+        }
+    }
 }
 
 /// @dynamicMemberLookup
-extension AsyncManaged
+public extension AsyncManaged
 {
-    public subscript<T>(dynamicMember keyPath: KeyPath<ManagedObject, T>) -> T {
+    subscript<T>(dynamicMember keyPath: KeyPath<ManagedObject, T>) -> T {
         get async {
-            guard let context = self.managedObjectContext else {
+            let result = await self.perform { $0[keyPath: keyPath] }
-                return self.wrappedValue[keyPath: keyPath]
+            return result
-            }
-            
-            return await context.performAsync {
-                return self.wrappedValue[keyPath: keyPath]
-            }
         }
     }
 
     // Optionals
-    public subscript<Wrapped, T>(dynamicMember keyPath: KeyPath<Wrapped, T>) -> T? where ManagedObject == Optional<Wrapped> {
+    subscript<Wrapped, T>(dynamicMember keyPath: KeyPath<Wrapped, T>) -> T? where ManagedObject == Optional<Wrapped> {
         get async {
-            guard let context = self.managedObjectContext else {
+            guard let wrappedValue else { return nil }
-                return self.wrappedValue?[keyPath: keyPath]
-            }
             
-            return await context.performAsync {
+            let result = await self.perform { _ in wrappedValue[keyPath: keyPath] }
-                return self.wrappedValue?[keyPath: keyPath]
+            return result
-            }
         }
     }
 }