Switch to Cow

Author: Zibi Braniecki

fluent-bundle/src/resolve.rs

@@ -177,11 +177,7 @@ impl<'source> ResolveValue for ast::InlineExpression<'source> {
     fn to_value(&self, env: &Env) -> Result<FluentValue, ResolverError> {
         match self {
             ast::InlineExpression::StringLiteral { raw } => {
-                if let Some(unescaped_value) = unescape_unicode(raw) {
-                    Ok(FluentValue::from(unescaped_value))
-                } else {
-                    Ok(FluentValue::from(*raw))
-                }
+                Ok(FluentValue::from(unescape_unicode(raw).into_owned()))
             }
             ast::InlineExpression::NumberLiteral { value } => {
                 Ok(FluentValue::as_number(*value).unwrap())

fluent-syntax/src/unicode.rs

@@ -1,3 +1,4 @@
+use std::borrow::Cow;
 use std::char;
 
 fn encode_unicode(s: &str) -> char {
@@ -7,22 +8,22 @@ fn encode_unicode(s: &str) -> char {
         .unwrap_or('�')
 }
 
-pub fn unescape_unicode(string: &str) -> Option<String> {
-    let bytes = string.as_bytes();
+pub fn unescape_unicode<'u>(input: &'u str) -> Cow<'u, str> {
+    let bytes = input.as_bytes();
     let mut result: Option<String> = None;
 
     let mut ptr = 0;
 
     while let Some(b) = bytes.get(ptr) {
         if b != &b'\\' {
-            if let Some(ref mut result) = result {
-                result.push(*b as char);
+            if let Some(ref mut s) = result {
+                s.push(*b as char);
             }
             ptr += 1;
             continue;
         }
 
-        let new_string = result.get_or_insert_with(|| String::from(&string[0..ptr]));
+        let new_string = result.get_or_insert_with(|| String::from(&input[0..ptr]));
 
         ptr += 1;
 
@@ -33,7 +34,7 @@ pub fn unescape_unicode(string: &str) -> Option<String> {
                 let start = ptr + 1;
                 let len = if u == &b'u' { 4 } else { 6 };
                 ptr += len;
-                string
+                input
                     .get(start..(start + len))
                     .map(|slice| encode_unicode(slice))
                     .unwrap_or('�')
@@ -43,5 +44,5 @@ pub fn unescape_unicode(string: &str) -> Option<String> {
         new_string.push(new_char);
         ptr += 1;
     }
-    return result;
+    result.map_or_else(|| Cow::from(input), Cow::from)
 }

fluent-syntax/tests/ast/mod.rs

@@ -359,11 +359,7 @@ where
     let mut map = serializer.serialize_map(Some(3))?;
     map.serialize_entry("type", "StringLiteral")?;
     map.serialize_entry("raw", raw)?;
-    if let Some(unescaped_value) = unescape_unicode(&raw) {
-        map.serialize_entry("value", &unescaped_value)?;
-    } else {
-        map.serialize_entry("value", &raw)?;
-    }
+    map.serialize_entry("value", &unescape_unicode(&raw))?;
     map.end()
 }
 

fluent-syntax/tests/unicode.rs

@@ -1,24 +1,32 @@
 use fluent_syntax::unicode::unescape_unicode;
+use std::borrow::Cow;
+
+fn is_cow_borrowed<'a>(input: Cow<'a, str>) -> bool {
+    if let Cow::Borrowed(_) = input {
+        true
+    } else {
+        false
+    }
+}
 
 #[test]
 fn unescape_unicode_test() {
-    assert_eq!(unescape_unicode("foo"), None);
-    assert_eq!(unescape_unicode("foo \\\\"), Some("foo \\".to_owned()));
-    assert_eq!(unescape_unicode("foo \\\""), Some("foo \"".to_owned()));
-    assert_eq!(
-        unescape_unicode("foo \\\\ faa"),
-        Some("foo \\ faa".to_owned())
-    );
+    assert!(is_cow_borrowed(unescape_unicode("foo")));
+
+    assert_eq!(unescape_unicode("foo"), "foo");
+    assert_eq!(unescape_unicode("foo \\\\"), "foo \\");
+    assert_eq!(unescape_unicode("foo \\\""), "foo \"");
+    assert_eq!(unescape_unicode("foo \\\\ faa"), "foo \\ faa");
     assert_eq!(
         unescape_unicode("foo \\\\ faa \\\\ fii"),
-        Some("foo \\ faa \\ fii".to_owned())
+        "foo \\ faa \\ fii"
     );
     assert_eq!(
         unescape_unicode("foo \\\\\\\" faa \\\"\\\\ fii"),
-        Some("foo \\\" faa \"\\ fii".to_owned())
+        "foo \\\" faa \"\\ fii"
     );
-    assert_eq!(unescape_unicode("\\u0041\\u004F"), Some("AO".to_owned()));
-    assert_eq!(unescape_unicode("\\uA"), Some("�".to_owned()));
-    assert_eq!(unescape_unicode("\\uA0Pl"), Some("�".to_owned()));
-    assert_eq!(unescape_unicode("\\d Foo"), Some("� Foo".to_owned()));
+    assert_eq!(unescape_unicode("\\u0041\\u004F"), "AO");
+    assert_eq!(unescape_unicode("\\uA"), "�");
+    assert_eq!(unescape_unicode("\\uA0Pl"), "�");
+    assert_eq!(unescape_unicode("\\d Foo"), "� Foo");
 }