Add date formatting and parsing code.

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.
 
-#library('intl');
-
-#import('dart:web');
-
-#source('intl_message.dart');
-#source('date_format.dart');
-#source('bidi_formatter.dart');
-#source('bidi_utils.dart');
-
 /**
  * Internationalization object providing access to message formatting objects,
  * date formatting, parsing, bidirectional text relative to a specific locale.
  */
 
+#library('intl');

[Emily Fortuna, 2012/08/06 22:43:00]

personal preference, but I preferred the documentation for this class to be
immediately above the class (Intl), without the #library and #source in between.

[Alan Knight, 2012/08/08 00:47:44]

Done.

+
+#import('dart:web');
+
+#import('date_format.dart');
+#source('intl_message.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;
 
   IntlMessage intlMsg;
 
-  DateFormat date;
+  /**
+   * 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;
+    return new DateFormat(pattern,actualLocale);

[Emily Fortuna, 2012/08/06 22:43:00]

space between parameters

[Alan Knight, 2012/08/08 00:47:44]

Done.

+  }
 
   /**
    * 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([a_locale]) {
-    _locale = a_locale;
-    if (_locale == null) _locale = _getDefaultLocale();
+    _locale = (a_locale == null) ? _getDefaultLocale() : a_locale;

[Emily Fortuna, 2012/08/06 22:43:00]

do we want to call "verifiedLocale" to canonicalize the locale being set?

[Alan Knight, 2012/08/08 00:47:44]

Good idea. Done.

     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'}. 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).
    */
   static String message(String message_str, [final String desc='',
                         final Map examples=const {}, String locale='']) {
     return message_str;
   }
 
+  /** The default locale for this environment. */
+  // TODO(alanknight): Return the correct locale using either
+  // window.navigator.language or appropriate environment variable or other
+  // mechanism for command-line apps.
+  static String defaultLocale = 'en_US';

[Emily Fortuna, 2012/08/06 22:43:00]

let's move this down to the _getDefaultLocale function so we don't have
duplicate functionality in two different ways.

+
+  /**
+   * Return the locale for this instance. If none was set, returns the
+   * default.
+   */
+  String get locale() {
+    if (_locale == null) {

[Emily Fortuna, 2012/08/06 22:43:00]

Since we do this check when Intl is created, do we really need this? We could
just make _locale public so anyone can read/change as they like...

+      return defaultLocale;
+    } else {
+      return _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) {
+    if (newLocale == null) return defaultLocale;

[Emily Fortuna, 2012/08/06 22:43:00]

call _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'");
+  }
+
+  /** Return the short version of a locale name, e.g. 'en_US' => 'en' */
+  static String _shortLocale(String aLocale) {
+    if (aLocale.length < 2) return aLocale;
+    return aLocale.substring(0,2).toLowerCase();
+  }
+
+  /**
+   * Return a locale name turned into xx_YY where it might possibly be
+   * in the wrong case or with a hyphen instead of an underscore.
+   */
+  static String _canonicalized(String aLocale) {
+    if (aLocale.length != 5) return aLocale;

[Emily Fortuna, 2012/08/06 22:43:00]

Consider rewriting. It feels a little misleading to me to not throw the error
here but instead wait for _localeExists to validate that it's an actual locale,
but if you prefer writing this this way, this clearly does work as well. :-)

[Alan Knight, 2012/08/08 00:47:44]

I think I'd rather not throw the exception here because I'd rather separate
making the name canonical from testing if we support it. If we don't have a
canonical name that isn't necessarily an error. The usage is that we
canonicalize the locale and then see if we have data for it. And if we don't
have it we also try the short form. That doesn't mean it doesn't exist. e.g. we
don't have en_CA, but what we want to do is just fall back to en, not throw an
exception. I don't think I'd want to throw an exception and catch it as part of
normal control flow when we're only one level down in the stack and can just
check it directly.

[Emily Fortuna, 2012/08/08 01:35:54]

Okay. Can you just put a comment maybe to the effect that locales that aren't
length 2 or 5 are invalid?

[Alan Knight, 2012/08/08 18:21:25]

Done. The es_419 case also points out that length 6 is possible, so made the
check test for <5 or >6.

+    if (aLocale[2] != '-' && (aLocale[2] != '_')) return aLocale;
+    return '${aLocale[0]}${aLocale[1]}_${aLocale[3].toUpperCase()}'
+           '${aLocale[4].toUpperCase()}';
+  }
+
   /**
    * 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!
     return select(howMany.toString(), cases);
   }
 
   /**
@@ skipping 38 matching lines @@
 
   /**
    * 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;
   }
 }