icu4x 0.6.2 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a9647737d3f7715bf56e3bc7c7c06be56aff4ac715e984bd245fa1d4410d4542
-  data.tar.gz: 5841b15fb21057937fcbdf98fedb4b78ff77acbb831a265ac7929106cd7ff39f
+  metadata.gz: 7871f9d79af05cf7edf90ca57fc7351b6cf8d027b5017606369748825265d359
+  data.tar.gz: e47cf84063cf0d7b8841d22c8776937cabb2fab7324a0dcb3e9129e5cec2df61
 SHA512:
-  metadata.gz: a86b5b21224069d5309cfd87f468313cc53636c8e724fd6d22644c15a6057d109f5e447d43466cb9b2ed36d82c1fad1dc9fffaa4ae6405ff127a10ee882b4751
-  data.tar.gz: bab512907b93d835df787cf89f3b4f98d0e8e31009d4e851f202904a2f57ec13e7d6e04e24e52b8157ce3b0f2cab570a34df7b7728e5d794b7c6cd668c708c8c
+  metadata.gz: 9b7d7683237505c31d148451262825f40458ab916717949f7a6e1c6f76397eb94f898eda81a00d5131efee1ef904623d2b128b38a366ef39f8804c90fda48daa
+  data.tar.gz: 1ec09d4d5f4a4529aa4ac6a2747d1c16f3c5b66fbc60e3b28fcb8bafd5e0c4ba43b41a4fde5cdc5cd5e14f7bc2edb8cd0793ca86fe2b4052787929baa5e469be

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 ## [Unreleased]
 
+## [0.8.0] - 2026-01-10
+
+### Added
+
+- `ICU4X::Locale#maximize!` and `#maximize` methods to expand locale using Likely Subtags algorithm (UTS #35)
+- `ICU4X::Locale#minimize!` and `#minimize` methods to remove redundant subtags
+
+## [0.7.0] - 2026-01-09
+
+### Added
+
+- `DateTimeFormat#format` now accepts any object responding to `#to_time` (e.g., `Date`, `DateTime`)
+
 ## [0.6.2] - 2026-01-02
 
 ### Fixed

data/ext/icu4x/src/collator.rs

@@ -46,7 +46,18 @@ pub struct Collator {
     case_first: Option<CaseFirstOption>,
 }
 
-// SAFETY: Ruby's GVL protects access to this type.
+// SAFETY: This type is marked as Send to allow Ruby to move it between threads.
+//
+// Thread safety is guaranteed by Ruby's Global VM Lock (GVL):
+// - All Ruby method calls are serialized by the GVL
+// - Only one thread can execute Ruby code at a time
+// - The underlying ICU4X types are only accessed through Ruby method calls
+//
+// WARNING: This safety guarantee does NOT hold if:
+// - The GVL is released via `rb_thread_call_without_gvl`
+// - Using threading libraries that bypass the GVL
+//
+// In such cases, concurrent access to this type would be unsafe.
 unsafe impl Send for Collator {}
 
 impl Collator {

data/ext/icu4x/src/data_provider.rs

@@ -25,8 +25,18 @@ pub struct DataProvider {
     pub(crate) inner: LocaleFallbackProvider<BlobDataProvider>,
 }
 
-// SAFETY: Ruby's GVL protects access to this type. The provider is only
-// accessed through Ruby method calls, which are serialized by the GVL.
+// SAFETY: This type is marked as Send to allow Ruby to move it between threads.
+//
+// Thread safety is guaranteed by Ruby's Global VM Lock (GVL):
+// - All Ruby method calls are serialized by the GVL
+// - Only one thread can execute Ruby code at a time
+// - The underlying ICU4X types are only accessed through Ruby method calls
+//
+// WARNING: This safety guarantee does NOT hold if:
+// - The GVL is released via `rb_thread_call_without_gvl`
+// - Using threading libraries that bypass the GVL
+//
+// In such cases, concurrent access to this type would be unsafe.
 unsafe impl Send for DataProvider {}
 
 impl DataProvider {

data/ext/icu4x/src/datetime_format.rs

@@ -106,7 +106,18 @@ pub struct DateTimeFormat {
     calendar: Calendar,
 }
 
-// SAFETY: Ruby's GVL protects access to this type.
+// SAFETY: This type is marked as Send to allow Ruby to move it between threads.
+//
+// Thread safety is guaranteed by Ruby's Global VM Lock (GVL):
+// - All Ruby method calls are serialized by the GVL
+// - Only one thread can execute Ruby code at a time
+// - The underlying ICU4X types are only accessed through Ruby method calls
+//
+// WARNING: This safety guarantee does NOT hold if:
+// - The GVL is released via `rb_thread_call_without_gvl`
+// - Using threading libraries that bypass the GVL
+//
+// In such cases, concurrent access to this type would be unsafe.
 unsafe impl Send for DateTimeFormat {}
 
 impl DateTimeFormat {
@@ -264,27 +275,34 @@ impl DateTimeFormat {
         }
     }
 
-    /// Format a Ruby Time object
+    /// Format a Ruby Time object or any object responding to #to_time
     ///
     /// # Arguments
-    /// * `time` - A Ruby Time object
+    /// * `time` - A Ruby Time object or an object responding to #to_time (e.g., Date, DateTime)
     ///
     /// # Returns
     /// A formatted string
     fn format(&self, time: Value) -> Result<String, Error> {
         let ruby = Ruby::get().expect("Ruby runtime should be available");
 
-        // Validate that time is a Time object
+        // 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", ())?
+        } else {
+            time
+        };
+
+        // Validate that the result is a Time object
         let time_class: Value = ruby.eval("Time")?;
-        if !time.is_kind_of(magnus::RClass::try_convert(time_class)?) {
+        if !time_value.is_kind_of(magnus::RClass::try_convert(time_class)?) {
             return Err(Error::new(
                 ruby.exception_type_error(),
-                "argument must be a Time object",
+                "argument must be a Time object or respond to #to_time",
             ));
         }
 
         // Convert Ruby Time to ICU4X DateTime, applying timezone if specified
-        let datetime = self.convert_time_to_datetime(&ruby, time)?;
+        let datetime = self.convert_time_to_datetime(&ruby, time_value)?;
 
         // Format the datetime
         let formatted = self.inner.format(&datetime);

data/ext/icu4x/src/display_names.rs

@@ -72,7 +72,18 @@ pub struct DisplayNames {
     fallback: DisplayNamesFallback,
 }
 
-// SAFETY: Ruby's GVL protects access to this type.
+// SAFETY: This type is marked as Send to allow Ruby to move it between threads.
+//
+// Thread safety is guaranteed by Ruby's Global VM Lock (GVL):
+// - All Ruby method calls are serialized by the GVL
+// - Only one thread can execute Ruby code at a time
+// - The underlying ICU4X types are only accessed through Ruby method calls
+//
+// WARNING: This safety guarantee does NOT hold if:
+// - The GVL is released via `rb_thread_call_without_gvl`
+// - Using threading libraries that bypass the GVL
+//
+// In such cases, concurrent access to this type would be unsafe.
 unsafe impl Send for DisplayNames {}
 
 impl DisplayNames {

data/ext/icu4x/src/list_format.rs

@@ -43,7 +43,18 @@ pub struct ListFormat {
     list_style: ListStyle,
 }
 
-// SAFETY: Ruby's GVL protects access to this type.
+// SAFETY: This type is marked as Send to allow Ruby to move it between threads.
+//
+// Thread safety is guaranteed by Ruby's Global VM Lock (GVL):
+// - All Ruby method calls are serialized by the GVL
+// - Only one thread can execute Ruby code at a time
+// - The underlying ICU4X types are only accessed through Ruby method calls
+//
+// WARNING: This safety guarantee does NOT hold if:
+// - The GVL is released via `rb_thread_call_without_gvl`
+// - Using threading libraries that bypass the GVL
+//
+// In such cases, concurrent access to this type would be unsafe.
 unsafe impl Send for ListFormat {}
 
 impl ListFormat {

data/ext/icu4x/src/locale.rs

@@ -1,6 +1,6 @@
 use crate::helpers;
-use icu_locale::Locale as IcuLocale;
-use magnus::{Error, RHash, RModule, Ruby, function, method, prelude::*};
+use icu_locale::{Locale as IcuLocale, LocaleExpander, TransformResult};
+use magnus::{Error, RHash, RModule, Ruby, function, method, prelude::*, typed_data::Obj};
 use std::cell::RefCell;
 
 /// Ruby wrapper for ICU4X Locale
@@ -162,6 +162,48 @@ impl Locale {
     fn eq(&self, other: &Locale) -> bool {
         *self.inner.borrow() == *other.inner.borrow()
     }
+
+    /// Maximize the locale in place (Add Likely Subtags algorithm, UTS #35)
+    /// Returns self if modified, nil if unchanged
+    fn maximize_bang(rb_self: Obj<Self>) -> Option<Obj<Self>> {
+        let expander = LocaleExpander::new_common();
+        let mut locale = rb_self.inner.borrow_mut();
+        match expander.maximize(&mut locale.id) {
+            TransformResult::Modified => Some(rb_self),
+            TransformResult::Unmodified => None,
+        }
+    }
+
+    /// Maximize the locale, returning a new Locale object
+    fn maximize(&self) -> Self {
+        let expander = LocaleExpander::new_common();
+        let mut new_id = self.inner.borrow().id.clone();
+        expander.maximize(&mut new_id);
+        Self {
+            inner: RefCell::new(IcuLocale::from(new_id)),
+        }
+    }
+
+    /// Minimize the locale in place (Remove Likely Subtags algorithm, UTS #35)
+    /// Returns self if modified, nil if unchanged
+    fn minimize_bang(rb_self: Obj<Self>) -> Option<Obj<Self>> {
+        let expander = LocaleExpander::new_common();
+        let mut locale = rb_self.inner.borrow_mut();
+        match expander.minimize(&mut locale.id) {
+            TransformResult::Modified => Some(rb_self),
+            TransformResult::Unmodified => None,
+        }
+    }
+
+    /// Minimize the locale, returning a new Locale object
+    fn minimize(&self) -> Self {
+        let expander = LocaleExpander::new_common();
+        let mut new_id = self.inner.borrow().id.clone();
+        expander.minimize(&mut new_id);
+        Self {
+            inner: RefCell::new(IcuLocale::from(new_id)),
+        }
+    }
 }
 
 pub fn init(ruby: &Ruby, module: &RModule) -> Result<(), Error> {
@@ -174,5 +216,9 @@ pub fn init(ruby: &Ruby, module: &RModule) -> Result<(), Error> {
     class.define_method("extensions", method!(Locale::extensions, 0))?;
     class.define_method("to_s", method!(Locale::to_s, 0))?;
     class.define_method("==", method!(Locale::eq, 1))?;
+    class.define_method("maximize!", method!(Locale::maximize_bang, 0))?;
+    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))?;
     Ok(())
 }

data/ext/icu4x/src/number_format.rs

@@ -83,7 +83,18 @@ pub struct NumberFormat {
     rounding_mode: RoundingMode,
 }
 
-// SAFETY: Ruby's GVL protects access to this type.
+// SAFETY: This type is marked as Send to allow Ruby to move it between threads.
+//
+// Thread safety is guaranteed by Ruby's Global VM Lock (GVL):
+// - All Ruby method calls are serialized by the GVL
+// - Only one thread can execute Ruby code at a time
+// - The underlying ICU4X types are only accessed through Ruby method calls
+//
+// WARNING: This safety guarantee does NOT hold if:
+// - The GVL is released via `rb_thread_call_without_gvl`
+// - Using threading libraries that bypass the GVL
+//
+// In such cases, concurrent access to this type would be unsafe.
 unsafe impl Send for NumberFormat {}
 
 impl NumberFormat {

data/ext/icu4x/src/plural_rules.rs

@@ -17,7 +17,18 @@ pub struct PluralRules {
     rule_type: PluralRuleType,
 }
 
-// SAFETY: Ruby's GVL protects access to this type.
+// SAFETY: This type is marked as Send to allow Ruby to move it between threads.
+//
+// Thread safety is guaranteed by Ruby's Global VM Lock (GVL):
+// - All Ruby method calls are serialized by the GVL
+// - Only one thread can execute Ruby code at a time
+// - The underlying ICU4X types are only accessed through Ruby method calls
+//
+// WARNING: This safety guarantee does NOT hold if:
+// - The GVL is released via `rb_thread_call_without_gvl`
+// - Using threading libraries that bypass the GVL
+//
+// In such cases, concurrent access to this type would be unsafe.
 unsafe impl Send for PluralRules {}
 
 impl PluralRules {

data/ext/icu4x/src/relative_time_format.rs

@@ -75,7 +75,18 @@ pub struct RelativeTimeFormat {
     numeric: NumericMode,
 }
 
-// SAFETY: Ruby's GVL protects access to this type.
+// SAFETY: This type is marked as Send to allow Ruby to move it between threads.
+//
+// Thread safety is guaranteed by Ruby's Global VM Lock (GVL):
+// - All Ruby method calls are serialized by the GVL
+// - Only one thread can execute Ruby code at a time
+// - The underlying ICU4X types are only accessed through Ruby method calls
+//
+// WARNING: This safety guarantee does NOT hold if:
+// - The GVL is released via `rb_thread_call_without_gvl`
+// - Using threading libraries that bypass the GVL
+//
+// In such cases, concurrent access to this type would be unsafe.
 unsafe impl Send for RelativeTimeFormat {}
 
 impl RelativeTimeFormat {

data/ext/icu4x/src/segmenter.rs

@@ -38,7 +38,18 @@ pub struct Segmenter {
     granularity: Granularity,
 }
 
-// SAFETY: Ruby's GVL protects access to this type.
+// SAFETY: This type is marked as Send to allow Ruby to move it between threads.
+//
+// Thread safety is guaranteed by Ruby's Global VM Lock (GVL):
+// - All Ruby method calls are serialized by the GVL
+// - Only one thread can execute Ruby code at a time
+// - The underlying ICU4X types are only accessed through Ruby method calls
+//
+// WARNING: This safety guarantee does NOT hold if:
+// - The GVL is released via `rb_thread_call_without_gvl`
+// - Using threading libraries that bypass the GVL
+//
+// In such cases, concurrent access to this type would be unsafe.
 unsafe impl Send for Segmenter {}
 
 impl Segmenter {

data/lib/icu4x/version.rb

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

data/lib/icu4x/yard_docs.rb

@@ -274,6 +274,74 @@
 #       # @return [Integer] hash code
 #       #
 #       def hash; end
+#
+#       # Maximizes the locale in place using the Add Likely Subtags algorithm (UTS #35).
+#       #
+#       # Adds likely script and region subtags based on the language.
+#       # This is useful for language negotiation.
+#       #
+#       # @return [self, nil] self if the locale was modified, nil if already maximized
+#       #
+#       # @example
+#       #   locale = ICU4X::Locale.parse("en")
+#       #   locale.maximize!  #=> locale
+#       #   locale.to_s       #=> "en-Latn-US"
+#       #
+#       # @example Already maximized
+#       #   locale = ICU4X::Locale.parse("en-Latn-US")
+#       #   locale.maximize!  #=> nil
+#       #
+#       # @see https://unicode.org/reports/tr35/#Likely_Subtags
+#       #
+#       def maximize!; end
+#
+#       # Returns a new locale with likely subtags added.
+#       #
+#       # Non-destructive version of {#maximize!}. The original locale is unchanged.
+#       #
+#       # @return [Locale] a new locale with likely subtags added
+#       #
+#       # @example
+#       #   locale = ICU4X::Locale.parse("zh")
+#       #   expanded = locale.maximize
+#       #   locale.to_s    #=> "zh" (unchanged)
+#       #   expanded.to_s  #=> "zh-Hans-CN"
+#       #
+#       def maximize; end
+#
+#       # Minimizes the locale in place using the Remove Likely Subtags algorithm (UTS #35).
+#       #
+#       # Removes redundant script and region subtags that can be inferred.
+#       # This is useful for language negotiation.
+#       #
+#       # @return [self, nil] self if the locale was modified, nil if already minimal
+#       #
+#       # @example
+#       #   locale = ICU4X::Locale.parse("ja-Jpan-JP")
+#       #   locale.minimize!  #=> locale
+#       #   locale.to_s       #=> "ja"
+#       #
+#       # @example Already minimal
+#       #   locale = ICU4X::Locale.parse("en")
+#       #   locale.minimize!  #=> nil
+#       #
+#       # @see https://unicode.org/reports/tr35/#Likely_Subtags
+#       #
+#       def minimize!; end
+#
+#       # Returns a new locale with redundant subtags removed.
+#       #
+#       # Non-destructive version of {#minimize!}. The original locale is unchanged.
+#       #
+#       # @return [Locale] a new locale with redundant subtags removed
+#       #
+#       # @example
+#       #   locale = ICU4X::Locale.parse("zh-Hans-CN")
+#       #   minimal = locale.minimize
+#       #   locale.to_s   #=> "zh-Hans-CN" (unchanged)
+#       #   minimal.to_s  #=> "zh"
+#       #
+#       def minimize; end
 #     end
 #
 #     # Provides locale-aware plural rules for cardinal and ordinal numbers.
@@ -441,7 +509,7 @@
 #
 #       # Formats a time value according to the configured options.
 #       #
-#       # @param time [Time] the time to format
+#       # @param time [Time, #to_time] the time to format (or any object responding to #to_time)
 #       # @return [String] the formatted date/time string
 #       #
 #       def format(time); end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: icu4x
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.8.0
 platform: ruby
 authors:
 - OZAWA Sakuro
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-01-02 00:00:00.000000000 Z
+date: 2026-01-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-configurable
@@ -38,7 +38,10 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.9'
-description: icu4x
+description: |-
+  ICU4X provides Ruby bindings for the ICU4X library, offering Unicode
+  internationalization support including locale handling, number formatting,
+  date/time formatting, collation, segmentation, and more.
 email:
 - 10973+sakuro@users.noreply.github.com
 executables: []
@@ -100,5 +103,5 @@ requirements: []
 rubygems_version: 3.4.19
 signing_key:
 specification_version: 4
-summary: icu4x
+summary: Ruby bindings for ICU4X Unicode internationalization library
 test_files: []