Add support for listing to the glob package.

pkg/glob/lib/glob.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;
 
+import 'dart:async';
+import 'dart:io';
+
 import 'package:path/path.dart' as p;
 
 import 'src/ast.dart';
+import 'src/list_tree.dart';
 import 'src/parser.dart';
 import 'src/utils.dart';
 
 /// Regular expression used to quote globs.
 final _quoteRegExp = new RegExp(r'[*{[?\\}\],\-()]');
 
-// TODO(nweiz): Add [list] and [listSync] methods.
 /// A glob for matching and listing files and directories.
 ///
 /// A glob matches an entire string as a path. Although the glob pattern uses
 /// POSIX syntax, it can match against POSIX, Windows, or URL paths. The format
 /// it expects paths to use is based on the `context` parameter to [new Glob];
 /// it defaults to the current system's syntax.
 ///
 /// Paths are normalized before being matched against a glob, so for example the
 /// glob `foo/bar` matches the path `foo/./bar`. A relative glob can match an
 /// absolute path and vice versa; globs and paths are both interpreted as
@@ skipping 11 matching lines @@
   /// The context in which paths matched against this glob are interpreted.
   final p.Context context;
 
   /// If true, a path matches if it matches the glob itself or is recursively
   /// contained within a directory that matches.
   final bool recursive;
 
   /// The parsed AST of the glob.
   final AstNode _ast;
 
+  ListTree _listTree;
+
   /// Whether [context]'s current directory is absolute.
   bool get _contextIsAbsolute {
     if (_contextIsAbsoluteCache == null) {
       _contextIsAbsoluteCache = context.isAbsolute(context.current);
     }
     return _contextIsAbsoluteCache;
   }
   bool _contextIsAbsoluteCache;
 
   /// Whether [pattern] could match absolute paths.
@@ skipping 33 matching lines @@
           recursive);
 
   // Internal constructor used to fake local variables for [context] and [ast].
   Glob._(String pattern, p.Context context, bool recursive)
       : pattern = pattern,
         context = context,
         recursive = recursive,
         _ast = new Parser(pattern + (recursive ? "{,/**}" : ""), context)
             .parse();
 
+  /// Lists all [FileSystemEntity]s beneath [root] that match the glob.
+  ///
+  /// This works much like [Directory.list], but it only lists directories that
+  /// could contain entities that match the glob. It provides no guarantees
+  /// about the order of the returned entities, although it does guarantee that
+  /// only one entity with a given path will be returned.
+  ///
+  /// [root] defaults to the current working directory.
+  ///
+  /// [followLinks] works the same as for [Directory.list].
+  Stream<FileSystemEntity> list({String root, bool followLinks: true}) {
+    if (context.style != p.style) {
+      throw new StateError("Can't list glob \"$this\"; it matches "
+          "${context.style} paths, but this platform uses ${p.style} paths.");
+    }
+
+    if (_listTree == null) _listTree = new ListTree(_ast);
+    return _listTree.list(root: root, followLinks: followLinks);
+  }
+
+  /// Synchronously lists all [FileSystemEntity]s beneath [root] that match the
+  /// glob.
+  ///
+  /// This works much like [Directory.listSync], but it only lists directories
+  /// that could contain entities that match the glob. It provides no guarantees
+  /// about the order of the returned entities, although it does guarantee that
+  /// only one entity with a given path will be returned.
+  ///
+  /// [root] defaults to the current working directory.
+  ///
+  /// [followLinks] works the same as for [Directory.list].
+  List<FileSystemEntity> listSync({String root, bool followLinks: true}) {
+    if (context.style != p.style) {
+      throw new StateError("Can't list glob \"$this\"; it matches "
+          "${context.style} paths, but this platform uses ${p.style} paths.");
+    }
+
+    if (_listTree == null) _listTree = new ListTree(_ast);
+    return _listTree.listSync(root: root, followLinks: followLinks);
+  }
+
   /// Returns whether this glob matches [path].
   bool matches(String path) => matchAsPrefix(path) != null;
 
   Match matchAsPrefix(String path, [int start = 0]) {
     // Globs are like anchored RegExps in that they only match entire paths, so
     // if the match starts anywhere after the first character it can't succeed.
     if (start != 0) return null;
 
     if (_patternCanMatchAbsolute &&
         (_contextIsAbsolute || context.isAbsolute(path))) {
@@ skipping 20 matching lines @@
     return path;
   }
 
   Iterable<Match> allMatches(String path, [int start = 0]) {
     var match = matchAsPrefix(path, start);
     return match == null ? [] : [match];
   }
 
   String toString() => pattern;
 }