Allow multiple patterns for date formats

pkg/intl/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.
  * 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, week name, field order, etc.
@@ skipping 48 matching lines @@
  *   HOUR_MINUTE_GENERIC_TZ       jmv
  *   HOUR_MINUTE_TZ               jmz
  *   HOUR_GENERIC_TZ              jv
  *   HOUR_TZ                      jz
  *   MINUTE                       m
  *   MINUTE_SECOND                ms
  *   SECOND                       s
  *
  * Examples Using the US Locale:
  *
- *     Pattern                           Result
- *     ----------------                  -------
- *     "yMd"                            -> 07/10/1996
- *     "yMMMMd"                         -> July 10, 1996
- *     "Hm"                             -> 12:08 PM
+ *      Pattern                           Result
+ *      ----------------                  -------
+ *      new DateFormat.yMd()             -> 07/10/1996
+ *      new DateFormat("yMd")            -> 07/10/1996
+ *      new DateFormat.yMMMMd("en_US")   -> July 10, 1996
+ *      new DateFormat("Hm", "en_US")    -> 12:08 PM
+ *      new DateFormat.yMd().Hm()        -> 07/10/1996 12:08 PM
  *
  * Explicit Pattern Syntax: Formats can also be specified with a pattern string.
  * The skeleton forms will resolve to explicit patterns of this form, but will
  * also adapt to different patterns in different locales.
  * The following characters are reserved:
  *
  *     Symbol   Meaning                Presentation        Example
  *     ------   -------                ------------        -------
  *     G        era designator         (Text)              AD
  *     y        year                   (Number)            1996
@@ skipping 59 matching lines @@
  * 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
  * century. Any other numeric string, such as a one digit string, a three or
  * more digit string will be interpreted as its face value.
  *
  * If the year pattern does not have exactly two 'y' characters, the year is
  * interpreted literally, regardless of the number of digits. So using the
  * pattern "MM/dd/yyyy", "01/11/12" parses to Jan 11, 12 A.D.
- *
- * When numeric fields abut one another directly, with no intervening
- * delimiter characters, they constitute a run of abutting numeric fields. Such
- * runs are parsed specially. For example, the format "HHmmss" parses the input
- * text "123456" to 12:34:56, parses the input text "12345" to 1:23:45, and
- * fails to parse "1234". In other words, the leftmost field of the run is
- * flexible, while the others keep a fixed width. If the parse fails anywhere in
- * 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('date_format');
 
 #import('intl.dart');
 #import('date_time_patterns.dart');
 #import('date_symbols.dart');
 #import('date_symbol_data.dart');
 
 #source('lib/date_format_field.dart');
@@ skipping 20 matching lines @@
    */
   DateFormat([String newPattern, String locale]) {
     // TODO(alanknight): It should be possible to specify multiple skeletons eg
     // date, time, timezone all separately. Adding many or named parameters to
     // the constructor seems awkward, especially with the possibility of
     // confusion with the locale. A "fluent" interface with cascading on an
     // instance might work better? A list of patterns is also possible.
     // TODO(alanknight): There will need to be at least setup type async
     // operations to avoid the need to bring along every locale in every program
     _locale = Intl.verifiedLocale(locale);
-    _setPattern(newPattern);
+    addPattern(newPattern);
   }
 
   /**
    * Return a string representing [date] formatted according to our locale
    * and internal format.
    */
   String format(Date date) {
     // TODO(efortuna): read optional TimeZone argument (or similar)?
     var result = new StringBuffer();
     _formatFields.forEach((field) => result.add(field.format(date)));
@@ skipping 16 matching lines @@
    */
   String formatDurationFrom(Duration duration, Date date) {
     return '';
   }
 
   /**
    * Given user input, attempt to parse the [inputString] into the anticipated
    * format, treating it as being in the local timezone.
    */
   Date parse(String inputString, [utc = false]) {
+    // TODO(alanknight): The Closure code refers to special parsing of numeric
+    // values with no delimiters, which we currently don't do. Should we?
     var dateFields = new _DateBuilder();
     if (utc) dateFields.utc=true;
     var stream = new _Stream(inputString);
     _formatFields.forEach(
         (each) => each.parse(stream, dateFields));
     return dateFields.asDate();
   }
 
   /**
    * Given user input, attempt to parse the [inputString] into the anticipated
@@ skipping 99 matching lines @@
   DateFormat.jms([locale]) : this("jms", locale);
   DateFormat.jmv([locale]) : this("jmv", locale);
   DateFormat.jmz([locale]) : this("jmz", locale);
   DateFormat.jv([locale]) : this("jv", locale);
   DateFormat.jz([locale]) : this("jz", locale);
   DateFormat.m([locale]) : this("m", locale);
   DateFormat.ms([locale]) : this("ms", locale);
   DateFormat.s([locale]) : this("s", locale);
 
   /**
+   * Methods for appending a particular skeleton to the format, or setting
+   * it as the only format if none was previously set. These are primarily
+   * useful for creating compound formats. For example
+   *       new DateFormat.yMd().hms();
+   * would create a date format that prints both the date and the time.
+   */
+  DateFormat d() => addPattern("d");
+  DateFormat E() => addPattern("E");
+  DateFormat EEEE() => addPattern("EEEE");
+  DateFormat LLL() => addPattern("LLL");
+  DateFormat LLLL() => addPattern("LLLL");
+  DateFormat M() => addPattern("M");
+  DateFormat Md() => addPattern("Md");
+  DateFormat MEd() => addPattern("MEd");
+  DateFormat MMM() => addPattern("MMM");
+  DateFormat MMMd() => addPattern("MMMd");
+  DateFormat MMMEd() => addPattern("MMMEd");
+  DateFormat MMMM() => addPattern("MMMM");
+  DateFormat MMMMd() => addPattern("MMMMd");
+  DateFormat MMMMEEEEd() => addPattern("MMMMEEEEd");
+  DateFormat QQQ() => addPattern("QQQ");
+  DateFormat QQQQ() => addPattern("QQQQ");
+  DateFormat y() => addPattern("y");
+  DateFormat yM() => addPattern("yM");
+  DateFormat yMd() => addPattern("yMd");
+  DateFormat yMEd() => addPattern("yMEd");
+  DateFormat yMMM() => addPattern("yMMM");
+  DateFormat yMMMd() => addPattern("yMMMd");
+  DateFormat yMMMEd() => addPattern("yMMMEd");
+  DateFormat yMMMM() => addPattern("yMMMM");
+  DateFormat yMMMMd() => addPattern("yMMMMd");
+  DateFormat yMMMMEEEEd() => addPattern("yMMMMEEEEd");
+  DateFormat yQQQ() => addPattern("yQQQ");
+  DateFormat yQQQQ() => addPattern("yQQQQ");
+  DateFormat H() => addPattern("H");
+  DateFormat Hm() => addPattern("Hm");
+  DateFormat Hms() => addPattern("Hms");
+  DateFormat j() => addPattern("j");
+  DateFormat jm() => addPattern("jm");
+  DateFormat jms() => addPattern("jms");
+  DateFormat jmv() => addPattern("jmv");
+  DateFormat jmz() => addPattern("jmz");
+  DateFormat jv() => addPattern("jv");
+  DateFormat jz() => addPattern("jz");
+  DateFormat m() => addPattern("m");
+  DateFormat ms() => addPattern("ms");
+  DateFormat s() => addPattern("s");
+
+  /**
    * ICU constants for format names, resolving to the corresponding skeletons.
    */
   static final String DAY = 'd';
   static final String ABBR_WEEKDAY = 'E';
   static final String WEEKDAY = 'EEEE';
   static final String ABBR_STANDALONE_MONTH = 'LLL';
   static final String STANDALONE_MONTH = 'LLLL';
   static final String NUM_MONTH = 'M';
   static final String NUM_MONTH_DAY = 'Md';
   static final String NUM_MONTH_WEEKDAY_DAY = 'MEd';
@@ skipping 35 matching lines @@
   String _locale;
 
   /**
    * The full template string. This may have been specified directly, or
    * it may have been derived from a skeleton and the locale information
    * on how to interpret that skeleton.
    */
   String _pattern;
 
   /**
-   * We parse the format string into individual fields and store them here.
-   * This is what is actually used to do the formatting.
+   * We parse the format string into individual [_DateFormatField] objects
+   * that are used to do the actual formatting and parsing. Do not use
+   * this variable directly, use the getter [_formatFields].
    */
-  List<_DateFormatField> _formatFields;
+  List<_DateFormatField> _formatFieldsPrivate;
+
+  /**
+   * Getter for [_formatFieldsPrivate] that lazily initializes it.
+   */
+  get _formatFields() {
+    if (_formatFieldsPrivate == null) {
+      _formatFieldsPrivate = parsePattern(_pattern);
+    }
+    return _formatFieldsPrivate;
+  }
 
   /**
    * A series of regular expressions used to parse a format string into its
    * component fields.
    */
   static var _matchers = const [
       // Quoted String - anything between single quotes, with escaping
       //   of single quotes by doubling them.
       // e.g. in the pattern "hh 'o''clock'" will match 'o''clock'
       const RegExp("^\'(?:[^\']|\'\')*\'"),
       // Fields - any sequence of 1 or more of the same field characters.
       // e.g. in "hh:mm:ss" will match hh, mm, and ss. But in "hms" would
       // match each letter individually.
       const RegExp(
         "^(?:G+|y+|M+|k+|S+|E+|a+|h+|K+|H+|c+|L+|Q+|d+|m+|s+|v+|z+|Z+)"),
       // Everything else - A sequence that is not quotes or field characters.
       // e.g. in "hh:mm:ss" will match the colons.
       const RegExp("^[^\'GyMkSEahKHcLQdmsvzZ]+")
   ];
 
   /**
-   * Given a format from the user look it up in our list of known skeletons.
-   * If it's there, then use the corresponding pattern for this locale.
-   * If it's not, then treat it as an explicit pattern.
+   * Set our pattern, appending it to any existing patterns. Also adds a single
+   * space to separate the two.
    */
-  _setPattern(String inputPattern) {
+  _setPattern(String inputPattern, [String separator = ' ']) {
+    if (_pattern == null) {
+      _pattern = inputPattern;
+    } else {
+      _pattern = "$_pattern$separator$inputPattern";
+    }
+  }
+
+  /**
+   * Add [inputPattern] to this instance as a pattern. If there was a previous
+   * pattern, then this appends to it, separating the two by [separator].
+   * [inputPattern] is first looked up in our list of known skeletons.
+   * If it's found there, then use the corresponding pattern for this locale.
+   * If it's not, then treat [inputPattern] as an explicit pattern.
+   */
+  DateFormat addPattern(String inputPattern, [String separator = ' ']) {
     // TODO(alanknight): This is an expensive operation. Caching recently used
     // formats, or possibly introducing an entire "locale" object that would
     // cache patterns for that locale could be a good optimization.
     if (!_availableSkeletons.containsKey(inputPattern)) {
-      _pattern = inputPattern;
+      _setPattern(inputPattern, separator);
     } else {
-      _pattern = _availableSkeletons[inputPattern];
+      _setPattern(_availableSkeletons[inputPattern], separator);
     }
-    _formatFields = parsePattern(_pattern);
+    // If we have already parsed the format fields, reset them.
+    _formatFieldsPrivate = null;
+    return this;
   }
 
   /** Return the pattern that we use to format dates.*/
   get pattern() => _pattern;
 
   /** Return the skeletons for our current locale. */
   Map get _availableSkeletons() {
     return dateTimePatterns[locale];
   }
 
@@ skipping 57 matching lines @@
   List _reverse(List list) {
     // TODO(alanknight): Use standardized list reverse when implemented.
     // See Issue 2804.
     var result = new List();
     for (var i = list.length-1; i >= 0; i--) {
       result.addLast(list[i]);
     }
     return result;
   }
 }