icu4x 0.9.0 → 0.11.0

data/README.md

@@ -24,7 +24,7 @@ No locale data is bundled with the gem. Users generate only the data they need,
 
 ## Requirements
 
-- Ruby 3.2+
+- Ruby 3.3+
 - Rust toolchain (only required when building from source; prebuilt binary gems are available for major platforms)
 
 ## Setup
@@ -114,7 +114,7 @@ lf.format(%w[Apple Banana Cherry])
 # Relative time formatting
 rtf = ICU4X::RelativeTimeFormat.new(locale, provider:)
 rtf.format(-3, :day)
-# => "3日前"
+# => "3 日前"
 
 # Display names
 dn = ICU4X::DisplayNames.new(locale, provider:, type: :language)

data/ext/icu4x/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "icu4x"
-version = "0.9.0"
+version = "0.11.0"
 edition = "2024"
 publish = false
 
@@ -10,14 +10,14 @@ crate-type = ["cdylib"]
 [dependencies]
 magnus = "0.8"
 writeable = "0.6"
-icu_locale = "2.1"
-icu_provider = "2.1"
-icu_provider_blob = { version = "2.1", features = ["alloc", "export"] }
-icu_provider_source = { version = "2.1", features = ["networking", "experimental"] }
-icu_provider_export = "2.1"
-icu_provider_registry = "2.1"
-icu_provider_adapters = "2.1"
-icu = { version = "2.1", features = ["experimental"] }
+icu_locale = "2.2"
+icu_provider = "2.2"
+icu_provider_blob = { version = "2.2", features = ["alloc", "export"] }
+icu_provider_source = { version = "2.2", features = ["networking", "unstable"] }
+icu_provider_export = "2.2"
+icu_provider_registry = "2.2"
+icu_provider_adapters = "2.2"
+icu = { version = "2.2", features = ["unstable"] }
 fixed_decimal = "0.7"
 tinystr = "0.8"
 jiff = "0.2"

data/ext/icu4x/src/data_generator.rs

@@ -19,7 +19,7 @@ fn marker_lookup() -> &'static HashMap<&'static str, DataMarkerInfo> {
     LOOKUP.get_or_init(|| {
         let mut map = HashMap::new();
         macro_rules! cb {
-            ($($marker_ty:ty:$marker:ident,)+ #[experimental] $($emarker_ty:ty:$emarker:ident,)+) => {
+            ($($marker_ty:ty:$marker:ident,)+ #[unstable] $($emarker_ty:ty:$emarker:ident,)+) => {
                 $(
                     // Add both the full type name and the short marker name
                     map.insert(stringify!($marker_ty), <$marker_ty>::INFO);

data/ext/icu4x/src/datetime_format.rs

@@ -4,21 +4,20 @@ use crate::parts_collector::{PartsCollector, parts_to_ruby_array};
 use icu::calendar::preferences::CalendarAlgorithm;
 use icu::calendar::{AnyCalendarKind, Date, Gregorian};
 use icu::datetime::fieldsets::enums::{
-    CalendarPeriodFieldSet, CompositeDateTimeFieldSet, DateAndTimeFieldSet, DateFieldSet,
-    TimeFieldSet,
+    CalendarPeriodFieldSet, CompositeDateTimeFieldSet, CompositeFieldSet, DateAndTimeFieldSet,
+    DateFieldSet, TimeFieldSet,
 };
-use icu::datetime::fieldsets::{self};
-use icu::datetime::options::Length;
-use icu::datetime::input::DateTime;
+use icu::datetime::fieldsets::{self, zone};
+use icu::datetime::options::{Length, TimePrecision, YearStyle as IcuYearStyle};
 use icu::datetime::parts as dt_parts;
 use icu::datetime::{DateTimeFormatter, DateTimeFormatterPreferences};
 use icu::locale::preferences::extensions::unicode::keywords::HourCycle as IcuHourCycle;
-use icu::time::Time;
-use icu::time::zone::IanaParser;
+use icu::time::zone::{models, IanaParser, UtcOffset, ZoneNameTimestamp};
+use icu::time::{Time, TimeZone, TimeZoneInfo, ZonedDateTime};
 use icu_provider::buf::AsDeserializingBufferProvider;
 use icu4x_macros::RubySymbol;
 use jiff::Timestamp;
-use jiff::tz::TimeZone;
+use jiff::tz::TimeZone as JiffTimeZone;
 use magnus::{Error, RArray, RHash, RModule, Ruby, TryConvert, Value, function, method, prelude::*};
 use writeable::{Part, Writeable};
 
@@ -65,6 +64,26 @@ enum YearStyle {
     TwoDigit,
 }
 
+/// Era display option
+#[derive(Clone, Copy, PartialEq, Eq, RubySymbol)]
+enum EraStyle {
+    Auto,
+    Full,
+    WithEra,
+    Never,
+}
+
+impl EraStyle {
+    fn to_icu_year_style(self) -> IcuYearStyle {
+        match self {
+            EraStyle::Auto => IcuYearStyle::Auto,
+            EraStyle::Full => IcuYearStyle::Full,
+            EraStyle::WithEra => IcuYearStyle::WithEra,
+            EraStyle::Never => IcuYearStyle::NoEra,
+        }
+    }
+}
+
 /// Month component option
 #[derive(Clone, Copy, PartialEq, Eq, RubySymbol)]
 enum MonthStyle {
@@ -218,7 +237,7 @@ impl Calendar {
             | AnyCalendarKind::HijriTabularTypeIIThursday
             | AnyCalendarKind::HijriUmmAlQura => Calendar::Islamic,
             AnyCalendarKind::Iso => Calendar::Gregory,
-            AnyCalendarKind::Japanese | AnyCalendarKind::JapaneseExtended => Calendar::Japanese,
+            AnyCalendarKind::Japanese => Calendar::Japanese,
             AnyCalendarKind::Persian => Calendar::Persian,
             AnyCalendarKind::Roc => Calendar::Roc,
             _ => Calendar::Gregory,
@@ -256,14 +275,16 @@ fn part_to_symbol_name(part: &Part) -> &'static str {
 /// Ruby wrapper for ICU4X datetime formatters
 #[magnus::wrap(class = "ICU4X::DateTimeFormat", free_immediately, size)]
 pub struct DateTimeFormat {
-    inner: DateTimeFormatter<CompositeDateTimeFieldSet>,
+    inner: DateTimeFormatter<CompositeFieldSet>,
     locale_str: String,
     date_style: Option<DateStyle>,
     time_style: Option<TimeStyle>,
     time_zone: Option<String>,
-    jiff_timezone: Option<TimeZone>,
+    jiff_timezone: Option<JiffTimeZone>,
     calendar: Calendar,
     hour_cycle: Option<HourCycle>,
+    hour12: Option<bool>,
+    era: Option<EraStyle>,
     component_options: Option<ComponentOptions>,
 }
 
@@ -360,7 +381,7 @@ impl DateTimeFormat {
                 ));
             }
             // Then create jiff TimeZone for offset calculation
-            let jiff_tz = TimeZone::get(tz_str).map_err(|e| {
+            let jiff_tz = JiffTimeZone::get(tz_str).map_err(|e| {
                 Error::new(
                     ruby.exception_arg_error(),
                     format!("invalid IANA timezone: {} ({})", tz_str, e),
@@ -379,15 +400,11 @@ impl DateTimeFormat {
         let hour_cycle =
             helpers::extract_symbol(ruby, &kwargs, "hour_cycle", HourCycle::from_ruby_symbol)?;
 
-        // Extract hour12 option and convert to hour_cycle if hour_cycle is not specified
-        // hour12: true → :h12, hour12: false → :h23
         let hour12: Option<bool> = kwargs.lookup::<_, Option<bool>>(ruby.to_symbol("hour12"))?;
-        let hour_cycle = match (hour_cycle, hour12) {
-            (Some(hc), _) => Some(hc), // hour_cycle takes precedence
-            (None, Some(true)) => Some(HourCycle::H12),
-            (None, Some(false)) => Some(HourCycle::H23),
-            (None, None) => None,
-        };
+
+        // Extract era option
+        let era =
+            helpers::extract_symbol(ruby, &kwargs, "era", EraStyle::from_ruby_symbol)?;
 
         // Get the error exception class
         let error_class = helpers::get_exception_class(ruby, "ICU4X::Error");
@@ -402,9 +419,10 @@ impl DateTimeFormat {
 
         // Create field set based on options
         let field_set = if has_component_options {
-            Self::create_field_set_from_components(ruby, &component_options)?
+            Self::create_field_set_from_components(ruby, &component_options, era)?
+                .to_composite_field_set()
         } else {
-            Self::create_field_set_from_style(date_style, time_style)
+            Self::create_field_set_from_style(date_style, time_style, era)
         };
 
         // Create formatter with calendar and hour_cycle preferences
@@ -414,6 +432,8 @@ impl DateTimeFormat {
         }
         if let Some(hc) = hour_cycle {
             prefs.hour_cycle = Some(hc.to_icu_hour_cycle());
+        } else if let Some(h12) = hour12 {
+            prefs.hour_cycle = Some(if h12 { IcuHourCycle::Clock12 } else { IcuHourCycle::Clock24 });
         }
 
         let formatter =
@@ -437,6 +457,8 @@ impl DateTimeFormat {
             jiff_timezone,
             calendar: resolved_calendar,
             hour_cycle,
+            hour12,
+            era,
             component_options: if has_component_options {
                 Some(component_options)
             } else {
@@ -477,6 +499,7 @@ impl DateTimeFormat {
     fn create_field_set_from_components(
         ruby: &Ruby,
         opts: &ComponentOptions,
+        era: Option<EraStyle>,
     ) -> Result<CompositeDateTimeFieldSet, Error> {
         let has_date = opts.has_date_components();
         let has_time = opts.has_time_components();
@@ -485,9 +508,9 @@ impl DateTimeFormat {
         match (has_date, has_time) {
             (true, true) => {
                 // Date and time components
-                Ok(CompositeDateTimeFieldSet::DateTime(
-                    DateAndTimeFieldSet::YMDT(fieldsets::YMDT::for_length(length)),
-                ))
+                let fs = fieldsets::YMDT::for_length(length);
+                let fs = if let Some(s) = era { fs.with_year_style(s.to_icu_year_style()) } else { fs };
+                Ok(CompositeDateTimeFieldSet::DateTime(DateAndTimeFieldSet::YMDT(fs)))
             }
             (true, false) => {
                 // Date only - choose field set based on which components are specified
@@ -498,13 +521,17 @@ impl DateTimeFormat {
 
                 match (has_year, has_month, has_day, has_weekday) {
                     // Year + Month + Day + Weekday
-                    (true, true, true, true) => Ok(CompositeDateTimeFieldSet::Date(
-                        DateFieldSet::YMDE(fieldsets::YMDE::for_length(length)),
-                    )),
+                    (true, true, true, true) => {
+                        let fs = fieldsets::YMDE::for_length(length);
+                        let fs = if let Some(s) = era { fs.with_year_style(s.to_icu_year_style()) } else { fs };
+                        Ok(CompositeDateTimeFieldSet::Date(DateFieldSet::YMDE(fs)))
+                    }
                     // Year + Month + Day
-                    (true, true, true, false) => Ok(CompositeDateTimeFieldSet::Date(
-                        DateFieldSet::YMD(fieldsets::YMD::for_length(length)),
-                    )),
+                    (true, true, true, false) => {
+                        let fs = fieldsets::YMD::for_length(length);
+                        let fs = if let Some(s) = era { fs.with_year_style(s.to_icu_year_style()) } else { fs };
+                        Ok(CompositeDateTimeFieldSet::Date(DateFieldSet::YMD(fs)))
+                    }
                     // Month + Day + Weekday
                     (false, true, true, true) => Ok(CompositeDateTimeFieldSet::Date(
                         DateFieldSet::MDE(fieldsets::MDE::for_length(length)),
@@ -514,9 +541,11 @@ impl DateTimeFormat {
                         DateFieldSet::MD(fieldsets::MD::for_length(length)),
                     )),
                     // Year + Month (calendar period)
-                    (true, true, false, _) => Ok(CompositeDateTimeFieldSet::CalendarPeriod(
-                        CalendarPeriodFieldSet::YM(fieldsets::YM::for_length(length)),
-                    )),
+                    (true, true, false, _) => {
+                        let fs = fieldsets::YM::for_length(length);
+                        let fs = if let Some(s) = era { fs.with_year_style(s.to_icu_year_style()) } else { fs };
+                        Ok(CompositeDateTimeFieldSet::CalendarPeriod(CalendarPeriodFieldSet::YM(fs)))
+                    }
                     // Month only (calendar period)
                     (false, true, false, _) => Ok(CompositeDateTimeFieldSet::CalendarPeriod(
                         CalendarPeriodFieldSet::M(fieldsets::M::for_length(length)),
@@ -534,13 +563,17 @@ impl DateTimeFormat {
                         DateFieldSet::E(fieldsets::E::for_length(length)),
                     )),
                     // Year only (calendar period)
-                    (true, false, false, _) => Ok(CompositeDateTimeFieldSet::CalendarPeriod(
-                        CalendarPeriodFieldSet::Y(fieldsets::Y::for_length(length)),
-                    )),
+                    (true, false, false, _) => {
+                        let fs = fieldsets::Y::for_length(length);
+                        let fs = if let Some(s) = era { fs.with_year_style(s.to_icu_year_style()) } else { fs };
+                        Ok(CompositeDateTimeFieldSet::CalendarPeriod(CalendarPeriodFieldSet::Y(fs)))
+                    }
                     // Year + Day (not a standard combination, use YMD as fallback)
-                    (true, false, true, _) => Ok(CompositeDateTimeFieldSet::Date(
-                        DateFieldSet::YMD(fieldsets::YMD::for_length(length)),
-                    )),
+                    (true, false, true, _) => {
+                        let fs = fieldsets::YMD::for_length(length);
+                        let fs = if let Some(s) = era { fs.with_year_style(s.to_icu_year_style()) } else { fs };
+                        Ok(CompositeDateTimeFieldSet::Date(DateFieldSet::YMD(fs)))
+                    }
                     // Should not happen - we checked has_date_components
                     (false, false, false, false) => unreachable!(),
                 }
@@ -562,7 +595,8 @@ impl DateTimeFormat {
     fn create_field_set_from_style(
         date_style: Option<DateStyle>,
         time_style: Option<TimeStyle>,
-    ) -> CompositeDateTimeFieldSet {
+        era: Option<EraStyle>,
+    ) -> CompositeFieldSet {
         match (date_style, time_style) {
             (Some(ds), Some(ts)) => {
                 // Both date and time
@@ -571,7 +605,9 @@ impl DateTimeFormat {
                     (DateStyle::Medium, _) => fieldsets::YMDT::medium(),
                     (DateStyle::Short, _) => fieldsets::YMDT::short(),
                 };
+                let ymdt = if let Some(s) = era { ymdt.with_year_style(s.to_icu_year_style()) } else { ymdt };
                 CompositeDateTimeFieldSet::DateTime(DateAndTimeFieldSet::YMDT(ymdt))
+                    .to_composite_field_set()
             }
             (Some(ds), None) => {
                 // Date only
@@ -580,16 +616,30 @@ impl DateTimeFormat {
                     DateStyle::Medium => fieldsets::YMD::medium(),
                     DateStyle::Short => fieldsets::YMD::short(),
                 };
-                CompositeDateTimeFieldSet::Date(DateFieldSet::YMD(ymd))
+                let ymd = if let Some(s) = era { ymd.with_year_style(s.to_icu_year_style()) } else { ymd };
+                CompositeDateTimeFieldSet::Date(DateFieldSet::YMD(ymd)).to_composite_field_set()
             }
             (None, Some(ts)) => {
-                // Time only
-                let t = match ts {
-                    TimeStyle::Full | TimeStyle::Long => fieldsets::T::long(),
-                    TimeStyle::Medium => fieldsets::T::medium(),
-                    TimeStyle::Short => fieldsets::T::short(),
-                };
-                CompositeDateTimeFieldSet::Time(TimeFieldSet::T(t))
+                // Time only; long/full include timezone per CLDR convention
+                match ts {
+                    TimeStyle::Full => CompositeFieldSet::TimeZone(
+                        fieldsets::T::long().with_zone(zone::SpecificLong).into_enums(),
+                    ),
+                    TimeStyle::Long => CompositeFieldSet::TimeZone(
+                        fieldsets::T::long().with_zone(zone::SpecificShort).into_enums(),
+                    ),
+                    TimeStyle::Medium => {
+                        CompositeDateTimeFieldSet::Time(TimeFieldSet::T(fieldsets::T::medium()))
+                            .to_composite_field_set()
+                    }
+                    // short omits seconds to match Intl.DateTimeFormat timeStyle: "short"
+                    TimeStyle::Short => {
+                        CompositeDateTimeFieldSet::Time(TimeFieldSet::T(
+                            fieldsets::T::short().with_time_precision(TimePrecision::Minute),
+                        ))
+                        .to_composite_field_set()
+                    }
+                }
             }
             (None, None) => {
                 // Should not happen due to validation
@@ -635,8 +685,12 @@ impl DateTimeFormat {
     /// Prepare a Ruby Time value for formatting.
     ///
     /// Converts objects responding to #to_time, validates the result,
-    /// and converts to ICU4X DateTime.
-    fn prepare_datetime(&self, ruby: &Ruby, time: Value) -> Result<DateTime<Gregorian>, Error> {
+    /// and converts to ICU4X ZonedDateTime.
+    fn prepare_datetime(
+        &self,
+        ruby: &Ruby,
+        time: Value,
+    ) -> Result<ZonedDateTime<Gregorian, TimeZoneInfo<models::AtTime>>, Error> {
         // Convert to Time if the object responds to #to_time
         let time_value = if time.respond_to("to_time", false)? {
             time.funcall::<_, _, Value>("to_time", ())?
@@ -653,75 +707,57 @@ impl DateTimeFormat {
             ));
         }
 
-        self.convert_time_to_datetime(ruby, time_value)
+        self.convert_time_to_zoned_datetime(ruby, time_value)
     }
 
-    /// Convert Ruby Time to ICU4X DateTime<Gregorian>
+    /// Convert Ruby Time to ICU4X ZonedDateTime<Gregorian, TimeZoneInfo<AtTime>>
     ///
-    /// If time_zone is specified, the UTC time is converted to local time in that timezone.
-    /// Otherwise, the time is treated as UTC.
-    fn convert_time_to_datetime(
+    /// If time_zone is specified, the time is represented in that timezone.
+    /// Otherwise, UTC is used.
+    fn convert_time_to_zoned_datetime(
         &self,
         ruby: &Ruby,
         time: Value,
-    ) -> Result<DateTime<Gregorian>, Error> {
-        // Get UTC time from Ruby Time object
-        let utc_time: Value = time.funcall("getutc", ())?;
-
-        let utc_year: i32 = utc_time.funcall("year", ())?;
-        let utc_month: i32 = utc_time.funcall("month", ())?;
-        let utc_day: i32 = utc_time.funcall("day", ())?;
-        let utc_hour: i32 = utc_time.funcall("hour", ())?;
-        let utc_min: i32 = utc_time.funcall("min", ())?;
-        let utc_sec: i32 = utc_time.funcall("sec", ())?;
-
-        // Get year, month, day, hour, min, sec in the target timezone
-        let (year, month, day, hour, min, sec) = if let Some(ref tz) = self.jiff_timezone {
-            // Create a jiff Timestamp from UTC components
-            let timestamp = Timestamp::from_second(utc_time.funcall::<_, _, i64>("to_i", ())?)
-                .map_err(|e| {
-                    Error::new(
-                        ruby.exception_arg_error(),
-                        format!("Invalid timestamp: {}", e),
-                    )
-                })?;
+    ) -> Result<ZonedDateTime<Gregorian, TimeZoneInfo<models::AtTime>>, Error> {
+        let ts_secs: i64 = time.funcall("to_i", ())?;
 
-            // Convert to local time in the target timezone
-            let zoned = timestamp.to_zoned(tz.clone());
-            let dt = zoned.datetime();
-
-            (
-                dt.year() as i32,
-                dt.month() as i32,
-                dt.day() as i32,
-                dt.hour() as i32,
-                dt.minute() as i32,
-                dt.second() as i32,
-            )
+        let timestamp = Timestamp::from_second(ts_secs).map_err(|e| {
+            Error::new(ruby.exception_arg_error(), format!("Invalid timestamp: {}", e))
+        })?;
+
+        let (jiff_tz, iana_name) = if let Some(ref tz) = self.jiff_timezone {
+            let name = tz.iana_name().unwrap_or("UTC").to_owned();
+            (tz.clone(), name)
         } else {
-            // No timezone specified, use UTC
-            (utc_year, utc_month, utc_day, utc_hour, utc_min, utc_sec)
+            (JiffTimeZone::UTC, "UTC".to_owned())
         };
 
-        // Create ISO date and convert to Gregorian
-        let iso_date = Date::try_new_iso(year, month as u8, day as u8)
+        let zoned = timestamp.to_zoned(jiff_tz);
+        let dt = zoned.datetime();
+
+        let iso_date = Date::try_new_iso(dt.year() as i32, dt.month() as u8, dt.day() as u8)
             .map_err(|e| Error::new(ruby.exception_arg_error(), format!("Invalid date: {}", e)))?;
         let gregorian_date = iso_date.to_calendar(Gregorian);
 
-        // Create time
-        let time_of_day = Time::try_new(hour as u8, min as u8, sec as u8, 0)
+        let icu_time = Time::try_new(dt.hour() as u8, dt.minute() as u8, dt.second() as u8, 0)
             .map_err(|e| Error::new(ruby.exception_arg_error(), format!("Invalid time: {}", e)))?;
 
-        Ok(DateTime {
+        let icu_tz: TimeZone = IanaParser::new().parse(&iana_name);
+        let utc_offset = UtcOffset::from_seconds_unchecked(zoned.offset().seconds());
+        let zone_name_ts = ZoneNameTimestamp::from_epoch_seconds(ts_secs);
+        let zone_info = icu_tz.with_offset(Some(utc_offset)).with_zone_name_timestamp(zone_name_ts);
+
+        Ok(ZonedDateTime {
             date: gregorian_date,
-            time: time_of_day,
+            time: icu_time,
+            zone: zone_info,
         })
     }
 
     /// Get the resolved options
     ///
     /// # Returns
-    /// A hash with :locale, :calendar, :date_style, :time_style, and optionally :time_zone, :hour_cycle
+    /// A hash with :locale, :calendar, :date_style, :time_style, and optionally :time_zone, :hour_cycle, :hour12
     fn resolved_options(&self) -> Result<RHash, Error> {
         let ruby = Ruby::get().expect("Ruby runtime should be available");
         let hash = ruby.hash_new();
@@ -757,6 +793,17 @@ impl DateTimeFormat {
             )?;
         }
 
+        if let Some(h12) = self.hour12 {
+            hash.aset(ruby.to_symbol("hour12"), h12)?;
+        }
+
+        if let Some(era) = self.era {
+            hash.aset(
+                ruby.to_symbol("era"),
+                ruby.to_symbol(era.to_symbol_name()),
+            )?;
+        }
+
         // Add component options if they were used
         if let Some(ref opts) = self.component_options {
             if let Some(year) = opts.year {

data/ext/icu4x/src/display_names.rs

@@ -1,8 +1,8 @@
 use crate::data_provider::DataProvider;
 use crate::helpers;
-use icu::experimental::displaynames::{
-    DisplayNamesOptions, Fallback, LanguageDisplayNames, LocaleDisplayNamesFormatter,
-    RegionDisplayNames, ScriptDisplayNames, Style,
+use icu::experimental::displaynames::{DisplayNamesOptions, Fallback, Style};
+use icu::experimental::displaynames::multi::{
+    LanguageDisplayNames, LocaleDisplayNamesFormatter, RegionDisplayNames, ScriptDisplayNames,
 };
 use icu_locale::LanguageIdentifier;
 use icu_provider::buf::AsDeserializingBufferProvider;

data/ext/icu4x/src/locale.rs

@@ -1,5 +1,6 @@
 use crate::helpers;
 use icu_locale::{Locale as IcuLocale, LocaleExpander, TransformResult};
+use icu_locale::subtags::Variant;
 use magnus::{Error, RHash, RModule, Ruby, function, method, prelude::*, typed_data::Obj};
 use std::cell::RefCell;
 
@@ -204,6 +205,57 @@ impl Locale {
             inner: RefCell::new(IcuLocale::from(new_id)),
         }
     }
+
+    /// Get the list of variants
+    fn variants(&self) -> Vec<String> {
+        self.inner
+            .borrow()
+            .id
+            .variants
+            .iter()
+            .map(|v| v.to_string())
+            .collect()
+    }
+
+    fn parse_variant(s: &str) -> Result<Variant, Error> {
+        let ruby = Ruby::get().expect("Ruby runtime should be available");
+        s.parse::<Variant>().map_err(|e| {
+            Error::new(
+                helpers::get_exception_class(&ruby, "ICU4X::LocaleError"),
+                format!("Invalid variant: {e}"),
+            )
+        })
+    }
+
+    /// Add a variant in place; returns self if added, nil if already present
+    fn add_variant_bang(rb_self: Obj<Self>, variant_str: String) -> Result<Option<Obj<Self>>, Error> {
+        let variant = Self::parse_variant(&variant_str)?;
+        let added = rb_self.inner.borrow_mut().id.variants.push(variant);
+        Ok(if added { Some(rb_self) } else { None })
+    }
+
+    /// Return a new Locale with the variant added
+    fn add_variant(&self, variant_str: String) -> Result<Self, Error> {
+        let variant = Self::parse_variant(&variant_str)?;
+        let mut new_locale = self.inner.borrow().clone();
+        new_locale.id.variants.push(variant);
+        Ok(Self { inner: RefCell::new(new_locale) })
+    }
+
+    /// Remove a variant in place; returns self if removed, nil if not present
+    fn remove_variant_bang(rb_self: Obj<Self>, variant_str: String) -> Result<Option<Obj<Self>>, Error> {
+        let variant = Self::parse_variant(&variant_str)?;
+        let removed = rb_self.inner.borrow_mut().id.variants.remove(&variant);
+        Ok(if removed { Some(rb_self) } else { None })
+    }
+
+    /// Return a new Locale with the variant removed
+    fn remove_variant(&self, variant_str: String) -> Result<Self, Error> {
+        let variant = Self::parse_variant(&variant_str)?;
+        let mut new_locale = self.inner.borrow().clone();
+        new_locale.id.variants.remove(&variant);
+        Ok(Self { inner: RefCell::new(new_locale) })
+    }
 }
 
 pub fn init(ruby: &Ruby, module: &RModule) -> Result<(), Error> {
@@ -221,5 +273,10 @@ pub fn init(ruby: &Ruby, module: &RModule) -> Result<(), Error> {
     class.define_method("maximize", method!(Locale::maximize, 0))?;
     class.define_method("minimize!", method!(Locale::minimize_bang, 0))?;
     class.define_method("minimize", method!(Locale::minimize, 0))?;
+    class.define_method("variants", method!(Locale::variants, 0))?;
+    class.define_method("add_variant!", method!(Locale::add_variant_bang, 1))?;
+    class.define_method("add_variant", method!(Locale::add_variant, 1))?;
+    class.define_method("remove_variant!", method!(Locale::remove_variant_bang, 1))?;
+    class.define_method("remove_variant", method!(Locale::remove_variant, 1))?;
     Ok(())
 }

data/ext/icu4x/src/number_format.rs

@@ -298,7 +298,7 @@ impl NumberFormat {
             FormatterKind::Decimal(formatter) => formatter.format(&decimal).to_string(),
             FormatterKind::Percent(formatter) => formatter.format(&decimal).to_string(),
             FormatterKind::Currency(formatter, currency_code) => formatter
-                .format_fixed_decimal(&decimal, *currency_code)
+                .format_fixed_decimal(&decimal, currency_code)
                 .to_string(),
         };
         Ok(formatted)
@@ -331,7 +331,7 @@ impl NumberFormat {
             }
             FormatterKind::Currency(formatter, currency_code) => {
                 formatter
-                    .format_fixed_decimal(&decimal, *currency_code)
+                    .format_fixed_decimal(&decimal, currency_code)
                     .write_to_parts(&mut collector)
                     .map_err(|e| Error::new(ruby.exception_runtime_error(), format!("{}", e)))?;
             }
@@ -399,11 +399,7 @@ impl NumberFormat {
 
     /// Check if value is a BigDecimal
     fn is_big_decimal(ruby: &Ruby, value: Value) -> bool {
-        // Try to get BigDecimal class; if bigdecimal is not loaded, return false
-        if let Ok(bigdecimal_class) = ruby.eval::<Value>("defined?(BigDecimal) && BigDecimal") {
-            if bigdecimal_class.is_nil() {
-                return false;
-            }
+        if let Ok(bigdecimal_class) = ruby.eval::<Value>("BigDecimal") {
             if let Ok(class) = magnus::RClass::try_convert(bigdecimal_class) {
                 return value.is_kind_of(class);
             }

data/ext/icu4x/src/relative_time_format.rs

@@ -146,9 +146,8 @@ impl RelativeTimeFormat {
         })?;
 
         // Build formatter options
-        let options = RelativeTimeFormatterOptions {
-            numeric: numeric.to_icu_numeric(),
-        };
+        let mut options = RelativeTimeFormatterOptions::default();
+        options.numeric = numeric.to_icu_numeric();
         let prefs: RelativeTimeFormatterPreferences = (&icu_locale).into();
 
         // Create formatters for all units based on style

data/ext/icu4x_macros/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "icu4x_macros"
-version = "0.9.0"
+version = "0.11.0"
 edition = "2024"
 
 [lib]

data/lib/icu4x/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module ICU4X
-  VERSION = "0.9.0"
+  VERSION = "0.11.0"
   public_constant :VERSION
 end