Add async initialization for Intl.message and an example

pkg/intl/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('../../pkg/htmlescape/htmlescape.dart');
+#import('../htmlescape/htmlescape.dart');
 
 #import('date_format.dart');
-#source('intl_message.dart');
+#import('lib/intl_helpers.dart');
+
 #source('bidi_formatter.dart');
 #source('bidi_utils.dart');
 
 class Intl {
   /**
    * String indicating the locale code with which the message is to be
    * formatted (such as en-CA).
    */
-  static String _locale;
+  String _locale;
 
-  IntlMessage intlMsg;
+  /** The default locale, which normally will be obtained from the browser. */
+  static String _defaultLocale;
 
   /**
    * Return a new date format using the specified [pattern].
    * If [desiredLocale] is not specified, then we default to [locale].
    */
-  DateFormat date(String pattern, [String desiredLocale]) {
-    var actualLocale = (desiredLocale == null) ? _locale : desiredLocale;
+  DateFormat date([String pattern, String desiredLocale]) {
+    var actualLocale = (desiredLocale == null) ? locale : desiredLocale;
     return new DateFormat(pattern, actualLocale);
   }
 
   /**
-   * Constructor optionally [_locale] for specifics of the language
+   * Constructor optionally [aLocale] 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([a_locale]) {
-    if (a_locale == null) {
-      _locale = _getDefaultLocale();
+  Intl([String aLocale]) {
+    if (aLocale != null) {
+      _locale = aLocale;
     } else {
-      _locale = verifiedLocale(a_locale);
+      _locale = getCurrentLocale();
     }
-    intlMsg = new IntlMessage(_locale);
   }
 
   /**
-   * Create a message that can be internationalized. It takes a
+   * Returns 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'}. 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, and additionally also a
    * locale (optional).
+   * Ultimately, the information about the enclosing function and its arguments
+   * will be extracted automatically but for the time being it must be passed
+   * explicitly in the [name] and [args] arguments.
    */
   static String message(String message_str, [final String desc='',
-                        final Map examples=const {}, String locale='']) {
-    return message_str;
+      final Map examples=const {}, String locale, String name,
+      List<String> args]) {
+    return _messageLookup.lookupMessage(
+        message_str, desc, examples, locale, name, args);
   }
 
   /**
    * Return the locale for this instance. If none was set, the locale will
    * be the default.
    */
   String get locale => _locale;
 
   /**
    * Return true if the locale exists, or if it is null. The null case
    * is interpreted to mean that we use the default locale.
    */
   static bool _localeExists(localeName) {
     return DateFormat.localeExists(localeName);
   }
 
   /**
    * Given [newLocale] return a locale that we have data for that is similar
    * to it, if possible.
    * If [newLocale] is found directly, return it. If it can't be found, look up
    * based on just the language (e.g. 'en_CA' -> 'en'). Also accepts '-'
    * as a separator and changes it into '_' for lookup, and changes the
    * country to uppercase.
    * Note that null is interpreted as meaning the default locale, so if
    * [newLocale] is null it will be returned.
    */
   static String verifiedLocale(String newLocale) {

[Emily Fortuna, 2012/09/12 21:55:59]

looks like this method is no longer being used (used to be used in the
constructor.) Shouldn't we call it from the constructor?

[Alan Knight, 2012/09/13 18:20:08]

It's used by DateFormat, because it uses the set of locales that have date
formats, which doesn't make sense to use generally, as the set might be quite
different for locales. Added a TODO to move, rename, or generalize it. There's
another TODO to add similar functionality for messages, at which point it might
be easier to see how to generalize it.

     if (newLocale == null) return _getDefaultLocale();
     if (_localeExists(newLocale)) {
       return newLocale;
     }
     for (var each in [_canonicalized(newLocale), _shortLocale(newLocale)]) {
       if (_localeExists(each)) {
         return each;
       }
     }
     throw new IllegalArgumentException("Invalid locale '$newLocale'");
@@ skipping 30 matching lines @@
 
   /**
    * Format the given function with a specific [locale], given a
    * [msg_function] 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) {
     // 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;
+    if (_defaultLocale == null) _defaultLocale = _getDefaultLocale();
+    var oldLocale = _defaultLocale;
+    _defaultLocale = locale;
     var result = msg_function();
-    _locale = oldLocale;
+    _defaultLocale = 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];
@@ skipping 14 matching lines @@
     // 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;
+    if (_defaultLocale == null) _defaultLocale = _getDefaultLocale();
+    return _defaultLocale;
   }
 }
+
+/**
+ * The internal mechanism for looking up messages. We expect this to be set
+ * by the implementing package so that we're not dependent on its
+ * implementation.
+ */
+var _messageLookup = const
+    UninitializedLocaleData('initializeMessages(<locale>)');
+
+/**
+ * Initialize the message lookup mechanism. This is for internal use only.
+ * User applications should import message_lookup_local.dart and call
+ * initializeMessages
+ */
+void initializeInternalMessageLookup(Function lookupFunction) {
+  if (_messageLookup is UninitializedLocaleData) {
+    _messageLookup = lookupFunction();
+  }
+}