[Intl] Cleanup some code

pkg/intl/lib/bidi_utils.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;
 
 /**
  * Bidi stands for Bi-directional text.
  * According to http://en.wikipedia.org/wiki/Bi-directional_text:
  * Bi-directional text is text containing text in both text directionalities,
@@ skipping 27 matching lines @@
 
   /** Textual representation of the directionality when used in span tag. */
   final String spanText;
 
   const TextDirection._(this.value, this.spanText);
 
   /**
    * Returns true if [otherDirection] is known to be different from this
    * direction.
    */
-  bool isDirectionChange(TextDirection otherDirection) {
-    return otherDirection != TextDirection.UNKNOWN && this != otherDirection;
-  }
+  bool isDirectionChange(TextDirection otherDirection) =>
+      otherDirection != TextDirection.UNKNOWN && this != otherDirection;
 }
 
 /**
  * This provides utility methods for working with bidirectional text. All
  * of the methods are static, and are organized into a class primarily to
  * group them together for documentation and discoverability.
  */
 class Bidi {
 
   /** Unicode "Left-To-Right Embedding" (LRE) character. */
@@ skipping 130 matching lines @@
 
   /**
    * Enforce the [html] snippet in RTL directionality regardless of overall
    * context. If the html piece was enclosed by a tag, the direction will be
    * applied to existing tag, otherwise a span tag will be added as wrapper.
    * For this reason, if html snippet start with with tag, this tag must enclose
    * the whole piece. If the tag already has a direction specified, this new one
    * will override existing one in behavior (should work on Chrome, FF, and IE
    * since this was ported directly from the Closure version).
    */
-  static String enforceRtlInHtml(String html) {
-    return _enforceInHtmlHelper(html, 'rtl');
-  }
+  static String enforceRtlInHtml(String html) =>
+      _enforceInHtmlHelper(html, 'rtl');
 
   /**
    * Enforce RTL on both end of the given [text] using unicode BiDi formatting
    * characters RLE and PDF.
    */
-  static String enforceRtlInText(String text) {
-    return '$RLE$text$PDF';
-  }
+  static String enforceRtlInText(String text) => '$RLE$text$PDF';
 
   /**
    * Enforce the [html] snippet in LTR directionality regardless of overall
    * context. If the html piece was enclosed by a tag, the direction will be
    * applied to existing tag, otherwise a span tag will be added as wrapper.
    * For this reason, if html snippet start with with tag, this tag must enclose
    * the whole piece. If the tag already has a direction specified, this new one
    * will override existing one in behavior (tested on FF and IE).
    */
-  static String enforceLtrInHtml(String html) {
-    return _enforceInHtmlHelper(html, 'ltr');
-  }
+  static String enforceLtrInHtml(String html) =>
+      _enforceInHtmlHelper(html, 'ltr');
 
   /**
    * Enforce LTR on both end of the given [text] using unicode BiDi formatting
    * characters LRE and PDF.
    */
-  static String enforceLtrInText(String text) {
-    return '$LRE$text$PDF';
-  }
+  static String enforceLtrInText(String text) => '$LRE$text$PDF';
 
   /**
    * Enforce the [html] snippet in the desired [direction] regardless of overall
    * context. If the html piece was enclosed by a tag, the direction will be
    * applied to existing tag, otherwise a span tag will be added as wrapper.
    * For this reason, if html snippet start with with tag, this tag must enclose
    * the whole piece. If the tag already has a direction specified, this new one
    * will override existing one in behavior (tested on FF and IE).
    */
   static String _enforceInHtmlHelper(String html, String direction) {
@@ skipping 45 matching lines @@
    * (Mostly) reimplements the $& functionality of "replace" in JavaScript.
    * Given a [str] and the [regexp] to match with, optionally supply a string to
    * be inserted [before] the match and/or [after]. For example,
    * `_guardBracketHelper('firetruck', new RegExp('truck'), 'hydrant', '!')`
    * would return 'firehydrant!'.
    */
   // TODO(efortuna): Get rid of this once this is implemented in Dart.
   // See Issue 2979.
   static String _guardBracketHelper(String str, RegExp regexp, [String before,
       String after]) {
-    StringBuffer buffer = new StringBuffer();
+    var buffer = new StringBuffer();
     var startIndex = 0;
-    Iterable matches = regexp.allMatches(str);
-    for (Match match in matches) {
+    regexp.allMatches(str).forEach((match) {
       buffer..write(str.substring(startIndex, match.start))
             ..write(before)
             ..write(str.substring(match.start, match.end))
             ..write(after);
       startIndex = match.end;
-    }
+    });
     return (buffer..write(str.substring(startIndex))).toString();
   }
 
   /**
    * Estimates the directionality of [text] using the best known
    * general-purpose method (using relative word counts). A
    * TextDirection.UNKNOWN return value indicates completely neutral input.
    * [isHtml] is true if [text] HTML or HTML-escaped.
    *
    * If the number of RTL words is above a certain percentage of the total
@@ skipping 58 matching lines @@
       }
     }
     return buf.toString();
   }
 
   /**
    * Check the estimated directionality of [str], return true if the piece of
    * text should be laid out in RTL direction. If [isHtml] is true, the string
    * is HTML or HTML-escaped.
    */
-  static bool detectRtlDirectionality(String str, {bool isHtml: false}) {
-    return estimateDirectionOfText(str, isHtml: isHtml) == TextDirection.RTL;
-  }
+  static bool detectRtlDirectionality(String str, {bool isHtml: false}) =>
+      estimateDirectionOfText(str, isHtml: isHtml) == TextDirection.RTL;
 }