Minor tweaks

Author: eonist

README.md

@@ -104,3 +104,70 @@ UpgradeAlert.showAlert(appInfo: .init(version: "1.0.1", trackViewUrl: "https://a
 - Testing and Coverage Improving tests to cover edge cases and error scenarios would enhance the reliability of the application. For instance:
 - UpgradeAlertTests.swift: The test cases could be expanded to cover more scenarios, including error handling and user interaction outcomes.
 - Upgrade this to Swift 6.0 (Might be a bit tricky)
+- Add a way to inject text for alert. so we can localize text from the caller etc.as we might want to use .modules with localizations etc
+- Enhance Error Handling with Swift's Result Type
+Issue: The current implementation of asynchronous methods uses custom closures with optional parameters for error handling. This can be improved by leveraging Swift's Result type, which provides a clearer and more structured way to handle success and failure cases.
+Improvement: Refactor asynchronous methods to use Result instead of optional parameters. This will make the code more readable and maintainable.
+
+```
+public final class UpgradeAlert {
+    public static func checkForUpdates(completion: @escaping (Result<Void, UAError>) -> Void) {
+        DispatchQueue.global(qos: .background).async {
+            getAppInfo { result in
+                switch result {
+                case .success(let appInfo):
+                    let needsUpdate = ComparisonResult.compareVersion(
+                        current: Bundle.version ?? "0",
+                        appStore: appInfo.version
+                    ) == .requiresUpgrade
+                    guard needsUpdate else {
+                        completion(.success(()))
+                        return
+                    }
+                    DispatchQueue.main.async {
+                        showAlert(appInfo: appInfo, completion: completion)
+                    }
+                case .failure(let error):
+                    completion(.failure(error))
+                }
+            }
+        }
+    }
+}
+```
+
+- Use Result in getAppInfo Method
+Issue: The getAppInfo method currently uses a closure with optional parameters for error handling.
+Improvement: Modify getAppInfo to use Result<AppInfo, UAError> in its completion handler.
+Updated Code:
+
+```swift
+private static func getAppInfo(completion: @escaping (Result<AppInfo, UAError>) -> Void) {
+    guard let url = requestURL else {
+        completion(.failure(.invalidURL))
+        return
+    }
+    let task = URLSession.shared.dataTask(with: url) { data, _, error in
+        if let error = error {
+            completion(.failure(.invalidResponse(description: error.localizedDescription)))
+            return
+        }
+        guard let data = data else {
+            completion(.failure(.invalidResponse(description: "No data received")))
+            return
+        }
+        do {
+            let result = try JSONDecoder().decode(LookupResult.self, from: data)
+            if let appInfo = result.results.first {
+                completion(.success(appInfo))
+            } else {
+                completion(.failure(.invalidResponse(description: "No app info available")))
+            }
+        } catch {
+            completion(.failure(.invalidResponse(description: error.localizedDescription)))
+        }
+    }
+    task.resume()
+}
+```
+

Sources/UpgradeAlert/UpgradeAlert+Variables.swift

@@ -14,11 +14,19 @@ extension UpgradeAlert {
     * - Fixme: ⚠️️ Consider renaming this to appInfoRequestURL for clarity.
     * - fix: maybe move url to const?
     */
+    @available(*, deprecated, renamed: "getRequestURL")
    internal static var requestURL: URL? {
       guard let bundleId: String = Bundle.identifier else { return nil }
       let requestURLStr: String = "https://itunes.apple.com/lookup?bundleId=\(bundleId)" // might need country code
       return .init(string: requestURLStr)
    }
+   // The App Store lookup URL may fail if the app is not available in all countries.
+   // prefer this
+   internal static var getRequestURL(countryCode = Locale.current.regionCode ?? "US") -> URL? {
+      guard let bundleId = Bundle.identifier else { return nil }
+      let requestURLStr = "https://itunes.apple.com/lookup?bundleId=\(bundleId)&country=\(countryCode)"
+      return URL(string: requestURLStr)
+   }
 }
 /**
  * Typealias

Sources/UpgradeAlert/UpgradeAlert.swift

@@ -100,6 +100,19 @@ extension UpgradeAlert {
 
                throw NSError(domain: "no app info", code: 0) // If there is no app info, throw an NSError with the description "no app info"
             }
+
+            // ⚠️️ new
+            // The App Store metadata may be updated before the app binary is available, causing users to see an update prompt before they can download the update.
+            // Check the currentVersionReleaseDate from the App Store response and delay prompting users if the update is very recent.
+            let dateFormatter = ISO8601DateFormatter()
+            if let releaseDate = dateFormatter.date(from: appInfo.currentVersionReleaseDate) {
+               let daysSinceRelease = Calendar.current.dateComponents([.day], from: releaseDate, to: Date()).day ?? 0
+               if daysSinceRelease < 1 {
+                     completion(.success(())) // Do not prompt the user yet
+                     return
+               }
+            }
+
             completion?(info, nil)
          } catch {
             // Handle potential errors during data fetching and decoding

Sources/UpgradeAlert/ext/Bundle+Ext.swift

@@ -8,25 +8,33 @@ extension Bundle {
     * - Description: Retrieves the name of the main bundle of the application.
     * Example: `let appName = Bundle.name`
     */
-   internal static let name: String? = Bundle.main.object(forInfoDictionaryKey: kCFBundleNameKey as String) as? String
+   internal static var name: String? {
+        main.object(forInfoDictionaryKey: kCFBundleNameKey as String) as? String
+   }
    /**
     * The version of the main bundle.
     * - Description: Retrieves the version number of the main bundle of the application.
     * Example: `let appVersion = Bundle.version`
     */
-   internal static let version: String? = Bundle.main.object(forInfoDictionaryKey: "CFBundleShortVersionString") as? String
+   internal static var version: String? {
+        main.object(forInfoDictionaryKey: "CFBundleShortVersionString") as? String
+   }
    /**
     * The build number of the main bundle.
     * - Description: Retrieves the build number of the main bundle of the application.
     * Example: `let buildNumber = Bundle.build`
     */
-   internal static let build: String? = Bundle.main.object(forInfoDictionaryKey: kCFBundleVersionKey as String) as? String
+   internal static var build: String? {
+        main.object(forInfoDictionaryKey: kCFBundleVersionKey as String) as? String
+   }
    /**
     * The identifier of the main bundle.
     * - Description: Retrieves the unique identifier of the main bundle of the application.
     * Example: `let bundleIdentifier = Bundle.identifier`
     */
-   internal static let identifier: String? = Bundle.main.object(forInfoDictionaryKey: kCFBundleIdentifierKey as String) as? String
+   internal static var identifier: String? {
+        main.object(forInfoDictionaryKey: kCFBundleIdentifierKey as String) as? String
+   }
    /**
     * Tests if an app is in beta
     * - Abstract: determines if beta from receipt

Sources/UpgradeAlert/ext/UIAlertController+Ext.swift

@@ -10,7 +10,11 @@ extension UIAlertController {
     * Fix: throw error if vc is not available?
     */
    internal func present() {
-      Self.presentedOrRootVC?.present(self, animated: true, completion: nil)
+       guard let viewController = Self.presentedOrRootVC else {
+         print("Error: No view controller available to present the alert.")
+         return
+      }
+      viewController.present(self, animated: true, completion: nil)
    }
 }
 /**

Sources/UpgradeAlert/helper/AppInfo.swift

@@ -30,6 +30,8 @@ public struct AppInfo: Decodable {
     *                review the app.
     */
    public let trackViewUrl: String
+   // ⚠️️ new
+    public let currentVersionReleaseDate: String
    /**
     * Initializes a new instance of `AppInfo`.
     * - Description: Initializes a new instance of `AppInfo` with the specified

Sources/UpgradeAlert/util/ComparisonResult.swift

@@ -38,18 +38,23 @@ extension ComparisonResult {
     *   - appStore: "1.2.9" The version of the app in the App Store.
     */
    static func compareVersion(current: String, appStore: String) -> ComparisonResult {
-   	let versionCompare/*: ComparisonResult*/ = current.compare(appStore, options: .numeric)
-      switch versionCompare {
-      case .orderedSame:// The current version is the same as the App Store version.
-         //print("same version")
-         return .compatible
-      case .orderedAscending:// The current version is older than the App Store version.
-         // will execute the code here
-         // print("ask user to update")
-         return .requiresUpgrade
-      case .orderedDescending: // app-store listing hasn't updated yet, The current version is newer than the App Store version. This is an unexpected case.
-         // execute if current > appStore
-         // print("don't expect happen...")
+   //	let versionCompare/*: ComparisonResult*/ = current.compare(appStore, options: .numeric)
+   //   switch versionCompare {
+   //   case .orderedSame:// The current version is the same as the App Store version.
+   //      //print("same version")
+   //      return .compatible
+   //   case .orderedAscending:// The current version is older than the App Store version.
+   //      // will execute the code here
+   //      // print("ask user to update")
+   //      return .requiresUpgrade
+   //   case .orderedDescending: // app-store listing hasn't updated yet, The current version is newer than the App Store version. This is an unexpected case.
+   //      // execute if current > appStore
+   //      // print("don't expect happen...")
+   //      return .compatible
+   //   }
+      if current.compare(appStore, options: .numeric) == .orderedAscending {
+            return .requiresUpgrade
+      } else {
          return .compatible
       }
    }

Tests/UpgradeAlertTests/UpgradeAlertTests.swift

@@ -30,4 +30,23 @@ final class UpgradeAlertTests: XCTestCase {
          }
       }
    }
+   // ⚠️️ untested
+   func testGetAppInfoWithInvalidURL() {
+      // Temporarily override the requestURL to be invalid
+      let originalURL = UpgradeAlert.requestURL
+      UpgradeAlert.requestURL = nil
+      let expectation = self.expectation(description: "Completion handler called")
+      UpgradeAlert.getAppInfo { result in
+         switch result {
+         case .success:
+               XCTFail("Expected failure when URL is invalid")
+         case .failure(let error):
+               XCTAssertEqual(error, .invalidURL)
+         }
+         expectation.fulfill()
+      }
+      waitForExpectations(timeout: 5, handler: nil)
+      // Restore the original URL
+      UpgradeAlert.requestURL = originalURL
+   }
 }