formatting

packages/url_launcher/url_launcher_ios/example/ios/RunnerTests/URLLauncherTests.swift

@@ -8,112 +8,112 @@ import XCTest
 @testable import url_launcher_ios
 
 class URLLauncherTests: XCTestCase {
-    var plugin: URLLauncherPlugin!
-    var launcher: FakeLauncher!
+  var plugin: URLLauncherPlugin!
+  var launcher: FakeLauncher!
 
-    override func setUp() {
-        launcher = FakeLauncher()
-        plugin = URLLauncherPlugin(launcher: launcher, binaryMessenger: FakeFlutterBinaryMessenger())
-    }
+  override func setUp() {
+    launcher = FakeLauncher()
+    plugin = URLLauncherPlugin(launcher: launcher, binaryMessenger: FakeFlutterBinaryMessenger())
+  }
 
-    func testCanLaunchSuccess() {
-        let result = plugin.canLaunchUrl(url: "good://url")
+  func testCanLaunchSuccess() {
+    let result = plugin.canLaunchUrl(url: "good://url")
 
-        XCTAssertTrue(result)
-    }
+    XCTAssertTrue(result)
+  }
 
-    func testCanLaunchFailure() {
-        let result = plugin.canLaunchUrl(url: "bad://url")
+  func testCanLaunchFailure() {
+    let result = plugin.canLaunchUrl(url: "bad://url")
 
-        XCTAssertFalse(result)
-    }
+    XCTAssertFalse(result)
+  }
 
-    func testCanLaunchFailureWithInvalidURL() {
-        let result = plugin.canLaunchUrl(url: "urls can't have spaces")
+  func testCanLaunchFailureWithInvalidURL() {
+    let result = plugin.canLaunchUrl(url: "urls can't have spaces")
 
-        XCTAssertFalse(result)
-    }
+    XCTAssertFalse(result)
+  }
 
-    func testLaunchSuccess() {
-        let expectation = XCTestExpectation(description: "completion called")
-        plugin.launchUrl(url: "good://url", universalLinksOnly: false) { result in
-            switch result {
-            case .success(let success):
-                XCTAssertTrue(success)
-            case .failure(let error):
-                XCTFail("Unexpected error: \(error)")
-            }
-            expectation.fulfill()
-        }
-
-        wait(for: [expectation], timeout: 1)
+  func testLaunchSuccess() {
+    let expectation = XCTestExpectation(description: "completion called")
+    plugin.launchUrl(url: "good://url", universalLinksOnly: false) { result in
+      switch result {
+      case .success(let success):
+        XCTAssertTrue(success)
+      case .failure(let error):
+        XCTFail("Unexpected error: \(error)")
+      }
+      expectation.fulfill()
     }
 
-    func testLaunchFailure() {
-        let expectation = XCTestExpectation(description: "completion called")
-        plugin.launchUrl(url: "bad://url", universalLinksOnly: false) { result in
-            switch result {
-            case .success(let success):
-                XCTAssertFalse(success)
-            case .failure(let error):
-                XCTFail("Unexpected error: \(error)")
-            }
-            expectation.fulfill()
-        }
-
-        wait(for: [expectation], timeout: 1)
+    wait(for: [expectation], timeout: 1)
+  }
+
+  func testLaunchFailure() {
+    let expectation = XCTestExpectation(description: "completion called")
+    plugin.launchUrl(url: "bad://url", universalLinksOnly: false) { result in
+      switch result {
+      case .success(let success):
+        XCTAssertFalse(success)
+      case .failure(let error):
+        XCTFail("Unexpected error: \(error)")
+      }
+      expectation.fulfill()
     }
 
-    func testLaunchFailureWithInvalidURL() {
-        let expectation = XCTestExpectation(description: "completion called")
-        plugin.launchUrl(url: "urls can't have spaces", universalLinksOnly: false) { result in
-            switch result {
-            case .success(_):
-                XCTFail("Expected an error")
-            case .failure(let error):
-                let generalError = error as! GeneralError
-                XCTAssertEqual(generalError.code, "argument_error")
-                XCTAssertEqual(generalError.message, "Unable to parse URL")
-                XCTAssertEqual(generalError.details, "Provided URL: urls can't have spaces")
-            }
-            expectation.fulfill()
-        }
-
-        wait(for: [expectation], timeout: 1)
+    wait(for: [expectation], timeout: 1)
+  }
+
+  func testLaunchFailureWithInvalidURL() {
+    let expectation = XCTestExpectation(description: "completion called")
+    plugin.launchUrl(url: "urls can't have spaces", universalLinksOnly: false) { result in
+      switch result {
+      case .success(_):
+        XCTFail("Expected an error")
+      case .failure(let error):
+        let generalError = error as! GeneralError
+        XCTAssertEqual(generalError.code, "argument_error")
+        XCTAssertEqual(generalError.message, "Unable to parse URL")
+        XCTAssertEqual(generalError.details, "Provided URL: urls can't have spaces")
+      }
+      expectation.fulfill()
     }
 
-    func testLaunchWithoutUniversalLinks() {
-        let expectation = XCTestExpectation(description: "completion called")
-        plugin.launchUrl(url: "good://url", universalLinksOnly: false) { result in
-            switch result {
-            case .success(let success):
-                XCTAssertTrue(success)
-            case .failure(let error):
-                XCTFail("Unexpected error: \(error)")
-            }
-            expectation.fulfill()
-        }
-
-        wait(for: [expectation], timeout: 1)
-        XCTAssertEqual(launcher.passedOptions?[.universalLinksOnly] as? Bool, false)
+    wait(for: [expectation], timeout: 1)
+  }
+
+  func testLaunchWithoutUniversalLinks() {
+    let expectation = XCTestExpectation(description: "completion called")
+    plugin.launchUrl(url: "good://url", universalLinksOnly: false) { result in
+      switch result {
+      case .success(let success):
+        XCTAssertTrue(success)
+      case .failure(let error):
+        XCTFail("Unexpected error: \(error)")
+      }
+      expectation.fulfill()
     }
 
-    func testLaunchWithUniversalLinks() {
-        let expectation = XCTestExpectation(description: "completion called")
-        plugin.launchUrl(url: "good://url", universalLinksOnly: true) { result in
-            switch result {
-            case .success(let success):
-                XCTAssertTrue(success)
-            case .failure(let error):
-                XCTFail("Unexpected error: \(error)")
-            }
-            expectation.fulfill()
-        }
-
-        wait(for: [expectation], timeout: 1)
-        XCTAssertEqual(launcher.passedOptions?[.universalLinksOnly] as? Bool, true)
+    wait(for: [expectation], timeout: 1)
+    XCTAssertEqual(launcher.passedOptions?[.universalLinksOnly] as? Bool, false)
+  }
+
+  func testLaunchWithUniversalLinks() {
+    let expectation = XCTestExpectation(description: "completion called")
+    plugin.launchUrl(url: "good://url", universalLinksOnly: true) { result in
+      switch result {
+      case .success(let success):
+        XCTAssertTrue(success)
+      case .failure(let error):
+        XCTFail("Unexpected error: \(error)")
+      }
+      expectation.fulfill()
     }
 
+    wait(for: [expectation], timeout: 1)
+    XCTAssertEqual(launcher.passedOptions?[.universalLinksOnly] as? Bool, true)
+  }
+
 }
 
 class FakeLauncher: Launcher {
@@ -123,20 +123,27 @@ class FakeLauncher: Launcher {
     return url.scheme == "good"
   }
 
-  func openURL(_ url: URL, options: [UIApplication.OpenExternalURLOptionsKey: Any] = [:], completionHandler: ((Bool) -> Void)? = nil) {
+  func openURL(
+    _ url: URL, options: [UIApplication.OpenExternalURLOptionsKey: Any] = [:],
+    completionHandler: ((Bool) -> Void)? = nil
+  ) {
     self.passedOptions = options
     completionHandler?(url.scheme == "good")
   }
 }
 
 class FakeFlutterBinaryMessenger: NSObject, FlutterBinaryMessenger {
-    func send(onChannel channel: String, message: Data?) { }
+  func send(onChannel channel: String, message: Data?) {}
 
-    func send(onChannel channel: String, message: Data?, binaryReply callback: FlutterBinaryReply? = nil) { }
+  func send(
+    onChannel channel: String, message: Data?, binaryReply callback: FlutterBinaryReply? = nil
+  ) {}
 
-    func setMessageHandlerOnChannel(_ channel: String, binaryMessageHandler handler: FlutterBinaryMessageHandler? = nil) -> FlutterBinaryMessengerConnection {
-        123
-    }
+  func setMessageHandlerOnChannel(
+    _ channel: String, binaryMessageHandler handler: FlutterBinaryMessageHandler? = nil
+  ) -> FlutterBinaryMessengerConnection {
+    123
+  }
 
-    func cleanUpConnection(_ connection: FlutterBinaryMessengerConnection) { }
+  func cleanUpConnection(_ connection: FlutterBinaryMessengerConnection) {}
 }

packages/url_launcher/url_launcher_ios/example/ios/RunnerUITests/URLLauncherUITests.swift

@@ -5,33 +5,33 @@
 import XCTest
 
 class URLLauncherUITests: XCTestCase {
-    var app: XCUIApplication!
+  var app: XCUIApplication!
 
-    override func setUp() {
-        continueAfterFailure = false
+  override func setUp() {
+    continueAfterFailure = false
 
-        app = XCUIApplication()
-        app.launch()
-    }
+    app = XCUIApplication()
+    app.launch()
+  }
 
-    func testLaunch() {
-        let app = self.app!
+  func testLaunch() {
+    let app = self.app!
 
-        let buttonNames: [String] = [
-            "Launch in app", "Launch in app(JavaScript ON)", "Launch in app(DOM storage ON)",
-            "Launch a universal link in a native app, fallback to Safari.(Youtube)"
-        ]
-        for buttonName in buttonNames {
-            let button = app.buttons[buttonName]
-            XCTAssertTrue(button.waitForExistence(timeout: 30.0))
-            XCTAssertEqual(app.webViews.count, 0)
-            button.tap()
-            let webView = app.webViews.firstMatch
-            XCTAssertTrue(webView.waitForExistence(timeout: 30.0))
-            XCTAssertTrue(app.buttons["ForwardButton"].waitForExistence(timeout: 30.0))
-            XCTAssertTrue(app.buttons["Share"].exists)
-            XCTAssertTrue(app.buttons["OpenInSafariButton"].exists)
-            app.buttons["Done"].tap()
-        }
+    let buttonNames: [String] = [
+      "Launch in app", "Launch in app(JavaScript ON)", "Launch in app(DOM storage ON)",
+      "Launch a universal link in a native app, fallback to Safari.(Youtube)",
+    ]
+    for buttonName in buttonNames {
+      let button = app.buttons[buttonName]
+      XCTAssertTrue(button.waitForExistence(timeout: 30.0))
+      XCTAssertEqual(app.webViews.count, 0)
+      button.tap()
+      let webView = app.webViews.firstMatch
+      XCTAssertTrue(webView.waitForExistence(timeout: 30.0))
+      XCTAssertTrue(app.buttons["ForwardButton"].waitForExistence(timeout: 30.0))
+      XCTAssertTrue(app.buttons["Share"].exists)
+      XCTAssertTrue(app.buttons["OpenInSafariButton"].exists)
+      app.buttons["Done"].tap()
     }
+  }
 }

packages/url_launcher/url_launcher_ios/ios/Classes/Launcher.swift

@@ -3,16 +3,21 @@
 // found in the LICENSE file.
 
 protocol Launcher {
-    func canOpenURL(_ url: URL) -> Bool
-    func openURL(_ url: URL, options: [UIApplication.OpenExternalURLOptionsKey: Any], completionHandler completion: ((Bool) -> Void)?)
+  func canOpenURL(_ url: URL) -> Bool
+  func openURL(
+    _ url: URL, options: [UIApplication.OpenExternalURLOptionsKey: Any],
+    completionHandler completion: ((Bool) -> Void)?)
 }
 
 class UIApplicationLauncher: Launcher {
-    func canOpenURL(_ url: URL) -> Bool {
-        UIApplication.shared.canOpenURL(url)
-    }
-
-    func openURL(_ url: URL, options: [UIApplication.OpenExternalURLOptionsKey: Any], completionHandler completion: ((Bool) -> Void)?) {
-        UIApplication.shared.open(url, options: options, completionHandler: completion)
-    }
+  func canOpenURL(_ url: URL) -> Bool {
+    UIApplication.shared.canOpenURL(url)
+  }
+
+  func openURL(
+    _ url: URL, options: [UIApplication.OpenExternalURLOptionsKey: Any],
+    completionHandler completion: ((Bool) -> Void)?
+  ) {
+    UIApplication.shared.open(url, options: options, completionHandler: completion)
+  }
 }

packages/url_launcher/url_launcher_ios/ios/Classes/URLLaunchSession.swift

@@ -7,34 +7,38 @@ import SafariServices
 typealias OpenInSafariVCResponse = (Result<Bool, Error>) -> Void
 
 class URLLaunchSession: NSObject, SFSafariViewControllerDelegate {
-
-    private let completion: OpenInSafariVCResponse
-    private let url: URL
-    let safari: SFSafariViewController
-    var didFinish: (() -> Void)?
-
-    init(url: URL, completion: @escaping OpenInSafariVCResponse) {
-        self.url = url
-        self.completion = completion
-        self.safari = SFSafariViewController(url: url)
-        super.init()
-        self.safari.delegate = self
-    }
-
-    func safariViewController(_ controller: SFSafariViewController, didCompleteInitialLoad didLoadSuccessfully: Bool) {
-        if didLoadSuccessfully {
-            completion(Result.success(true))
-        } else {
-            completion(Result.failure(GeneralError(code: "Error", message: "Error while launching \(url)", details: nil)))
-        }
-    }
-
-    func safariViewControllerDidFinish(_ controller: SFSafariViewController) {
-        controller.dismiss(animated: true, completion: nil)
-        didFinish?()
-    }
-
-    func close() {
-        safariViewControllerDidFinish(safari)
+
+  private let completion: OpenInSafariVCResponse
+  private let url: URL
+  let safari: SFSafariViewController
+  var didFinish: (() -> Void)?
+
+  init(url: URL, completion: @escaping OpenInSafariVCResponse) {
+    self.url = url
+    self.completion = completion
+    self.safari = SFSafariViewController(url: url)
+    super.init()
+    self.safari.delegate = self
+  }
+
+  func safariViewController(
+    _ controller: SFSafariViewController, didCompleteInitialLoad didLoadSuccessfully: Bool
+  ) {
+    if didLoadSuccessfully {
+      completion(Result.success(true))
+    } else {
+      completion(
+        Result.failure(
+          GeneralError(code: "Error", message: "Error while launching \(url)", details: nil)))
     }
+  }
+
+  func safariViewControllerDidFinish(_ controller: SFSafariViewController) {
+    controller.dismiss(animated: true, completion: nil)
+    didFinish?()
+  }
+
+  func close() {
+    safariViewControllerDidFinish(safari)
+  }
 }