Update SwiftSoup from 2.7.5 to 2.13.6 (#25811)

* Update `SwiftSoup` from `2.7.5` to `2.13.6`

Removes the `'swiftsoup': found 4 file(s) which are unhandled` warning
emitted during `swift test`. Upstream dropped the four stray `Info*.plist`
files from the package's `Sources/` directory in 2.8.2, so any release past
our pin resolves it — this takes us to the latest, 2.13.6.

No breaking API changes across 2.8–2.13.6 (Swift 5.9+ floor, satisfied). Our
usage — `parse`, `parseBodyFragment`, `clean`, `Element`/`Elements`/`Comment`/
`Entities` — is unchanged.

* Fix Gutenberg upload processors under `SwiftSoup` 2.13.6

`SwiftSoup` 2.12+ serializes unchanged nodes from a cached slice of the
original source, so the `attr()` mutations the media upload processors
make on nested elements weren't reflected in the output — only the mutated
node is marked dirty, not its ancestors, so `body.html()` re-emitted stale
bytes and uploaded media kept their local `file://` URLs and temp IDs.

`GutenbergContentParser.html()` now replaces each top-level element with a
copy to force a fresh render of the mutated subtrees, while emitting the
surrounding comment/text nodes (Gutenberg block delimiters) from their
original bytes. Output is byte-for-byte identical to the previous behavior.
All Gutenberg upload processor tests pass on 2.13.6.

* Add `GutenbergContentParser` tests for its serialization contract

Extends the existing suite with the coverage the SwiftSoup 2.13.6 fix
relies on but that was missing. The prior element-mutation test only
mutates a top-level node, whose change survives serialization even with
the 2.12+ regression; the new tests mutate nested and deeply-nested
elements, which are the paths that actually broke.

Also pins the serialization contract that shifts across SwiftSoup
versions — void-element normalization, entity / raw-text / preformatted /
unicode fidelity, `html()` idempotence — and the malformed-JSON and
sorted-key attribute handling.

* Extract Gutenberg content processors into a `GutenbergProcessors` module

Moves the SwiftSoup-based Gutenberg code — `GutenbergContentParser`, the
`GutenbergProcessor` protocol, and the image/gallery/file upload
processors — out of the app target into a new `GutenbergProcessors`
module so its tests run under `swift test` on macOS instead of a full
iOS app build. The Aztec-based processors stay in the app; they depend on
UIKit and can't run cross-platform.

Wiring is entirely in Package.swift, no project changes: the module is
added to `keystoneDependencies` (how the app links it), a cross-platform
test target is added to the root package, and the target is registered in
the unit-test plan. `PostCoordinator` is the only consumer.

Runs via `swift test --filter GutenbergProcessorsTests`.

Author: jkmassel

Modules/Package.resolved

@@ -12,6 +12,7 @@ let package = Package(
         .library(name: "AsyncImageKit", targets: ["AsyncImageKit"]),
         .library(name: "DesignSystem", targets: ["DesignSystem"]),
         .library(name: "FormattableContentKit", targets: ["FormattableContentKit"]),
+        .library(name: "GutenbergProcessors", targets: ["GutenbergProcessors"]),
         .library(name: "JetpackStats", targets: ["JetpackStats"]),
         .library(name: "JetpackSocial", targets: ["JetpackSocial"]),
         .library(name: "JetpackStatsWidgetsCore", targets: ["JetpackStatsWidgetsCore"]),
@@ -46,7 +47,7 @@ let package = Package(
         .package(url: "https://github.com/erikdoe/ocmock", revision: "2c0bfd373289f4a7716db5d6db471640f91a6507"),
         .package(url: "https://github.com/johnxnguyen/Down", branch: "master"),
         .package(url: "https://github.com/kaishin/Gifu", from: "3.4.1"),
-        .package(url: "https://github.com/scinfu/SwiftSoup", exact: "2.7.5"),
+        .package(url: "https://github.com/scinfu/SwiftSoup", exact: "2.13.6"),
         .package(url: "https://github.com/squarefrog/UIDeviceIdentifier", from: "2.3.0"),
         // We can remove the SVProgressHUD fork once this PR is merged: https://github.com/SVProgressHUD/SVProgressHUD/pull/1131
         .package(url: "https://github.com/automattic/SVProgressHUD", branch: "master"),
@@ -334,6 +335,11 @@ let package = Package(
                 .enableUpcomingFeature("BareSlashRegexLiterals")
             ]
         ),
+        .target(
+            name: "GutenbergProcessors",
+            dependencies: [.product(name: "SwiftSoup", package: "SwiftSoup")],
+            swiftSettings: [.swiftLanguageMode(.v5)]
+        ),
         .target(
             name: "WordPressReader",
             dependencies: [
@@ -400,6 +406,14 @@ let package = Package(
         ),
         .testTarget(name: "WordPressCoreTests", dependencies: [.target(name: "WordPressCore")]),
         .testTarget(name: "WordPressIntelligenceTests", dependencies: [.target(name: "WordPressIntelligence")]),
+        .testTarget(
+            name: "GutenbergProcessorsTests",
+            dependencies: [
+                .target(name: "GutenbergProcessors"),
+                .product(name: "SwiftSoup", package: "SwiftSoup")
+            ],
+            swiftSettings: [.swiftLanguageMode(.v5)]
+        ),
         .testTarget(name: "WordPressReaderTests", dependencies: [.target(name: "WordPressReader")]),
         .testTarget(
             name: "JetpackSocialTests",
@@ -484,6 +498,7 @@ enum XcodeSupport {
             "DesignSystem",
             "BuildSettingsKit",
             "FormattableContentKit",
+            "GutenbergProcessors",
             "JetpackSocial",
             "JetpackStats",
             "JetpackStatsWidgetsCore",

Modules/Package.swift

@@ -10,9 +10,9 @@ public class GutenbergParsedBlock {
 
     public var attributes: [String: Any] {
         get {
-            guard let data = self.attributesData.data(using: .utf8 ),
-                  let jsonObject = try? JSONSerialization.jsonObject(with: data, options: .allowFragments),
-                  let attributes = jsonObject as? [String: Any]
+            guard let data = self.attributesData.data(using: .utf8),
+                let jsonObject = try? JSONSerialization.jsonObject(with: data, options: .allowFragments),
+                let attributes = jsonObject as? [String: Any]
             else {
                 return [:]
             }
@@ -21,7 +21,8 @@ public class GutenbergParsedBlock {
 
         set(newValue) {
             guard let data = try? JSONSerialization.data(withJSONObject: newValue, options: .sortedKeys),
-                  let attributes = String(data: data, encoding: .utf8) else {
+                let attributes = String(data: data, encoding: .utf8)
+            else {
                 return
             }
             self.attributesData = attributes
@@ -44,8 +45,7 @@ public class GutenbergParsedBlock {
         if let separatorRange = data.range(of: " ") {
             self.name = String(data[data.startIndex..<separatorRange.lowerBound])
             self.attributesData = String(data[separatorRange.upperBound..<data.endIndex])
-        }
-        else {
+        } else {
             self.name = data
             self.attributesData = ""
         }
@@ -114,7 +114,8 @@ public class GutenbergContentParser {
     private let htmlDocument: Document?
 
     public init(for content: String) {
-        self.htmlDocument = try? SwiftSoup.parseBodyFragment(content).outputSettings(OutputSettings().prettyPrint(pretty: false))
+        self.htmlDocument = try? SwiftSoup.parseBodyFragment(content)
+            .outputSettings(OutputSettings().prettyPrint(pretty: false))
         self.blocks = []
 
         guard let htmlContent = self.htmlDocument?.body() else {
@@ -124,37 +125,53 @@ public class GutenbergContentParser {
     }
 
     public func html() -> String {
-        return (try? self.htmlDocument?.body()?.html()) ?? ""
+        guard let body = self.htmlDocument?.body() else {
+            return ""
+        }
+        // SwiftSoup 2.12+ serializes unchanged nodes from a cached copy of the
+        // original source, so the attribute mutations the processors make on
+        // nested elements aren't reflected in the output. Replacing each
+        // top-level element with a copy marks its subtree dirty and forces a
+        // re-render, while the surrounding comment and text nodes (the Gutenberg
+        // block delimiters) are emitted from their original bytes.
+        for element in body.children().array() {
+            guard let clone = try? element.copy() as? Element else {
+                continue
+            }
+            try? element.replaceWith(clone)
+        }
+        return (try? body.html()) ?? ""
     }
 
     private func traverseChildNodes(element: Element, parentBlock: GutenbergParsedBlock? = nil) {
         var currentBlock: GutenbergParsedBlock?
-        element.getChildNodes().forEach { node in
-            switch node {
-            // Convert comment tag into block
-            case let comment as SwiftSoup.Comment:
-                guard let block = GutenbergParsedBlock(comment: comment, parentBlock: parentBlock) else {
-                    return
-                }
+        element.getChildNodes()
+            .forEach { node in
+                switch node {
+                // Convert comment tag into block
+                case let comment as SwiftSoup.Comment:
+                    guard let block = GutenbergParsedBlock(comment: comment, parentBlock: parentBlock) else {
+                        return
+                    }
 
-                // Identify close tag
-                if let currrentBlock = currentBlock, block.name == "/\(currrentBlock.name)" {
-                    currentBlock = nil
-                    return
-                }
+                    // Identify close tag
+                    if let currrentBlock = currentBlock, block.name == "/\(currrentBlock.name)" {
+                        currentBlock = nil
+                        return
+                    }
 
-                self.blocks.append(block)
-                currentBlock = block
-            // Insert HTML elements into block being processed
-            case let element as SwiftSoup.Element:
-                if let currentBlock {
-                    currentBlock.elements.add(element)
+                    self.blocks.append(block)
+                    currentBlock = block
+                // Insert HTML elements into block being processed
+                case let element as SwiftSoup.Element:
+                    if let currentBlock {
+                        currentBlock.elements.add(element)
+                    }
+                    if element.childNodeSize() > 0 {
+                        traverseChildNodes(element: element, parentBlock: currentBlock ?? parentBlock)
+                    }
+                default: break
                 }
-                if element.childNodeSize() > 0 {
-                    traverseChildNodes(element: element, parentBlock: currentBlock ?? parentBlock)
-                }
-            default: break
             }
-        }
     }
 }

…/Processors/GutenbergContentParser.swift …gProcessors/GutenbergContentParser.swiftWordPress/Classes/ViewRelated/Gutenberg/Processors/GutenbergContentParser.swift renamed to Modules/Sources/GutenbergProcessors/GutenbergContentParser.swift WordPress/Classes/ViewRelated/Gutenberg/Processors/GutenbergContentParser.swift renamed to Modules/Sources/GutenbergProcessors/GutenbergContentParser.swift

@@ -1,6 +1,6 @@
 import Foundation
 
-class GutenbergFileUploadProcessor: GutenbergProcessor {
+public class GutenbergFileUploadProcessor: GutenbergProcessor {
     private struct FileBlockKeys {
         static var name = "wp:file"
         static var id = "id"
@@ -11,7 +11,7 @@ class GutenbergFileUploadProcessor: GutenbergProcessor {
     let remoteURLString: String
     let serverMediaID: Int
 
-    init(mediaUploadID: Int32, serverMediaID: Int, remoteURLString: String) {
+    public init(mediaUploadID: Int32, serverMediaID: Int, remoteURLString: String) {
         self.mediaUploadID = mediaUploadID
         self.serverMediaID = serverMediaID
         self.remoteURLString = remoteURLString
@@ -34,7 +34,7 @@ class GutenbergFileUploadProcessor: GutenbergProcessor {
         }
     }
 
-    func process(_ blocks: [GutenbergParsedBlock]) {
+    public func process(_ blocks: [GutenbergParsedBlock]) {
         processFileBlocks(blocks)
     }
 }

…ssors/GutenbergFileUploadProcessor.swift …ssors/GutenbergFileUploadProcessor.swiftWordPress/Classes/ViewRelated/Gutenberg/Processors/GutenbergFileUploadProcessor.swift renamed to Modules/Sources/GutenbergProcessors/GutenbergFileUploadProcessor.swift WordPress/Classes/ViewRelated/Gutenberg/Processors/GutenbergFileUploadProcessor.swift renamed to Modules/Sources/GutenbergProcessors/GutenbergFileUploadProcessor.swift

@@ -1,7 +1,7 @@
 import Foundation
 import SwiftSoup
 
-class GutenbergGalleryUploadProcessor: GutenbergProcessor {
+public class GutenbergGalleryUploadProcessor: GutenbergProcessor {
 
     let mediaUploadID: Int32
     let remoteURLString: String
@@ -12,7 +12,7 @@ class GutenbergGalleryUploadProcessor: GutenbergProcessor {
 
     static let imgClassIDPrefixAttribute = "wp-image-"
 
-    init(mediaUploadID: Int32, serverMediaID: Int, remoteURLString: String, mediaLink: String) {
+    public init(mediaUploadID: Int32, serverMediaID: Int, remoteURLString: String, mediaLink: String) {
         self.mediaUploadID = mediaUploadID
         self.serverMediaID = serverMediaID
         self.remoteURLString = remoteURLString
@@ -139,7 +139,7 @@ class GutenbergGalleryUploadProcessor: GutenbergProcessor {
         }
     }
 
-    func process(_ blocks: [GutenbergParsedBlock]) {
+    public func process(_ blocks: [GutenbergParsedBlock]) {
         processGalleryBlocks(blocks)
     }
 }

…rs/GutenbergGalleryUploadProcessor.swift …rs/GutenbergGalleryUploadProcessor.swiftWordPress/Classes/ViewRelated/Gutenberg/Processors/GutenbergGalleryUploadProcessor.swift renamed to Modules/Sources/GutenbergProcessors/GutenbergGalleryUploadProcessor.swift WordPress/Classes/ViewRelated/Gutenberg/Processors/GutenbergGalleryUploadProcessor.swift renamed to Modules/Sources/GutenbergProcessors/GutenbergGalleryUploadProcessor.swift

@@ -1,13 +1,13 @@
 import Foundation
 
-class GutenbergImgUploadProcessor: GutenbergProcessor {
+public class GutenbergImgUploadProcessor: GutenbergProcessor {
 
     let mediaUploadID: Int32
     let remoteURLString: String
     let serverMediaID: Int
     static let imgClassIDPrefixAttribute = "wp-image-"
 
-    init(mediaUploadID: Int32, serverMediaID: Int, remoteURLString: String) {
+    public init(mediaUploadID: Int32, serverMediaID: Int, remoteURLString: String) {
         self.mediaUploadID = mediaUploadID
         self.serverMediaID = serverMediaID
         self.remoteURLString = remoteURLString
@@ -63,7 +63,7 @@ class GutenbergImgUploadProcessor: GutenbergProcessor {
         }
     }
 
-    func process(_ blocks: [GutenbergParsedBlock]) {
+    public func process(_ blocks: [GutenbergParsedBlock]) {
         processImageBlocks(blocks)
         processMediaTextBlocks(blocks)
     }