Implement Extended Currency DataModel

components/experimental/src/dimension/provider/currency.rs

@@ -106,6 +106,7 @@ pub enum PlaceholderValue {
  /// The place holder is the iso code.
  ISO,
 }
+
 #[cfg_attr(
  feature = "datagen",
  derive(serde::Serialize, databake::Bake),

components/experimental/src/dimension/provider/extended_currency.rs

@@ -0,0 +1,85 @@
+// 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 ).
+
+// Provider structs must be stable
+#![allow(clippy::exhaustive_structs, clippy::exhaustive_enums)]
+
+//! Data provider struct definitions for this ICU4X component.
+//!
+//! Read more about data providers: [`icu_provider`]
+
+use icu_provider::prelude::*;
+use zerovec::ZeroMap;
+
+#[cfg(feature = "compiled_data")]
+/// Baked data
+///
+/// <div class="stab unstable">
+/// 🚧 This code is considered unstable; it may change at any time, in breaking or non-breaking ways,
+/// including in SemVer minor releases. In particular, the `DataProvider` implementations are only
+/// guaranteed to match with this version's `*_unstable` providers. Use with caution.
+/// </div>
+pub use crate::provider::Baked;
+
+/// Currency Extended V1 data struct.
+#[icu_provider::data_struct(marker(CurrencyExtendedDataV1Marker, "currency/extended@1"))]
+#[derive(Debug, Clone, Default, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize))]
+#[cfg_attr(
+ feature = "datagen", 
+ derive(serde::Serialize, databake::Bake),
+ databake(path = icu_experimental::dimension::provider::extended_currency)
+)]
+#[yoke(prove_covariance_manually)]
+pub struct CurrencyExtendedDataV1<'data> {
+ // TODO: Implement currency pattern selection logic to choose between standard or standard next to text pattern.
+ /// Contains the localized display names for a currency based on plural rules.
+ /// For instance, in the "en" locale for the "USD" currency:
+ /// - "US Dollars" when count is `zero`,
+ /// - "US Dollar" when count is `one`,
+ /// ... etc.
+ #[cfg_attr(feature = "serde", serde(borrow))]
+ pub display_names: ZeroMap<'data, Count, str>,
+}
+
+/// A CLDR plural keyword, or the explicit value 1.
+/// See <https://www.unicode.org/reports/tr35/tr35-numbers.html#Language_Plural_Rules>.
+#[zerovec::make_ule(CountULE)]
+#[zerovec::derive(Debug)]
+#[derive(Copy, Clone, PartialOrd, Ord, PartialEq, Eq, Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize))]
+#[cfg_attr(
+ feature = "datagen", 
+ derive(serde::Serialize, databake::Bake),
+ databake(path = icu_experimental::dimension::provider::extended_currency)
+)]
+#[repr(u8)]
+pub enum Count {
+ /// The CLDR keyword `zero`.
+ Zero = 0,
+ /// The CLDR keyword `one`.
+ One = 1,
+ /// The CLDR keyword `two`.
+ Two = 2,
+ /// The CLDR keyword `few`.
+ Few = 3,
+ /// The CLDR keyword `many`.
+ Many = 4,
+ /// The CLDR keyword `other`.
+ Other = 5,
+ // TODO(younies): revise this for currency
+ /// The explicit 1 case, see <https://www.unicode.org/reports/tr35/tr35-numbers.html#Explicit_0_1_rules>.
+ Explicit1 = 6,
+ // NOTE(egg): No explicit 0, because the compact decimal pattern selection
+ // algorithm does not allow such a thing to arise.
+ // TODO(younies): implment this case.
+ /// The default case.
+ /// NOTE:
+ /// Used as the default when there is no match.
+ /// This is also used to replace the most frequently occurring case in all plural rules.
+ Default = 7,
+
+ /// The display name for the currency.
+ DisplayName = 8,
+}

components/experimental/src/dimension/provider/mod.rs

@@ -3,5 +3,6 @@
 // (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
 
 pub mod currency;
+pub mod extended_currency;
 pub mod percent;
 pub mod ule;

provider/datagen/src/transform/cldr/cldr_serde/currencies.rs → provider/datagen/src/transform/cldr/cldr_serde/currencies/data.rs

@@ -18,6 +18,27 @@ pub(in crate::provider) struct CurrencyPatterns {
 
  #[serde(rename = "symbol-alt-narrow")]
  pub(in crate::provider) narrow: Option<String>,
+
+ #[serde(rename = "displayName")]
+ pub(in crate::provider) display_name: Option<String>,
+
+ #[serde(rename = "displayName-count-zero")]
+ pub(in crate::provider) zero: Option<String>,
+
+ #[serde(rename = "displayName-count-one")]
+ pub(in crate::provider) one: Option<String>,
+
+ #[serde(rename = "displayName-count-two")]
+ pub(in crate::provider) two: Option<String>,
+
+ #[serde(rename = "displayName-count-few")]
+ pub(in crate::provider) few: Option<String>,
+
+ #[serde(rename = "displayName-count-many")]
+ pub(in crate::provider) many: Option<String>,
+
+ #[serde(rename = "displayName-count-other")]
+ pub(in crate::provider) other: Option<String>,
 }
 
 #[derive(PartialEq, Debug, Deserialize)]
@@ -30,4 +51,4 @@ pub(in crate::provider) struct LangNumbers {
  pub(in crate::provider) numbers: Numbers,
 }
 
-pub(in crate::provider) type Resource = super::LocaleResource<LangNumbers>;
+pub(in crate::provider) type Resource = super::super::LocaleResource<LangNumbers>;

provider/datagen/src/transform/cldr/cldr_serde/currencies/mod.rs

@@ -0,0 +1,6 @@
+// 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 ).
+
+pub mod data;
+pub mod supplemental;

provider/datagen/src/transform/cldr/cldr_serde/mod.rs

@@ -12,7 +12,6 @@ pub(in crate::provider) mod ca;
 pub(in crate::provider) mod coverage_levels;
 #[cfg(feature = "experimental_components")]
 pub(in crate::provider) mod currencies;
-pub(in crate::provider) mod currency_data;
 #[cfg(feature = "experimental_components")]
 pub(in crate::provider) mod date_fields;
 pub(in crate::provider) mod directionality;

provider/datagen/src/transform/cldr/currency/essentials.rs

@@ -83,10 +83,10 @@ impl DataProvider<CurrencyEssentialsV1Marker> for DatagenProvider {
  self.check_req::<CurrencyEssentialsV1Marker>(req)?;
  let langid = req.locale.get_langid();
 
- let currencies_resource: &cldr_serde::currencies::Resource = self
- .cldr()?
- .numbers()
- .read_and_parse(&langid, "currencies.json")?;
+ let currencies_resource: &cldr_serde::currencies::data::Resource =
+ self.cldr()?
+  .numbers()
+  .read_and_parse(&langid, "currencies.json")?;
 
  let numbers_resource: &cldr_serde::numbers::Resource = self
  .cldr()?
@@ -117,7 +117,7 @@ impl IterableDataProviderCached<CurrencyEssentialsV1Marker> for DatagenProvider
 
 fn extract_currency_essentials<'data>(
  provider: &DatagenProvider,
- currencies_resource: &cldr_serde::currencies::Resource,
+ currencies_resource: &cldr_serde::currencies::data::Resource,
  numbers_resource: &cldr_serde::numbers::Resource,
 ) -> Result<CurrencyEssentialsV1<'data>, DataError> {
  let currencies = &currencies_resource.main.value.numbers.currencies;

provider/datagen/src/transform/cldr/currency/extended.rs

@@ -0,0 +1,172 @@
+// 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 ).
+
+use crate::provider::transform::cldr::cldr_serde;
+use crate::DatagenProvider;
+
+use std::borrow::Cow;
+use std::collections::BTreeMap;
+use std::collections::HashSet;
+
+use icu_experimental::dimension::provider::extended_currency::Count;
+use icu_provider::datagen::IterableDataProvider;
+use tinystr::TinyAsciiStr;
+
+use icu_experimental::dimension::provider::extended_currency::*;
+use icu_provider::prelude::*;
+use icu_provider::DataProvider;
+
+impl DataProvider<CurrencyExtendedDataV1Marker> for crate::DatagenProvider {
+ fn load(
+ &self,
+ req: DataRequest,
+ ) -> Result<DataResponse<CurrencyExtendedDataV1Marker>, DataError> {
+ self.check_req::<CurrencyExtendedDataV1Marker>(req)?;
+
+ let langid = req.locale.get_langid();
+ let currencies_resource: &cldr_serde::currencies::data::Resource =
+ self.cldr()?
+ .numbers()
+ .read_and_parse(&langid, "currencies.json")?;
+
+ let aux = req
+ .marker_attributes
+ .parse::<TinyAsciiStr<3>>()
+ .map_err(|_| DataError::custom("failed to parse aux key into tinystr"))?;
+ let currency = currencies_resource
+ .main
+ .value
+ .numbers
+ .currencies
+ .get(&aux.to_unvalidated())
+ .ok_or(DataError::custom("No currency associated with the aux key"))?;
+
+ let mut placeholders: BTreeMap<Count, String> = BTreeMap::new();
+
+ fn add_placeholder(
+ placeholders: &mut BTreeMap<Count, String>,
+ key: Count,
+ value: Option<String>,
+ ) {
+ if let Some(val) = value {
+ placeholders.insert(key, val);
+ }
+ }
+
+ add_placeholder(&mut placeholders, Count::Zero, currency.zero.clone());
+ add_placeholder(&mut placeholders, Count::One, currency.one.clone());
+ add_placeholder(&mut placeholders, Count::Two, currency.two.clone());
+ add_placeholder(&mut placeholders, Count::Few, currency.few.clone());
+ add_placeholder(&mut placeholders, Count::Many, currency.many.clone());
+ add_placeholder(&mut placeholders, Count::Other, currency.other.clone());
+ add_placeholder(
+ &mut placeholders,
+ Count::DisplayName,
+ currency.display_name.clone(),
+ );
+
+ let data = CurrencyExtendedDataV1 {
+ display_names: placeholders
+ .into_iter()
+ .map(|(k, v)| (k, Cow::Owned(v)))
+ .collect(),
+ };
+
+ Ok(DataResponse {
+ metadata: Default::default(),
+ payload: Some(DataPayload::from_owned(data)),
+ })
+ }
+}
+
+impl IterableDataProvider<CurrencyExtendedDataV1Marker> for DatagenProvider {
+ fn supported_requests(&self) -> Result<HashSet<(DataLocale, DataMarkerAttributes)>, DataError> {
+ // TODO: This is a temporary implementation until we have a better way to handle large number of json files.
+ let currencies_to_support: HashSet<_> =
+ ["USD", "CAD", "EUR", "GBP", "EGP"].into_iter().collect();
+
+ let mut result = HashSet::new();
+ let numbers = self.cldr()?.numbers();
+ let langids = numbers.list_langs()?;
+ for langid in langids {
+ let currencies_resource: &cldr_serde::currencies::data::Resource = self
+ .cldr()?
+ .numbers()
+ .read_and_parse(&langid, "currencies.json")?;
+
+ let currencies = &currencies_resource.main.value.numbers.currencies;
+ for key in currencies.keys() {
+ let key_string = key
+ .try_into_tinystr()
+ .map_err(|_| DataError::custom("failed to parse currency code into tinystr"))?
+ .parse::<String>()
+ .map_err(|_| DataError::custom("failed to parse currency code into string"))?;
+ if !currencies_to_support.contains(key_string.as_str()) {
+ continue;
+ }
+
+ let key = key
+ .try_into_tinystr()
+ .map_err(|_| DataError::custom("failed to parse currency code into tinystr"))?;
+
+ let attributes = DataMarkerAttributes::from_tinystr(key.resize());
+ result.insert((DataLocale::from(&langid), attributes));
+ }
+ }
+
+ Ok(result)
+ }
+}
+
+#[test]
+fn test_basic() {
+ use icu_locale_core::langid;
+
+ let provider = DatagenProvider::new_testing();
+ let en: DataPayload<CurrencyExtendedDataV1Marker> = provider
+ .load(DataRequest {
+ locale: &langid!("en").into(),
+ marker_attributes: &"USD".parse().unwrap(),
+ ..Default::default()
+ })
+ .unwrap()
+ .take_payload()
+ .unwrap();
+ let display_names = en.get().to_owned().display_names;
+ assert_eq!(display_names.get(&Count::Zero), None);
+ assert_eq!(display_names.get(&Count::One).unwrap(), "US dollar");
+ assert_eq!(display_names.get(&Count::Two), None);
+ assert_eq!(display_names.get(&Count::Few), None);
+ assert_eq!(display_names.get(&Count::Many), None);
+ assert_eq!(display_names.get(&Count::Other).unwrap(), "US dollars");
+ assert_eq!(display_names.get(&Count::DisplayName).unwrap(), "US Dollar");
+
+ let fr: DataPayload<CurrencyExtendedDataV1Marker> = provider
+ .load(DataRequest {
+ locale: &langid!("fr").into(),
+ marker_attributes: &"USD".parse().unwrap(),
+ ..Default::default()
+ })
+ .unwrap()
+ .take_payload()
+ .unwrap();
+
+ let display_names = fr.get().to_owned().display_names;
+ assert_eq!(display_names.get(&Count::Zero), None);
+ assert_eq!(
+ display_names.get(&Count::One).unwrap(),
+ "dollar des États-Unis"
+ );
+ assert_eq!(display_names.get(&Count::Two), None);
+ assert_eq!(display_names.get(&Count::Few), None);
+ assert_eq!(display_names.get(&Count::Many), None);
+ assert_eq!(
+ display_names.get(&Count::Other).unwrap(),
+ "dollars des États-Unis"
+ );
+ assert_eq!(
+ display_names.get(&Count::DisplayName).unwrap(),
+ "dollar des États-Unis"
+ );
+}

provider/datagen/src/transform/cldr/currency/mod.rs

@@ -3,3 +3,4 @@
 // (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
 
 pub(in crate::provider) mod essentials;
+pub(in crate::provider) mod extended;