[Intl] Cleanup some code

pkg/intl/lib/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.
 
 part of intl;
 
 // TODO(efortuna): Customized pattern system -- suggested by i18n needs
 // feedback on appropriateness.
 /**
  * DateFormat is for formatting and parsing dates in a locale-sensitive
@@ skipping 219 matching lines @@
     var result = new StringBuffer();
     _formatFields.forEach((field) => result.write(field.format(date)));
     return result.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] DateTime relative to the current time.
    */
-  String formatDuration(DateTime reference) {
-    return '';
-  }
+  String formatDuration(DateTime reference) => '';
 
   /**
    * 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].
    */
-  String formatDurationFrom(Duration duration, DateTime date) {
-    return '';
-  }
+  String formatDurationFrom(Duration duration, DateTime date) => '';
 
   /**
    * Given user input, attempt to parse the [inputString] into the anticipated
    * format, treating it as being in the local timezone. If [inputString] does
    * not match our format, throws a [FormatException].
    */
   DateTime 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;
+    if (utc) dateFields.utc = true;
     var stream = new _Stream(inputString);
-    _formatFields.forEach(
-        (each) => each.parse(stream, dateFields));
+    _formatFields.forEach((f) => f.parse(stream, dateFields));
     return dateFields.asDate();
   }
 
   /**
    * Given user input, attempt to parse the [inputString] into the anticipated
    * format, treating it as being in UTC.
    */
-  DateTime parseUTC(String inputString) {
-    return parse(inputString, true);
-  }
+  DateTime parseUTC(String inputString) => parse(inputString, true);
 
   /**
    * Return the locale code in which we operate, e.g. 'en_US' or 'pt'.
    */
   String get locale => _locale;
 
   /**
    * Returns a list of all locales for which we have date formatting
    * information.
    */
@@ skipping 204 matching lines @@
       // Everything else - A sequence that is not quotes or field characters.
       // e.g. in "hh:mm:ss" will match the colons.
       new RegExp("^[^\'GyMkSEahKHcLQdDmsvzZ]+")
   ];
 
   /**
    * Set our pattern, appending it to any existing patterns. Also adds a single
    * space to separate the two.
    */
   _appendPattern(String inputPattern, [String separator = ' ']) {
-    if (_pattern == null) {
-      _pattern = inputPattern;
-    } else {
-      _pattern = "$_pattern$separator$inputPattern";
-    }
+    _pattern = _pattern == null ?
+      inputPattern :
+      "$_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 we have already parsed the format fields, reset them.
     _formatFieldsPrivate = null;
     if (inputPattern == null) return this;
     if (!_availableSkeletons.containsKey(inputPattern)) {
       _appendPattern(inputPattern, separator);
     } else {
       _appendPattern(_availableSkeletons[inputPattern], separator);
     }
     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];
-  }
+  Map get _availableSkeletons => dateTimePatterns[locale];
 
   /**
    * Return the [DateSymbol] information for the locale. This can be useful
    * to find lists like the names of weekdays or months in a locale, but
    * the structure of this data may change, and it's generally better to go
    * through the [format] and [parse] APIs. If the locale isn't present, or
    * is uninitialized, returns null;
    */
   DateSymbols get dateSymbols => dateTimeSymbols[_locale];
 
@@ skipping 29 matching lines @@
   }
 
   /** Recursive helper for parsing the template pattern. */
   List _parsePatternHelper(String pattern) {
     if (pattern.isEmpty) return [];
 
     var matched = _match(pattern);
     if (matched == null) return [];
 
     var parsed = _parsePatternHelper(
-                      pattern.substring(matched.fullPattern().length));
+        pattern.substring(matched.fullPattern().length));
     parsed.add(matched);
     return parsed;
   }
 
   /** Find elements in a string that are patterns for specific fields.*/
   _DateFormatField _match(String pattern) {
     for (var i = 0; i < _matchers.length; i++) {
       var regex = _matchers[i];
       var match = regex.firstMatch(pattern);
       if (match != null) {
         return _fieldConstructors[i](match.group(0), this);
       }
     }
   }
 }