[intl] Implement Intl.PluralRules

src/js/i18n.js

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // ECMAScript 402 API implementation.
 
 /**
  * Intl object is a single object that has some named properties,
  * all of which are constructors.
  */
 (function(global, utils) {
 
 "use strict";
 
 %CheckIsBootstrapping();
 
 // -------------------------------------------------------------------
 // Imports
 
 var ArrayJoin;
 var ArrayPush;
 var GlobalDate = global.Date;
 var GlobalIntl = global.Intl;
 var GlobalIntlDateTimeFormat = GlobalIntl.DateTimeFormat;
 var GlobalIntlNumberFormat = GlobalIntl.NumberFormat;
 var GlobalIntlCollator = GlobalIntl.Collator;
+var GlobalIntlPluralRules = utils.ImportNow("PluralRules");
 var GlobalIntlv8BreakIterator = GlobalIntl.v8BreakIterator;
 var GlobalNumber = global.Number;
 var GlobalRegExp = global.RegExp;
 var GlobalString = global.String;
 var IntlFallbackSymbol = utils.ImportNow("intl_fallback_symbol");
 var InstallFunctions = utils.InstallFunctions;
 var InstallGetter = utils.InstallGetter;
 var InternalArray = utils.InternalArray;
 var MaxSimple;
 var ObjectHasOwnProperty = utils.ImportNow("ObjectHasOwnProperty");
+var ObjectKeys = global.Object.keys;
 var OverrideFunction = utils.OverrideFunction;
 var patternSymbol = utils.ImportNow("intl_pattern_symbol");
 var resolvedSymbol = utils.ImportNow("intl_resolved_symbol");
 var SetFunctionName = utils.SetFunctionName;
 var StringSubstr = GlobalString.prototype.substr;
 var StringSubstring = GlobalString.prototype.substring;
 
 utils.Import(function(from) {
   ArrayJoin = from.ArrayJoin;
   ArrayPush = from.ArrayPush;
@@ skipping 84 matching lines @@
 
 // -------------------------------------------------------------------
 
 /**
  * Caches available locales for each service.
  */
 var AVAILABLE_LOCALES = {
   'collator': UNDEFINED,
   'numberformat': UNDEFINED,
   'dateformat': UNDEFINED,
-  'breakiterator': UNDEFINED
+  'breakiterator': UNDEFINED,
+  'pluralrules': UNDEFINED,
 };
 
 /**
  * Caches default ICU locale.
  */
 var DEFAULT_ICU_LOCALE = UNDEFINED;
 
 function GetDefaultICULocaleJS() {
   if (IS_UNDEFINED(DEFAULT_ICU_LOCALE)) {
     DEFAULT_ICU_LOCALE = %GetDefaultICULocale();
@@ skipping 45 matching lines @@
 }
 
 /**
  * Matches valid service name.
  */
 var SERVICE_RE = UNDEFINED;
 
 function GetServiceRE() {
   if (IS_UNDEFINED(SERVICE_RE)) {
     SERVICE_RE =
-        new GlobalRegExp('^(collator|numberformat|dateformat|breakiterator)$');
+        new GlobalRegExp('^(' + %_Call(ArrayJoin, ObjectKeys(AVAILABLE_LOCALES), '|') + ')$');
   }
   return SERVICE_RE;
 }
 
 /**
  * Validates a language tag against bcp47 spec.
  * Actual value is assigned on first run.
  */
 var LANGUAGE_TAG_RE = UNDEFINED;
 
@@ skipping 881 matching lines @@
  * on whether x comes before y in the sort order, the Strings are equal under
  * the sort order, or x comes after y in the sort order, respectively.
  */
 function compare(collator, x, y) {
   return %InternalCompare(collator, TO_STRING(x), TO_STRING(y));
 };
 
 
 AddBoundMethod(GlobalIntlCollator, 'compare', compare, 2, 'collator', false);
 
+function PluralRulesConstructor() {
+  var locales = arguments[0];
+  var options = arguments[1];
+
+  if (IS_UNDEFINED(options)) {
+    options = {};
+  }
+
+  var getOption = getGetOption(options, 'pluralrules');
+
+  var locale = resolveLocale('pluralrules', locales, options);
+
+  var internalOptions = {};
+  defineWEProperty(internalOptions, 'type', getOption(
+    'type', 'string', ['cardinal', 'ordinal'], 'cardinal'));
+
+  SetNumberFormatDigitOptions(internalOptions, options, 0, 3);
+
+  var requestedLocale = locale.locale;
+  var resolved = %object_define_properties({}, {
+    type: {value: internalOptions.type, writable: true},
+    locale: {writable: true},
+    maximumFractionDigits: {writable: true},
+    minimumFractionDigits: {writable: true},
+    minimumIntegerDigits: {writable: true},
+    requestedLocale: {value: requestedLocale, writable: true},
+  });
+  if (HAS_OWN_PROPERTY(internalOptions, 'minimumSignificantDigits')) {
+    defineWEProperty(resolved, 'minimumSignificantDigits', UNDEFINED);
+  }
+  if (HAS_OWN_PROPERTY(internalOptions, 'maximumSignificantDigits')) {
+    defineWEProperty(resolved, 'maximumSignificantDigits', UNDEFINED);
+  }
+  defineWEProperty(resolved, 'pluralCategories', []);
+  var pluralRules = %CreatePluralRules(requestedLocale, internalOptions,
+                                       resolved);
+
+  %MarkAsInitializedIntlObjectOfType(pluralRules, 'pluralrules');
+  pluralRules[resolvedSymbol] = resolved;
+
+  return pluralRules;
+}
+%SetCode(GlobalIntlPluralRules, PluralRulesConstructor);
+
+InstallFunction(GlobalIntlPluralRules.prototype, 'resolvedOptions',
+  function() {
+    if (!%IsInitializedIntlObjectOfType(this, 'pluralrules')) {
+      throw %make_type_error(kIncompatibleMethodReceiver,
+                             'Intl.PluralRules.prototype.resolvedOptions',
+                             this);
+    }
+    var locale = getOptimalLanguageTag(this[resolvedSymbol].requestedLocale,
+                                       this[resolvedSymbol].locale);
+
+    var result = {
+      locale: locale,
+      type: this[resolvedSymbol].type,
+      minimumIntegerDigits: this[resolvedSymbol].minimumIntegerDigits,
+      minimumFractionDigits: this[resolvedSymbol].minimumFractionDigits,
+      maximumFractionDigits: this[resolvedSymbol].maximumFractionDigits,
+    };
+
+    if (HAS_OWN_PROPERTY(this[resolvedSymbol], 'minimumSignificantDigits')) {
+      defineWECProperty(result, 'minimumSignificantDigits',
+                        this[resolvedSymbol].minimumSignificantDigits);
+    }
+
+    if (HAS_OWN_PROPERTY(this[resolvedSymbol], 'maximumSignificantDigits')) {
+      defineWECProperty(result, 'maximumSignificantDigits',
+                        this[resolvedSymbol].maximumSignificantDigits);
+    }
+
+    defineWECProperty(result, 'pluralCategories',
+                      this[resolvedSymbol].pluralCategories);
+
+    return result;
+  }
+);
+
+InstallFunction(GlobalIntlPluralRules, 'supportedLocalesOf',
+  function(locales) {
+    return supportedLocalesOf('pluralrules', locales, arguments[1]);
+  }
+);
+
+InstallFunction(GlobalIntlPluralRules.prototype, 'select',
+  function(value) {
+    if (!%IsInitializedIntlObjectOfType(this, 'pluralrules')) {
+      throw %make_type_error(kIncompatibleMethodReceiver,
+                            'Intl.PluralRules.prototype.select',
+                            this);
+    }
+
+    return %PluralRulesSelect(this, TO_NUMBER(value) + 0);
+  }
+);
+
 /**
  * Verifies that the input is a well-formed ISO 4217 currency code.
  * Don't uppercase to test. It could convert invalid code into a valid one.
  * For example \u00DFP (Eszett+P) becomes SSP.
  */
 function isWellFormedCurrencyCode(currency) {
   return typeof currency === "string" && currency.length === 3 &&
       IS_NULL(%regexp_internal_match(/[^A-Za-z]/, currency));
 }
 
@@ skipping 1047 matching lines @@
 
 utils.Export(function(to) {
   to.FormatDateToParts = FormatDateToParts;
   to.ToLowerCaseI18N = ToLowerCaseI18N;
   to.ToUpperCaseI18N = ToUpperCaseI18N;
   to.ToLocaleLowerCaseI18N = ToLocaleLowerCaseI18N;
   to.ToLocaleUpperCaseI18N = ToLocaleUpperCaseI18N;
 });
 
 })