Merge pull request #371 from macdrevx/fix-nbsp-escape-fast-path

Fix nbsp not escaped when it's the only special character

Author: aehlke

Sources/Entities.swift

@@ -601,6 +601,12 @@ public final class Entities: Sendable {
                 if memchr(base, Int32(TokeniserStateVars.ampersandByte), len) != nil {
                     return true
                 }
+                if let nbspLead = memchr(base, Int32(StringUtil.utf8NBSPLead), len) {
+                    let idx = base.distance(to: nbspLead.assumingMemoryBound(to: UInt8.self))
+                    if idx + 1 < len, base[idx + 1] == StringUtil.utf8NBSPTrail {
+                        return true
+                    }
+                }
                 if inAttribute {
                     if escapeMode == .xhtml,
                        memchr(base, Int32(TokeniserStateVars.lessThanByte), len) != nil {
@@ -634,6 +640,12 @@ public final class Entities: Sendable {
                 if memchr(base, Int32(TokeniserStateVars.ampersandByte), len) != nil {
                     return true
                 }
+                if let nbspLead = memchr(base, Int32(StringUtil.utf8NBSPLead), len) {
+                    let idx = base.distance(to: nbspLead.assumingMemoryBound(to: UInt8.self))
+                    if idx + 1 < len, base[idx + 1] == StringUtil.utf8NBSPTrail {
+                        return true
+                    }
+                }
                 if inAttribute {
                     if escapeMode == .xhtml,
                        memchr(base, Int32(TokeniserStateVars.lessThanByte), len) != nil {
@@ -662,11 +674,18 @@ public final class Entities: Sendable {
            count > 0 {
             var needsEscape = false
             var sawWhitespace = false
-            for b in string {
+            for i in string.indices {
+                let b = string[i]
                 if encoderIsAscii && b >= asciiUpperLimitByte {
                     needsEscape = true
                     break
                 }
+                if b == StringUtil.utf8NBSPLead,
+                   i + 1 < string.endIndex,
+                   string[i + 1] == StringUtil.utf8NBSPTrail {
+                    needsEscape = true
+                    break
+                }
                 if normaliseWhite && b.isWhitespace {
                     sawWhitespace = true
                     break
@@ -843,6 +862,12 @@ public final class Entities: Sendable {
                 if memchr(base, Int32(TokeniserStateVars.ampersandByte), len) != nil {
                     return true
                 }
+                if let nbspLead = memchr(base, Int32(StringUtil.utf8NBSPLead), len) {
+                    let idx = base.distance(to: nbspLead.assumingMemoryBound(to: UInt8.self))
+                    if idx + 1 < len, base[idx + 1] == StringUtil.utf8NBSPTrail {
+                        return true
+                    }
+                }
                 if inAttribute {
                     if escapeMode == .xhtml,
                        memchr(base, Int32(TokeniserStateVars.lessThanByte), len) != nil {
@@ -876,6 +901,12 @@ public final class Entities: Sendable {
                 if memchr(base, Int32(TokeniserStateVars.ampersandByte), len) != nil {
                     return true
                 }
+                if let nbspLead = memchr(base, Int32(StringUtil.utf8NBSPLead), len) {
+                    let idx = base.distance(to: nbspLead.assumingMemoryBound(to: UInt8.self))
+                    if idx + 1 < len, base[idx + 1] == StringUtil.utf8NBSPTrail {
+                        return true
+                    }
+                }
                 if inAttribute {
                     if escapeMode == .xhtml,
                        memchr(base, Int32(TokeniserStateVars.lessThanByte), len) != nil {
@@ -904,11 +935,18 @@ public final class Entities: Sendable {
            count > 0 {
             var needsEscape = false
             var sawWhitespace = false
-            for b in string {
+            for i in string.indices {
+                let b = string[i]
                 if encoderIsAscii && b >= asciiUpperLimitByte {
                     needsEscape = true
                     break
                 }
+                if b == StringUtil.utf8NBSPLead,
+                   string.index(after: i) < string.endIndex,
+                   string[string.index(after: i)] == StringUtil.utf8NBSPTrail {
+                    needsEscape = true
+                    break
+                }
                 if normaliseWhite && b.isWhitespace {
                     sawWhitespace = true
                     break
@@ -1084,6 +1122,12 @@ public final class Entities: Sendable {
                 if memchr(base, Int32(TokeniserStateVars.ampersandByte), len) != nil {
                     return true
                 }
+                if let nbspLead = memchr(base, Int32(StringUtil.utf8NBSPLead), len) {
+                    let idx = base.distance(to: nbspLead.assumingMemoryBound(to: UInt8.self))
+                    if idx + 1 < len, base[idx + 1] == StringUtil.utf8NBSPTrail {
+                        return true
+                    }
+                }
                 if inAttribute {
                     if escapeMode == .xhtml,
                        memchr(base, Int32(TokeniserStateVars.lessThanByte), len) != nil {
@@ -1117,6 +1161,12 @@ public final class Entities: Sendable {
                 if memchr(base, Int32(TokeniserStateVars.ampersandByte), len) != nil {
                     return true
                 }
+                if let nbspLead = memchr(base, Int32(StringUtil.utf8NBSPLead), len) {
+                    let idx = base.distance(to: nbspLead.assumingMemoryBound(to: UInt8.self))
+                    if idx + 1 < len, base[idx + 1] == StringUtil.utf8NBSPTrail {
+                        return true
+                    }
+                }
                 if inAttribute {
                     if escapeMode == .xhtml,
                        memchr(base, Int32(TokeniserStateVars.lessThanByte), len) != nil {

Tests/SwiftSoupTests/EntitiesTest.swift

@@ -141,4 +141,43 @@ class EntitiesTest: XCTestCase {
 		doc.outputSettings().escapeMode(Entities.EscapeMode.xhtml)
 		XCTAssertEqual("<a title=\"&lt;p>One&lt;/p>\">One</a>", try  element.outerHtml())
 	}
+
+	func testNbspEscapedWhenOnlySpecialChar() {
+		// When nbsp is the only special character present, the fast-path needsEscape
+		// check must still detect it and escape it (not output raw U+00A0 bytes).
+		let text = "hello\u{A0}world"
+
+		// Default: UTF-8, extended mode → &nbsp;
+		XCTAssertEqual("hello&nbsp;world", Entities.escape(text))
+
+		// Base mode, UTF-8 → &nbsp;
+		let base = OutputSettings().charset(.utf8).escapeMode(Entities.EscapeMode.base)
+		XCTAssertEqual("hello&nbsp;world", Entities.escape(text, base))
+
+		// XHTML mode, UTF-8 → &#xa0;
+		let xhtml = OutputSettings().charset(.utf8).escapeMode(Entities.EscapeMode.xhtml)
+		XCTAssertEqual("hello&#xa0;world", Entities.escape(text, xhtml))
+
+		// ASCII charset → should also escape
+		let ascii = OutputSettings().charset(.ascii).escapeMode(Entities.EscapeMode.base)
+		XCTAssertEqual("hello&nbsp;world", Entities.escape(text, ascii))
+	}
+
+	func testNbspPreservedThroughParseAndSerialize() throws {
+		// Round-trip: parse HTML containing &nbsp;, then serialize back.
+		// The output must contain the &nbsp; entity, not raw U+00A0 bytes.
+		let html = "<p>hello&nbsp;world</p>"
+		let doc = try SwiftSoup.parse(html)
+		let p = try doc.select("p").first()!
+		let output = try p.html()
+
+		XCTAssertEqual("hello&nbsp;world", output)
+		XCTAssertFalse(output.contains("\u{A0}"), "Output should not contain raw U+00A0")
+	}
+
+	func testMultipleNbspEscaped() {
+		// Multiple nbsp characters, no other special chars
+		let text = "a\u{A0}b\u{A0}c"
+		XCTAssertEqual("a&nbsp;b&nbsp;c", Entities.escape(text))
+	}
 }