Roll to pickup pool changes

packages/glob/lib/src/ast.dart

 // Copyright (c) 2014, 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.
 
 import 'package:path/path.dart' as p;
 import 'package:collection/collection.dart';
 
 import 'utils.dart';
 
 const _SEPARATOR = 0x2F; // "/"
@@ skipping 20 matching lines @@
 
   /// Returns a new glob with all the options bubbled to the top level.
   ///
   /// In particular, this returns a glob AST with two guarantees:
   ///
   /// 1. There are no [OptionsNode]s other than the one at the top level.
   /// 2. It matches the same set of paths as [this].
   ///
   /// For example, given the glob `{foo,bar}/{click/clack}`, this would return
   /// `{foo/click,foo/clack,bar/click,bar/clack}`.
-  OptionsNode flattenOptions() => new OptionsNode(
-      [new SequenceNode([this], caseSensitive: caseSensitive)],
-      caseSensitive: caseSensitive);
+  OptionsNode flattenOptions() => new OptionsNode([
+        new SequenceNode([this], caseSensitive: caseSensitive)
+      ], caseSensitive: caseSensitive);
 
   /// Returns whether this glob matches [string].
   bool matches(String string) {
     if (_regExp == null) {
       _regExp = new RegExp('^${_toRegExp()}\$', caseSensitive: caseSensitive);
     }
     return _regExp.hasMatch(string);
   }
 
   /// Subclasses should override this to return a regular expression component.
@@ skipping 10 matching lines @@
 
   SequenceNode(Iterable<AstNode> nodes, {bool caseSensitive: true})
       : nodes = nodes.toList(),
         super._(caseSensitive);
 
   OptionsNode flattenOptions() {
     if (nodes.isEmpty) {
       return new OptionsNode([this], caseSensitive: caseSensitive);
     }
 
-    var sequences = nodes.first.flattenOptions().options
-        .map((sequence) => sequence.nodes);
+    var sequences =
+        nodes.first.flattenOptions().options.map((sequence) => sequence.nodes);
     for (var node in nodes.skip(1)) {
       // Concatenate all sequences in the next options node ([nextSequences])
       // onto all previous sequences ([sequences]).
       var nextSequences = node.flattenOptions().options;
       sequences = sequences.expand((sequence) {
         return nextSequences.map((nextSequence) {
           return sequence.toList()..addAll(nextSequence.nodes);
         });
       });
     }
 
     return new OptionsNode(sequences.map((sequence) {
       // Combine any adjacent LiteralNodes in [sequence].
-      return new SequenceNode(sequence.fold/*<List<AstNode>>*/([], (combined, node) {
-        if (combined.isEmpty || combined.last is! LiteralNode ||
-            node is! LiteralNode) {
-          return combined..add(node);
-        }
+      return new SequenceNode(
+          sequence.fold<List<AstNode>>([], (combined, node) {
+            if (combined.isEmpty ||
+                combined.last is! LiteralNode ||
+                node is! LiteralNode) {
+              return combined..add(node);
+            }
 
-        combined[combined.length - 1] = new LiteralNode(
-            // TODO(nweiz): Avoid casting when sdk#25565 is fixed.
-            (combined.last as LiteralNode).text + (node as LiteralNode).text,
-            caseSensitive: caseSensitive);
-        return combined;
-      }), caseSensitive: caseSensitive);
+            combined[combined.length - 1] = new LiteralNode(
+                // TODO(nweiz): Avoid casting when sdk#25565 is fixed.
+                (combined.last as LiteralNode).text +
+                    (node as LiteralNode).text,
+                caseSensitive: caseSensitive);
+            return combined;
+          }),
+          caseSensitive: caseSensitive);
     }), caseSensitive: caseSensitive);
   }
 
   /// Splits this glob into components along its path separators.
   ///
   /// For example, given the glob `foo/*/*.dart`, this would return three globs:
   /// `foo`, `*`, and `*.dart`.
   ///
   /// Path separators within options nodes are not split. For example,
   /// `foo/{bar,baz/bang}/qux` will return three globs: `foo`, `{bar,baz/bang}`,
@@ skipping 67 matching lines @@
       addNode(new LiteralNode(components.last, caseSensitive: caseSensitive));
       if (literal.text.endsWith('/')) finishComponent();
     }
 
     finishComponent();
     return componentsToReturn;
   }
 
   String _toRegExp() => nodes.map((node) => node._toRegExp()).join();
 
-  bool operator==(Object other) => other is SequenceNode &&
+  bool operator ==(Object other) =>
+      other is SequenceNode &&
       const IterableEquality().equals(nodes, other.nodes);
 
   int get hashCode => const IterableEquality().hash(nodes);
 
   String toString() => nodes.join();
 }
 
 /// A node matching zero or more non-separator characters.
 class StarNode extends AstNode {
   StarNode({bool caseSensitive: true}) : super._(caseSensitive);
 
   String _toRegExp() => '[^/]*';
 
-  bool operator==(Object other) => other is StarNode;
+  bool operator ==(Object other) => other is StarNode;
 
   int get hashCode => 0;
 
   String toString() => '*';
 }
 
 /// A node matching zero or more characters that may be separators.
 class DoubleStarNode extends AstNode {
   /// The path context for the glob.
   ///
@@ skipping 21 matching lines @@
       assert(_context.style == p.Style.url);
       buffer.write(r'[a-zA-Z][-+.a-zA-Z\d]*://|/');
     }
 
     // Use `[^]` rather than `.` so that it matches newlines as well.
     buffer.write(r'))[^]*');
 
     return buffer.toString();
   }
 
-  bool operator==(Object other) => other is DoubleStarNode;
+  bool operator ==(Object other) => other is DoubleStarNode;
 
   int get hashCode => 1;
 
   String toString() => '**';
 }
 
 /// A node matching a single non-separator character.
 class AnyCharNode extends AstNode {
   AnyCharNode({bool caseSensitive: true}) : super._(caseSensitive);
 
   String _toRegExp() => '[^/]';
 
-  bool operator==(Object other) => other is AnyCharNode;
+  bool operator ==(Object other) => other is AnyCharNode;
 
   int get hashCode => 2;
 
   String toString() => '?';
 }
 
 /// A node matching a single character in a range of options.
 class RangeNode extends AstNode {
   /// The ranges matched by this node.
   ///
@@ skipping 44 matching lines @@
       buffer.write(regExpQuote(start));
       if (range.isSingleton) continue;
       buffer.write('-');
       buffer.write(regExpQuote(new String.fromCharCodes([range.max])));
     }
 
     buffer.write(']');
     return buffer.toString();
   }
 
-  bool operator==(Object other) {
+  bool operator ==(Object other) {
     if (other is! RangeNode) return false;
     if ((other as RangeNode).negated != negated) return false;
     return const SetEquality().equals(ranges, (other as RangeNode).ranges);
   }
 
   int get hashCode => (negated ? 1 : 3) * const SetEquality().hash(ranges);
 
   String toString() {
     var buffer = new StringBuffer()..write('[');
     for (var range in ranges) {
@@ skipping 19 matching lines @@
       : options = options.toList(),
         super._(caseSensitive);
 
   OptionsNode flattenOptions() => new OptionsNode(
       options.expand((option) => option.flattenOptions().options),
       caseSensitive: caseSensitive);
 
   String _toRegExp() =>
       '(?:${options.map((option) => option._toRegExp()).join("|")})';
 
-  bool operator==(Object other) => other is OptionsNode &&
+  bool operator ==(Object other) =>
+      other is OptionsNode &&
       const UnorderedIterableEquality().equals(options, other.options);
 
   int get hashCode => const UnorderedIterableEquality().hash(options);
 
   String toString() => '{${options.join(',')}}';
 }
 
 /// A node that matches a literal string.
 class LiteralNode extends AstNode {
   /// The string to match.
   final String text;
 
   /// The path context for the glob.
   ///
   /// This is used to determine whether this could match an absolute path.
   final p.Context _context;
 
   bool get canMatchAbsolute {
-    var nativeText = _context.style == p.Style.windows ?
-        text.replaceAll('/', '\\') : text;
+    var nativeText =
+        _context.style == p.Style.windows ? text.replaceAll('/', '\\') : text;
     return _context.isAbsolute(nativeText);
   }
 
   bool get canMatchRelative => !canMatchAbsolute;
 
   LiteralNode(this.text, {p.Context context, bool caseSensitive: true})
       : _context = context,
         super._(caseSensitive);
 
   String _toRegExp() => regExpQuote(text);
 
-  bool operator==(Object other) => other is LiteralNode && other.text == text;
+  bool operator ==(Object other) => other is LiteralNode && other.text == text;
 
   int get hashCode => text.hashCode;
 
   String toString() => text;
 }