Update FluentBundle to the latest API

Author: zbraniecki

fluent-bundle/benches/resolver.rs

@@ -91,7 +91,14 @@ fn resolver_bench(c: &mut Criterion) {
 
             b.iter(|| {
                 for id in &ids {
-                    let (_msg, errors) = bundle.compound(id, args.as_ref()).expect("Message found");
+                    let msg = bundle.get_message2(id).expect("Message found");
+                    let mut errors = vec![];
+                    if let Some(value) = msg.value {
+                        let _ = bundle.format_pattern(value, args.as_ref(), &mut errors);
+                    }
+                    for (_, value) in msg.attributes {
+                        let _ = bundle.format_pattern(value, args.as_ref(), &mut errors);
+                    }
                     assert!(errors.len() == 0, "Resolver errors: {:#?}", errors);
                 }
             })

fluent-bundle/src/bundle.rs

@@ -15,12 +15,18 @@ use intl_pluralrules::{IntlPluralRules, PluralRuleType};
 use crate::entry::Entry;
 use crate::entry::GetEntry;
 use crate::errors::FluentError;
-use crate::resolve::{resolve_value_for_entry, Scope};
+use crate::resolve::{resolve_pattern_for_entry, Scope};
 use crate::resource::FluentResource;
 use crate::types::FluentValue;
 
 #[derive(Debug, PartialEq)]
 pub struct Message<'m> {
+    pub value: Option<&'m ast::Pattern<'m>>,
+    pub attributes: HashMap<&'m str, &'m ast::Pattern<'m>>,
+}
+
+#[derive(Debug, PartialEq)]
+pub struct FormattedMessage<'m> {
     pub value: Option<Cow<'m, str>>,
     pub attributes: HashMap<&'m str, Cow<'m, str>>,
 }
@@ -246,6 +252,43 @@ impl<'bundle, R> FluentBundle<'bundle, R> {
         self.get_message(id).is_some()
     }
 
+    pub fn get_message2(&'bundle self, id: &str) -> Option<Message>
+    where
+        R: Borrow<FluentResource>,
+    {
+        let message = self.get_message(id)?;
+        let value = message.value.as_ref();
+        let mut attributes = if message.attributes.is_empty() {
+            HashMap::new()
+        } else {
+            HashMap::with_capacity(message.attributes.len())
+        };
+
+        for attr in message.attributes.iter() {
+            attributes.insert(attr.id.name, &attr.value);
+        }
+        return Some(Message { value, attributes });
+    }
+
+    pub fn format_pattern(
+        &'bundle self,
+        pattern: &'bundle ast::Pattern,
+        args: Option<&'bundle HashMap<&str, FluentValue>>,
+        errors: &mut Vec<FluentError>,
+    ) -> Cow<'bundle, str>
+    where
+        R: Borrow<FluentResource>,
+    {
+        let mut scope = Scope::new(self, args);
+        let result = resolve_pattern_for_entry(pattern, &mut scope).to_string();
+
+        for err in scope.errors {
+            errors.push(err.into());
+        }
+
+        result
+    }
+
     /// Makes the provided rust function available to messages with the name `id`. See
     /// the [FTL syntax guide] to learn how these are used in messages.
     ///
@@ -295,83 +338,6 @@ impl<'bundle, R> FluentBundle<'bundle, R> {
         }
     }
 
-    /// Formats the message value identified by `path` using `args` to
-    /// provide variables. `path` is either a message id ("hello"), or
-    /// message id plus attribute ("hello.tooltip").
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use fluent_bundle::{FluentBundle, FluentResource, FluentValue};
-    /// use std::collections::HashMap;
-    ///
-    /// let ftl_string = String::from("intro = Welcome, { $name }.");
-    /// let resource = FluentResource::try_new(ftl_string)
-    ///     .expect("Could not parse an FTL string.");
-    /// let mut bundle = FluentBundle::new(&["en-US"]);
-    /// bundle.add_resource(resource)
-    ///     .expect("Failed to add FTL resources to the bundle.");
-    ///
-    /// let mut args = HashMap::new();
-    /// args.insert("name", FluentValue::from("Rustacean"));
-    ///
-    /// let (value, _) = bundle.format("intro", Some(&args))
-    ///     .expect("Failed to format a message.");
-    /// assert_eq!(&value, "Welcome, \u{2068}Rustacean\u{2069}.");
-    ///
-    /// ```
-    ///
-    /// An example with attributes and no args:
-    ///
-    /// ```
-    /// use fluent_bundle::{FluentBundle, FluentResource};
-    ///
-    /// let ftl_string = String::from("
-    /// hello =
-    ///     .title = Hi!
-    ///     .tooltip = This says 'Hi!'
-    /// ");
-    /// let resource = FluentResource::try_new(ftl_string)
-    ///     .expect("Could not parse an FTL string.");
-    /// let mut bundle = FluentBundle::new(&["en-US"]);
-    /// bundle.add_resource(resource)
-    ///     .expect("Failed to add FTL resources to the bundle.");
-    ///
-    /// let (value, _) = bundle.format("hello.title", None)
-    ///     .expect("Failed to format a message.");
-    /// assert_eq!(&value, "Hi!");
-    /// ```
-    ///
-    /// # Errors
-    ///
-    /// For some cases where `format` can't find a message it will return `None`.
-    ///
-    /// In all other cases `format` returns a string even if it
-    /// encountered errors. Generally, during partial errors `format` will
-    /// use ids to replace parts of the formatted message that it could
-    /// not successfuly build. For more fundamental errors `format` will return
-    /// the path itself as the translation.
-    ///
-    /// The second term of the tuple will contain any extra error information
-    /// gathered during formatting. A caller may safely ignore the extra errors
-    /// if the fallback formatting policies are acceptable.
-    ///
-    /// ```
-    /// use fluent_bundle::{FluentBundle, FluentResource};
-    ///
-    /// // Create a message with bad cyclic reference
-    /// let ftl_string = String::from("foo = a { foo } b");
-    /// let resource = FluentResource::try_new(ftl_string)
-    ///     .expect("Could not parse an FTL string.");
-    /// let mut bundle = FluentBundle::new(&["en-US"]);
-    /// bundle.add_resource(resource)
-    ///     .expect("Failed to add FTL resources to the bundle.");
-    ///
-    /// // The result falls back to "a foo b"
-    /// let (value, _) = bundle.format("foo", None)
-    ///     .expect("Failed to format a message.");
-    /// assert_eq!(&value, "a foo b");
-    /// ```
     pub fn format(
         &'bundle self,
         path: &str,
@@ -380,113 +346,47 @@ impl<'bundle, R> FluentBundle<'bundle, R> {
     where
         R: Borrow<FluentResource>,
     {
-        let mut scope = Scope::new(self, args);
-
         let mut errors = vec![];
 
-        let string = if let Some(ptr_pos) = path.find('.') {
+        let val = if let Some(ptr_pos) = path.find('.') {
             let message_id = &path[..ptr_pos];
-            let message = self.get_message(message_id)?;
+            let message = self.get_message2(message_id)?;
             let attr_name = &path[(ptr_pos + 1)..];
-            let attr = message
-                .attributes
-                .iter()
-                .find(|attr| attr.id.name == attr_name)?;
-            resolve_value_for_entry(&attr.value, (message, attr).into(), &mut scope).to_string()
+            let attr = message.attributes.get(attr_name)?;
+            self.format_pattern(attr, args, &mut errors)
         } else {
             let message_id = path;
-            let message = self.get_message(message_id)?;
-            message
-                .value
-                .as_ref()
-                .map(|value| resolve_value_for_entry(value, message.into(), &mut scope))?
-                .to_string()
+            let message = self.get_message2(message_id)?;
+            self.format_pattern(message.value?, args, &mut errors)
         };
 
-        for err in scope.errors {
-            errors.push(err.into());
-        }
-
-        Some((string, errors))
+        return Some((val, errors));
     }
 
-    /// Formats both the message value and attributes identified by `message_id`
-    /// using `args` to provide variables. This is useful for cases where a UI
-    /// element requires multiple related text fields, such as a button that has
-    /// both display text and assistive text.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use fluent_bundle::{FluentBundle, FluentResource, FluentValue};
-    /// use std::collections::HashMap;
-    ///
-    /// let ftl_string = String::from("
-    /// login-input = Predefined value
-    ///     .placeholder = [email protected]
-    ///     .aria-label = Login input value
-    ///     .title = Type your login email
-    /// ");
-    /// let resource = FluentResource::try_new(ftl_string)
-    ///     .expect("Could not parse an FTL string.");
-    /// let mut bundle = FluentBundle::new(&["en-US"]);
-    /// bundle.add_resource(resource)
-    ///     .expect("Failed to add FTL resources to the bundle.");
-    ///
-    /// let (message, _) = bundle.compound("login-input", None)
-    ///     .expect("Failed to format a message.");
-    /// assert_eq!(message.value, Some("Predefined value".into()));
-    /// assert_eq!(message.attributes.get("title"), Some(&"Type your login email".into()));
-    /// ```
-    ///
-    /// # Errors
-    ///
-    /// For some cases where `compound` can't find a message it will return `None`.
-    ///
-    /// In all other cases `compound` returns a message even if it
-    /// encountered errors. Generally, during partial errors `compound` will
-    /// use ids to replace parts of the formatted message that it could
-    /// not successfuly build. For more fundamental errors `compound` will return
-    /// the path itself as the translation.
-    ///
-    /// The second term of the tuple will contain any extra error information
-    /// gathered during formatting. A caller may safely ignore the extra errors
-    /// if the fallback formatting policies are acceptable.
     pub fn compound(
         &'bundle self,
         message_id: &str,
         args: Option<&'bundle HashMap<&str, FluentValue>>,
-    ) -> Option<(Message<'bundle>, Vec<FluentError>)>
+    ) -> Option<(FormattedMessage<'bundle>, Vec<FluentError>)>
     where
         R: Borrow<FluentResource>,
     {
-        let mut scope = Scope::new(self, args);
         let mut errors = vec![];
-        let message = self.get_message(message_id)?;
-
+        let message = self.get_message2(message_id)?;
         let value = message
             .value
-            .as_ref()
-            .map(|value| resolve_value_for_entry(value, message.into(), &mut scope).to_string());
+            .map(|pattern| self.format_pattern(pattern, args, &mut errors));
 
-        // Setting capacity helps performance for cases with attributes,
-        // but is slower than `::new` for cases without.
-        // Maybe one day this will be fixed but for now let's use the trick.
         let mut attributes = if message.attributes.is_empty() {
             HashMap::new()
         } else {
-            HashMap::with_capacity(message.attributes.len())
+            HashMap::with_capacity(message.attributes.keys().len())
         };
 
-        for attr in message.attributes.iter() {
-            let val = resolve_value_for_entry(&attr.value, (message, attr).into(), &mut scope);
-            attributes.insert(attr.id.name, val.to_string());
-        }
-
-        for err in scope.errors {
-            errors.push(err.into());
+        for (key, pattern) in message.attributes {
+            attributes.insert(key, self.format_pattern(pattern, args, &mut errors));
         }
 
-        Some((Message { value, attributes }, errors))
+        return Some((FormattedMessage { value, attributes }, errors));
     }
 }