The feature set of ICU4X

use icu_calendar::{types::IsoWeekday, Date};

fn main() {
  let mut date_iso = Date::try_new_iso_date(1977, 5, 13)
    .expect("Failed to initialize ISO Date instance.");

  // use the methods {year, month, day_of_month} to access the metadata
  assert_eq!(date_iso.year().number, 1977);
  assert_eq!(date_iso.month().ordinal, 5);
  assert_eq!(date_iso.day_of_month().0, 13);

  // compute data about this timestamp
  assert_eq!(date_iso.day_of_week(), IsoWeekday::Friday);
  assert_eq!(date_iso.days_in_year(), 365);
  assert_eq!(date_iso.days_in_month(), 31);
}

// Conversion into Indian calendar: 1899-02-23.
let date_indian = date_iso.to_calendar(Indian);
assert_eq!(date_indian.year().number, 1899);
assert_eq!(date_indian.month().ordinal, 2);
assert_eq!(date_indian.day_of_month().0, 23);

cargo install icu_datagen
icu4x-datagen --keys all --locales full --include-collations 'search*' --cldr-tag 'latest' --format blob --out internationalization_blob.postcard

cargo add icu --features serde
cargo add icu_provider_blob

use std::fs;

use icu::locid::{locale, Locale};
use icu::calendar::DateTime;
use icu::datetime::{DateTimeFormatter, options::length};
use icu_provider_blob::BlobDataProvider;

// locale to use
const LOCALE: Locale = locale!("ja");

fn main() {
  // configuration
  let options = length::Bag::from_date_time_style(length::Date::Long, length::Time::Medium);
  let blob = fs::read("internationalization_blob.postcard").expect("Failed to read file");
  let provider = BlobDataProvider::try_new_from_blob(blob.into_boxed_slice())
    .expect("Failed to initialize Data Provider.");

  // timestamp to use
  let timestamp = DateTime::try_new_iso_datetime(1977, 5, 13, 15, 43, 26)
    .expect("Failed to initialize ISO datetime");

  // formatter instance
  let dtf = DateTimeFormatter::try_new_with_buffer_provider(&provider, &LOCALE.into(), options.into())
    .expect("Failed to initialize DateTimeFormatter");

  println!("{}", dtf.format(&timestamp.to_any()).expect("Formatting should succeed"));
  // prints "1977年5月13日 15:43:26"
}

use std::fs;
use icu::calendar::DateTime;
use icu::datetime::time_zone::TimeZoneFormatterOptions;
use icu::timezone::CustomTimeZone;
use icu::timezone::MetazoneCalculator;
use icu::datetime::time_zone::TimeZoneFormatter;
use icu::datetime::{DateTimeFormatter, options::length};
use icu::locid::locale;
use icu_provider_blob::BlobDataProvider;
use icu::timezone::provider::{MetazoneId, TimeZoneBcp47Id};
use tinystr::tinystr;
use icu::timezone::GmtOffset;

fn main() {
  let blob = fs::read("internationalization_blob.postcard").expect("Failed to read file");
  let provider = BlobDataProvider::try_new_from_blob(blob.into_boxed_slice())
    .expect("Failed to initialize Data Provider.");
  let mzc = MetazoneCalculator::try_new_with_buffer_provider(&provider).unwrap();

  let tzf = TimeZoneFormatter::try_new_with_buffer_provider(
    &provider, &locale!("en").into(), TimeZoneFormatterOptions::default()
  ).unwrap();

  // timezone "gugum" corresponds to metazone "guam"
  let ref_date = DateTime::try_new_iso_datetime(1977, 5, 13, 15, 43, 26)
    .expect("Failed to initialize ISO Date instance.");

  let timezone_id = TimeZoneBcp47Id(tinystr!(8, "gugum"));
  let metazone = mzc.compute_metazone_from_time_zone(timezone_id, &ref_date);
  let expected_metazone_id = MetazoneId(tinystr!(4, "guam"));

  assert_eq!(metazone, Some(expected_metazone_id));

  // parsing and default formatting
  let timezone = "+0530".parse::<CustomTimeZone>().unwrap();
  assert_eq!(tzf.format_to_string(&timezone), "GMT+05:30");

  // more sophisticated parsing
  let tz0: CustomTimeZone = "Z".parse().expect("Failed to parse a time zone.");
  let tz1: CustomTimeZone = "+02".parse().expect("Failed to parse a time zone.");
  let tz2: CustomTimeZone = "-0230".parse().expect("Failed to parse a time zone.");
  let tz3: CustomTimeZone = "+02:30".parse().expect("Failed to parse a time zone.");

  assert_eq!(tz0.gmt_offset.map(GmtOffset::offset_seconds), Some(0));
  assert_eq!(tz1.gmt_offset.map(GmtOffset::offset_seconds), Some(7200));
  assert_eq!(tz2.gmt_offset.map(GmtOffset::offset_seconds), Some(-9000));
  assert_eq!(tz3.gmt_offset.map(GmtOffset::offset_seconds), Some(9000));
}

use std::fs;
use icu::locid::{locale, Locale};
use icu_provider::DataLocale;
use icu_provider_blob::BlobDataProvider;
use fixed_decimal::FixedDecimal;
use icu::decimal::FixedDecimalFormatter;

// locale to use
const LOCALE: Locale = locale!("en");

fn main() {
  let blob = fs::read("internationalization_blob.postcard").expect("Failed to read file");
  let provider = BlobDataProvider::try_new_from_blob(blob.into_boxed_slice())
    .expect("Failed to initialize Data Provider.");

  let fdf = FixedDecimalFormatter::try_new_with_buffer_provider(
    &provider, &DataLocale::from(LOCALE), Default::default()
  ).expect("Data should load successfully");

  let fixed_decimal = FixedDecimal::from(1000007);

  println!("{}", fdf.format_to_string(&fixed_decimal));
  // prints "১০,০০,০০৭" for locale "bn"
  // prints "1 000 007" for locale "sv"
  // prints "1.000.007" for locale "de"
  // prints "1,000,007" for locale "en"
}

use std::fs;
use icu::locid::{locale, Locale};
use icu_provider_blob::BlobDataProvider;
use icu::plurals::{PluralCategory, PluralRules};

// locale to use
const LOCALE: Locale = locale!("en");

fn main() {
  let blob = fs::read("internationalization_blob.postcard").expect("Failed to read file");
  let provider = BlobDataProvider::try_new_from_blob(blob.into_boxed_slice()).unwrap();

  let pr = PluralRules::try_new_ordinal_with_buffer_provider(&provider, &LOCALE.into()).unwrap();

  for i in 0..6 {
    let fallback = format!("{}th", i);
    println!("{} apple",
      match pr.category_for(i) {
        PluralCategory::Zero => panic!("impossible for locale 'en'"),
        PluralCategory::One => "1st", // {1}
        PluralCategory::Two => "2nd", // {2}
        PluralCategory::Few => "3rd", // {3}
        PluralCategory::Many => panic!("impossible for locale 'en'"),
        PluralCategory::Other => &fallback, // {0, 4, 5}
      }
    );
  }
}

use std::fs;
use core::cmp::Ordering;
use icu_provider_blob::BlobDataProvider;
use icu::collator::*;
use icu::locid::{locale, Locale};

// locale to use
const LOCALE: Locale = locale!("en");

fn main() {
  let blob = fs::read("internationalization_blob.postcard").expect("Failed to read file");
  let provider = BlobDataProvider::try_new_from_blob(blob.into_boxed_slice())
    .expect("Failed to initialize Data Provider.");

  let mut words = ["pollo", "polvo"];

  let locale_es: Locale = locale!("es-u-co-trad");
  let mut options = CollatorOptions::new();
  options.strength = Some(Strength::Primary);
  let collator_es: Collator = Collator::try_new_with_buffer_provider(
    &provider, &locale_es.into(), options
  ).unwrap();

  // NOTE: "pollo" > "polvo" in traditional Spanish
  words.sort();
  println!("words = {:?}", &words); // ["pollo", "polvo"] in pure rust without locale support
  words.sort_by(|a, b| collator_es.compare(a, b));
  println!("words = {:?}", &words); // ["polvo", "pollo"] in ICU4X with locale support
}

use std::fs;
use icu_provider_blob::BlobDataProvider;
use icu::locid::locale;
use icu::list::ListFormatter;
use icu::list::ListLength;

fn main() {
  let blob = fs::read("internationalization_blob.postcard").expect("Failed to read file");
  let provider = BlobDataProvider::try_new_from_blob(blob.into_boxed_slice())
    .expect("Failed to initialize Data Provider.");

  let list_formatter = ListFormatter::try_new_and_with_length_with_buffer_provider(
    &provider,
    &locale!("es").into(),
    ListLength::Wide,
  )
  .expect("Data should load successfully");

  println!("{:?}", list_formatter.format_to_string(["España", "Suiza"].iter()));
  // prints "España y Suiza"

  println!("{:?}", list_formatter.format_to_string(["España", "Suiza", "Italia"].iter()));
  // The Spanish 'y' sometimes becomes an 'e':
  // prints "España, Suiza e Italia"
}

use icu::properties::{maps, Script};

let map = maps::load_script(&icu_testdata::unstable())
  .expect("The data should be valid");
let script = map.as_borrowed();

assert_eq!(script.get('🎃'), Script::Common); // U+1F383 JACK-O-LANTERN
assert_eq!(script.get('木'), Script::Han); // U+6728

use icu_testdata;
use icu::normalizer;

fn main() -> Result<(), normalizer::NormalizerError> {
  {
    let normalizer = normalizer::ComposingNormalizer::try_new_nfc_with_any_provider(&icu_testdata::any())?;
    // X := U+0043  LATIN CAPITAL LETTER C
    // Y := U+0327  COMBINING CEDILLA
    // Z := U+00C7  LATIN CAPITAL LETTER C WITH CEDILLA
    // {X, Y} is canonically equivalent to {Z}
    let input_text = "\u{0043}\u{0327}";
    let expected_text = "\u{00C7}";
    let normalized_text = normalizer.normalize(input_text);
    assert_eq!(normalized_text, expected_text);
  }

  {
    let normalizer = normalizer::ComposingNormalizer::try_new_nfkc_with_any_provider(&icu_testdata::any())?;
    // R := 0x2460  CIRCLED DIGIT ONE
    // S := 0x31  DIGIT ONE
    // {R} is compatible-equivalent to {S}
    let input_text = "\u{2460}";
    let expected_text = "\u{0031}";
    let normalized_text = normalizer.normalize(input_text);
    assert_eq!(normalized_text, expected_text);
  }

  Ok(())
}

use icu::segmenter::LineSegmenter;
use icu::segmenter::WordSegmenter;
use icu::segmenter::SentenceSegmenter;
use icu::segmenter::GraphemeClusterSegmenter;
use icu_testdata;

fn main() {
  let line_seg = LineSegmenter::try_new_unstable(&icu_testdata::unstable()).unwrap();

  let breakpoints: Vec<usize> = line_seg.segment_str("Hello World").collect();
  assert_eq!(&breakpoints, &[6, 11]);

  let word_seg = WordSegmenter::try_new_unstable(&icu_testdata::unstable()).unwrap();
  let breakpoints: Vec<usize> = word_seg.segment_latin1(b"Hello World").collect();
  assert_eq!(&breakpoints, &[0, 5, 6, 11]);

  let sentence_seg = SentenceSegmenter::try_new_unstable(&icu_testdata::unstable()).unwrap();
  let breakpoints: Vec<usize> = sentence_seg.segment_latin1(b"Hello World").collect();
  assert_eq!(&breakpoints, &[0, 11]);

  let graph_seg = GraphemeClusterSegmenter::try_new_unstable(&icu_testdata::unstable()).unwrap();
  let breakpoints: Vec<usize> = graph_seg.segment_str("देवनागरी 🗺").collect();
  assert_eq!(&breakpoints, &[0, 6, 9, 15, 18, 24, 25, 29]);
}