Add loose parsing option for dates, accepting mixed case and missing delimiters

lib/src/intl/date_format_field.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.
 
 part of intl;
 
 /**
  * This is a private class internal to DateFormat which is used for formatting
  * particular fields in a template. e.g. if the format is hh:mm:ss then the
  * fields would be "hh", ":", "mm", ":", and "ss". Each type of field knows
@@ skipping 21 matching lines @@
   /** Format date according to our specification and return the result. */
   String format(DateTime date) {
     // Default implementation in the superclass, works for both types of
     // literal patterns, and is overridden by _DateFormatPatternField.
     return pattern;
   }
 
   /** Abstract method for subclasses to implementing parsing for their format.*/
   void parse(_Stream input, _DateBuilder dateFields);
 
+  /**
+   * Abstract method for subclasses to implementing 'loose' parsing for
+   * their format, accepting input case-insensitively, and allowing some
+   * delimiters to be skipped.
+   */
+  void parseLoose(_Stream input, _DateBuilder dateFields);
+
   /** Parse a literal field. We just look for the exact input. */
   void parseLiteral(_Stream input) {
     var found = input.read(width);
     if (found != pattern) {
       throwFormatException(input);
     }
   }
 
+  /**
+   * Parse a literal field. We accept either an exact match, or an arbitrary
+   * amount of whitespace.
+   */
+  void parseLiteralLoose(_Stream input) {
+    var found = input.peek(width);
+    if (found == pattern) {
+      input.read(width);
+    }
+    while (!input.atEnd() && input.peek().trim().isEmpty) {
+      input.read();
+    }
+  }
+
   /** Throw a format exception with an error message indicating the position.*/
   void throwFormatException(_Stream stream) {
     throw new FormatException("Trying to read $this from ${stream.contents} "
         "at position ${stream.index}");
   }
 }
 
 /**
  * Represents a literal field - a sequence of characters that doesn't
  * change according to the date's data. As such, the implementation
  * is extremely simple.
  */
 class _DateFormatLiteralField extends _DateFormatField {
 
   _DateFormatLiteralField(pattern, parent): super(pattern, parent);
 
   parse(_Stream input, _DateBuilder dateFields) {
-    return parseLiteral(input);
+    parseLiteral(input);
   }
+
+  parseLoose(_Stream input, _DateBuilder dateFields) =>
+    parseLiteralLoose(input);
 }
 
 /**
  * Represents a literal field with quoted characters in it. This is
  * only slightly more complex than a _DateFormatLiteralField.
  */
 class _DateFormatQuotedField extends _DateFormatField {
 
   String _fullPattern;
 
   String fullPattern() => _fullPattern;
 
   _DateFormatQuotedField(pattern, parent): super(pattern, parent) {
     _fullPattern = pattern;
     patchQuotes();
   }
 
   parse(_Stream input, _DateBuilder dateFields) {
-    return parseLiteral(input);
+    parseLiteral(input);
   }
 
+  parseLoose(_Stream input, _DateBuilder dateFields) =>
+    parseLiteralLoose(input);
+
   void patchQuotes() {
     if (pattern == "''") {
       pattern = "'";
     } else {
       pattern = pattern.substring(1, pattern.length - 1);
       var twoEscapedQuotes = new RegExp(r"''");
       pattern = pattern.replaceAll(twoEscapedQuotes, "'");
     }
   }
 }
 
+/**
+ * A field that parses "loosely", meaning that we'll accept input that is
+ * missing delimiters, has upper/lower case mixed up, and might not strictly
+ * conform to the pattern, e.g. the pattern calls for Sep we might accept
+ * sep, september, sEPTember. Doesn't affect numeric fields.
+ */
+class _LoosePatternField extends _DateFormatPatternField {
+  _LoosePatternField(String pattern, parent) : super(pattern, parent);
+
+   /**
+    * Parse from a list of possibilities, but case-insensitively.
+    * Assumes that input is lower case.
+    */
+   int parseEnumeratedString(_Stream input, List possibilities) {
+     var lowercasePossibilities = possibilities
+         .map((x) => x.toLowerCase())
+         .toList();
+     try {
+       return super.parseEnumeratedString(input, lowercasePossibilities);
+     } on FormatException {
+       return -1;
+     }
+   }
+
+  /**
+   * Parse a month name, case-insensitively, and set it in [dateFields].
+   * Assumes that [input] is lower case.
+   */
+  void parseMonth(input, dateFields) {
+    if (width <= 2) {
+      handleNumericField(input, dateFields.setMonth);
+      return;
+    }
+    var possibilities =
+        [symbols.MONTHS, symbols.SHORTMONTHS];
+    for (var monthNames in possibilities) {
+      var month = parseEnumeratedString(input, monthNames);
+      if (month != -1) {
+        dateFields.month = month + 1;
+        return;
+      }
+    }
+  }
+
+  /**
+   * Parse a standalone day name, case-insensitively.
+   * Assumes that input is lower case. Doesn't do anything
+   */
+  void parseStandaloneDay(input) {
+    // This is ignored, but we still have to skip over it the correct amount.
+    if (width <= 2) {
+      handleNumericField(input, (x) => x);
+      return;
+    }
+    var possibilities =
+        [symbols.STANDALONEWEEKDAYS, symbols.STANDALONESHORTWEEKDAYS];
+    for (var dayNames in possibilities) {
+       var day = parseEnumeratedString(input, dayNames);
+       if (day != -1) {
+         return;
+       }
+     }
+  }
+
+  /**
+   * Parse a standalone month name, case-insensitively.
+   * Assumes that input is lower case. Doesn't do anything
+   */
+  void parseStandaloneMonth(input, dateFields) {
+    if (width <= 2) {
+      handleNumericField(input, (x) => x);
+      return;
+    }
+    var possibilities =
+        [symbols.STANDALONEMONTHS, symbols.STANDALONESHORTMONTHS];
+    for (var monthNames in possibilities) {
+      var month = parseEnumeratedString(input, monthNames);
+      if (month != -1) {
+        dateFields.month = month + 1;
+        return;
+      }
+    }
+  }
+
+  /**
+   * Parse a day of the week name, case-insensitively.
+   * Assumes that input is lower case. Doesn't do anything
+   */
+  void parseDayOfWeek(_Stream input) {
+    // This is IGNORED, but we still have to skip over it the correct amount.
+    if (width <= 2) {
+      handleNumericField(input, (x) => x);
+      return;
+    }
+    var possibilities = [symbols.WEEKDAYS, symbols.SHORTWEEKDAYS];
+    for (var dayNames in possibilities) {
+       var day = parseEnumeratedString(input, dayNames);
+       if (day != -1) {
+         return;
+       }
+     }
+  }
+}
+
 /*
  * Represents a field in the pattern that formats some aspect of the
  * date. Consists primarily of a switch on the particular pattern characters
  * to determine what to do.
  */
 class _DateFormatPatternField extends _DateFormatField {
 
   _DateFormatPatternField(pattern, parent): super(pattern,  parent);
 
   /** Format date according to our specification and return the result. */
   String format(DateTime date) {
     return formatField(date);
   }
 
   /**
    * Parse the date according to our specification and put the result
    * into the correct place in dateFields.
    */
   void parse(_Stream input, _DateBuilder dateFields) {
     parseField(input, dateFields);
   }
 
+
+  /**
+   * Parse the date according to our specification and put the result
+   * into the correct place in dateFields. Allow looser parsing, accepting
+   * case-insensitive input and skipped delimiters.
+   */
+  void parseLoose(_Stream input, _DateBuilder dateFields) {
+    new _LoosePatternField(pattern, parent).parse(input, dateFields);
+  }
+
   /**
    * Parse a field representing part of a date pattern. Note that we do not
    * return a value, but rather build up the result in [builder].
    */
   void parseField(_Stream input, _DateBuilder builder) {
    try {
      switch(pattern[0]) {
        case 'a': parseAmPm(input, builder); break;
        case 'c': parseStandaloneDay(input); break;
        case 'd': handleNumericField(input, builder.setDay); break; // day
@@ skipping 293 matching lines @@
     var basicString = toBePrinted.toString();
     if (basicString.length >= width) return basicString;
     var buffer = new StringBuffer();
     for (var i = 0; i < width - basicString.length; i++) {
       buffer.write('0');
     }
     buffer.write(basicString);
     return buffer.toString();
   }
 }