Decouple swiftsoup from the library

Author: jkmassel

Package.swift

@@ -15,19 +15,35 @@ let package = Package(
     targets: [
         .target(
             name: "GutenbergKit",
-            dependencies: ["SwiftSoup"],
+            dependencies: [],
             path: "ios/Sources/GutenbergKit",
             exclude: [],
             resources: [.copy("Gutenberg")]
         ),
+        .target(
+            name: "SwiftSoupAssetManifestParser",
+            dependencies: ["GutenbergKit", "SwiftSoup"],
+            path: "ios/Sources/SwiftSoupAssetManifestParser",
+            exclude: [],
+            resources: []
+        ),
         .testTarget(
             name: "GutenbergKitTests",
             dependencies: ["GutenbergKit"],
-            path: "ios/Tests",
+            path: "ios/Tests/GutenbergKitTests",
             exclude: [],
             resources: [
-                .copy("GutenbergKitTests/Resources/manifest-test-case-1.json")
+                .copy("Resources/manifest-test-case-1.json")
             ]
         ),
+        .testTarget(
+            name: "SwiftSoupAssetManifestParserTests",
+            dependencies: ["SwiftSoupAssetManifestParser"],
+            path: "ios/Tests/SwiftSoupAssetManifestParserTests",
+            exclude: [],
+            resources: [
+                .copy("../GutenbergKitTests/Resources/manifest-test-case-1.json")
+            ]
+        )
     ]
 )

ios/Sources/GutenbergKit/Sources/Cache/CachedAssetSchemeHandler.swift

@@ -16,11 +16,14 @@ class CachedAssetSchemeHandler: NSObject, WKURLSchemeHandler {
         return components.url
     }
 
-    nonisolated static func cachedURL(forWebLink link: String) -> String? {
-        if link.starts(with: "http://") || link.starts(with: "https://") {
-            return cachedURLSchemePrefix + link
+    nonisolated static func cachedURL(for url: URL) -> URL {
+        if url.scheme == "http" || url.scheme == "https" {
+            var components = URLComponents(string: url.absoluteString)!
+            components.scheme = cachedURLSchemePrefix + (url.scheme ?? "")
+            return components.url!
         }
-        return nil
+
+        return url
     }
 
     let worker: Worker
@@ -105,4 +108,3 @@ class CachedAssetSchemeHandler: NSObject, WKURLSchemeHandler {
         }
     }
 }
-

ios/Sources/GutenbergKit/Sources/Cache/EditorAssetsLibrary.swift

@@ -1,11 +1,11 @@
 import Foundation
 import CryptoKit
-import SwiftSoup
 
 public actor EditorAssetsLibrary {
     enum ManifestError: Error {
         case unavailable
         case invalidServerResponse
+        case invalidSiteUrl
     }
 
     let urlSession: URLSession
@@ -45,46 +45,46 @@ public actor EditorAssetsLibrary {
     ///
     /// - SeeAlso: `CachedAssetSchemeHandler`
     /// - SeeAlso: `EditorAssetsLibrary.addAsset`
-    func manifestContentForEditor() async throws -> Data {
+    func manifestContentForEditor(using parser: EditorAssetManifestParser) async throws -> Data {
         // For scheme-less links (i.e. '//stats.wp.com/w.js'), use the scheme in `siteURL`.
-        let siteURLScheme = URL(string: configuration.siteURL)?.scheme
+        guard let siteURLScheme = URL(string: configuration.siteURL)?.scheme else {
+            throw ManifestError.invalidSiteUrl
+        }
+
         let data = try await loadManifestContent()
-        let manifest = try JSONDecoder().decode(EditorAssetsMainifest.self, from: data)
-        return try manifest.renderForEditor(defaultScheme: siteURLScheme)
+        let manifest = try EditorAssetManifest(data: data)
+
+        return try JSONEncoder().encode(manifest.applyingUrlScheme(siteURLScheme, using: parser))
     }
 
     /// Fetches all assets in the `EditorConfiguration.editorAssetsEndpoint` manifest and stores them on the device.
     ///
     /// - SeeAlso: CachedAssetSchemeHandler
-    public func fetchAssets() async throws {
+    public func fetchAssets(using manifestParser: EditorAssetManifestParser) async throws {
         // For scheme-less links (i.e. '//stats.wp.com/w.js'), use the scheme in `siteURL`.
         let siteURLScheme = URL(string: configuration.siteURL)?.scheme
 
         let data = try await loadManifestContent()
-        let manifest = try JSONDecoder().decode(EditorAssetsMainifest.self, from: data)
-        let assetLinks = try manifest.parseAssetLinks(defaultScheme: siteURLScheme)
-
-        for link in assetLinks {
-            guard let url = URL(string: link) else {
-                NSLog("Malformed asset link: \(link)")
-                continue
-            }
+        let manifest = try EditorAssetManifest(data: data).applyingUrlScheme(siteURLScheme, using: manifestParser)
+        let assetUrls = try manifest.getAllAssetUrls(using: manifestParser)
 
+        for url in assetUrls {
             guard url.scheme == "http" || url.scheme == "https" else {
-                NSLog("Unexpected asset link: \(link)")
+                NSLog("Unexpected asset link: \(url)")
                 continue
             }
 
-            _ = try await cacheAsset(from: url)
+            try await cacheAsset(from: url)
         }
-        NSLog("\(assetLinks.count) resources processed.")
+        NSLog("\(assetUrls.count) resources processed.")
     }
 
     /// Fetches one asset (JavaScript or stylesheet) and caches its content on the device.
     ///
     /// - Parameters:
     ///   - httpURL: The javascript or css URL.
     ///   - webViewURL: The corresponding URL requested by web view, which should the "GBK cache prefix" (`gbk-cache-https://`)
+    @discardableResult
     func cacheAsset(from httpURL: URL, webViewURL: URL? = nil) async throws -> (URLResponse, Data) {
         // The Web Inspector automatically requests ".js.map" files, we'll support it here for debugging purpose.
         let supportedResourceSuffixes = [".js", ".css", ".js.map"]
@@ -191,97 +191,107 @@ private extension String {
     }
 }
 
-struct EditorAssetsMainifest: Codable {
-    var scripts: String
-    var styles: String
-    var allowedBlockTypes: [String]
+public struct EditorAssetSchemeResolver {
+
+    // Takes a URL string and applies the given scheme to it.
+    //
+    // If there is no scheme present, the `defaultScheme` will be applied to it. If no `defaultScheme` is
+    // provided, `https` will be used.
+    public static func resolveSchemeFor(_ link: String, defaultScheme: String?) -> String {
+        if link.starts(with: "//") {
+            return "\(defaultScheme ?? "https"):\(link)"
+        }
+
+        return link
+    }
+}
+
+
+// An object representing the JSON response we receive from the server
+//
+public struct EditorAssetManifest: Codable {
+    public let scripts: String
+    public let styles: String
+    public let allowedBlockTypes: [String]
 
     enum CodingKeys: String, CodingKey {
         case scripts
         case styles
         case allowedBlockTypes = "allowed_block_types"
     }
 
-    func parseAssetLinks(defaultScheme: String?) throws -> [String] {
-        let html = """
-            <html>
-                <head>
-                \(scripts)
-                \(styles)
-                </head>
-                <body></body>
-            </html>
-            """
-        let document = try SwiftSoup.parse(html)
-
-        var assetLinks: [String] = []
-        assetLinks += try document.select("script[src]").map {
-            Self.resolveAssetLink(try $0.attr("src"), defaultScheme: defaultScheme)
-        }
-        assetLinks += try document.select(#"link[rel="stylesheet"][href]"#).map {
-            Self.resolveAssetLink(try $0.attr("href"), defaultScheme: defaultScheme)
-        }
-        return assetLinks
+    init(data: Data) throws {
+        self = try JSONDecoder().decode(EditorAssetManifest.self, from: data)
     }
 
-    func renderForEditor(defaultScheme: String?) throws -> Data {
-        var rendered = self
-        rendered.scripts = try Self.renderForEditor(scripts: self.scripts, defaultScheme: defaultScheme)
-        rendered.styles = try Self.renderForEditor(styles: self.styles, defaultScheme: defaultScheme)
-        return try JSONEncoder().encode(rendered)
+    init(scripts: String, styles: String, allowedBlockTypes: [String]) {
+        self.scripts = scripts
+        self.styles = styles
+        self.allowedBlockTypes = allowedBlockTypes
     }
 
-    private static func renderForEditor(scripts: String, defaultScheme: String?) throws -> String {
-        let html = """
-            <html>
-                <head>
-                \(scripts)
-                </head>
-                <body></body>
-            </html>
-            """
-        let document = try SwiftSoup.parse(html)
-
-        for script in try document.select("script[src]") {
-            if let src = try? script.attr("src") {
-                let link = Self.resolveAssetLink(src, defaultScheme: defaultScheme)
-                let newLink = CachedAssetSchemeHandler.cachedURL(forWebLink: link) ?? link
-                try script.attr("src", newLink)
-            }
-        }
+    func getScriptUrlStrings(using parser: EditorAssetManifestParser) throws -> [String] {
+        try parser.extractScriptURLs(from: self.scripts)
+    }
 
-        let head = document.head()!
-        return try head.html()
+    func getScriptUrls(using parser: EditorAssetManifestParser) throws -> [URL] {
+        try getScriptUrlStrings(using: parser).compactMap(URL.init)
     }
 
-    private static func renderForEditor(styles: String, defaultScheme: String?) throws -> String {
-        let html = """
-            <html>
-                <head>
-                \(styles)
-                </head>
-                <body></body>
-            </html>
-            """
-        let document = try SwiftSoup.parse(html)
-
-        for stylesheet in try document.select(#"link[rel="stylesheet"][href]"#) {
-            if let href = try? stylesheet.attr("href") {
-                let link = Self.resolveAssetLink(href, defaultScheme: defaultScheme)
-                let newLink = CachedAssetSchemeHandler.cachedURL(forWebLink: link) ?? link
-                try stylesheet.attr("href", newLink)
-            }
+    func getStyleUrlStrings(using parser: EditorAssetManifestParser) throws -> [String] {
+        try parser.extractStyleURLs(from: self.styles)
+    }
+
+    func getStyleUrls(using parser: EditorAssetManifestParser) throws -> [URL] {
+        try getStyleUrlStrings(using: parser).compactMap(URL.init)
+    }
+
+    func getAllAssetUrls(applyingDefaultScheme scheme: String? = nil, using parser: EditorAssetManifestParser) throws -> [URL] {
+        let scriptUrls = try self.getScriptUrls(using: parser)
+        let styleUrls = try self.getStyleUrls(using: parser)
+
+        return scriptUrls + styleUrls
+    }
+
+    func applyingUrlScheme(_ newScheme: String?, using manifestParser: EditorAssetManifestParser) throws -> Self {
+        var mutableStyles = self.styles
+        var mutableScripts = self.scripts
+
+        for rawLink in try getStyleUrlStrings(using: manifestParser) {
+            let resolvedLink = EditorAssetSchemeResolver.resolveSchemeFor(rawLink, defaultScheme: newScheme)
+            mutableStyles = mutableStyles.replacingOccurrences(of: rawLink, with: resolvedLink)
+        }
+
+        for rawLink in try getScriptUrlStrings(using: manifestParser) {
+            let resolvedLink = EditorAssetSchemeResolver.resolveSchemeFor(rawLink, defaultScheme: newScheme)
+            mutableScripts = mutableScripts.replacingOccurrences(of: rawLink, with: resolvedLink)
         }
 
-        let head = document.head()!
-        return try head.html()
+        return EditorAssetManifest(
+            scripts: mutableScripts,
+            styles: mutableStyles,
+            allowedBlockTypes: self.allowedBlockTypes
+        )
     }
 
-    private static func resolveAssetLink(_ link: String, defaultScheme: String?) -> String {
-        if link.starts(with: "//") {
-            return "\(defaultScheme ?? "https"):\(link)"
+    func resolvingCachedUrls(using manifestParser: EditorAssetManifestParser) throws -> Self {
+        var mutableStyles = self.styles
+        var mutableScripts = self.scripts
+
+        for url in try getStyleUrls(using: manifestParser) {
+            let cachedLink = CachedAssetSchemeHandler.cachedURL(for: url)
+            mutableStyles = mutableStyles.replacingOccurrences(of: url.absoluteString, with: cachedLink.absoluteString)
         }
 
-        return link
+        for url in try getScriptUrls(using: manifestParser) {
+            let cachedLink = CachedAssetSchemeHandler.cachedURL(for: url)
+            mutableScripts = mutableScripts.replacingOccurrences(of: url.absoluteString, with: cachedLink.absoluteString)
+        }
+
+        return EditorAssetManifest(
+            scripts: mutableScripts,
+            styles: mutableStyles,
+            allowedBlockTypes: self.allowedBlockTypes
+        )
     }
 }

ios/Sources/GutenbergKit/Sources/Cache/EditorAssetsProvider.swift

@@ -3,9 +3,11 @@ import WebKit
 
 class EditorAssetsProvider: NSObject, WKScriptMessageHandlerWithReply {
     let library: EditorAssetsLibrary
+    let manifestParser: EditorAssetManifestParser
 
-    init(library: EditorAssetsLibrary) {
+    init(library: EditorAssetsLibrary, manifestParser: EditorAssetManifestParser) {
         self.library = library
+        self.manifestParser = manifestParser
     }
 
     func userContentController(_ userContentController: WKUserContentController, didReceive message: WKScriptMessage, replyHandler: @escaping @MainActor @Sendable (Any?, String?) -> Void) {
@@ -19,7 +21,7 @@ class EditorAssetsProvider: NSObject, WKScriptMessageHandlerWithReply {
 
         Task.detached { [library] in
             do {
-                let data = try await library.manifestContentForEditor()
+                let data = try await library.manifestContentForEditor(using: self.manifestParser)
                 let dict = try JSONSerialization.jsonObject(with: data)
                 await replyHandler(dict, nil)
             } catch {

ios/Sources/GutenbergKit/Sources/EditorViewController+AssetManifest.swift

@@ -0,0 +1,17 @@
+import Foundation
+import OSLog
+
+extension EditorViewController {
+    func getAssetManifestParser() -> EditorAssetManifestParser {
+        if let parser = self.assetManifestParser {
+            return parser
+        }
+
+        if #available(iOS 16.0, *) {
+            Logger.gbkit.warning("Warning: using the default `AssetManifestParser` – this is not recommended. You can use the included `SwiftSoupAssetManifestParser` or create your own.")
+            return DefaultEditorAssetManifestParser()
+        } else {
+            preconditionFailure("You must provide an implementation of `EditorAssetManifestParser`. You can use the included `SwiftSoupAssetManifestParser` or create your own.")
+        }
+    }
+}

ios/Sources/GutenbergKit/Sources/EditorViewController.swift

@@ -19,6 +19,8 @@ public final class EditorViewController: UIViewController, GutenbergEditorContro
 
     public weak var delegate: EditorViewControllerDelegate?
 
+    public var assetManifestParser: EditorAssetManifestParser?
+
     private var cancellables: [AnyCancellable] = []
 
     /// Warmup mode preloads resources into memory to make the UI transition seamless when displaying the editor for the first time
@@ -123,7 +125,7 @@ public final class EditorViewController: UIViewController, GutenbergEditorContro
     private func loadEditor() {
         if configuration.plugins {
             webView.configuration.userContentController.addScriptMessageHandler(
-                EditorAssetsProvider(library: assetsLibrary),
+                EditorAssetsProvider(library: assetsLibrary, manifestParser: self.getAssetManifestParser()),
                 contentWorld: .page,
                 name: "loadFetchedEditorAssets"
             )

ios/Sources/GutenbergKit/Sources/Logger.swift

@@ -0,0 +1,9 @@
+import Foundation
+
+#if canImport(OSLog)
+import OSLog
+
+extension Logger {
+    static let gbkit = Logger(subsystem: "org.wordpress.gutenberg", category: "all")
+}
+#endif