Vendor dependencies

notes-service/vendor/unic-langid-impl/tests/canonicalize_test.rs

@@ -0,0 +1,13 @@
+use unic_langid_impl::canonicalize;
+
+fn assert_canonicalize(input: &str, output: &str) {
+    assert_eq!(&canonicalize(input).unwrap(), output);
+}
+
+#[test]
+fn test_canonicalize() {
+    assert_canonicalize("Pl", "pl");
+    assert_canonicalize("eN-uS", "en-US");
+    assert_canonicalize("ZH_hans_hK", "zh-Hans-HK");
+    assert_canonicalize("en-scouse-fonipa", "en-fonipa-scouse");
+}

notes-service/vendor/unic-langid-impl/tests/fixtures.rs

@@ -0,0 +1,75 @@
+use std::convert::TryInto;
+use std::error::Error;
+use std::fs::File;
+use std::path::Path;
+
+use unic_langid_impl::LanguageIdentifier;
+
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize)]
+struct LangIdTestInputData {
+    string: String,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+struct LangIdTestOutputObject {
+    language: Option<String>,
+    script: Option<String>,
+    region: Option<String>,
+    #[serde(default)]
+    variants: Vec<String>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(untagged)]
+enum LangIdTestOutput {
+    String(String),
+    Object(LangIdTestOutputObject),
+}
+
+#[derive(Serialize, Deserialize)]
+struct LangIdTestSet {
+    input: LangIdTestInputData,
+    output: LangIdTestOutput,
+}
+
+fn read_langid_testsets<P: AsRef<Path>>(path: P) -> Result<Vec<LangIdTestSet>, Box<dyn Error>> {
+    let file = File::open(path)?;
+    let sets = serde_json::from_reader(file)?;
+    Ok(sets)
+}
+
+fn test_langid_fixtures(path: &str) {
+    let tests = read_langid_testsets(path).unwrap();
+
+    for test in tests {
+        let s = test.input.string;
+
+        let langid: LanguageIdentifier = s.parse().expect("Parsing failed.");
+
+        match test.output {
+            LangIdTestOutput::Object(o) => {
+                let expected = LanguageIdentifier::from_parts(
+                    o.language.try_into().unwrap(),
+                    o.script.as_ref().map(|s| s.parse().unwrap()),
+                    o.region.as_ref().map(|r| r.parse().unwrap()),
+                    o.variants
+                        .iter()
+                        .map(|s| s.parse().unwrap())
+                        .collect::<Vec<_>>()
+                        .as_ref(),
+                );
+                assert_eq!(langid, expected);
+            }
+            LangIdTestOutput::String(s) => {
+                assert_eq!(langid.to_string(), s);
+            }
+        }
+    }
+}
+
+#[test]
+fn parse() {
+    test_langid_fixtures("./tests/fixtures/parsing.json");
+}

notes-service/vendor/unic-langid-impl/tests/language_identifier_test.rs

@@ -0,0 +1,225 @@
+use unic_langid_impl::parser::parse_language_identifier;
+use unic_langid_impl::subtags;
+use unic_langid_impl::CharacterDirection;
+use unic_langid_impl::LanguageIdentifier;
+
+fn assert_language_identifier(
+    loc: &LanguageIdentifier,
+    language: Option<&str>,
+    script: Option<&str>,
+    region: Option<&str>,
+    variants: Option<&[&str]>,
+) {
+    assert_eq!(
+        loc.language,
+        language.map_or(subtags::Language::default(), |l| {
+            subtags::Language::from_bytes(l.as_bytes()).unwrap()
+        })
+    );
+    assert_eq!(loc.script, script.map(|s| s.parse().unwrap()));
+    assert_eq!(loc.region, region.map(|r| r.parse().unwrap()));
+    let v = variants
+        .unwrap_or(&[])
+        .iter()
+        .map(|v| -> subtags::Variant { v.parse().unwrap() })
+        .collect::<Vec<_>>();
+    assert_eq!(
+        loc.variants().collect::<Vec<_>>(),
+        v.iter().collect::<Vec<_>>(),
+    );
+}
+
+fn assert_parsed_language_identifier(
+    input: &str,
+    language: Option<&str>,
+    script: Option<&str>,
+    region: Option<&str>,
+    variants: Option<&[&str]>,
+) {
+    let langid = parse_language_identifier(input.as_bytes()).unwrap();
+    assert_language_identifier(&langid, language, script, region, variants);
+}
+
+#[test]
+fn test_language_identifier_parser() {
+    assert_parsed_language_identifier("pl", Some("pl"), None, None, None);
+    assert_parsed_language_identifier("und", None, None, None, None);
+    assert_parsed_language_identifier("en-US", Some("en"), None, Some("US"), None);
+    assert_parsed_language_identifier("en-Latn-US", Some("en"), Some("Latn"), Some("US"), None);
+    assert_parsed_language_identifier("sl-nedis", Some("sl"), None, None, Some(&["nedis"]));
+}
+
+#[test]
+fn test_language_casing() {
+    assert_parsed_language_identifier("Pl", Some("pl"), None, None, None);
+    assert_parsed_language_identifier("En-uS", Some("en"), None, Some("US"), None);
+    assert_parsed_language_identifier("eN-lAtN-uS", Some("en"), Some("Latn"), Some("US"), None);
+    assert_parsed_language_identifier("ZH_cyrl_hN", Some("zh"), Some("Cyrl"), Some("HN"), None);
+}
+
+#[test]
+fn test_serialize_langid() {
+    let langid: LanguageIdentifier = "en-Latn-US".parse().unwrap();
+    assert_eq!(&langid.to_string(), "en-Latn-US");
+}
+
+#[test]
+fn test_sorted_variants() {
+    let langid: LanguageIdentifier = "en-nedis-macos".parse().unwrap();
+    assert_eq!(&langid.to_string(), "en-macos-nedis");
+
+    let langid = LanguageIdentifier::from_parts(
+        "en".parse().unwrap(),
+        None,
+        None,
+        &["nedis".parse().unwrap(), "macos".parse().unwrap()],
+    );
+    assert_eq!(&langid.to_string(), "en-macos-nedis");
+}
+
+#[test]
+fn test_from_parts_unchecked() {
+    let langid: LanguageIdentifier = "en-nedis-macos".parse().unwrap();
+    let (lang, script, region, variants) = langid.into_parts();
+    let langid = LanguageIdentifier::from_raw_parts_unchecked(
+        lang,
+        script,
+        region,
+        Some(variants.into_boxed_slice()),
+    );
+    assert_eq!(&langid.to_string(), "en-macos-nedis");
+}
+
+#[test]
+fn test_matches() {
+    let langid_en: LanguageIdentifier = "en".parse().unwrap();
+    let langid_en_us: LanguageIdentifier = "en-US".parse().unwrap();
+    let langid_en_us2: LanguageIdentifier = "en-US".parse().unwrap();
+    let langid_pl: LanguageIdentifier = "pl".parse().unwrap();
+    assert_eq!(langid_en.matches(&langid_en_us, false, false), false);
+    assert_eq!(langid_en_us.matches(&langid_en_us2, false, false), true);
+    assert_eq!(langid_en.matches(&langid_pl, false, false), false);
+    assert_eq!(langid_en.matches(&langid_en_us, true, false), true);
+}
+
+#[test]
+fn test_set_fields() {
+    let mut langid = LanguageIdentifier::default();
+    assert_eq!(&langid.to_string(), "und");
+
+    langid.language = "pl".parse().expect("Setting language failed");
+    assert_eq!(&langid.to_string(), "pl");
+
+    langid.language = "de".parse().expect("Setting language failed");
+    assert_eq!(&langid.to_string(), "de");
+    langid.region = Some("AT".parse().expect("Setting region failed"));
+    assert_eq!(&langid.to_string(), "de-AT");
+    langid.script = Some("Latn".parse().expect("Setting script failed"));
+    assert_eq!(&langid.to_string(), "de-Latn-AT");
+    langid.set_variants(&["macos".parse().expect("Setting variants failed")]);
+    assert_eq!(&langid.to_string(), "de-Latn-AT-macos");
+
+    assert_eq!(langid.has_variant("macos".parse().unwrap()), true);
+    assert_eq!(langid.has_variant("windows".parse().unwrap()), false);
+
+    langid.language.clear();
+    assert_eq!(&langid.to_string(), "und-Latn-AT-macos");
+    langid.region = None;
+    assert_eq!(&langid.to_string(), "und-Latn-macos");
+    langid.script = None;
+    assert_eq!(&langid.to_string(), "und-macos");
+    langid.clear_variants();
+    assert_eq!(&langid.to_string(), "und");
+
+    assert_eq!(langid.has_variant("macos".parse().unwrap()), false);
+}
+
+#[test]
+fn test_matches_as_range() {
+    let langid: LanguageIdentifier = "en-US".parse().unwrap();
+    let langid2: LanguageIdentifier = "en-US-windows".parse().unwrap();
+    assert_eq!(langid.matches(&langid2, false, false), false);
+    assert_eq!(langid.matches(&langid2, true, false), true);
+    assert_eq!(langid.matches(&langid2, false, true), false);
+    assert_eq!(langid.matches(&langid2, true, true), true);
+}
+
+#[test]
+fn test_character_direction() {
+    let en_us: LanguageIdentifier = "en-US".parse().unwrap();
+    assert_eq!(en_us.character_direction(), CharacterDirection::LTR);
+
+    let ar_af: LanguageIdentifier = "ar-AF".parse().unwrap();
+    assert_eq!(ar_af.character_direction(), CharacterDirection::RTL);
+
+    let ks: LanguageIdentifier = "ks".parse().unwrap();
+    assert_eq!(ks.character_direction(), CharacterDirection::RTL);
+
+    let ks_deva: LanguageIdentifier = "ks-Deva".parse().unwrap();
+    assert_eq!(ks_deva.character_direction(), CharacterDirection::LTR);
+
+    let mn_mong: LanguageIdentifier = "mn-Mong".parse().unwrap();
+    assert_eq!(mn_mong.character_direction(), CharacterDirection::TTB);
+
+    let lid: LanguageIdentifier = "pa-Guru".parse().unwrap();
+    assert_eq!(lid.character_direction(), CharacterDirection::LTR);
+
+    let lid_pa_pk: LanguageIdentifier = "pa-PK".parse().unwrap();
+    assert_eq!(lid_pa_pk.character_direction(), CharacterDirection::RTL);
+
+    let lid_ar_us: LanguageIdentifier = "ar-US".parse().unwrap();
+    assert_eq!(lid_ar_us.character_direction(), CharacterDirection::RTL);
+}
+
+#[cfg(not(feature = "likelysubtags"))]
+#[test]
+fn test_character_direction_without_likelysubtags() {
+    let lid: LanguageIdentifier = "pa".parse().unwrap();
+    assert_eq!(lid.character_direction(), CharacterDirection::RTL);
+}
+
+#[cfg(feature = "likelysubtags")]
+#[test]
+fn test_character_direction_with_likelysubtags() {
+    let lid_pa: LanguageIdentifier = "pa".parse().unwrap();
+    assert_eq!(lid_pa.character_direction(), CharacterDirection::LTR);
+}
+
+#[test]
+fn test_langid_ord() {
+    let input = &[
+        "en-US-macos-zarab",
+        "en-US-macos-nedis",
+        "en-US-macos",
+        "en-GB",
+        "en",
+        "en-US",
+        "ar",
+        "fr",
+        "de",
+    ];
+
+    let mut langids = input
+        .iter()
+        .map(|l| -> LanguageIdentifier { l.parse().unwrap() })
+        .collect::<Vec<_>>();
+
+    langids.sort();
+
+    let result = langids.iter().map(|l| l.to_string()).collect::<Vec<_>>();
+
+    assert_eq!(
+        &result,
+        &[
+            "ar",
+            "de",
+            "en",
+            "en-GB",
+            "en-US",
+            "en-US-macos",
+            "en-US-macos-nedis",
+            "en-US-macos-zarab",
+            "fr"
+        ]
+    );
+}

notes-service/vendor/unic-langid-impl/tests/likelysubtags.rs

@@ -0,0 +1,113 @@
+use unic_langid_impl::likelysubtags::{maximize, minimize, CLDR_VERSION};
+use unic_langid_impl::subtags;
+
+static STRINGS: &[(&str, Option<&str>)] = &[
+    ("en-US", Some("en-Latn-US")),
+    ("en-GB", Some("en-Latn-GB")),
+    ("es-AR", Some("es-Latn-AR")),
+    ("it", Some("it-Latn-IT")),
+    ("zh-Hans-CN", None),
+    ("de-AT", Some("de-Latn-AT")),
+    ("pl", Some("pl-Latn-PL")),
+    ("fr-FR", Some("fr-Latn-FR")),
+    ("de-AT", Some("de-Latn-AT")),
+    ("sr-Cyrl-SR", None),
+    ("nb-NO", Some("nb-Latn-NO")),
+    ("fr-FR", Some("fr-Latn-FR")),
+    ("mk", Some("mk-Cyrl-MK")),
+    ("uk", Some("uk-Cyrl-UA")),
+    ("und-PL", Some("pl-Latn-PL")),
+    ("und-Latn-AM", Some("ku-Latn-AM")),
+    ("ug-Cyrl", Some("ug-Cyrl-KZ")),
+    ("sr-ME", Some("sr-Latn-ME")),
+    ("mn-Mong", Some("mn-Mong-CN")),
+    ("lif-Limb", Some("lif-Limb-IN")),
+    ("gan", Some("gan-Hans-CN")),
+    ("zh-Hant", Some("zh-Hant-TW")),
+    ("yue-Hans", Some("yue-Hans-CN")),
+    ("unr", Some("unr-Beng-IN")),
+    ("unr-Deva", Some("unr-Deva-NP")),
+    ("und-Thai-CN", Some("lcp-Thai-CN")),
+    ("ug-Cyrl", Some("ug-Cyrl-KZ")),
+    ("en-Latn-DE", None),
+    ("pl-FR", Some("pl-Latn-FR")),
+    ("de-CH", Some("de-Latn-CH")),
+    ("tuq", Some("tuq-Latn-TD")),
+    ("sr-ME", Some("sr-Latn-ME")),
+    ("ng", Some("ng-Latn-NA")),
+    ("klx", Some("klx-Latn-PG")),
+    ("kk-Arab", Some("kk-Arab-CN")),
+    ("en-Cyrl", Some("en-Cyrl-US")),
+    ("und-Cyrl-UK", Some("ru-Cyrl-UK")),
+    ("und-Arab", Some("ar-Arab-EG")),
+    ("und-Arab-FO", Some("ar-Arab-FO")),
+    ("zh-TW", Some("zh-Hant-TW")),
+];
+
+fn extract_input(
+    s: &str,
+) -> (
+    subtags::Language,
+    Option<subtags::Script>,
+    Option<subtags::Region>,
+) {
+    let chunks: Vec<&str> = s.split("-").collect();
+    let lang: subtags::Language = chunks[0].parse().unwrap();
+    let (script, region) = if let Some(s) = chunks.get(1) {
+        if let Ok(script) = s.parse() {
+            let region = chunks.get(2).map(|r| r.parse().unwrap());
+            (Some(script), region)
+        } else {
+            let region = s.parse().unwrap();
+            (None, Some(region))
+        }
+    } else {
+        (None, None)
+    };
+    (lang, script, region)
+}
+
+fn extract_output(
+    s: Option<&str>,
+) -> Option<(
+    subtags::Language,
+    Option<subtags::Script>,
+    Option<subtags::Region>,
+)> {
+    s.map(|s| {
+        let chunks: Vec<&str> = s.split("-").collect();
+        (
+            chunks[0].parse().unwrap(),
+            chunks.get(1).map(|s| s.parse().unwrap()),
+            chunks.get(2).map(|s| s.parse().unwrap()),
+        )
+    })
+}
+
+#[test]
+fn maximize_test() {
+    for i in STRINGS {
+        let chunks = extract_input(i.0);
+        let result = maximize(chunks.0, chunks.1, chunks.2);
+        assert_eq!(extract_output(i.1), result);
+    }
+}
+
+#[test]
+fn version_works() {
+    assert_eq!(CLDR_VERSION, "44");
+}
+
+#[test]
+fn minimize_test() {
+    let lang = "zh".parse().unwrap();
+    let script = "Hant".parse().unwrap();
+    let result = minimize(lang, Some(script), None);
+    assert_eq!(result, Some(extract_input("zh-TW")));
+
+    let lang = "en".parse().unwrap();
+    let script = "Latn".parse().unwrap();
+    let region = "US".parse().unwrap();
+    let result = minimize(lang, Some(script), Some(region));
+    assert_eq!(result, Some(extract_input("en")));
+}