Allow passing a custom argument resolver to format

Author: JasperDeSutter

fluent-bundle/src/bundle.rs

@@ -24,6 +24,7 @@ use crate::message::FluentMessage;
 use crate::resolver::{ResolveValue, Scope, WriteValue};
 use crate::resource::FluentResource;
 use crate::types::FluentValue;
+use crate::ArgumentResolver;
 
 /// A collection of localization messages for a single locale, which are meant
 /// to be used together in a single view, widget or any other UI abstraction.
@@ -488,6 +489,21 @@ impl<R, M> FluentBundle<R, M> {
         args: Option<&'args FluentArgs>,
         errors: &mut Vec<FluentError>,
     ) -> Cow<'bundle, str>
+    where
+        R: Borrow<FluentResource>,
+        M: MemoizerKind,
+    {
+        self.format_pattern_with_argument_resolver(pattern, args, errors)
+    }
+
+    /// Formats a pattern which comes from a `FluentMessage`.
+    /// Works the same as [`FluentBundle::format_pattern`], but allows passing a custom argument resolver.
+    pub fn format_pattern_with_argument_resolver<'bundle, 'args>(
+        &'bundle self,
+        pattern: &'bundle ast::Pattern<&'bundle str>,
+        args: impl ArgumentResolver<'args>,
+        errors: &mut Vec<FluentError>,
+    ) -> Cow<'bundle, str>
     where
         R: Borrow<FluentResource>,
         M: MemoizerKind,

fluent-bundle/src/lib.rs

@@ -122,6 +122,7 @@ pub use args::FluentArgs;
 pub type FluentBundle<R> = bundle::FluentBundle<R, intl_memoizer::IntlLangMemoizer>;
 pub use errors::FluentError;
 pub use message::{FluentAttribute, FluentMessage};
+pub use resolver::ArgumentResolver;
 pub use resource::FluentResource;
 #[doc(inline)]
 pub use types::FluentValue;

fluent-bundle/src/resolver/expression.rs

@@ -1,4 +1,4 @@
-use super::scope::Scope;
+use super::scope::{ArgumentResolver, Scope};
 use super::WriteValue;
 
 use std::borrow::Borrow;
@@ -12,15 +12,16 @@ use crate::resource::FluentResource;
 use crate::types::FluentValue;
 
 impl<'bundle> WriteValue<'bundle> for ast::Expression<&'bundle str> {
-    fn write<'ast, 'args, 'errors, W, R, M>(
+    fn write<'ast, 'args, 'errors, W, R, M, Args>(
         &'ast self,
         w: &mut W,
-        scope: &mut Scope<'bundle, 'ast, 'args, 'errors, R, M>,
+        scope: &mut Scope<'bundle, 'ast, 'args, 'errors, R, M, Args>,
     ) -> fmt::Result
     where
         W: fmt::Write,
         R: Borrow<FluentResource>,
         M: MemoizerKind,
+        Args: ArgumentResolver<'args>,
     {
         match self {
             Self::Inline(exp) => exp.write(w, scope),

fluent-bundle/src/resolver/inline_expression.rs

@@ -1,4 +1,4 @@
-use super::scope::Scope;
+use super::scope::{ArgumentResolver, Scope};
 use super::{ResolveValue, ResolverError, WriteValue};
 
 use std::borrow::Borrow;
@@ -13,15 +13,16 @@ use crate::resource::FluentResource;
 use crate::types::FluentValue;
 
 impl<'bundle> WriteValue<'bundle> for ast::InlineExpression<&'bundle str> {
-    fn write<'ast, 'args, 'errors, W, R, M>(
+    fn write<'ast, 'args, 'errors, W, R, M, Args>(
         &'ast self,
         w: &mut W,
-        scope: &mut Scope<'bundle, 'ast, 'args, 'errors, R, M>,
+        scope: &mut Scope<'bundle, 'ast, 'args, 'errors, R, M, Args>,
     ) -> fmt::Result
     where
         W: fmt::Write,
         R: Borrow<FluentResource>,
         M: MemoizerKind,
+        Args: ArgumentResolver<'args>,
     {
         match self {
             Self::StringLiteral { value } => unescape_unicode(w, value),
@@ -100,9 +101,15 @@ impl<'bundle> WriteValue<'bundle> for ast::InlineExpression<&'bundle str> {
                 }
             }
             Self::VariableReference { id } => {
-                let args = scope.local_args.as_ref().or(scope.args);
+                let resolved_arg;
+                let opt_arg = if let Some(args) = scope.local_args.as_ref() {
+                    args.get(id.name)
+                } else {
+                    resolved_arg = scope.args.resolve(id.name);
+                    resolved_arg.as_ref().map(|it| it.as_ref())
+                };
 
-                if let Some(arg) = args.and_then(|args| args.get(id.name)) {
+                if let Some(arg) = opt_arg {
                     arg.write(w, scope)
                 } else {
                     if scope.local_args.is_none() {
@@ -148,13 +155,14 @@ impl<'bundle> WriteValue<'bundle> for ast::InlineExpression<&'bundle str> {
 }
 
 impl<'bundle> ResolveValue<'bundle> for ast::InlineExpression<&'bundle str> {
-    fn resolve<'ast, 'args, 'errors, R, M>(
+    fn resolve<'ast, 'args, 'errors, R, M, Args>(
         &'ast self,
-        scope: &mut Scope<'bundle, 'ast, 'args, 'errors, R, M>,
+        scope: &mut Scope<'bundle, 'ast, 'args, 'errors, R, M, Args>,
     ) -> FluentValue<'bundle>
     where
         R: Borrow<FluentResource>,
         M: MemoizerKind,
+        Args: ArgumentResolver<'args>,
     {
         match self {
             Self::StringLiteral { value } => unescape_unicode_to_string(value).into(),
@@ -164,8 +172,8 @@ impl<'bundle> ResolveValue<'bundle> for ast::InlineExpression<&'bundle str> {
                     if let Some(arg) = local_args.get(id.name) {
                         return arg.clone();
                     }
-                } else if let Some(arg) = scope.args.and_then(|args| args.get(id.name)) {
-                    return arg.into_owned();
+                } else if let Some(arg) = scope.args.resolve(id.name) {
+                    return arg.as_ref().into_owned();
                 }
 
                 if scope.local_args.is_none() {

fluent-bundle/src/resolver/mod.rs

@@ -10,7 +10,7 @@ mod pattern;
 mod scope;
 
 pub use errors::ResolverError;
-pub use scope::Scope;
+pub use scope::{ArgumentResolver, Scope};
 
 use std::borrow::Borrow;
 use std::fmt;
@@ -22,27 +22,29 @@ use crate::types::FluentValue;
 /// Resolves an AST node to a [`FluentValue`].
 pub(crate) trait ResolveValue<'bundle> {
     /// Resolves an AST node to a [`FluentValue`].
-    fn resolve<'ast, 'args, 'errors, R, M>(
+    fn resolve<'ast, 'args, 'errors, R, M, Args>(
         &'ast self,
-        scope: &mut Scope<'bundle, 'ast, 'args, 'errors, R, M>,
+        scope: &mut Scope<'bundle, 'ast, 'args, 'errors, R, M, Args>,
     ) -> FluentValue<'bundle>
     where
         R: Borrow<FluentResource>,
-        M: MemoizerKind;
+        M: MemoizerKind,
+        Args: ArgumentResolver<'args>;
 }
 
 /// Resolves an AST node to a string that is written to source `W`.
 pub(crate) trait WriteValue<'bundle> {
     /// Resolves an AST node to a string that is written to source `W`.
-    fn write<'ast, 'args, 'errors, W, R, M>(
+    fn write<'ast, 'args, 'errors, W, R, M, Args>(
         &'ast self,
         w: &mut W,
-        scope: &mut Scope<'bundle, 'ast, 'args, 'errors, R, M>,
+        scope: &mut Scope<'bundle, 'ast, 'args, 'errors, R, M, Args>,
     ) -> fmt::Result
     where
         W: fmt::Write,
         R: Borrow<FluentResource>,
-        M: MemoizerKind;
+        M: MemoizerKind,
+        Args: ArgumentResolver<'args>;
 
     /// Writes error information to `W`. This can be used to add FTL errors inline
     /// to a message.

fluent-bundle/src/resolver/pattern.rs

@@ -1,4 +1,4 @@
-use super::scope::Scope;
+use super::scope::{ArgumentResolver, Scope};
 use super::{ResolverError, WriteValue};
 
 use std::borrow::Borrow;
@@ -14,15 +14,16 @@ use crate::types::FluentValue;
 const MAX_PLACEABLES: u8 = 100;
 
 impl<'bundle> WriteValue<'bundle> for ast::Pattern<&'bundle str> {
-    fn write<'ast, 'args, 'errors, W, R, M>(
+    fn write<'ast, 'args, 'errors, W, R, M, Args>(
         &'ast self,
         w: &mut W,
-        scope: &mut Scope<'bundle, 'ast, 'args, 'errors, R, M>,
+        scope: &mut Scope<'bundle, 'ast, 'args, 'errors, R, M, Args>,
     ) -> fmt::Result
     where
         W: fmt::Write,
         R: Borrow<FluentResource>,
         M: MemoizerKind,
+        Args: ArgumentResolver<'args>,
     {
         let len = self.elements.len();
 
@@ -81,13 +82,14 @@ impl<'bundle> WriteValue<'bundle> for ast::Pattern<&'bundle str> {
 }
 
 impl<'bundle> ResolveValue<'bundle> for ast::Pattern<&'bundle str> {
-    fn resolve<'ast, 'args, 'errors, R, M>(
+    fn resolve<'ast, 'args, 'errors, R, M, Args>(
         &'ast self,
-        scope: &mut Scope<'bundle, 'ast, 'args, 'errors, R, M>,
+        scope: &mut Scope<'bundle, 'ast, 'args, 'errors, R, M, Args>,
     ) -> FluentValue<'bundle>
     where
         R: Borrow<FluentResource>,
         M: MemoizerKind,
+        Args: ArgumentResolver<'args>,
     {
         let len = self.elements.len();
 

fluent-bundle/src/resolver/scope.rs

@@ -4,15 +4,17 @@ use crate::resolver::{ResolveValue, ResolverError, WriteValue};
 use crate::types::FluentValue;
 use crate::{FluentArgs, FluentError, FluentResource};
 use fluent_syntax::ast;
-use std::borrow::Borrow;
+use std::borrow::{Borrow, Cow};
 use std::fmt;
+use std::marker::PhantomData;
 
 /// State for a single `ResolveValue::to_value` call.
-pub struct Scope<'bundle, 'ast, 'args, 'errors, R, M> {
+pub struct Scope<'bundle, 'ast, 'args, 'errors, R, M, Args> {
+    lt: PhantomData<&'args ()>,
     /// The current `FluentBundle` instance.
     pub bundle: &'bundle FluentBundle<R, M>,
     /// The current arguments passed by the developer.
-    pub(super) args: Option<&'args FluentArgs<'args>>,
+    pub(super) args: Args,
     /// Local args
     pub(super) local_args: Option<FluentArgs<'bundle>>,
     /// The running count of resolved placeables. Used to detect the Billion
@@ -26,15 +28,16 @@ pub struct Scope<'bundle, 'ast, 'args, 'errors, R, M> {
     pub dirty: bool,
 }
 
-impl<'bundle, 'ast, 'args, 'errors, R, M> Scope<'bundle, 'ast, 'args, 'errors, R, M> {
+impl<'bundle, 'ast, 'args, 'errors, R, M, Args> Scope<'bundle, 'ast, 'args, 'errors, R, M, Args> {
     pub fn new(
         bundle: &'bundle FluentBundle<R, M>,
-        args: Option<&'args FluentArgs>,
+        arg_resolver: Args,
         errors: Option<&'errors mut Vec<FluentError>>,
     ) -> Self {
         Scope {
+            lt: PhantomData,
             bundle,
-            args,
+            args: arg_resolver,
             local_args: None,
             placeables: 0,
             travelled: Default::default(),
@@ -48,7 +51,11 @@ impl<'bundle, 'ast, 'args, 'errors, R, M> Scope<'bundle, 'ast, 'args, 'errors, R
             errors.push(error.into());
         }
     }
+}
 
+impl<'bundle, 'ast, 'args, 'errors, R, M, Args: ArgumentResolver<'args>>
+    Scope<'bundle, 'ast, 'args, 'errors, R, M, Args>
+{
     /// This method allows us to lazily add Pattern on the stack, only if the
     /// Pattern::resolve has been called on an empty stack.
     ///
@@ -138,3 +145,14 @@ impl<'bundle, 'ast, 'args, 'errors, R, M> Scope<'bundle, 'ast, 'args, 'errors, R
         }
     }
 }
+
+pub trait ArgumentResolver<'a>: Copy {
+    fn resolve(self, name: &str) -> Option<Cow<FluentValue<'a>>>;
+}
+
+impl<'args> ArgumentResolver<'args> for Option<&'args FluentArgs<'args>> {
+    fn resolve(self, name: &str) -> Option<Cow<FluentValue<'args>>> {
+        let arg = self?.get(name)?;
+        Some(Cow::Borrowed(arg))
+    }
+}

fluent-bundle/src/types/mod.rs

@@ -157,12 +157,13 @@ impl<'source> FluentValue<'source> {
     ///
     /// ```
     /// use fluent_bundle::resolver::Scope;
-    /// use fluent_bundle::{types::FluentValue, FluentBundle, FluentResource};
+    /// use fluent_bundle::{types::FluentValue, FluentArgs, FluentBundle, FluentResource};
     /// use unic_langid::langid;
     ///
     /// let langid_ars = langid!("en");
     /// let bundle: FluentBundle<FluentResource> = FluentBundle::new(vec![langid_ars]);
-    /// let scope = Scope::new(&bundle, None, None);
+    /// let argument_resolver: Option<&FluentArgs> = None;
+    /// let scope = Scope::new(&bundle, argument_resolver, None);
     ///
     /// // Matching examples:
     /// assert!(FluentValue::try_number("2").matches(&FluentValue::try_number("2"), &scope));
@@ -177,10 +178,10 @@ impl<'source> FluentValue<'source> {
     /// assert!(!FluentValue::from("fluent").matches(&FluentValue::from("not fluent"), &scope));
     /// assert!(!FluentValue::from("two").matches(&FluentValue::try_number("100"), &scope),);
     /// ```
-    pub fn matches<R: Borrow<FluentResource>, M>(
+    pub fn matches<R: Borrow<FluentResource>, M, Args>(
         &self,
         other: &FluentValue,
-        scope: &Scope<R, M>,
+        scope: &Scope<R, M, Args>,
     ) -> bool
     where
         M: MemoizerKind,
@@ -214,7 +215,7 @@ impl<'source> FluentValue<'source> {
     }
 
     /// Write out a string version of the [`FluentValue`] to `W`.
-    pub fn write<W, R, M>(&self, w: &mut W, scope: &Scope<R, M>) -> fmt::Result
+    pub fn write<W, R, M, Args>(&self, w: &mut W, scope: &Scope<R, M, Args>) -> fmt::Result
     where
         W: fmt::Write,
         R: Borrow<FluentResource>,
@@ -235,7 +236,10 @@ impl<'source> FluentValue<'source> {
     }
 
     /// Converts the [`FluentValue`] to a string.
-    pub fn as_string<R: Borrow<FluentResource>, M>(&self, scope: &Scope<R, M>) -> Cow<'source, str>
+    pub fn as_string<R: Borrow<FluentResource>, M, Args>(
+        &self,
+        scope: &Scope<R, M, Args>,
+    ) -> Cow<'source, str>
     where
         M: MemoizerKind,
     {

fluent-bundle/tests/types_test.rs

@@ -21,7 +21,8 @@ fn fluent_value_matches() {
     // plural rules categories.
     let langid_ars = langid!("ars");
     let bundle: FluentBundle<FluentResource> = FluentBundle::new(vec![langid_ars]);
-    let scope = Scope::new(&bundle, None, None);
+    let arg_resolver: Option<&FluentArgs> = None;
+    let scope = Scope::new(&bundle, arg_resolver, None);
 
     let string_val = FluentValue::from("string1");
     let string_val_copy = FluentValue::from("string1");