rusteerio 0.0.0-stage → 0.1.0

package/native/src/codec.rs

@@ -0,0 +1,172 @@
+//! Lossless JavaScript UTF-16 over valid Rust strings. Ordinary Unicode keeps
+//! its original representation; lone surrogates use BMP private-use frames.
+use serde_json::Value;
+
+pub(crate) const ESCAPE: char = '\u{e800}';
+pub(crate) fn is_reserved(ch: char) -> bool {
+    ('\u{e000}'..=ESCAPE).contains(&ch)
+}
+pub(crate) fn has_encoding(value: &str) -> bool {
+    value.chars().any(is_reserved)
+}
+pub(crate) fn from_units(units: &[u16]) -> String {
+    let mut output = String::with_capacity(units.len());
+    let mut index = 0;
+    while index < units.len() {
+        let unit = units[index];
+        if (0xd800..=0xdbff).contains(&unit)
+            && units
+                .get(index + 1)
+                .is_some_and(|unit| (0xdc00..=0xdfff).contains(unit))
+        {
+            let code =
+                0x10000 + ((unit as u32 - 0xd800) << 10) + (units[index + 1] as u32 - 0xdc00);
+            output.push(char::from_u32(code).unwrap());
+            index += 2;
+            continue;
+        }
+        if (0xd800..=0xdfff).contains(&unit) {
+            output.push(char::from_u32(0xe000 + unit as u32 - 0xd800).unwrap());
+        } else {
+            let ch = char::from_u32(unit as u32).unwrap();
+            if is_reserved(ch) {
+                output.push(ESCAPE);
+            }
+            output.push(ch);
+        }
+        index += 1;
+    }
+    output
+}
+pub(crate) fn to_units(value: &str) -> Vec<u16> {
+    let mut output = Vec::with_capacity(value.len());
+    let mut chars = value.chars().peekable();
+    while let Some(ch) = chars.next() {
+        if ch == ESCAPE && chars.peek().copied().is_some_and(is_reserved) {
+            output.push(chars.next().unwrap() as u16);
+        } else if ('\u{e000}'..'\u{e800}').contains(&ch) {
+            output.push(0xd800 + (ch as u16 - 0xe000));
+        } else {
+            let mut encoded = [0; 2];
+            output.extend_from_slice(ch.encode_utf16(&mut encoded));
+        }
+    }
+    output
+}
+pub(crate) fn logical_len(value: &str) -> usize {
+    if has_encoding(value) {
+        to_units(value).len()
+    } else {
+        value.encode_utf16().count()
+    }
+}
+pub(crate) fn to_usv(value: &str) -> String {
+    if has_encoding(value) {
+        String::from_utf16_lossy(&to_units(value))
+    } else {
+        value.to_owned()
+    }
+}
+pub(crate) fn encode_scalar(ch: char) -> String {
+    let mut output = String::new();
+    if is_reserved(ch) {
+        output.push(ESCAPE);
+    }
+    output.push(ch);
+    output
+}
+pub(crate) fn encode_literal(value: &str) -> String {
+    if !has_encoding(value) {
+        return value.to_owned();
+    }
+    let mut output = String::with_capacity(value.len());
+    for ch in value.chars() {
+        if is_reserved(ch) {
+            output.push(ESCAPE);
+        }
+        output.push(ch);
+    }
+    output
+}
+
+/// JSON.parse accepts lone escaped UTF-16 units. serde_json's String decoder
+/// requires scalar values, so translate only JSON unicode escape tokens first.
+/// Raw characters are already encoded by the native transport and stay intact.
+pub(crate) fn parse_json(source: &str) -> serde_json::Result<Value> {
+    if !source.contains("\\u") {
+        return serde_json::from_str(source);
+    }
+    let mut output = String::with_capacity(source.len());
+    let bytes = source.as_bytes();
+    let mut index = 0;
+    let mut quoted = false;
+    while index < source.len() {
+        if bytes[index] == b'"' {
+            quoted = !quoted;
+            output.push('"');
+            index += 1;
+            continue;
+        }
+        if quoted && bytes[index] == b'\\' {
+            if bytes.get(index + 1) == Some(&b'u') && index + 6 <= source.len() {
+                if let Some(unit) = source
+                    .get(index + 2..index + 6)
+                    .and_then(|text| u16::from_str_radix(text, 16).ok())
+                {
+                    if (0xd800..=0xdbff).contains(&unit)
+                        && source.get(index + 6..index + 8) == Some("\\u")
+                    {
+                        if let Some(next) = source
+                            .get(index + 8..index + 12)
+                            .and_then(|text| u16::from_str_radix(text, 16).ok())
+                            .filter(|next| (0xdc00..=0xdfff).contains(next))
+                        {
+                            let _ = next;
+                            output.push_str(&source[index..index + 12]);
+                            index += 12;
+                            continue;
+                        }
+                    }
+                    if (0xd800..=0xdfff).contains(&unit) || (0xe000..=0xe800).contains(&unit) {
+                        output.push_str(&from_units(&[unit]));
+                        index += 6;
+                        continue;
+                    }
+                }
+            }
+            output.push('\\');
+            index += 1;
+            if let Some(ch) = source[index..].chars().next() {
+                output.push(ch);
+                index += ch.len_utf8();
+            }
+            continue;
+        }
+        let ch = source[index..].chars().next().unwrap();
+        output.push(ch);
+        index += ch.len_utf8();
+    }
+    serde_json::from_str(&output)
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn framing_preserves_all_utf16_units_and_literal_private_use() {
+        let units = [0xd800, 0x41, 0xdfff, 0xe000, 0xe800, 0xd83d, 0xde00];
+        assert_eq!(to_units(&from_units(&units)), units);
+        assert_eq!(
+            to_usv(&from_units(&units)),
+            "\u{fffd}A\u{fffd}\u{e000}\u{e800}😀"
+        );
+    }
+    #[test]
+    fn json_data_decoding_preserves_escaped_units_and_literal_escape_sequences() {
+        let value =
+            parse_json(r#"{"a":"\ud800","b":"\ue000","c":"\\ud800","d":"\ud83d\ude00"}"#).unwrap();
+        assert_eq!(to_units(value["a"].as_str().unwrap()), vec![0xd800]);
+        assert_eq!(to_units(value["b"].as_str().unwrap()), vec![0xe000]);
+        assert_eq!(value["c"], r"\ud800");
+        assert_eq!(value["d"], "😀");
+    }
+}