fix: Unicode-aware word boundaries in word replacements - #855

// Repro + regression harness for VoiceInk issue #756
// Mirrors WordReplacementService.applyReplacements' boundary-regex path verbatim.
// Run: swift word_replacement_boundary_check.swift
import Foundation

// Boundary classes under test
let asciiClass = "[a-zA-Z0-9]" // current production (line 43)
let unicodeClass = "[[\\p{L}\\p{M}\\p{N}]-[\\p{scx=Han}\\p{scx=Hiragana}\\p{scx=Katakana}\\p{scx=Hangul}\\p{scx=Thai}]]" // proposed fix

// Verbatim copy of the service's boundary-path replacement (case-insensitive lookarounds)
func replace(_ text: String, trigger: String, with replacementText: String, wordChar: String) -> String {
    let escaped = NSRegularExpression.escapedPattern(for: trigger)
    let pattern = "(?<!\(wordChar))\(escaped)(?!\(wordChar))"
    guard let regex = try? NSRegularExpression(pattern: pattern, options: .caseInsensitive) else {
        fatalError("pattern failed to compile: \(pattern)")
    }
    let range = NSRange(text.startIndex..., in: text)
    return regex.stringByReplacingMatches(in: text, options: [], range: range, withTemplate: replacementText)
}

struct Case {
    let name: String
    let text: String
    let trigger: String
    let replacement: String
    let expected: String   // correct behavior (what the fix must produce)
    let oldIsBroken: Bool  // does the current ASCII class get this wrong?
}

let cases: [Case] = [
    // The reported bug (#756): ß treated as a boundary corrupts vergrößern
    Case(name: "german ß interior", text: "vergrößern", trigger: "ERN", replacement: "EAN",
         expected: "vergrößern", oldIsBroken: true),
    // Accented Latin
    Case(name: "accented é interior", text: "café", trigger: "caf", replacement: "X",
         expected: "café", oldIsBroken: true),
    // Cyrillic
    Case(name: "cyrillic interior", text: "котёнок", trigger: "кот", replacement: "СОБАКА",
         expected: "котёнок", oldIsBroken: true),
    // Combining mark after trigger (needs \p{M})
    Case(name: "combining mark after", text: "ern\u{0301}", trigger: "ern", replacement: "EAN",
         expected: "ern\u{0301}", oldIsBroken: true),
    // Non-ASCII digit neighbor (needs \p{N}, not [0-9])
    Case(name: "devanagari digit after", text: "ern१", trigger: "ern", replacement: "EAN",
         expected: "ern१", oldIsBroken: true),

    // Regression guards: correct today, must stay correct
    Case(name: "standalone word", text: "the ern here", trigger: "ern", replacement: "EAN",
         expected: "the EAN here", oldIsBroken: false),
    Case(name: "case-insensitive standalone", text: "ERN", trigger: "ern", replacement: "EAN",
         expected: "EAN", oldIsBroken: false),
    Case(name: "punctuation boundary", text: "(ern)", trigger: "ern", replacement: "EAN",
         expected: "(EAN)", oldIsBroken: false),
    Case(name: "string edges", text: "ern", trigger: "ern", replacement: "EAN",
         expected: "EAN", oldIsBroken: false),
    Case(name: "ascii interior stays", text: "modern", trigger: "ern", replacement: "EAN",
         expected: "modern", oldIsBroken: false),
    Case(name: "ascii digit neighbor stays", text: "ern2", trigger: "ern", replacement: "EAN",
         expected: "ern2", oldIsBroken: false),
    // Why lookarounds exist at all (commit 620a843): triggers ending in punctuation
    Case(name: "punctuation trigger c++", text: "use c++ now", trigger: "c++", replacement: "CPP",
         expected: "use CPP now", oldIsBroken: false),
    // Latin trigger flush against non-spaced scripts must still replace (script exemptions)
    Case(name: "CJK-adjacent latin trigger", text: "これはapiです", trigger: "api", replacement: "API",
         expected: "これはAPIです", oldIsBroken: false),
    Case(name: "hangul-adjacent latin trigger", text: "한api국", trigger: "api", replacement: "API",
         expected: "한API국", oldIsBroken: false),
    Case(name: "thai-adjacent latin trigger", text: "ไทยapiไทย", trigger: "api", replacement: "API",
         expected: "ไทยAPIไทย", oldIsBroken: false),
    // Prolonged sound mark ー (U+30FC) is Script=Common but scx=Hira|Kana, so it must stay
    // exempt so triggers flush against katakana loanwords keep matching (needs scx=)
    Case(name: "prolonged mark before trigger", text: "サーバーapi", trigger: "api", replacement: "API",
         expected: "サーバーAPI", oldIsBroken: false),
    Case(name: "prolonged mark after trigger", text: "apiー", trigger: "api", replacement: "API",
         expected: "APIー", oldIsBroken: false),
    Case(name: "halfwidth prolonged mark (U+FF70)", text: "ｻｰﾊﾞｰapi", trigger: "api", replacement: "API",
         expected: "ｻｰﾊﾞｰAPI", oldIsBroken: false),
    Case(name: "combining dakuten (U+3099) adjacent", text: "か\u{3099}api", trigger: "api", replacement: "API",
         expected: "か\u{3099}API", oldIsBroken: false),
]

var mode = CommandLine.arguments.contains("--old") ? "old" : "new"
let cls = mode == "old" ? asciiClass : unicodeClass
var failures = 0

for c in cases {
    let got = replace(c.text, trigger: c.trigger, with: c.replacement, wordChar: cls)
    let want = (mode == "old" && c.oldIsBroken) ? nil : c.expected // old mode: broken cases just reported
    if mode == "old" {
        let brokenNow = got != c.expected
        let marker = brokenNow == c.oldIsBroken ? "as-documented" : "UNEXPECTED"
        if marker == "UNEXPECTED" { failures += 1 }
        print("[old] \(c.name): \"\(c.text)\" -> \"\(got)\" (\(brokenNow ? "WRONG" : "ok"), \(marker))")
    } else {
        let pass = got == want
        if !pass { failures += 1 }
        print("[new] \(c.name): \"\(c.text)\" -> \"\(got)\" \(pass ? "PASS" : "FAIL (want \"\(want!)\")")")
    }
}

if failures > 0 {
    print("\n\(failures) FAILURE(S)")
    exit(1)
}
print("\nall \(cases.count) cases \(mode == "old" ? "behave as documented" : "PASS")")