Fix case-insensitive absolute listing.

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.
 
 import 'dart:io';
 import 'dart:async';
 
 import 'package:path/path.dart' as p;
 
 import 'ast.dart';
@@ skipping 296 matching lines @@
     }
   }
 
   /// 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)));

[Bob Nystrom, 2016/03/08 21:40:31]

What's the performance impact of this?

It might be worth adding a benchmark and seeing if this noticeably regresses it.

[nweiz, 2016/03/08 22:01:15]

I doubt the performance impact is that high—it's hard to imagine that path
munging could overshadow IO, and p.relative has been pretty heavily
optimized—but also, this is just more correct than the previous version. Even if
it turns out to be substantially slower, there's not much we can do with that
information.

I'm also generally not a fan of adding benchmarking infrastructure to stuff that
we don't know to be performance-critical anywhere. It's extra work, and it can
lead to premature optimization (like this substring thing!).

     }
 
     var resultPool = new StreamPool();
 
     // 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),
             followLinks: followLinks));
       });
       resultPool.closeWhenEmpty();
       return resultPool.stream;
     }
 
     var resultController = new StreamController(sync: true);
     resultPool.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
@@ skipping 14 matching lines @@
 
   /// 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);
       });
     }
 
     return new Directory(dir).listSync(followLinks: followLinks)
         .expand((entity) {
       var entities = [];
-      var basename = entity.path.substring(dir.length + 1);
+      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 28 matching lines @@
 SequenceNode _join(Iterable<AstNode> components) {
   var componentsList = components.toList();
   var first = componentsList.removeAt(0);
   var nodes = [first];
   for (var component in componentsList) {
     nodes.add(new LiteralNode('/', caseSensitive: first.caseSensitive));
     nodes.add(component);
   }
   return new SequenceNode(nodes, caseSensitive: first.caseSensitive);
 }