Updating plural rules to support num instead of int

Subset of cr/247298271

See this document for more context:
https://docs.google.com/document/d/103PiFk2oopzG2ZT8n1TbWL2lMPgiXiEI3o05Eq45Lr4

The solution part is not up to date, but the problems identified are still valid.
That is what I am trying to solve, by improving the existing class, no a rewrite.

PiperOrigin-RevId: 258316144

Author: Dart Team

lib/intl.dart

@@ -173,7 +173,7 @@ class Intl {
   /// the placeholder automatically translated.
   static String message(String message_str,
           {String desc: '',
-          Map<String, Object> examples: const {},
+          Map<String, Object> examples,
           String locale,
           String name,
           List<Object> args,
@@ -267,11 +267,17 @@ class Intl {
     return '${aLocale[0]}${aLocale[1]}_$region';
   }
 
-  /// Format a message differently depending on [howMany]. Normally used
-  /// as part of an `Intl.message` text that is to be translated.
-  /// Selects the correct plural form from
-  /// the provided alternatives. The [other] named argument is mandatory.
-  static String plural(int howMany,
+  /// Formats a message differently depending on [howMany].
+  ///
+  /// Selects the correct plural form from the provided alternatives.
+  /// The [other] named argument is mandatory.
+  /// The [precision] is the number of fractional digits that would be rendered
+  /// when [howMany] is formatted. In some cases just knowing the numeric value
+  /// of [howMany] itsef is not enough, for example "1 mile" vs "1.00 miles"
+  ///
+  /// For an explanation of plurals and the [zero], [one], [two], [few], [many]
+  /// categories see http://cldr.unicode.org/index/cldr-spec/plural-rules
+  static String plural(num howMany,
       {String zero,
       String one,
       String two,
@@ -281,6 +287,7 @@ class Intl {
       String desc,
       Map<String, Object> examples,
       String locale,
+      int precision,
       String name,
       List<Object> args,
       String meaning,
@@ -295,19 +302,21 @@ class Intl {
         many: many,
         other: other,
         locale: locale,
+        precision: precision,
         name: name,
         args: args,
         meaning: meaning);
   }
 
-  static String _plural(int howMany,
+  static String _plural(num howMany,
       {String zero,
       String one,
       String two,
       String few,
       String many,
       String other,
       String locale,
+      int precision,
       String name,
       List<Object> args,
       String meaning}) {
@@ -325,29 +334,40 @@ class Intl {
             few: few,
             many: many,
             other: other,
-            locale: locale);
+            locale: locale,
+            precision: precision);
   }
 
   /// Internal: Implements the logic for plural selection - use [plural] for
   /// normal messages.
-  static pluralLogic(int howMany,
-      {zero, one, two, few, many, other, String locale, String meaning}) {
+  static pluralLogic(num howMany,
+      {zero, one, two, few, many, other, String locale, int precision,
+      String meaning}) {
     if (other == null) {
       throw new ArgumentError("The 'other' named argument must be provided");
     }
     if (howMany == null) {
       throw new ArgumentError("The howMany argument to plural cannot be null");
     }
-    // If there's an explicit case for the exact number, we use it. This is not
-    // strictly in accord with the CLDR rules, but it seems to be the
-    // expectation. At least I see e.g. Russian translations that have a zero
-    // case defined. The rule for that locale will never produce a zero, and
-    // treats it as other. But it seems reasonable that, even if the language
-    // rules treat zero as other, we might want a special message for zero.
-    if (howMany == 0 && zero != null) return zero;
-    if (howMany == 1 && one != null) return one;
-    if (howMany == 2 && two != null) return two;
-    var pluralRule = _pluralRule(locale, howMany);
+
+    // This is for backward compatibility.
+    // We interpret the presence of [precision] parameter as an "opt-in" to
+    // the new behavior, since [precision] did not exist before.
+    // For an English example: if the precision is 2 then the formatted string
+    // would not map to 'one' (for example "1.00 miles")
+    if (precision == null || precision == 0) {
+      // If there's an explicit case for the exact number, we use it. This is
+      // not strictly in accord with the CLDR rules, but it seems to be the
+      // expectation. At least I see e.g. Russian translations that have a zero
+      // case defined. The rule for that locale will never produce a zero, and
+      // treats it as other. But it seems reasonable that, even if the language
+      // rules treat zero as other, we might want a special message for zero.
+      if (howMany == 0 && zero != null) return zero;
+      if (howMany == 1 && one != null) return one;
+      if (howMany == 2 && two != null) return two;
+    }
+
+    var pluralRule = _pluralRule(locale, howMany, precision);
     var pluralCase = pluralRule();
     switch (pluralCase) {
       case plural_rules.PluralCase.ZERO:
@@ -371,8 +391,8 @@ class Intl {
   static var _cachedPluralRule;
   static String _cachedPluralLocale;
 
-  static _pluralRule(String locale, int howMany) {
-    plural_rules.startRuleEvaluation(howMany);
+  static _pluralRule(String locale, num howMany, int precision) {
+    plural_rules.startRuleEvaluation(howMany, precision);
     var verifiedLocale = Intl.verifiedLocale(
         locale, plural_rules.localeHasPluralRules,
         onFailure: (locale) => 'default');
@@ -414,7 +434,6 @@ class Intl {
       String male,
       String other,
       String desc,
-      Map<String, Object> examples,
       String locale,
       String name,
       List<Object> args,

lib/src/plural_rules.dart

@@ -16,6 +16,8 @@
 /// * t	- visible fractional digits in n, without trailing zeros.
 library plural_rules;
 
+import 'dart:math' as math;
+
 typedef PluralCase PluralRule();
 
 /// The possible cases used in a plural rule.
@@ -26,8 +28,12 @@ PluralCase _default_rule() => OTHER;
 
 /// This must be called before evaluating a new rule, because we're using
 /// library-global state to both keep the rules terse and minimize space.
-startRuleEvaluation(int howMany) {
+startRuleEvaluation(num howMany, [int precision = 0]) {
   _n = howMany;
+  _precision = precision;
+  _i = _n.round();
+  _updateVF(_n, _precision);
+  _updateWT(_f, _v);
 }
 
 /// The number whose [PluralCase] we are trying to find.
@@ -37,27 +43,81 @@ startRuleEvaluation(int howMany) {
 // not introduce a subclass per locale or have instance tear-offs which
 // we can't cache. This is fine as long as these methods aren't async, which
 // they should never be.
-int _n;
+num _n;
+
+/// The integer part of [_n]
+int _i;
+int _precision;
+
+/// Returns the number of digits in the fractional part of a number
+/// (3.1416 => 4)
+///
+/// Takes the item count [n] and a [precision].
+/// That's because a just looking at the value of a number is not enough to
+/// decide the plural form. For example "1 dollar" vs "1.00 dollars", the
+/// value is 1, but how it is formatted also matters.
+int _decimals(num n, int precision) {
+  var str = _precision == null ? '$n' : n.toStringAsFixed(precision);
+  var result = str.indexOf('.');
+  return (result == -1) ? 0 : str.length - result - 1;
+}
+
+/// Calculates and sets the _v and _f as per CLDR plural rules.
+///
+/// The short names for parameters / return match the CLDR syntax and UTS #35
+///     (https://unicode.org/reports/tr35/tr35-numbers.html#Plural_rules_syntax)
+/// Takes the item count [n] and a [precision].
+_updateVF(num n, int precision) {
+  int defaultDigits = 3;
+
+  _v = precision ?? math.min(_decimals(n, precision), defaultDigits);
+
+  int base = math.pow(10, _v);
+  _f = (n * base).floor() % base;
+}
+
+/// Calculates and sets _w and _t as per CLDR plural rules.
+///
+/// The short names for parameters / return match the CLDR syntax and UTS #35
+///     (https://unicode.org/reports/tr35/tr35-numbers.html#Plural_rules_syntax)
+/// @param v Calculated previously.
+/// @param f Calculated previously.
+_updateWT(int v, int f) {
+  if (f == 0) {
+    // Unused, for now _w = 0;
+    _t = 0;
+    return;
+  }
+
+  while ((f % 10) == 0) {
+    f = (f / 10).floor();
+    v--;
+  }
+
+  // Unused, for now _w = v;
+  _t = f;
+}
 
-/// The integer part of [_n] - since we only support integers, it's the same as
-/// [_n].
-int get _i => _n;
-int opt_precision; // Not currently used.
+/// Number of visible fraction digits.
+int _v = 0;
 
-/// Number of visible fraction digits. Always zero since we only support int.
-int get _v => 0;
+/// Number of visible fraction digits without trailing zeros.
+// Unused, for now int _w = 0;
 
-/// Number of visible fraction digits without trailing zeros. Always zero
-/// since we only support int.
-//int get _w => 0;
+/// The visible fraction digits in n, with trailing zeros.
+int _f = 0;
 
-/// The visible fraction digits in n, with trailing zeros. Always zero since
-/// we only support int.
-int get _f => 0;
+/// The visible fraction digits in n, without trailing zeros.
+int _t = 0;
 
-/// The visible fraction digits in n, without trailing zeros. Always zero since
-/// we only support int.
-int get _t => 0;
+// An example, for precision n = 3.1415 and precision = 7)
+//   n  : 3.1415
+// str n: 3.1415000 (the "formatted" n, 7 fractional digits)
+//   i  : 3         (the integer part of n)
+//   f  :   1415000 (the fractional part of n)
+//   v  : 7         (how many digits in f)
+//   t  :   1415    (f, without trailing 0s)
+//   w  : 4         (how many digits in t)
 
 PluralCase get ZERO => PluralCase.ZERO;
 PluralCase get ONE => PluralCase.ONE;

test/plural_test.dart

@@ -195,6 +195,20 @@ main() {
     expect(() => plural(null, null), throwsArgumentError);
     expect(() => plural(null, "ru"), throwsArgumentError);
   });
+
+  verify_with_precision('1 dollar', 'en', 1, 0);
+  // This would not work in back-compatibility for one vs. =1 in plurals,
+  // because of this test in intl.dart:
+  //    if (howMany == 1 && one != null) return one;
+  // That one will ignore the precision and always return one, while the
+  // test below requires the result to be 'other'
+  // verify_with_precision('1.00 dollars', 'en', 1, 2);
+
+  verify_with_precision('1 dollar', 'en', 1.2, 0);
+  verify_with_precision('1.20 dollars', 'en', 1.2, 2);
+
+  verify_with_precision('3 dollars', 'en', 3.14, 0);
+  verify_with_precision('3.14 dollars', 'en', 3.14, 2);
 }
 
 verify(String expectedValues, String locale, pluralFunction) {
@@ -206,3 +220,15 @@ verify(String expectedValues, String locale, pluralFunction) {
     });
   }
 }
+
+verify_with_precision(String expected, String locale, num n, int precision) {
+  test('verify_with_precision(howMany: $n, precision: $precision)', () {
+    var nString = n.toStringAsFixed(precision);
+    var actual = Intl.plural(n,
+        locale: locale,
+        precision: precision,
+        one: '$nString dollar',
+        other: '$nString dollars');
+    expect(actual, expected);
+  });
+}