Convert importOPML to async await.

Account/Package.swift

@@ -48,10 +48,10 @@ let package = Package(
 				"FeedFinder",
 				"CommonErrors",
 				"Feedly"
+			],
+			swiftSettings: [
+				.enableExperimentalFeature("StrictConcurrency")
 			]
-//			swiftSettings: [
-//				.enableExperimentalFeature("StrictConcurrency")
-//			]
 		),
 		.testTarget(
 			name: "AccountTests",

Account/Sources/Account/AccountDelegates/FeedlyAccountDelegate.swift

@@ -259,56 +259,27 @@ final class FeedlyAccountDelegate: AccountDelegate {
 	
 	func importOPML(for account: Account, opmlFile: URL) async throws {
 
-		try await withCheckedThrowingContinuation { continuation in
+		let data = try Data(contentsOf: opmlFile)
-			self.importOPML(for: account, opmlFile: opmlFile) { result in
+
-				switch result {
+		os_log(.debug, log: log, "Begin importing OPML…")
-				case .success:
-					continuation.resume()
-				case .failure(let error):
-					continuation.resume(throwing: error)
-				}
-			}
-		}
-	}
 
-	private func importOPML(for account: Account, opmlFile: URL, completion: @escaping @Sendable (Result<Void, Error>) -> Void) {
-		let data: Data
-		
-		do {
-			data = try Data(contentsOf: opmlFile)
-		} catch {
-			completion(.failure(error))
-			return
-		}
-		
-		os_log(.debug, log: log, "Begin importing OPML...")
 		isOPMLImportInProgress = true
-		refreshProgress.addToNumberOfTasksAndRemaining(1)
+		refreshProgress.addTask()
-		
+		defer {
-		caller.importOpml(data) { result in
+			isOPMLImportInProgress = false
+			refreshProgress.completeTask()
+		}
 
-			MainActor.assumeIsolated {
+		do {
-				switch result {
+			try await caller.importOPML(data)
-				case .success:
+			os_log(.debug, log: self.log, "Import OPML done.")
-					os_log(.debug, log: self.log, "Import OPML done.")
+		} catch {
-					self.refreshProgress.completeTask()
+			os_log(.debug, log: self.log, "Import OPML failed.")
-					self.isOPMLImportInProgress = false
+			let wrappedError = AccountError.wrappedError(error: error, account: account)
-					DispatchQueue.main.async {
+			throw wrappedError
-						completion(.success(()))
-					}
-				case .failure(let error):
-					os_log(.debug, log: self.log, "Import OPML failed.")
-					self.refreshProgress.completeTask()
-					self.isOPMLImportInProgress = false
-					DispatchQueue.main.async {
-						let wrappedError = AccountError.wrappedError(error: error, account: account)
-						completion(.failure(wrappedError))
-					}
-				}
-			}
 		}
 	}
-	
+
 	func createFolder(for account: Account, name: String) async throws -> Folder {
 
 		try await withCheckedThrowingContinuation { continuation in

Account/Sources/Account/Feedly/FeedlyAPICaller.swift

@@ -17,8 +17,8 @@ protocol FeedlyAPICallerDelegate: AnyObject {
 	@MainActor func reauthorizeFeedlyAPICaller(_ caller: FeedlyAPICaller, completionHandler: @escaping (Bool) -> ())
 }
 
-final class FeedlyAPICaller {
+@MainActor final class FeedlyAPICaller {
-	
+
 	enum API {
 		case sandbox
 		case cloud
@@ -151,43 +151,32 @@ final class FeedlyAPICaller {
 		}
 	}
 	
-	func importOpml(_ opmlData: Data, completion: @escaping @Sendable (Result<Void, Error>) -> ()) {
+	func importOPML(_ opmlData: Data) async throws {
+
 		guard !isSuspended else {
-			return DispatchQueue.main.async {
+			throw TransportError.suspended
-				completion(.failure(TransportError.suspended))
-			}
 		}
-		
 		guard let accessToken = credentials?.secret else {
-			return DispatchQueue.main.async {
+			throw CredentialsError.incompleteCredentials
-				completion(.failure(CredentialsError.incompleteCredentials))
-			}
 		}
+
 		var components = baseUrlComponents
 		components.path = "/v3/opml"
-		
+
 		guard let url = components.url else {
 			fatalError("\(components) does not produce a valid URL.")
 		}
-		
+
 		var request = URLRequest(url: url)
 		request.httpMethod = "POST"
 		request.addValue("text/xml", forHTTPHeaderField: HTTPRequestHeader.contentType)
 		request.addValue("application/json", forHTTPHeaderField: "Accept-Type")
 		request.addValue("OAuth \(accessToken)", forHTTPHeaderField: HTTPRequestHeader.authorization)
 		request.httpBody = opmlData
-		
+
-		send(request: request, resultType: String.self, dateDecoding: .millisecondsSince1970, keyDecoding: .convertFromSnakeCase) { result in
+		let (httpResponse, _) = try await send(request: request, resultType: String.self)
-			switch result {
+		if httpResponse.statusCode != HTTPResponseCode.OK {
-			case .success(let (httpResponse, _)):
+			throw URLError(.cannotDecodeContentData)
-				if httpResponse.statusCode == 200 {
-					completion(.success(()))
-				} else {
-					completion(.failure(URLError(.cannotDecodeContentData)))
-				}
-			case .failure(let error):
-				completion(.failure(error))
-			}
 		}
 	}