icu_provider_source 2.2.0

A data provider based on CLDR and ICU data.
Documentation 
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

// This file is part of ICU4X. For terms of use, please see the file
// called LICENSE at the top level of the ICU4X source tree
// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).

/// Data for calendar arithmetic
pub(crate) mod eras;

#[test]
fn test_calendar_resolution() {
    use std::collections::BTreeMap;

    use icu::{
        calendar::preferences::{CalendarAlgorithm, CalendarPreferences},
        locale::{
            extensions::unicode::Value,
            subtags::{Language, Region},
            LanguageIdentifier,
        },
    };

    #[derive(serde::Deserialize)]
    struct Resource {
        supplemental: Supplemental,
    }

    #[derive(serde::Deserialize)]
    #[serde(rename_all = "camelCase")]
    struct Supplemental {
        calendar_preference_data: BTreeMap<Region, Vec<String>>,
    }

    for (&region, algorithms) in &crate::SourceDataProvider::new_testing()
        .cldr()
        .unwrap()
        .core()
        .read_and_parse::<Resource>("supplemental/calendarPreferenceData.json")
        .unwrap()
        .supplemental
        .calendar_preference_data
    {
        let mut region_preferences = CalendarPreferences::from(&LanguageIdentifier::from((
            Language::UNKNOWN,
            None,
            Some(region),
        )));

        let algorithms = algorithms
            .iter()
            .map(|a| match a.as_str() {
                "gregorian" => CalendarAlgorithm::Gregory,
                a => CalendarAlgorithm::try_from(&Value::try_from_str(a).unwrap()).unwrap(),
            })
            .collect::<Vec<_>>();

        assert_eq!(
            region_preferences.resolved_algorithm(),
            algorithms[0],
            "{region:?}",
        );

        if let Some(&preferred_islamic_algorithm) = algorithms
            .iter()
            .find(|&&a| matches!(a, CalendarAlgorithm::Hijri(Some(_))))
        {
            region_preferences.calendar_algorithm = Some(CalendarAlgorithm::Hijri(None));
            assert_eq!(
                region_preferences.resolved_algorithm(),
                preferred_islamic_algorithm,
                "{region:?}",
            );
        }
    }
}