1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

use std::borrow::Cow;
use std::iter::FromIterator;

use crate::types::FluentValue;

/// Fluent messages can use arguments in order to programmatically add values to a
/// translated string. For instance, in a localized application you may wish to display
/// a user's email count. This could be done with the following message.
///
/// `msg-key = Hello, { $user }. You have { $emailCount } messages.`
///
/// Here `$user` and `$emailCount` are the arguments, which can be filled with values.
///
/// The [`FluentArgs`] struct is the map from the argument name (for example `$user`) to
/// the argument value (for example "John".) The logic to apply these to write these
/// to messages is elsewhere, this struct just stores the value.
///
/// # Example
///
/// ```
/// use fluent_bundle::{FluentArgs, FluentBundle, FluentResource};
///
/// let mut args = FluentArgs::new();
/// args.set("user", "John");
/// args.set("emailCount", 5);
///
/// let res = FluentResource::try_new(r#"
///
/// msg-key = Hello, { $user }. You have { $emailCount } messages.
///
/// "#.to_string())
///     .expect("Failed to parse FTL.");
///
/// let mut bundle = FluentBundle::default();
///
/// // For this example, we'll turn on BiDi support.
/// // Please, be careful when doing it, it's a risky move.
/// bundle.set_use_isolating(false);
///
/// bundle.add_resource(res)
///     .expect("Failed to add a resource.");
///
/// let mut err = vec![];
///
/// let msg = bundle.get_message("msg-key")
///     .expect("Failed to retrieve a message.");
/// let value = msg.value()
///     .expect("Failed to retrieve a value.");
///
/// assert_eq!(
///     bundle.format_pattern(value, Some(&args), &mut err),
///     "Hello, John. You have 5 messages."
/// );
/// ```
#[derive(Debug, Default)]
pub struct FluentArgs<'args>(Vec<(Cow<'args, str>, FluentValue<'args>)>);

impl<'args> FluentArgs<'args> {
    /// Creates a new empty argument map.
    pub fn new() -> Self {
        Self::default()
    }

    /// Pre-allocates capacity for arguments.
    pub fn with_capacity(capacity: usize) -> Self {
        Self(Vec::with_capacity(capacity))
    }

    /// Gets the [`FluentValue`] at the `key` if it exists.
    pub fn get<K>(&self, key: K) -> Option<&FluentValue<'args>>
    where
        K: Into<Cow<'args, str>>,
    {
        let key = key.into();
        if let Ok(idx) = self.0.binary_search_by_key(&&key, |(k, _)| k) {
            Some(&self.0[idx].1)
        } else {
            None
        }
    }

    /// Sets the key value pair.
    pub fn set<K, V>(&mut self, key: K, value: V)
    where
        K: Into<Cow<'args, str>>,
        V: Into<FluentValue<'args>>,
    {
        let key = key.into();
        match self.0.binary_search_by_key(&&key, |(k, _)| k) {
            Ok(idx) => self.0[idx] = (key, value.into()),
            Err(idx) => self.0.insert(idx, (key, value.into())),
        };
    }

    /// Iterate over a tuple of the key an [`FluentValue`].
    pub fn iter(&self) -> impl Iterator<Item = (&str, &FluentValue)> {
        self.0.iter().map(|(k, v)| (k.as_ref(), v))
    }
}

impl<'args, K, V> FromIterator<(K, V)> for FluentArgs<'args>
where
    K: Into<Cow<'args, str>>,
    V: Into<FluentValue<'args>>,
{
    fn from_iter<I>(iter: I) -> Self
    where
        I: IntoIterator<Item = (K, V)>,
    {
        let iter = iter.into_iter();
        let mut args = if let Some(size) = iter.size_hint().1 {
            FluentArgs::with_capacity(size)
        } else {
            FluentArgs::new()
        };

        for (k, v) in iter {
            args.set(k, v);
        }

        args
    }
}

impl<'args> IntoIterator for FluentArgs<'args> {
    type Item = (Cow<'args, str>, FluentValue<'args>);
    type IntoIter = std::vec::IntoIter<Self::Item>;

    fn into_iter(self) -> Self::IntoIter {
        self.0.into_iter()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn replace_existing_arguments() {
        let mut args = FluentArgs::new();

        args.set("name", "John");
        args.set("emailCount", 5);
        assert_eq!(args.0.len(), 2);
        assert_eq!(
            args.get("name"),
            Some(&FluentValue::String(Cow::Borrowed("John")))
        );
        assert_eq!(args.get("emailCount"), Some(&FluentValue::try_number("5")));

        args.set("name", "Jane");
        args.set("emailCount", 7);
        assert_eq!(args.0.len(), 2);
        assert_eq!(
            args.get("name"),
            Some(&FluentValue::String(Cow::Borrowed("Jane")))
        );
        assert_eq!(args.get("emailCount"), Some(&FluentValue::try_number("7")));
    }
}