icu4x 0.8.1 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a97e647de7657f35756c1c2fb3f03132773ad7fcc0f275a53c939995307d31d
-  data.tar.gz: 6484dfe98f82c00e2036d884ae31a5bc91c5122e96b6eff5db2ca5d8b6551080
+  metadata.gz: 0c0cb2adcc5d5af24a00272def5a66e3b03a928b0cb522a0d7c5ee6b50eacdb5
+  data.tar.gz: 2f44d6cddb74e64fc922c6269d32b060ed8b03e751969d7bd0e1c87d584f0a59
 SHA512:
-  metadata.gz: 83845dc2f7a88a6719ce992842fd9e30276f324a2a370a496fe076608a51f6695d0fb7f327195aad8bdbef01d8a768f3edcc67bf8f4da69b5b11b1b329beac42
-  data.tar.gz: 9e9fdaea6e4004c4671b3a4491cd0a251408be272ad233c7d3bbc59871d98bab23ef7e95e50c50be319bcadb3440713cb714d591bdaa589970fa9fee5d295979
+  metadata.gz: 15b7967a5eecc044bbd3d3c1f3dfc36c08fd655cf9e83164c418239aa24a6cad7b622ac25d923cbc1d8f453cb8996be8ce5a1e38e3114f511a5f4ef1ebae2950
+  data.tar.gz: 68e9db100a5255557d6bf1c298f990dae44f8743ce0829ecc050a56491dd9ba27ac9d42aff3df583f1111b919c9af8395cca75f1c3eccc98ce6789502e826f56

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 ## [Unreleased]
 
+## [0.9.0] - 2026-02-01
+
+### Added
+
+- `hour12` option for `ICU4X::DateTimeFormat` as a simpler alternative to `hour_cycle` (#132)
+- Default behavior for `ICU4X::DateTimeFormat` when no options specified, matching JavaScript Intl.DateTimeFormat (#130)
+- Component options for `ICU4X::DateTimeFormat` (`year`, `month`, `day`, `weekday`, `hour`, `minute`, `second`) as an alternative to style options (#129)
+- Document numbering system support via BCP 47 locale extensions (`-u-nu-xxx`) for `NumberFormat`, `DateTimeFormat`, and `RelativeTimeFormat` (#127)
+- `hour_cycle` option for `ICU4X::DateTimeFormat` to control 12/24-hour time display (#112)
+- `ICU4X::RelativeTimeFormat#format_to_parts` method for breaking down formatted output into typed parts (#117)
+- `ICU4X::ListFormat#format_to_parts` method for breaking down formatted output into typed parts (#116)
+- `ICU4X::NumberFormat#format_to_parts` method for breaking down formatted output into typed parts (#115)
+- `ICU4X::DateTimeFormat#format_to_parts` method for breaking down formatted output into typed parts (#114)
+- `ICU4X::FormattedPart` data class for representing formatted parts (#113)
+- `ICU4X::PluralRules#select_range` method for plural category selection on number ranges (#106)
+- Allow data gems to be required by gem name (#104)
+- `ICU4X::Locale.parse_bcp47` method for explicit BCP 47 parsing; `parse` is now an alias (#108)
+
 ## [0.8.1] - 2026-01-12
 
 ### Added

data/Cargo.lock

@@ -417,7 +417,7 @@ dependencies = [
 
 [[package]]
 name = "icu4x"
-version = "0.1.0"
+version = "0.9.0"
 dependencies = [
  "fixed_decimal",
  "icu",
@@ -432,11 +432,12 @@ dependencies = [
  "jiff",
  "magnus",
  "tinystr",
+ "writeable",
 ]
 
 [[package]]
 name = "icu4x_macros"
-version = "0.1.0"
+version = "0.9.0"
 dependencies = [
  "proc-macro2",
  "quote",

data/README.md

@@ -41,16 +41,11 @@ Prebuilt binary gems are available for x86_64-linux, aarch64-linux, x86_64-darwi
 
 #### Option 1: Use Pre-built Data Gem (Quick Start)
 
-Add a companion data gem for instant setup:
+Add a companion data gem to your Gemfile:
 
 ```ruby
 gem "icu4x"
-gem "icu4x-data-recommended"  # 164 locales, ~24MB
-```
-
-```ruby
-require "icu4x"
-require "icu4x/data/recommended"  # Auto-configures default provider
+gem "icu4x-data-recommended"  # 164 locales, ~24MB, auto-configures default provider
 ```
 
 Available data gems:

data/ext/icu4x/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "icu4x"
-version = "0.1.0"
+version = "0.9.0"
 edition = "2024"
 publish = false
 
@@ -9,6 +9,7 @@ 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"] }

data/ext/icu4x/src/datetime_format.rs

@@ -1,22 +1,26 @@
 use crate::data_provider::DataProvider;
 use crate::helpers;
+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::{
-    CompositeDateTimeFieldSet, DateAndTimeFieldSet, DateFieldSet, TimeFieldSet,
+    CalendarPeriodFieldSet, CompositeDateTimeFieldSet, DateAndTimeFieldSet, DateFieldSet,
+    TimeFieldSet,
 };
 use icu::datetime::fieldsets::{self};
+use icu::datetime::options::Length;
 use icu::datetime::input::DateTime;
+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_provider::buf::AsDeserializingBufferProvider;
 use icu4x_macros::RubySymbol;
 use jiff::Timestamp;
 use jiff::tz::TimeZone;
-use magnus::{
-    Error, RHash, RModule, Ruby, TryConvert, Value, function, method, prelude::*,
-};
+use magnus::{Error, RArray, RHash, RModule, Ruby, TryConvert, Value, function, method, prelude::*};
+use writeable::{Part, Writeable};
 
 /// Date style option
 #[derive(Clone, Copy, PartialEq, Eq, RubySymbol)]
@@ -36,6 +40,134 @@ enum TimeStyle {
     Short,
 }
 
+/// Hour cycle option
+#[derive(Clone, Copy, PartialEq, Eq, RubySymbol)]
+enum HourCycle {
+    H11,
+    H12,
+    H23,
+}
+
+impl HourCycle {
+    fn to_icu_hour_cycle(self) -> IcuHourCycle {
+        match self {
+            HourCycle::H11 => IcuHourCycle::H11,
+            HourCycle::H12 => IcuHourCycle::H12,
+            HourCycle::H23 => IcuHourCycle::H23,
+        }
+    }
+}
+
+/// Year component option
+#[derive(Clone, Copy, PartialEq, Eq, RubySymbol)]
+enum YearStyle {
+    Numeric,
+    TwoDigit,
+}
+
+/// Month component option
+#[derive(Clone, Copy, PartialEq, Eq, RubySymbol)]
+enum MonthStyle {
+    Numeric,
+    TwoDigit,
+    Long,
+    Short,
+    Narrow,
+}
+
+/// Day component option
+#[derive(Clone, Copy, PartialEq, Eq, RubySymbol)]
+enum DayStyle {
+    Numeric,
+    TwoDigit,
+}
+
+/// Weekday component option
+#[derive(Clone, Copy, PartialEq, Eq, RubySymbol)]
+enum WeekdayStyle {
+    Long,
+    Short,
+    Narrow,
+}
+
+/// Hour component option
+#[derive(Clone, Copy, PartialEq, Eq, RubySymbol)]
+enum HourStyle {
+    Numeric,
+    TwoDigit,
+}
+
+/// Minute component option
+#[derive(Clone, Copy, PartialEq, Eq, RubySymbol)]
+enum MinuteStyle {
+    Numeric,
+    TwoDigit,
+}
+
+/// Second component option
+#[derive(Clone, Copy, PartialEq, Eq, RubySymbol)]
+enum SecondStyle {
+    Numeric,
+    TwoDigit,
+}
+
+/// Component options for date/time formatting
+#[derive(Clone, Copy, Default)]
+struct ComponentOptions {
+    year: Option<YearStyle>,
+    month: Option<MonthStyle>,
+    day: Option<DayStyle>,
+    weekday: Option<WeekdayStyle>,
+    hour: Option<HourStyle>,
+    minute: Option<MinuteStyle>,
+    second: Option<SecondStyle>,
+}
+
+impl ComponentOptions {
+    fn has_date_components(&self) -> bool {
+        self.year.is_some() || self.month.is_some() || self.day.is_some() || self.weekday.is_some()
+    }
+
+    fn has_time_components(&self) -> bool {
+        self.hour.is_some() || self.minute.is_some() || self.second.is_some()
+    }
+
+    fn is_empty(&self) -> bool {
+        !self.has_date_components() && !self.has_time_components()
+    }
+
+    /// Determine the appropriate ICU4X Length based on component option values.
+    ///
+    /// When text-based month or weekday styles (:long, :short, :narrow) are specified,
+    /// we use Length::Long to ensure the format uses localized text patterns
+    /// (e.g., "2026年2月" in Japanese instead of "2026/02").
+    ///
+    /// This matches JavaScript Intl.DateTimeFormat behavior where specifying
+    /// month: "short" produces text-based formats with abbreviated month names,
+    /// not numeric formats.
+    ///
+    /// - If any text-based component (:long, :short, :narrow) → Length::Long
+    /// - Default (all numeric) → Length::Short
+    fn determine_length(&self) -> Length {
+        // Check for any text-based month or weekday option
+        let has_text_month = matches!(
+            self.month,
+            Some(MonthStyle::Long) | Some(MonthStyle::Short) | Some(MonthStyle::Narrow)
+        );
+        let has_text_weekday = matches!(
+            self.weekday,
+            Some(WeekdayStyle::Long) | Some(WeekdayStyle::Short) | Some(WeekdayStyle::Narrow)
+        );
+
+        if has_text_month || has_text_weekday {
+            return Length::Long;
+        }
+
+        // Default for numeric-only options
+        Length::Short
+    }
+}
+
 /// Calendar option
 #[derive(Clone, Copy, PartialEq, Eq, RubySymbol)]
 enum Calendar {
@@ -94,6 +226,33 @@ impl Calendar {
     }
 }
 
+/// Convert ICU4X datetime Part to Ruby symbol name
+fn part_to_symbol_name(part: &Part) -> &'static str {
+    if *part == dt_parts::YEAR {
+        "year"
+    } else if *part == dt_parts::MONTH {
+        "month"
+    } else if *part == dt_parts::DAY {
+        "day"
+    } else if *part == dt_parts::WEEKDAY {
+        "weekday"
+    } else if *part == dt_parts::HOUR {
+        "hour"
+    } else if *part == dt_parts::MINUTE {
+        "minute"
+    } else if *part == dt_parts::SECOND {
+        "second"
+    } else if *part == dt_parts::DAY_PERIOD {
+        "day_period"
+    } else if *part == dt_parts::ERA {
+        "era"
+    } else if *part == dt_parts::TIME_ZONE_NAME {
+        "time_zone_name"
+    } else {
+        "literal"
+    }
+}
+
 /// Ruby wrapper for ICU4X datetime formatters
 #[magnus::wrap(class = "ICU4X::DateTimeFormat", free_immediately, size)]
 pub struct DateTimeFormat {
@@ -104,6 +263,8 @@ pub struct DateTimeFormat {
     time_zone: Option<String>,
     jiff_timezone: Option<TimeZone>,
     calendar: Calendar,
+    hour_cycle: Option<HourCycle>,
+    component_options: Option<ComponentOptions>,
 }
 
 // SAFETY: This type is marked as Send to allow Ruby to move it between threads.
@@ -131,6 +292,7 @@ impl DateTimeFormat {
     /// * `time_zone:` - IANA timezone name (e.g., "Asia/Tokyo")
     /// * `calendar:` - :gregory, :japanese, :buddhist, :chinese, :hebrew, :islamic,
     ///   :persian, :indian, :ethiopian, :coptic, :roc, :dangi
+    /// * `hour_cycle:` - :h11, :h12, or :h23
     fn new(ruby: &Ruby, args: &[Value]) -> Result<Self, Error> {
         // Parse arguments: (locale, **kwargs)
         let (icu_locale, locale_str) = helpers::extract_locale(ruby, args)?;
@@ -153,14 +315,35 @@ impl DateTimeFormat {
         let time_style =
             helpers::extract_symbol(ruby, &kwargs, "time_style", TimeStyle::from_ruby_symbol)?;
 
-        // At least one of date_style or time_style must be specified
-        if date_style.is_none() && time_style.is_none() {
+        // Extract component options
+        let component_options = Self::extract_component_options(ruby, &kwargs)?;
+
+        // Validate: style options and component options are mutually exclusive
+        let has_style_options = date_style.is_some() || time_style.is_some();
+        let has_component_options = !component_options.is_empty();
+
+        if has_style_options && has_component_options {
             return Err(Error::new(
                 ruby.exception_arg_error(),
-                "at least one of date_style or time_style must be specified",
+                "cannot use date_style/time_style together with component options (year, month, day, etc.)",
             ));
         }
 
+        // Apply default component options if no options specified
+        // Default: year: :numeric, month: :numeric, day: :numeric
+        // This matches JavaScript Intl.DateTimeFormat default behavior
+        let component_options = if !has_style_options && !has_component_options {
+            ComponentOptions {
+                year: Some(YearStyle::Numeric),
+                month: Some(MonthStyle::Numeric),
+                day: Some(DayStyle::Numeric),
+                ..Default::default()
+            }
+        } else {
+            component_options
+        };
+        let has_component_options = !component_options.is_empty();
+
         // Extract time_zone option and parse it
         let time_zone: Option<String> =
             kwargs.lookup::<_, Option<String>>(ruby.to_symbol("time_zone"))?;
@@ -192,6 +375,20 @@ impl DateTimeFormat {
         let calendar =
             helpers::extract_symbol(ruby, &kwargs, "calendar", Calendar::from_ruby_symbol)?;
 
+        // Extract hour_cycle option
+        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,
+        };
+
         // Get the error exception class
         let error_class = helpers::get_exception_class(ruby, "ICU4X::Error");
 
@@ -203,14 +400,21 @@ impl DateTimeFormat {
             )
         })?;
 
-        // Create field set based on date_style and time_style
-        let field_set = Self::create_field_set(date_style, time_style);
+        // Create field set based on options
+        let field_set = if has_component_options {
+            Self::create_field_set_from_components(ruby, &component_options)?
+        } else {
+            Self::create_field_set_from_style(date_style, time_style)
+        };
 
-        // Create formatter with calendar preference
+        // Create formatter with calendar and hour_cycle preferences
         let mut prefs: DateTimeFormatterPreferences = (&icu_locale).into();
         if let Some(cal) = calendar {
             prefs.calendar_algorithm = Some(cal.to_calendar_algorithm());
         }
+        if let Some(hc) = hour_cycle {
+            prefs.hour_cycle = Some(hc.to_icu_hour_cycle());
+        }
 
         let formatter =
             DateTimeFormatter::try_new_unstable(&dp.inner.as_deserializing(), prefs, field_set)
@@ -232,11 +436,130 @@ impl DateTimeFormat {
             time_zone,
             jiff_timezone,
             calendar: resolved_calendar,
+            hour_cycle,
+            component_options: if has_component_options {
+                Some(component_options)
+            } else {
+                None
+            },
         })
     }
 
+    /// Extract component options from kwargs
+    fn extract_component_options(ruby: &Ruby, kwargs: &RHash) -> Result<ComponentOptions, Error> {
+        let year = helpers::extract_symbol(ruby, kwargs, "year", YearStyle::from_ruby_symbol)?;
+        let month = helpers::extract_symbol(ruby, kwargs, "month", MonthStyle::from_ruby_symbol)?;
+        let day = helpers::extract_symbol(ruby, kwargs, "day", DayStyle::from_ruby_symbol)?;
+        let weekday =
+            helpers::extract_symbol(ruby, kwargs, "weekday", WeekdayStyle::from_ruby_symbol)?;
+        let hour = helpers::extract_symbol(ruby, kwargs, "hour", HourStyle::from_ruby_symbol)?;
+        let minute =
+            helpers::extract_symbol(ruby, kwargs, "minute", MinuteStyle::from_ruby_symbol)?;
+        let second =
+            helpers::extract_symbol(ruby, kwargs, "second", SecondStyle::from_ruby_symbol)?;
+
+        Ok(ComponentOptions {
+            year,
+            month,
+            day,
+            weekday,
+            hour,
+            minute,
+            second,
+        })
+    }
+
+    /// Create field set from component options
+    ///
+    /// Maps component combinations to appropriate ICU4X Field Sets.
+    /// Field Sets determine which components appear; the locale determines their order.
+    /// The length is determined by the component option values (e.g., :long → Long).
+    fn create_field_set_from_components(
+        ruby: &Ruby,
+        opts: &ComponentOptions,
+    ) -> Result<CompositeDateTimeFieldSet, Error> {
+        let has_date = opts.has_date_components();
+        let has_time = opts.has_time_components();
+        let length = opts.determine_length();
+
+        match (has_date, has_time) {
+            (true, true) => {
+                // Date and time components
+                Ok(CompositeDateTimeFieldSet::DateTime(
+                    DateAndTimeFieldSet::YMDT(fieldsets::YMDT::for_length(length)),
+                ))
+            }
+            (true, false) => {
+                // Date only - choose field set based on which components are specified
+                let has_year = opts.year.is_some();
+                let has_month = opts.month.is_some();
+                let has_day = opts.day.is_some();
+                let has_weekday = opts.weekday.is_some();
+
+                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)),
+                    )),
+                    // Year + Month + Day
+                    (true, true, true, false) => Ok(CompositeDateTimeFieldSet::Date(
+                        DateFieldSet::YMD(fieldsets::YMD::for_length(length)),
+                    )),
+                    // Month + Day + Weekday
+                    (false, true, true, true) => Ok(CompositeDateTimeFieldSet::Date(
+                        DateFieldSet::MDE(fieldsets::MDE::for_length(length)),
+                    )),
+                    // Month + Day
+                    (false, true, true, false) => Ok(CompositeDateTimeFieldSet::Date(
+                        DateFieldSet::MD(fieldsets::MD::for_length(length)),
+                    )),
+                    // Year + Month (calendar period)
+                    (true, true, false, _) => Ok(CompositeDateTimeFieldSet::CalendarPeriod(
+                        CalendarPeriodFieldSet::YM(fieldsets::YM::for_length(length)),
+                    )),
+                    // Month only (calendar period)
+                    (false, true, false, _) => Ok(CompositeDateTimeFieldSet::CalendarPeriod(
+                        CalendarPeriodFieldSet::M(fieldsets::M::for_length(length)),
+                    )),
+                    // Day + Weekday
+                    (false, false, true, true) => Ok(CompositeDateTimeFieldSet::Date(
+                        DateFieldSet::DE(fieldsets::DE::for_length(length)),
+                    )),
+                    // Day only
+                    (false, false, true, false) => Ok(CompositeDateTimeFieldSet::Date(
+                        DateFieldSet::D(fieldsets::D::for_length(length)),
+                    )),
+                    // Weekday only
+                    (false, false, false, true) => Ok(CompositeDateTimeFieldSet::Date(
+                        DateFieldSet::E(fieldsets::E::for_length(length)),
+                    )),
+                    // Year only (calendar period)
+                    (true, false, false, _) => Ok(CompositeDateTimeFieldSet::CalendarPeriod(
+                        CalendarPeriodFieldSet::Y(fieldsets::Y::for_length(length)),
+                    )),
+                    // Year + Day (not a standard combination, use YMD as fallback)
+                    (true, false, true, _) => Ok(CompositeDateTimeFieldSet::Date(
+                        DateFieldSet::YMD(fieldsets::YMD::for_length(length)),
+                    )),
+                    // Should not happen - we checked has_date_components
+                    (false, false, false, false) => unreachable!(),
+                }
+            }
+            (false, true) => {
+                // Time only - use medium as default since time components are always numeric
+                Ok(CompositeDateTimeFieldSet::Time(TimeFieldSet::T(
+                    fieldsets::T::for_length(length),
+                )))
+            }
+            (false, false) => Err(Error::new(
+                ruby.exception_arg_error(),
+                "at least one component option must be specified",
+            )),
+        }
+    }
+
     /// Create field set based on date_style and time_style
-    fn create_field_set(
+    fn create_field_set_from_style(
         date_style: Option<DateStyle>,
         time_style: Option<TimeStyle>,
     ) -> CompositeDateTimeFieldSet {
@@ -284,7 +607,36 @@ impl DateTimeFormat {
     /// A formatted string
     fn format(&self, time: Value) -> Result<String, Error> {
         let ruby = Ruby::get().expect("Ruby runtime should be available");
+        let datetime = self.prepare_datetime(&ruby, time)?;
+        let formatted = self.inner.format(&datetime);
+        Ok(formatted.to_string())
+    }
+
+    /// Format a Ruby Time object and return an array of FormattedPart
+    ///
+    /// # Arguments
+    /// * `time` - A Ruby Time object or an object responding to #to_time (e.g., Date, DateTime)
+    ///
+    /// # Returns
+    /// An array of FormattedPart objects with :type and :value
+    fn format_to_parts(&self, time: Value) -> Result<RArray, Error> {
+        let ruby = Ruby::get().expect("Ruby runtime should be available");
+        let datetime = self.prepare_datetime(&ruby, time)?;
+
+        let formatted = self.inner.format(&datetime);
+        let mut collector = PartsCollector::new();
+        formatted
+            .write_to_parts(&mut collector)
+            .map_err(|e| Error::new(ruby.exception_runtime_error(), format!("{}", e)))?;
+
+        parts_to_ruby_array(&ruby, collector, part_to_symbol_name)
+    }
 
+    /// 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> {
         // 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", ())?
@@ -301,12 +653,7 @@ impl DateTimeFormat {
             ));
         }
 
-        // Convert Ruby Time to ICU4X DateTime, applying timezone if specified
-        let datetime = self.convert_time_to_datetime(&ruby, time_value)?;
-
-        // Format the datetime
-        let formatted = self.inner.format(&datetime);
-        Ok(formatted.to_string())
+        self.convert_time_to_datetime(ruby, time_value)
     }
 
     /// Convert Ruby Time to ICU4X DateTime<Gregorian>
@@ -374,7 +721,7 @@ impl DateTimeFormat {
     /// Get the resolved options
     ///
     /// # Returns
-    /// A hash with :locale, :calendar, :date_style, :time_style, and optionally :time_zone
+    /// A hash with :locale, :calendar, :date_style, :time_style, and optionally :time_zone, :hour_cycle
     fn resolved_options(&self) -> Result<RHash, Error> {
         let ruby = Ruby::get().expect("Ruby runtime should be available");
         let hash = ruby.hash_new();
@@ -403,6 +750,59 @@ impl DateTimeFormat {
             hash.aset(ruby.to_symbol("time_zone"), tz.as_str())?;
         }
 
+        if let Some(hc) = self.hour_cycle {
+            hash.aset(
+                ruby.to_symbol("hour_cycle"),
+                ruby.to_symbol(hc.to_symbol_name()),
+            )?;
+        }
+
+        // Add component options if they were used
+        if let Some(ref opts) = self.component_options {
+            if let Some(year) = opts.year {
+                hash.aset(
+                    ruby.to_symbol("year"),
+                    ruby.to_symbol(year.to_symbol_name()),
+                )?;
+            }
+            if let Some(month) = opts.month {
+                hash.aset(
+                    ruby.to_symbol("month"),
+                    ruby.to_symbol(month.to_symbol_name()),
+                )?;
+            }
+            if let Some(day) = opts.day {
+                hash.aset(
+                    ruby.to_symbol("day"),
+                    ruby.to_symbol(day.to_symbol_name()),
+                )?;
+            }
+            if let Some(weekday) = opts.weekday {
+                hash.aset(
+                    ruby.to_symbol("weekday"),
+                    ruby.to_symbol(weekday.to_symbol_name()),
+                )?;
+            }
+            if let Some(hour) = opts.hour {
+                hash.aset(
+                    ruby.to_symbol("hour"),
+                    ruby.to_symbol(hour.to_symbol_name()),
+                )?;
+            }
+            if let Some(minute) = opts.minute {
+                hash.aset(
+                    ruby.to_symbol("minute"),
+                    ruby.to_symbol(minute.to_symbol_name()),
+                )?;
+            }
+            if let Some(second) = opts.second {
+                hash.aset(
+                    ruby.to_symbol("second"),
+                    ruby.to_symbol(second.to_symbol_name()),
+                )?;
+            }
+        }
+
         Ok(hash)
     }
 }
@@ -411,6 +811,10 @@ pub fn init(ruby: &Ruby, module: &RModule) -> Result<(), Error> {
     let class = module.define_class("DateTimeFormat", ruby.class_object())?;
     class.define_singleton_method("new", function!(DateTimeFormat::new, -1))?;
     class.define_method("format", method!(DateTimeFormat::format, 1))?;
+    class.define_method(
+        "format_to_parts",
+        method!(DateTimeFormat::format_to_parts, 1),
+    )?;
     class.define_method(
         "resolved_options",
         method!(DateTimeFormat::resolved_options, 0),

data/ext/icu4x/src/lib.rs

@@ -7,6 +7,7 @@ mod helpers;
 mod list_format;
 mod locale;
 mod number_format;
+mod parts_collector;
 mod plural_rules;
 mod relative_time_format;
 mod segmenter;