Switch to unic_langid for Language Identifier Management

Author: zbraniecki

fluent-bundle/Cargo.toml

@@ -18,13 +18,14 @@ keywords = ["localization", "l10n", "i18n", "intl", "internationalization"]
 categories = ["localization", "internationalization"]
 
 [dependencies]
-fluent-locale = "^0.4.1"
+fluent-locale = "^0.6.0"
 fluent-syntax = "^0.9"
 failure = "^0.1"
 failure_derive = "^0.1"
-intl_pluralrules = "^1.0"
+intl_pluralrules = "^1.1.0"
 rental = "^0.5.4"
-smallvec = "0.6.10"
+smallvec = "^0.6.10"
+unic-langid = "^0.3.0"
 
 [dev-dependencies]
 criterion = "^0.2"

fluent-bundle/README.md

@@ -23,13 +23,16 @@ Usage
 
 ```rust
 use fluent_bundle::{FluentBundle, FluentResource};
+use std::convert::TryFrom;
+use unic_langid::LanguageIdentifier;
 
 fn main() {
     let ftl_string = "hello-world = Hello, world!".to_owned();
     let res = FluentResource::try_new(ftl_string)
         .expect("Could not parse an FTL string.");
 
-    let mut bundle = FluentBundle::new(&["en-US"]);
+    let langid_en = LanguageIdentifier::try_from("en").expect("Parsing failed.");
+    let mut bundle = FluentBundle::new(&[langid_en]);
 
     bundle.add_resource(&res)
         .expect("Failed to add FTL resources to the bundle.");

fluent-bundle/benches/resolver.rs

@@ -85,7 +85,7 @@ fn resolver_bench(c: &mut Criterion) {
             let res =
                 FluentResource::try_new(source.to_owned()).expect("Couldn't parse an FTL source");
             let ids = get_ids(&res);
-            let mut bundle = FluentBundle::new(&["x-testing"]);
+            let mut bundle = FluentBundle::default();
             bundle
                 .add_resource(res)
                 .expect("Couldn't add FluentResource to the FluentBundle");

fluent-bundle/examples/external_arguments.rs

@@ -1,5 +1,7 @@
 use fluent_bundle::{FluentBundle, FluentResource, FluentValue};
 use std::collections::HashMap;
+use std::convert::TryFrom;
+use unic_langid::LanguageIdentifier;
 
 fn main() {
     let ftl_string = String::from(
@@ -14,7 +16,8 @@ unread-emails =
     ",
     );
     let res = FluentResource::try_new(ftl_string).expect("Could not parse an FTL string.");
-    let mut bundle = FluentBundle::new(&["en"]);
+    let langid_en = LanguageIdentifier::try_from("en").expect("Parsing failed.");
+    let mut bundle = FluentBundle::new(&[langid_en]);
     bundle
         .add_resource(res)
         .expect("Failed to add FTL resources to the bundle.");

fluent-bundle/examples/functions.rs

@@ -1,4 +1,6 @@
 use fluent_bundle::{FluentBundle, FluentResource, FluentValue};
+use std::convert::TryFrom;
+use unic_langid::LanguageIdentifier;
 
 fn main() {
     // We define the resources here so that they outlive
@@ -10,7 +12,8 @@ fn main() {
     let res2 = FluentResource::try_new(ftl_string2).expect("Could not parse an FTL string.");
     let res3 = FluentResource::try_new(ftl_string3).expect("Could not parse an FTL string.");
 
-    let mut bundle = FluentBundle::new(&["en-US"]);
+    let langid_en_us = LanguageIdentifier::try_from("en-US").expect("Parsing failed.");
+    let mut bundle = FluentBundle::new(&[langid_en_us]);
 
     // Test for a simple function that returns a string
     bundle

fluent-bundle/examples/hello.rs

@@ -3,7 +3,7 @@ use fluent_bundle::{FluentBundle, FluentResource};
 fn main() {
     let ftl_string = String::from("hello-world = Hello, world!");
     let res = FluentResource::try_new(ftl_string).expect("Could not parse an FTL string.");
-    let mut bundle = FluentBundle::new(&["en-US"]);
+    let mut bundle = FluentBundle::default();
     bundle
         .add_resource(&res)
         .expect("Failed to add FTL resources to the bundle.");

fluent-bundle/examples/message_reference.rs

@@ -10,7 +10,7 @@ bazbar = { baz } Bar
     );
     let res = FluentResource::try_new(ftl_string).expect("Could not parse an FTL string.");
 
-    let mut bundle = FluentBundle::new(&["x-testing"]);
+    let mut bundle = FluentBundle::default();
     bundle
         .add_resource(res)
         .expect("Failed to add FTL resources to the bundle.");

fluent-bundle/examples/selector.rs

@@ -16,7 +16,7 @@ hello-world2 = Hello { $name ->
     ",
     );
     let res = FluentResource::try_new(ftl_string).expect("Could not parse an FTL string.");
-    let mut bundle = FluentBundle::new(&["x-testing"]);
+    let mut bundle = FluentBundle::default();
     bundle
         .add_resource(res)
         .expect("Failed to add FTL resources to the bundle.");

fluent-bundle/examples/simple-app.rs

@@ -20,12 +20,14 @@
 use fluent_bundle::{FluentBundle, FluentResource, FluentValue};
 use fluent_locale::{negotiate_languages, NegotiationStrategy};
 use std::collections::HashMap;
+use std::convert::TryFrom;
 use std::env;
 use std::fs;
 use std::fs::File;
 use std::io;
 use std::io::prelude::*;
 use std::str::FromStr;
+use unic_langid::LanguageIdentifier;
 
 /// We need a generic file read helper function to
 /// read the localization resource file.
@@ -45,7 +47,7 @@ fn read_file(path: &str) -> Result<String, io::Error> {
 ///
 /// It is expected that every directory inside it
 /// has a name that is a valid BCP47 language tag.
-fn get_available_locales() -> Result<Vec<String>, io::Error> {
+fn get_available_locales() -> Result<Vec<LanguageIdentifier>, io::Error> {
     let mut locales = vec![];
 
     let res_dir = fs::read_dir("./fluent-bundle/examples/resources/")?;
@@ -55,7 +57,8 @@ fn get_available_locales() -> Result<Vec<String>, io::Error> {
             if path.is_dir() {
                 if let Some(name) = path.file_name() {
                     if let Some(name) = name.to_str() {
-                        locales.push(String::from(name));
+                        let langid = LanguageIdentifier::try_from(name).expect("Parsing failed.");
+                        locales.push(langid);
                     }
                 }
             }
@@ -64,27 +67,6 @@ fn get_available_locales() -> Result<Vec<String>, io::Error> {
     return Ok(locales);
 }
 
-/// This function negotiates the locales between available
-/// and requested by the user.
-///
-/// It uses `fluent-locale` library but one could
-/// use any other that will resolve the list of
-/// available locales based on the list of
-/// requested locales.
-fn get_app_locales(requested: &[&str]) -> Result<Vec<String>, io::Error> {
-    let available = get_available_locales()?;
-    let resolved_locales = negotiate_languages(
-        requested,
-        &available,
-        Some("en-US"),
-        &NegotiationStrategy::Filtering,
-    );
-    return Ok(resolved_locales
-        .into_iter()
-        .map(|s| String::from(s))
-        .collect());
-}
-
 static L10N_RESOURCES: &[&str] = &["simple.ftl"];
 
 fn main() {
@@ -94,24 +76,34 @@ fn main() {
     // 3. If the argument length is more than 1,
     //    take the second argument as a comma-separated
     //    list of requested locales.
-    //
-    //    Otherwise, take ["en-US"] as the default.
-    let requested = args
-        .get(2)
-        .map_or(vec!["en-US"], |arg| arg.split(",").collect());
+    let requested = args.get(2).map_or(vec![], |arg| {
+        arg.split(",")
+            .map(|s| LanguageIdentifier::try_from(s).expect("Parsing locale failed."))
+            .collect()
+    });
 
     // 4. Negotiate it against the available ones
-    let locales = get_app_locales(&requested).expect("Failed to retrieve available locales");
+    let default_locale = LanguageIdentifier::try_from("en-US").expect("Parsing failed.");
+    let available = get_available_locales().expect("Retrieving available locales failed.");
+    let resolved_locales = negotiate_languages(
+        &requested,
+        &available,
+        Some(&default_locale),
+        NegotiationStrategy::Filtering,
+    );
+    let current_locale = resolved_locales
+        .get(0)
+        .expect("At least one locale should match.");
 
     // 5. Create a new Fluent FluentBundle using the
     //    resolved locales.
-    let mut bundle = FluentBundle::new(&locales);
+    let mut bundle = FluentBundle::new(resolved_locales.clone());
 
     // 6. Load the localization resource
     for path in L10N_RESOURCES {
         let full_path = format!(
             "./fluent-bundle/examples/resources/{locale}/{path}",
-            locale = locales[0],
+            locale = current_locale,
             path = path
         );
         let source = read_file(&full_path).expect("Failed to read file.");

fluent-bundle/src/bundle.rs

@@ -7,10 +7,13 @@
 use std::borrow::Borrow;
 use std::borrow::Cow;
 use std::collections::hash_map::{Entry as HashEntry, HashMap};
+use std::convert::TryFrom;
+use std::default::Default;
 
 use fluent_locale::{negotiate_languages, NegotiationStrategy};
 use fluent_syntax::ast;
 use intl_pluralrules::{IntlPluralRules, PluralRuleType};
+use unic_langid::LanguageIdentifier;
 
 use crate::entry::Entry;
 use crate::entry::GetEntry;
@@ -33,12 +36,15 @@ pub struct Message<'m> {
 /// ```
 /// use fluent_bundle::{FluentBundle, FluentResource, FluentValue};
 /// use std::collections::HashMap;
+/// use std::convert::TryFrom;
+/// use unic_langid::LanguageIdentifier;
 ///
 /// 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"]);
+/// let langid_en = LanguageIdentifier::try_from("en-US").expect("Parsing failed.");
+/// let mut bundle = FluentBundle::new(&[langid_en]);
 /// bundle.add_resource(&resource)
 ///     .expect("Failed to add FTL resources to the bundle.");
 ///
@@ -86,7 +92,7 @@ pub struct Message<'m> {
 /// [`add_resource`]: ./struct.FluentBundle.html#method.add_resource
 /// [`Cow<str>`]: http://doc.rust-lang.org/std/borrow/enum.Cow.html
 pub struct FluentBundle<R> {
-    pub locales: Vec<String>,
+    pub locales: Vec<LanguageIdentifier>,
     pub(crate) resources: Vec<R>,
     pub(crate) entries: HashMap<String, Entry>,
     pub(crate) plural_rules: IntlPluralRules,
@@ -103,27 +109,33 @@ impl<R> FluentBundle<R> {
     /// ```
     /// use fluent_bundle::FluentBundle;
     /// use fluent_bundle::FluentResource;
+    /// use std::convert::TryFrom;
+    /// use unic_langid::LanguageIdentifier;
     ///
-    /// let mut bundle: FluentBundle<FluentResource> = FluentBundle::new(&["en-US"]);
+    /// let langid_en = LanguageIdentifier::try_from("en-US").expect("Parsing failed.");
+    /// let mut bundle: FluentBundle<FluentResource> = FluentBundle::new(&[langid_en]);
     /// ```
     ///
     /// # Errors
     ///
     /// This will panic if no formatters can be found for the locales.
-    pub fn new<S: ToString>(locales: &[S]) -> Self {
+    pub fn new<'a, L: 'a + Into<LanguageIdentifier> + PartialEq + Clone>(
+        locales: impl IntoIterator<Item = &'a L>,
+    ) -> Self {
         let locales = locales
-            .iter()
-            .map(std::string::ToString::to_string)
+            .into_iter()
+            .map(|s| s.clone().into())
             .collect::<Vec<_>>();
+        let default_langid = LanguageIdentifier::try_from("en").expect("Parsing failed.");
         let pr_locale = negotiate_languages(
             &locales,
-            IntlPluralRules::get_locales(PluralRuleType::CARDINAL),
-            Some("en"),
-            &NegotiationStrategy::Lookup,
+            &IntlPluralRules::get_locales(PluralRuleType::CARDINAL),
+            Some(&default_langid),
+            NegotiationStrategy::Lookup,
         )[0]
-        .to_owned();
+        .clone();
 
-        let pr = IntlPluralRules::create(&pr_locale, PluralRuleType::CARDINAL)
+        let pr = IntlPluralRules::create(pr_locale, PluralRuleType::CARDINAL)
             .expect("Failed to initialize PluralRules.");
         FluentBundle {
             locales,
@@ -149,14 +161,17 @@ impl<R> FluentBundle<R> {
     ///
     /// ```
     /// use fluent_bundle::{FluentBundle, FluentResource};
+    /// use std::convert::TryFrom;
+    /// use unic_langid::LanguageIdentifier;
     ///
     /// let ftl_string = String::from("
     /// hello = Hi!
     /// goodbye = Bye!
     /// ");
     /// let resource = FluentResource::try_new(ftl_string)
     ///     .expect("Could not parse an FTL string.");
-    /// let mut bundle = FluentBundle::new(&["en-US"]);
+    /// let langid_en = LanguageIdentifier::try_from("en-US").expect("Parsing failed.");
+    /// let mut bundle = FluentBundle::new(&[langid_en]);
     /// bundle.add_resource(resource)
     ///     .expect("Failed to add FTL resources to the bundle.");
     /// assert_eq!(true, bundle.has_message("hello"));
@@ -230,11 +245,14 @@ impl<R> FluentBundle<R> {
     ///
     /// ```
     /// use fluent_bundle::{FluentBundle, FluentResource};
+    /// use std::convert::TryFrom;
+    /// use unic_langid::LanguageIdentifier;
     ///
     /// let ftl_string = String::from("hello = Hi!");
     /// let resource = FluentResource::try_new(ftl_string)
     ///     .expect("Failed to parse an FTL string.");
-    /// let mut bundle = FluentBundle::new(&["en-US"]);
+    /// let langid_en = LanguageIdentifier::try_from("en-US").expect("Parsing failed.");
+    /// let mut bundle = FluentBundle::new(&[langid_en]);
     /// bundle.add_resource(&resource)
     ///     .expect("Failed to add FTL resources to the bundle.");
     /// assert_eq!(true, bundle.has_message("hello"));
@@ -262,7 +280,7 @@ impl<R> FluentBundle<R> {
         for attr in message.attributes.iter() {
             attributes.insert(attr.id.name, &attr.value);
         }
-        return Some(Message { value, attributes });
+        Some(Message { value, attributes })
     }
 
     pub fn format_pattern<'bundle>(
@@ -295,11 +313,14 @@ impl<R> FluentBundle<R> {
     ///
     /// ```
     /// use fluent_bundle::{FluentBundle, FluentResource, FluentValue};
+    /// use std::convert::TryFrom;
+    /// use unic_langid::LanguageIdentifier;
     ///
     /// let ftl_string = String::from("length = { STRLEN(\"12345\") }");
     /// let resource = FluentResource::try_new(ftl_string)
     ///     .expect("Could not parse an FTL string.");
-    /// let mut bundle = FluentBundle::new(&["en-US"]);
+    /// let langid_en = LanguageIdentifier::try_from("en-US").expect("Parsing failed.");
+    /// let mut bundle = FluentBundle::new(&[langid_en]);
     /// bundle.add_resource(&resource)
     ///     .expect("Failed to add FTL resources to the bundle.");
     ///
@@ -335,3 +356,20 @@ impl<R> FluentBundle<R> {
         }
     }
 }
+
+impl<R> Default for FluentBundle<R> {
+    fn default() -> Self {
+        let pr_langid = LanguageIdentifier::try_from("en").expect("Parsing failed.");
+        let langid = LanguageIdentifier::new();
+
+        let pr = IntlPluralRules::create(pr_langid, PluralRuleType::CARDINAL)
+            .expect("Failed to initialize PluralRules.");
+        FluentBundle {
+            plural_rules: pr,
+            locales: vec![langid],
+            resources: vec![],
+            entries: Default::default(),
+            use_isolating: false,
+        }
+    }
+}