icu4x 0.8.1 → 0.10.0

data/ext/icu4x/src/list_format.rs

@@ -1,12 +1,13 @@
 use crate::data_provider::DataProvider;
 use crate::helpers;
+use crate::parts_collector::{PartsCollector, parts_to_ruby_array};
+use icu::list::parts as list_parts;
 use icu::list::ListFormatter;
 use icu::list::options::{ListFormatterOptions, ListLength};
 use icu_provider::buf::AsDeserializingBufferProvider;
 use icu4x_macros::RubySymbol;
-use magnus::{
-    Error, RArray, RHash, RModule, Ruby, TryConvert, Value, function, method, prelude::*,
-};
+use magnus::{Error, RArray, RHash, RModule, Ruby, TryConvert, Value, function, method, prelude::*};
+use writeable::{Part, Writeable};
 
 /// The type of list formatting
 #[derive(Clone, Copy, PartialEq, Eq, RubySymbol)]
@@ -34,6 +35,17 @@ impl ListStyle {
     }
 }
 
+/// Convert ICU4X list Part to Ruby symbol name
+fn part_to_symbol_name(part: &Part) -> &'static str {
+    if *part == list_parts::ELEMENT {
+        "element"
+    } else if *part == list_parts::LITERAL {
+        "literal"
+    } else {
+        "literal"
+    }
+}
+
 /// Ruby wrapper for ICU4X ListFormatter
 #[magnus::wrap(class = "ICU4X::ListFormat", free_immediately, size)]
 pub struct ListFormat {
@@ -134,18 +146,42 @@ impl ListFormat {
     /// A formatted string
     fn format(&self, list: Value) -> Result<String, Error> {
         let ruby = Ruby::get().expect("Ruby runtime should be available");
+        let items = self.prepare_list(&ruby, list)?;
+        let formatted = self.inner.format(items.iter().map(|s| s.as_str()));
+        Ok(formatted.to_string())
+    }
 
-        // Convert Ruby Array to Vec<String>
+    /// Format a list of strings and return an array of FormattedPart
+    ///
+    /// # Arguments
+    /// * `list` - An array of strings
+    ///
+    /// # Returns
+    /// An array of FormattedPart objects with :type and :value
+    fn format_to_parts(&self, list: Value) -> Result<RArray, Error> {
+        let ruby = Ruby::get().expect("Ruby runtime should be available");
+        let items = self.prepare_list(&ruby, list)?;
+
+        let formatted = self.inner.format(items.iter().map(|s| s.as_str()));
+        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 list for formatting.
+    ///
+    /// Converts Ruby Array to Vec<String>.
+    fn prepare_list(&self, ruby: &Ruby, list: Value) -> Result<Vec<String>, Error> {
         let array: RArray = TryConvert::try_convert(list)
             .map_err(|_| Error::new(ruby.exception_type_error(), "list must be an Array"))?;
 
-        let items: Vec<String> = array
+        array
             .into_iter()
             .map(TryConvert::try_convert)
-            .collect::<Result<Vec<_>, _>>()?;
-
-        let formatted = self.inner.format(items.iter().map(|s| s.as_str()));
-        Ok(formatted.to_string())
+            .collect::<Result<Vec<_>, _>>()
     }
 
     /// Get the resolved options
@@ -172,6 +208,7 @@ pub fn init(ruby: &Ruby, module: &RModule) -> Result<(), Error> {
     let class = module.define_class("ListFormat", ruby.class_object())?;
     class.define_singleton_method("new", function!(ListFormat::new, -1))?;
     class.define_method("format", method!(ListFormat::format, 1))?;
+    class.define_method("format_to_parts", method!(ListFormat::format_to_parts, 1))?;
     class.define_method("resolved_options", method!(ListFormat::resolved_options, 0))?;
     Ok(())
 }

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;
 
@@ -11,7 +12,7 @@ pub struct Locale {
 
 impl Locale {
     /// Parse a BCP 47 locale string
-    fn parse(ruby: &Ruby, s: String) -> Result<Self, Error> {
+    fn parse_bcp47(ruby: &Ruby, s: String) -> Result<Self, Error> {
         let locale: IcuLocale = s.parse().map_err(|e| {
             Error::new(
                 helpers::get_exception_class(ruby, "ICU4X::LocaleError"),
@@ -32,7 +33,7 @@ impl Locale {
     fn parse_posix(ruby: &Ruby, posix_str: String) -> Result<Self, Error> {
         // Handle special cases
         if posix_str == "C" || posix_str == "POSIX" {
-            return Self::parse(ruby, "und".to_string());
+            return Self::parse_bcp47(ruby, "und".to_string());
         }
 
         // Handle empty string
@@ -90,7 +91,7 @@ impl Locale {
             bcp47.push_str(&t.to_uppercase());
         }
 
-        Self::parse(ruby, bcp47)
+        Self::parse_bcp47(ruby, bcp47)
     }
 
     /// Get the language component
@@ -204,11 +205,63 @@ 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> {
     let class = module.define_class("Locale", ruby.class_object())?;
-    class.define_singleton_method("parse", function!(Locale::parse, 1))?;
+    class.define_singleton_method("parse_bcp47", function!(Locale::parse_bcp47, 1))?;
+    class.singleton_class()?.define_alias("parse", "parse_bcp47")?;
     class.define_singleton_method("parse_posix", function!(Locale::parse_posix, 1))?;
     class.define_method("language", method!(Locale::language, 0))?;
     class.define_method("script", method!(Locale::script, 0))?;
@@ -220,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

@@ -1,7 +1,9 @@
 use crate::data_provider::DataProvider;
 use crate::helpers;
+use crate::parts_collector::{PartsCollector, parts_to_ruby_array};
 use fixed_decimal::{Decimal, SignedRoundingMode, UnsignedRoundingMode};
 use icu::decimal::options::{DecimalFormatterOptions, GroupingStrategy};
+use icu::decimal::parts as decimal_parts;
 use icu::decimal::{DecimalFormatter, DecimalFormatterPreferences};
 use icu::experimental::dimension::currency::CurrencyCode;
 use icu::experimental::dimension::currency::formatter::{
@@ -14,10 +16,9 @@ use icu::experimental::dimension::percent::formatter::{
 use icu::experimental::dimension::percent::options::PercentFormatterOptions;
 use icu_provider::buf::AsDeserializingBufferProvider;
 use icu4x_macros::RubySymbol;
-use magnus::{
-    Error, RHash, RModule, Ruby, TryConvert, Value, function, method, prelude::*,
-};
+use magnus::{Error, RArray, RHash, RModule, Ruby, TryConvert, Value, function, method, prelude::*};
 use tinystr::TinyAsciiStr;
+use writeable::{Part, Writeable};
 
 /// The style of number formatting
 #[derive(Clone, Copy, PartialEq, Eq, RubySymbol)]
@@ -69,6 +70,29 @@ enum FormatterKind {
     Currency(CurrencyFormatter, CurrencyCode),
 }
 
+/// Convert ICU4X decimal Part to Ruby symbol name
+fn part_to_symbol_name(part: &Part) -> &'static str {
+    if *part == decimal_parts::INTEGER {
+        "integer"
+    } else if *part == decimal_parts::FRACTION {
+        "fraction"
+    } else if *part == decimal_parts::DECIMAL {
+        "decimal"
+    } else if *part == decimal_parts::GROUP {
+        "group"
+    } else if *part == decimal_parts::MINUS_SIGN {
+        "minus_sign"
+    } else if *part == decimal_parts::PLUS_SIGN {
+        "plus_sign"
+    } else if part.category == "currency" {
+        "currency"
+    } else if part.category == "percent" {
+        "percent_sign"
+    } else {
+        "literal"
+    }
+}
+
 /// Ruby wrapper for ICU4X number formatters
 #[magnus::wrap(class = "ICU4X::NumberFormat", free_immediately, size)]
 pub struct NumberFormat {
@@ -268,8 +292,59 @@ impl NumberFormat {
     /// A formatted string
     fn format(&self, number: Value) -> Result<String, Error> {
         let ruby = Ruby::get().expect("Ruby runtime should be available");
+        let decimal = self.prepare_decimal(&ruby, number)?;
+
+        let formatted = match &self.inner {
+            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)
+                .to_string(),
+        };
+        Ok(formatted)
+    }
+
+    /// Format a number and return an array of FormattedPart
+    ///
+    /// # Arguments
+    /// * `number` - An integer, float, or BigDecimal
+    ///
+    /// # Returns
+    /// An array of FormattedPart objects with :type and :value
+    fn format_to_parts(&self, number: Value) -> Result<RArray, Error> {
+        let ruby = Ruby::get().expect("Ruby runtime should be available");
+        let decimal = self.prepare_decimal(&ruby, number)?;
+
+        let mut collector = PartsCollector::new();
+        match &self.inner {
+            FormatterKind::Decimal(formatter) => {
+                formatter
+                    .format(&decimal)
+                    .write_to_parts(&mut collector)
+                    .map_err(|e| Error::new(ruby.exception_runtime_error(), format!("{}", e)))?;
+            }
+            FormatterKind::Percent(formatter) => {
+                formatter
+                    .format(&decimal)
+                    .write_to_parts(&mut collector)
+                    .map_err(|e| Error::new(ruby.exception_runtime_error(), format!("{}", e)))?;
+            }
+            FormatterKind::Currency(formatter, currency_code) => {
+                formatter
+                    .format_fixed_decimal(&decimal, currency_code)
+                    .write_to_parts(&mut collector)
+                    .map_err(|e| Error::new(ruby.exception_runtime_error(), format!("{}", e)))?;
+            }
+        }
 
-        let mut decimal = Self::convert_to_decimal(&ruby, number)?;
+        parts_to_ruby_array(&ruby, collector, part_to_symbol_name)
+    }
+
+    /// Prepare a Ruby number for formatting.
+    ///
+    /// Converts to Decimal, adjusts for percent style, and applies digit options.
+    fn prepare_decimal(&self, ruby: &Ruby, number: Value) -> Result<Decimal, Error> {
+        let mut decimal = Self::convert_to_decimal(ruby, number)?;
 
         // For percent style, multiply by 100 (same as Intl.NumberFormat)
         if self.style == Style::Percent {
@@ -288,14 +363,7 @@ impl NumberFormat {
             decimal.pad_start(min);
         }
 
-        let formatted = match &self.inner {
-            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)
-                .to_string(),
-        };
-        Ok(formatted)
+        Ok(decimal)
     }
 
     /// Convert Ruby number to Decimal
@@ -331,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);
             }
@@ -382,6 +446,10 @@ pub fn init(ruby: &Ruby, module: &RModule) -> Result<(), Error> {
     let class = module.define_class("NumberFormat", ruby.class_object())?;
     class.define_singleton_method("new", function!(NumberFormat::new, -1))?;
     class.define_method("format", method!(NumberFormat::format, 1))?;
+    class.define_method(
+        "format_to_parts",
+        method!(NumberFormat::format_to_parts, 1),
+    )?;
     class.define_method(
         "resolved_options",
         method!(NumberFormat::resolved_options, 0),

data/ext/icu4x/src/parts_collector.rs

@@ -0,0 +1,117 @@
+use magnus::{Error, RArray, Ruby, Value, prelude::*};
+use std::fmt;
+use writeable::{Part, PartsWrite};
+
+/// A collector for formatted parts that handles nested part annotations.
+///
+/// ICU4X uses nested parts - e.g., datetime/day wraps decimal/integer.
+/// We track a stack of parts and prefer the outermost (top-level) annotations.
+pub struct PartsCollector {
+    parts: Vec<(String, Part)>,
+    current_buffer: String,
+    /// Stack of part contexts for handling nested with_part calls
+    part_stack: Vec<Part>,
+}
+
+impl PartsCollector {
+    pub fn new() -> Self {
+        Self {
+            parts: Vec::new(),
+            current_buffer: String::new(),
+            part_stack: Vec::new(),
+        }
+    }
+
+    fn flush(&mut self) {
+        // Store any remaining content as "literal"
+        if !self.current_buffer.is_empty() {
+            self.parts.push((
+                std::mem::take(&mut self.current_buffer),
+                Part {
+                    category: "literal",
+                    value: "literal",
+                },
+            ));
+        }
+    }
+
+    pub fn into_parts(mut self) -> Vec<(String, Part)> {
+        self.flush();
+        self.parts
+    }
+}
+
+impl fmt::Write for PartsCollector {
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        self.current_buffer.push_str(s);
+        Ok(())
+    }
+}
+
+impl PartsWrite for PartsCollector {
+    type SubPartsWrite = Self;
+
+    fn with_part(
+        &mut self,
+        part: Part,
+        mut f: impl FnMut(&mut Self::SubPartsWrite) -> fmt::Result,
+    ) -> fmt::Result {
+        // If at top level, store any buffered content as literal before entering new part
+        if self.part_stack.is_empty() && !self.current_buffer.is_empty() {
+            self.parts.push((
+                std::mem::take(&mut self.current_buffer),
+                Part {
+                    category: "literal",
+                    value: "literal",
+                },
+            ));
+        }
+
+        // Push this part onto the stack
+        self.part_stack.push(part);
+
+        // Execute the writing function
+        f(self)?;
+
+        // Pop this part from the stack
+        self.part_stack.pop();
+
+        // If back at top level, store collected content with effective part
+        if self.part_stack.is_empty() && !self.current_buffer.is_empty() {
+            self.parts
+                .push((std::mem::take(&mut self.current_buffer), part));
+        }
+
+        Ok(())
+    }
+}
+
+/// Converts collected parts to a Ruby array of FormattedPart objects.
+///
+/// # Arguments
+/// * `ruby` - The Ruby runtime reference
+/// * `collector` - The PartsCollector with collected parts
+/// * `part_mapper` - Function to convert a Part to a symbol name string
+///
+/// # Returns
+/// A Ruby array containing FormattedPart objects.
+pub fn parts_to_ruby_array<F>(
+    ruby: &Ruby,
+    collector: PartsCollector,
+    part_mapper: F,
+) -> Result<RArray, Error>
+where
+    F: Fn(&Part) -> &'static str,
+{
+    let formatted_part_class: Value = ruby.eval("ICU4X::FormattedPart")?;
+    let result = ruby.ary_new();
+
+    for (value, part) in collector.into_parts() {
+        let symbol_name = part_mapper(&part);
+        let part_obj: Value =
+            formatted_part_class.funcall("[]", (ruby.to_symbol(symbol_name), value.as_str()))?;
+        result.push(part_obj)?;
+    }
+
+    Ok(result)
+}

data/ext/icu4x/src/plural_rules.rs

@@ -2,7 +2,7 @@ use crate::data_provider::DataProvider;
 use crate::helpers;
 use fixed_decimal::Decimal;
 use icu::plurals::{
-    PluralCategory, PluralRuleType, PluralRules as IcuPluralRules, PluralRulesPreferences,
+    PluralCategory, PluralRuleType, PluralRulesPreferences, PluralRulesWithRanges,
 };
 use icu_provider::buf::AsDeserializingBufferProvider;
 use magnus::{
@@ -12,7 +12,7 @@ use magnus::{
 /// Ruby wrapper for ICU4X PluralRules
 #[magnus::wrap(class = "ICU4X::PluralRules", free_immediately, size)]
 pub struct PluralRules {
-    inner: IcuPluralRules,
+    inner: PluralRulesWithRanges<icu::plurals::PluralRules>,
     locale_str: String,
     rule_type: PluralRuleType,
 }
@@ -84,15 +84,20 @@ impl PluralRules {
             )
         })?;
 
-        // Create PluralRules from DataProvider
+        // Create PluralRulesWithRanges from DataProvider
         let rules = match rule_type {
-            PluralRuleType::Cardinal => {
-                IcuPluralRules::try_new_cardinal_unstable(&dp.inner.as_deserializing(), prefs)
-            }
-            PluralRuleType::Ordinal => {
-                IcuPluralRules::try_new_ordinal_unstable(&dp.inner.as_deserializing(), prefs)
-            }
-            _ => IcuPluralRules::try_new_cardinal_unstable(&dp.inner.as_deserializing(), prefs),
+            PluralRuleType::Cardinal => PluralRulesWithRanges::try_new_cardinal_unstable(
+                &dp.inner.as_deserializing(),
+                prefs,
+            ),
+            PluralRuleType::Ordinal => PluralRulesWithRanges::try_new_ordinal_unstable(
+                &dp.inner.as_deserializing(),
+                prefs,
+            ),
+            _ => PluralRulesWithRanges::try_new_cardinal_unstable(
+                &dp.inner.as_deserializing(),
+                prefs,
+            ),
         }
         .map_err(|e| Error::new(error_class, format!("Failed to create PluralRules: {}", e)))?;
 
@@ -120,7 +125,7 @@ impl PluralRules {
             // For floats, convert to Decimal to preserve fractional digits
             let s = format!("{}", f);
             if let Ok(fd) = s.parse::<Decimal>() {
-                self.inner.category_for(&fd)
+                self.inner.rules().category_for(&fd)
             } else {
                 return Err(Error::new(
                     ruby.exception_arg_error(),
@@ -129,7 +134,7 @@ impl PluralRules {
             }
         } else if number.is_kind_of(ruby.class_integer()) {
             let n: i64 = TryConvert::try_convert(number)?;
-            self.inner.category_for(n as usize)
+            self.inner.rules().category_for(n as usize)
         } else {
             return Err(Error::new(
                 ruby.exception_type_error(),
@@ -140,6 +145,49 @@ impl PluralRules {
         Ok(Self::category_to_symbol(&ruby, category))
     }
 
+    /// Determine the plural category for a range of numbers
+    ///
+    /// # Arguments
+    /// * `start` - The start of the range (integer or float)
+    /// * `end` - The end of the range (integer or float)
+    ///
+    /// # Returns
+    /// A symbol: :zero, :one, :two, :few, :many, or :other
+    fn select_range(&self, start: Value, end: Value) -> Result<Symbol, Error> {
+        let ruby = Ruby::get().expect("Ruby runtime should be available");
+
+        let start_decimal = Self::value_to_decimal(&ruby, start, "start")?;
+        let end_decimal = Self::value_to_decimal(&ruby, end, "end")?;
+
+        let category = self
+            .inner
+            .category_for_range(&start_decimal, &end_decimal);
+
+        Ok(Self::category_to_symbol(&ruby, category))
+    }
+
+    /// Convert a Ruby Value to a fixed_decimal::Decimal
+    fn value_to_decimal(ruby: &Ruby, value: Value, name: &str) -> Result<Decimal, Error> {
+        if value.is_kind_of(ruby.class_float()) {
+            let f: f64 = TryConvert::try_convert(value)?;
+            let s = format!("{}", f);
+            s.parse::<Decimal>().map_err(|_| {
+                Error::new(
+                    ruby.exception_arg_error(),
+                    format!("Failed to convert {} ({}) to Decimal", name, f),
+                )
+            })
+        } else if value.is_kind_of(ruby.class_integer()) {
+            let n: i64 = TryConvert::try_convert(value)?;
+            Ok(Decimal::from(n))
+        } else {
+            Err(Error::new(
+                ruby.exception_type_error(),
+                format!("{} must be an Integer or Float", name),
+            ))
+        }
+    }
+
     /// Get the list of plural categories for this locale
     ///
     /// # Returns
@@ -147,7 +195,7 @@ impl PluralRules {
     fn categories(&self) -> RArray {
         let ruby = Ruby::get().expect("Ruby runtime should be available");
         let array = ruby.ary_new();
-        for category in self.inner.categories() {
+        for category in self.inner.rules().categories() {
             let _ = array.push(Self::category_to_symbol(&ruby, category));
         }
         array
@@ -187,6 +235,7 @@ pub fn init(ruby: &Ruby, module: &RModule) -> Result<(), Error> {
     let class = module.define_class("PluralRules", ruby.class_object())?;
     class.define_singleton_method("new", function!(PluralRules::new, -1))?;
     class.define_method("select", method!(PluralRules::select, 1))?;
+    class.define_method("select_range", method!(PluralRules::select_range, 2))?;
     class.define_method("categories", method!(PluralRules::categories, 0))?;
     class.define_method(
         "resolved_options",