Update charted to 0.4.8 and roll

packages/glob/lib/src/list_tree.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.
 
-library glob.list_tree;
-
 import 'dart:io';
 import 'dart:async';
 
+import 'package:async/async.dart';
 import 'package:path/path.dart' as p;
 
 import 'ast.dart';
-import 'stream_pool.dart';
 import 'utils.dart';
 
 /// The errno for a file or directory not existing on Mac and Linux.
 const _ENOENT = 2;
 
 /// Another errno we see on Windows when trying to list a non-existent
 /// directory.
 const _ENOENT_WIN = 3;
 
 /// A structure built from a glob that efficiently lists filesystem entities
@@ skipping 68 matching lines @@
         }
       }
 
       _addGlob(root, components);
     }
 
     _canOverlap = _computeCanOverlap();
   }
 
   /// Add the glob represented by [components] to the tree under [root].
-  void _addGlob(String root, List<AstNode> components) {
+  void _addGlob(String root, List<SequenceNode> components) {
     // The first [parent] represents the root directory itself. It may be null
     // here if this is the first option with this particular [root]. If so,
     // we'll create it below.
     //
     // As we iterate through [components], [parent] will be set to
     // progressively more nested nodes.
     var parent = _trees[root];
     for (var i = 0; i < components.length; i++) {
       var component = components[i];
       var recursive = component.nodes.any((node) => node is DoubleStarNode);
@@ skipping 52 matching lines @@
     if (_trees.length > 1 && _trees.containsKey('.')) return true;
 
     // Otherwise, this can only overlap if the tree beneath any given root could
     // overlap internally.
     return _trees.values.any((node) => node.canOverlap);
   }
 
   /// List all entities that match this glob beneath [root].
   Stream<FileSystemEntity> list({String root, bool followLinks: true}) {
     if (root == null) root = '.';
-    var pool = new StreamPool();
+    var group = new StreamGroup<FileSystemEntity>();
     for (var rootDir in _trees.keys) {
       var dir = rootDir == '.' ? root : rootDir;
-      pool.add(_trees[rootDir].list(dir, followLinks: followLinks));
+      group.add(_trees[rootDir].list(dir, followLinks: followLinks));
     }
-    pool.closeWhenEmpty();
+    group.close();
 
-    if (!_canOverlap) return pool.stream;
+    if (!_canOverlap) return group.stream;
 
     // TODO(nweiz): Rather than filtering here, avoid double-listing directories
     // in the first place.
     var seen = new Set();
-    return pool.stream.where((entity) {
+    return group.stream.where((entity) {
       if (seen.contains(entity.path)) return false;
       seen.add(entity.path);
       return true;
     });
   }
 
   /// Synchronosuly list all entities that match this glob beneath [root].
   List<FileSystemEntity> listSync({String root, bool followLinks: true}) {
     if (root == null) root = '.';
 
-    var result = _trees.keys.expand((rootDir) {
+    // TODO(nweiz): Remove the explicit annotation when sdk#26139 is fixed.
+    var result = _trees.keys.expand/*<FileSystemEntity>*/((rootDir) {
       var dir = rootDir == '.' ? root : rootDir;
       return _trees[rootDir].listSync(dir, followLinks: followLinks);
     });
 
     if (!_canOverlap) return result.toList();
 
     // TODO(nweiz): Rather than filtering here, avoid double-listing directories
     // in the first place.
-    var seen = new Set();
+    var seen = new Set<String>();
     return result.where((entity) {
       if (seen.contains(entity.path)) return false;
       seen.add(entity.path);
       return true;
     }).toList();
   }
 }
 
 /// A single node in a [ListTree].
 class _ListTreeNode {
   /// This node's child nodes, by their corresponding globs.
   ///
   /// Each child node will only be listed on directories that match its glob.
   ///
   /// This may be `null`, indicating that this node should be listed
   /// recursively.
   Map<SequenceNode, _ListTreeNode> children;
 
   /// This node's validator.
   ///
   /// This determines which entities will ultimately be emitted when [list] is
   /// called.
   OptionsNode _validator;
 
   /// Whether this node is recursive.
   ///
   /// A recursive node has no children and is listed recursively.
   bool get isRecursive => children == null;
 
+  bool get _caseSensitive {
+    if (_validator != null) return _validator.caseSensitive;
+    if (children == null) return true;
+    if (children.isEmpty) return true;
+    return children.keys.first.caseSensitive;
+  }
+
   /// Whether this node doesn't itself need to be listed.
   ///
   /// If a node has no validator and all of its children are literal filenames,
   /// there's no need to list its contents. We can just directly traverse into
   /// its children.
   bool get _isIntermediate {
     if (_validator != null) return false;
+    if (!_caseSensitive) return false;
     return children.keys.every((sequence) =>
         sequence.nodes.length == 1 && sequence.nodes.first is LiteralNode);
   }
 
   /// Returns whether listing this node might return overlapping results.
   bool get canOverlap {
     // A recusive node can never overlap with itself, because it will only ever
     // involve a single call to [Directory.list] that's then filtered with
     // [_validator].
     if (isRecursive) return false;
 
     // If there's more than one child node and at least one of the children is
     // dynamic (that is, matches more than just a literal string), there may be
     // overlap.
-    if (children.length > 1 && children.keys.any((sequence) =>
+    if (children.length > 1) {
+      // Case-insensitivity means that even literals may match multiple entries.
+      if (!_caseSensitive) return true;
+
+      if (children.keys.any((sequence) =>
           sequence.nodes.length > 1 || sequence.nodes.single is! LiteralNode)) {
-      return true;
+        return true;
+      }
     }
 
     return children.values.any((node) => node.canOverlap);
   }
 
   /// Creates a node with no children and no validator.
   _ListTreeNode()
       : children = new Map<SequenceNode, _ListTreeNode>(),
         _validator = null;
 
   /// Creates a recursive node the given [validator].
   _ListTreeNode.recursive(SequenceNode validator)
       : children = null,
-        _validator = new OptionsNode([validator]);
+        _validator = new OptionsNode([validator],
+            caseSensitive: validator.caseSensitive);
 
   /// Transforms this into recursive node, folding all its children into its
   /// validator.
   void makeRecursive() {
     if (isRecursive) return;
     _validator = new OptionsNode(children.keys.map((sequence) {
       var child = children[sequence];
       child.makeRecursive();
       return _join([sequence, child._validator]);
-    }));
+    }), caseSensitive: _caseSensitive);
     children = null;
   }
 
   /// Adds [validator] to this node's existing validator.
   void addOption(SequenceNode validator) {
     if (_validator == null) {
-      _validator = new OptionsNode([validator]);
+      _validator = new OptionsNode([validator],
+          caseSensitive: validator.caseSensitive);
     } else {
       _validator.options.add(validator);
     }
   }
 
   /// Lists all entities within [dir] matching this node or its children.
   ///
   /// This may return duplicate entities. These will be filtered out in
   /// [ListTree.list].
   Stream<FileSystemEntity> list(String dir, {bool followLinks: true}) {
     if (isRecursive) {
       return new Directory(dir).list(recursive: true, followLinks: followLinks)
-          .where((entity) => _matches(entity.path.substring(dir.length + 1)));
+          .where((entity) => _matches(p.relative(entity.path, from: dir)));
     }
 
-    var resultPool = new StreamPool();
+    var resultGroup = new StreamGroup<FileSystemEntity>();
 
     // Don't spawn extra [Directory.list] calls when we already know exactly
     // which subdirectories we're interested in.
     if (_isIntermediate) {
       children.forEach((sequence, child) {
-        resultPool.add(child.list(p.join(dir, sequence.nodes.single.text),
+        resultGroup.add(child.list(
+            p.join(dir, (sequence.nodes.single as LiteralNode).text),
             followLinks: followLinks));
       });
-      resultPool.closeWhenEmpty();
-      return resultPool.stream;
+      resultGroup.close();
+      return resultGroup.stream;
     }
 
-    var resultController = new StreamController(sync: true);
-    resultPool.add(resultController.stream);
+    var resultController = new StreamController<FileSystemEntity>(sync: true);
+    resultGroup.add(resultController.stream);
     new Directory(dir).list(followLinks: followLinks).listen((entity) {
-      var basename = entity.path.substring(dir.length + 1);
+      var basename = p.relative(entity.path, from: dir);
       if (_matches(basename)) resultController.add(entity);
 
       children.forEach((sequence, child) {
         if (entity is! Directory) return;
         if (!sequence.matches(basename)) return;
         var stream = child.list(p.join(dir, basename), followLinks: followLinks)
             .handleError((_) {}, test: (error) {
           // Ignore errors from directories not existing. We do this here so
           // that we only ignore warnings below wild cards. For example, the
           // glob "foo/bar/*/baz" should fail if "foo/bar" doesn't exist but
           // succeed if "foo/bar/qux/baz" doesn't exist.
           return error is FileSystemException &&
               (error.osError.errorCode == _ENOENT ||
               error.osError.errorCode == _ENOENT_WIN);
         });
-        resultPool.add(stream);
+        resultGroup.add(stream);
       });
     },
         onError: resultController.addError,
-        onDone: resultController.close);
+        onDone: () {
+          resultController.close();
+          resultGroup.close();
+        });
 
-    resultPool.closeWhenEmpty();
-    return resultPool.stream;
+    return resultGroup.stream;
   }
 
   /// Synchronously lists all entities within [dir] matching this node or its
   /// children.
   ///
   /// This may return duplicate entities. These will be filtered out in
   /// [ListTree.listSync].
   Iterable<FileSystemEntity> listSync(String dir, {bool followLinks: true}) {
     if (isRecursive) {
       return new Directory(dir)
           .listSync(recursive: true, followLinks: followLinks)
-          .where((entity) => _matches(entity.path.substring(dir.length + 1)));
+          .where((entity) => _matches(p.relative(entity.path, from: dir)));
     }
 
     // Don't spawn extra [Directory.listSync] calls when we already know exactly
     // which subdirectories we're interested in.
     if (_isIntermediate) {
       return children.keys.expand((sequence) {
         return children[sequence].listSync(
-            p.join(dir, sequence.nodes.single.text), followLinks: followLinks);
+            p.join(dir, (sequence.nodes.single as LiteralNode).text),
+            followLinks: followLinks);
       });
     }
 
     return new Directory(dir).listSync(followLinks: followLinks)
         .expand((entity) {
-      var entities = [];
-      var basename = entity.path.substring(dir.length + 1);
+      var entities = <FileSystemEntity>[];
+      var basename = p.relative(entity.path, from: dir);
       if (_matches(basename)) entities.add(entity);
       if (entity is! Directory) return entities;
 
       entities.addAll(children.keys
           .where((sequence) => sequence.matches(basename))
           .expand((sequence) {
         try {
           return children[sequence].listSync(
               p.join(dir, basename), followLinks: followLinks).toList();
         } on FileSystemException catch (error) {
@@ skipping 20 matching lines @@
     return _validator.matches(toPosixPath(p.context, path));
   }
 
   String toString() => "($_validator) $children";
 }
 
 /// Joins each [components] into a new glob where each component is separated by
 /// a path separator.
 SequenceNode _join(Iterable<AstNode> components) {
   var componentsList = components.toList();
-  var nodes = [componentsList.removeAt(0)];
+  var first = componentsList.removeAt(0);
+  var nodes = [first];
   for (var component in componentsList) {
-    nodes.add(new LiteralNode('/'));
+    nodes.add(new LiteralNode('/', caseSensitive: first.caseSensitive));
     nodes.add(component);
   }
-  return new SequenceNode(nodes);
+  return new SequenceNode(nodes, caseSensitive: first.caseSensitive);
 }