Make Intl.message static

lib/i18n/intl.dart

 /**
  * Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
  * for details. All rights reserved. Use of this source code is governed by a
  * BSD-style license that can be found in the LICENSE file.
  *
  * Internationalization object providing access to message formatting objects,
  * date formatting, parsing, bidirectional text relative to a specific locale.
  */
 
 #library('Intl');
 
 #import('intl_message.dart');
 #import('date_format.dart');
 
 class Intl {
 
   /**
    * String indicating the locale code with which the message is to be
    * formatted (such as en-CA).
    */
-  String _locale;
+  static String _locale;
 
   IntlMessage intlMsg;
 
   DateFormat date;
 
   /**
    * Constructor optionally [_locale] for specifics of the language
    * locale to be used, otherwise, we will attempt to infer it (acceptable if
    * Dart is running on the client, we can infer from the browser/client
    * preferences).
    */
-  Intl([this._locale]) {
+  Intl([a_locale]) {
+    _locale = a_locale;
+    if (_locale == null) _locale = _getDefaultLocale();
     intlMsg = new IntlMessage(_locale);
     date = new DateFormat(_locale);
   }
 
   /**
    * Create a message that can be internationalized. It takes a
    * [message_str] that will be translated, which may be interpolated
    * based on one or more variables, a [desc] providing a description of usage
    * for the [message_str], and a map of [examples] for each data element to be
    * substituted into the message. For example, if message="Hello, $name", then
-   * examples = {'name': 'Sparky'}. The values of [desc] and [examples] are
-   * not used at run-time but are only made available to the translators, so
-   * they MUST be simple Strings available at compile time: no String
-   * interpolation or concatenation.
+   * examples = {'name': 'Sparky'}. If not using the user's default locale, or
+   * if the locale is not easily detectable, explicitly pass [locale].
+   * The values of [desc] and [examples] are not used at run-time but are only
+   * made available to the translators, so they MUST be simple Strings available
+   * at compile time: no String interpolation or concatenation.
    * The expected usage of this is inside a function that takes as parameters
-   * the variables used in the interpolated string.
+   * the variables used in the interpolated string, and additionally also a
+   * locale (optional).
    */
-  String message(String message_str, [final String desc='',
-                 final Map examples=const {}]) {
+  static String message(String message_str, [final String desc='',
+                        final Map examples=const {}, String locale='']) {
     return message_str;
   }
 
   /**
    * Support method for message formatting. Select the correct plural form from
    * [cases] given [howMany].
    */
   static String plural(var howMany, Map cases, [num offset=0]) {
     // TODO(efortuna): Deal with "few" and "many" cases, offset, and others!
-    // TODO(alanknight): Should we have instance methods instead/as well?
-    // Or have the others as statics?
     return select(howMany.toString(), cases);
   }
 
   /**
+   * Format the given function with a specific [locale], given a
+   * [msg_function_future] that takes no parameters and returns a String. We
+   * basically delay calling the message function proper until after the proper
+   * locale has been set.
+   */
+  static String withLocale(String locale, Function msg_function_future) {

[Alan Knight, 2012/06/13 15:37:09]

"future" seems like a confusing suffix, since there's a language feature by that
name, but it's not what we're using.

[Emily Fortuna, 2012/06/13 17:24:04]

Agreed. But what do you recommend instead? msg_function seemed like the best I
could come up with, you recommended against that. msg_function_promise or
msg_function_closure seem to be the only other names I can come up with them,
but both of those are strange for other reasons...?

+    // We have to do this silliness because Locale is not known at compile time,
+    // but must be a static variable.
+    if (_locale == null) _locale = _getDefaultLocale();
+    var oldLocale = _locale;
+    _locale = locale;
+    var result = msg_function_future();

[Alan Knight, 2012/06/13 15:37:09]

In the longer term, we'd probably want to use a finally to ensure that if the
function throws an exception we still reset the locale.  But we can live without
that for the moment.

+    _locale = oldLocale;
+    return result;
+  }
+
+  /**
    * Support method for message formatting. Select the correct exact (gender,
    * usually) form from [cases] given the user [choice].
    */
   static String select(String choice, Map cases) {
     if (cases.containsKey(choice)) {
       return cases[choice];
     } else if (cases.containsKey('other')){
       return cases['other'];
     } else {
       return '';
     }
   }
+
+  /**
+   * Helper to detect the locale as defined at runtime.
+   */
+  static String _getDefaultLocale() {
+    // TODO(efortuna): Detect the default locale given the user preferences.
+    // Yay, hard-coding for now!
+    return 'en-US';
+  }
+
+  /**
+   * Accessor for the current locale. This should always == the default locale,
+   * unless for some reason this gets called inside a message that resets the
+   * locale.
+   */
+  static String getCurrentLocale() {
+    return _locale;
+  }
 }