Updated message formatting to be more compatible with Dart string interpolation.

lib/i18n/date_format.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.
  *
- * DateFormat is for formatting and parsing dates in a locale-sensitive 
- * manner. 
+ * DateFormat is for formatting and parsing dates in a locale-sensitive
+ * manner.
  * It allows the user to choose from a set of standard date time formats as well
  * as specify a customized pattern under certain locales. Date elements that
  * vary across locales include month name, weekname, field, order, etc.
  * //TODO(efortuna): Customized pattern system -- suggested by i18n needs
  * // feedback on appropriateness.
- * We also allow the user to use any customized pattern to parse or format 
- * date-time strings under certain locales. Date elements that vary across 
+ * We also allow the user to use any customized pattern to parse or format
+ * date-time strings under certain locales. Date elements that vary across
  * locales include month name, weekname, field, order, etc.
  *
  * This library uses the ICU/JDK date/time pattern specification as described
  * below.
  *
  * Time Format Syntax: To specify the time format use a time pattern string.
  * In this pattern, following letters are reserved as pattern letters, which
  * are defined in the following manner:
  *
  *     Symbol   Meaning                Presentation        Example
@@ skipping 38 matching lines @@
  * instance, characters like ':', '.', ' ', '#' and '@' will appear in the
  * resulting time text even they are not embraced within single quotes. In our
  * current pattern usage, we didn't use up all letters. But those unused
  * letters are strongly discouraged to be used as quoted text without quote.
  * That's because we may use other letter for pattern in future.
  *
  * Examples Using the US Locale:
  *
  *     Format Pattern                         Result
  *     --------------                         -------
- *     "yyyy.MM.dd G 'at' HH:mm:ss vvvv"->1996.07.10 AD at 15:08:56 Pacific Time
- *     "EEE, MMM d, ''yy"               ->Wed, July 10, '96
- *     "h:mm a"                         ->12:08 PM
- *     "hh 'o''clock' a, zzzz"          ->12 o'clock PM, Pacific Daylight Time
- *     "K:mm a, vvv"                    ->0:00 PM, PT
- *     "yyyyy.MMMMM.dd GGG hh:mm aaa"   ->01996.July.10 AD 12:08 PM
+ *     "yyyy.MM.dd G 'at' HH:mm:ss vvvv"->> 1996.07.10 AD at 15:08:56 Pacific Time
+ *     "EEE, MMM d, ''yy"               ->> Wed, July 10, '96
+ *     "h:mm a"                         ->> 12:08 PM

[Emily Fortuna, 2012/06/07 21:33:36]

Please put the formatting back for this. Markdown will read this correctly a
table if it is indented 4 spaces. I have a fix that solves this in my CL. 

[Alan Knight, 2012/06/07 21:58:53]

Done.

+ *     "hh 'o''clock' a, zzzz"          ->> 12 o'clock PM, Pacific Daylight Time
+ *     "K:mm a, vvv"                    ->> 0:00 PM, PT
+ *     "yyyyy.MMMMM.dd GGG hh:mm aaa"   ->> 01996.July.10 AD 12:08 PM
  *
  * When parsing a date string using the abbreviated year pattern ("yy"),
  * DateTimeParse must interpret the abbreviated year relative to some
  * century. It does this by adjusting dates to be within 80 years before and 20
  * years after the time the parse function is called. For example, using a
  * pattern of "MM/dd/yy" and a DateTimeParse instance created on Jan 1, 1997,
  * the string "01/11/12" would be interpreted as Jan 11, 2012 while the string
  * "05/04/64" would be interpreted as May 4, 1964. During parsing, only
  * strings consisting of exactly two digits, as defined by {@link
  * java.lang.Character#isDigit(char)}, will be parsed into the default
@@ skipping 13 matching lines @@
  * the run, then the leftmost field is shortened by one character, and the
  * entire run is parsed again. This is repeated until either the parse succeeds
  * or the leftmost field is one character in length. If the parse still fails at
  * that point, the parse of the run fails.
  */
 
 #library('DateFormat');
 
 class DateFormat {
 
-  /** Definition of this object formats dates. */
+  /**
+   * Definition of how this object formats dates.
+   * (TODO) alanknight This might just be a String, but it's not clear yet.
+   */
   var formatDefinition;
 
   /**
    * String indicating the locale code with which the message is to be
    * formatted (such as en-CA).
    */
   String _locale;
 
-  /** 
+  /**
    * Date/Time format "skeleton" patterns. Also specifiable by String, but
    * written this way so that they can be discoverable via autocomplete. These
    * follow the ICU syntax described at the top of the file. These skeletons can
    * be combined and we will attempt to find the best format for each locale
    * given the pattern.
    * // TODO(efortuna): Hear back from i18n about Time Zones and the "core set"
    * // of skeleton patterns.
    */
                                           // Example of how this looks in the US
                                           // locale.
   static final String Hm = 'Hm';          // HH:mm
-  static final String Hms = 'Hms';        // HH:mm:ss 
+  static final String Hms = 'Hms';        // HH:mm:ss
   static final String M = 'M';            // L
   static final String MEd = 'MEd';        // E, M/d
   static final String MMM = 'MMM';        // LLL
   static final String MMMEd = 'MMMEd';    // E, MMM d
   static final String MMMMEd = 'MMMMEd';  // E, MMMM d
   static final String MMMMd = 'MMMMd';    // MMMM d
   static final String MMMd = 'MMMd';      // MMM d
   static final String Md = 'Md';          // M/d
   static final String d = 'd';            // d
   static final String hm = 'hm';          // h:mm a
   static final String ms = 'ms';          // mm:ss
   static final String y = 'y';            // yyyy
   static final String yM = 'yM';          // M/yyyy
   static final String yMEd = 'yMEd';      // EEE, M/d/yyyy
   static final String yMMM = 'yMMM';      // MMM yyyy
   static final String yMMMEd = 'yMMMEd';  // EEE, MM d, yyyy
   static final String yMMMM = 'yMMMM';    // MMMM yyyy
   static final String yQ = 'yQ';          // Q yyyy
   static final String yQQQ = 'yQQQ';      // QQQ yyyy
 
   /** Date/Time format patterns. */
-  // TODO(efortuna): This are just guesses of what a full date, long date is. 
+  // TODO(efortuna): This are just guesses of what a full date, long date is.
   // Do the proper homework on ICU to find the proper set "Hms"/"yMMd"
   // applicable to each case.
   static final String fullDate = '$y$MMMMd';
   static final String longDate = yMMMEd;
   static final String mediumDate = '$y$Md';
   static final String shortDate = Md;
   static final String fullTime = '$Hms a';
   static final String longTime = '$Hms a zzzz';
   static final String mediumTime = Hms;
   static final String shortTime = Hm;
   static final String fullDateTime = '$fullDate$fullTime';
-  static final String longDateTime = '$logDate$longTime';
+  static final String longDateTime = '$longDate$longTime';
   static final String mediumDateTime = '$mediumDate$mediumTime';
   static final String shortDateTime = '$shortDate$shortTime';
-    
+
   /**
-   * Named constructors for the above values.
-   */
+   * Constructors for dates/times that use a default format.
+  **/
+
   DateFormat.Hm([this._locale]) : formatDefinition = Hm;
   DateFormat.Hms([this._locale]) : formatDefinition = Hms;
   DateFormat.M([this._locale]) : formatDefinition = M;
   DateFormat.MEd([this._locale]) : formatDefinition = MEd;
   DateFormat.MMM([this._locale]) : formatDefinition = MMM;
   DateFormat.MMMEd([this._locale]) : formatDefinition = MMMEd;
   DateFormat.MMMMEd([this._locale]) : formatDefinition = MMMMEd;
   DateFormat.MMMMd([this._locale]) : formatDefinition = MMMMd;
   DateFormat.MMMd([this._locale]) : formatDefinition = MMMd;
   DateFormat.Md([this._locale]) : formatDefinition = Md;
@@ skipping 14 matching lines @@
   DateFormat.mediumDate([this._locale]) : formatDefinition = mediumDate;
   DateFormat.shortDate([this._locale]) : formatDefinition = shortDate;
   DateFormat.fullTime([this._locale]) : formatDefinition = fullTime;
   DateFormat.longTime([this._locale]) : formatDefinition = longTime;
   DateFormat.mediumTime([this._locale]) : formatDefinition = mediumTime;
   DateFormat.shortTime([this._locale]) : formatDefinition = shortTime;
   DateFormat.fullDateTime([this._locale]) : formatDefinition = fullDateTime;
   DateFormat.longDateTime([this._locale]) : formatDefinition = longDateTime;
   DateFormat.mediumDateTime([this._locale]) : formatDefinition = mediumDateTime;
   DateFormat.shortDateTime([this._locale]) : formatDefinition = shortDateTime;
-  
+
   /**
    * Constructor accepts a [formatDefinition], which can be a String, one of the
    * predefined static forms, or a custom date format using the syntax described
    * above. An optional [_locale] can be provided 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).
    */
   DateFormat([this.formatDefinition = fullDate, this._locale]);
 
   /**
    * Given user input, attempt to parse the [inputString] into the anticipated
    * format.
    */
   String parse(String inputString) {
     return inputString;
   }
 
  /**
-  * Format the given [date] object according to preset pattern and current 
+  * Format the given [date] object according to preset pattern and current
   * locale and return a formated string for the given date.
   */
   String format(Date date, [TimeZone timeZone]) {
     // TODO(efortuna): optional TimeZone argument? TimeZone is deprecated...
     return date.toString();
   }
 
   /**
    * Returns a date string indicating how long ago (3 hours, 2 minutes)
    * something has happened or how long in the future something will happen
    * given a [reference] Date relative to the current time.
    */
   String formatDuration(Date reference) {
     return '';
   }
-  
+
   /**
    * Formats a String indicating how long ago (negative [duration]) or how far
    * in the future (positive [duration]) some time is with respect to a
    * reference [date]. The [duration] is expressed in miliseconds.
    */
   String formatDurationFrom(num duration, Date date) {
     return '';
   }
 }