Add a caseSensitive flag to new 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;
@@ skipping 27 matching lines @@
   /// The pattern used to create this glob.
   final String pattern;
 
   /// 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;
 
+  /// Whether the glob matches paths case-sensitively.
+  bool get caseSensitive => _ast.caseSensitive;
+
   /// 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);
     }
@@ skipping 22 matching lines @@
   /// Returns [contents] with characters that are meaningful in globs
   /// backslash-escaped.
   static String quote(String contents) =>
       contents.replaceAllMapped(_quoteRegExp, (match) => '\\${match[0]}');
 
   /// Creates a new glob with [pattern].
   ///
   /// Paths matched against the glob are interpreted according to [context]. It
   /// defaults to the system context.
   ///
-  /// If [recursive] is true, this glob will match and list not only the files
-  /// and directories it explicitly lists, but anything beneath those as well.
-  Glob(String pattern, {p.Context context, bool recursive: false})
-      : this._(
-          pattern,
-          context == null ? p.context : context,
-          recursive);
+  /// If [recursive] is true, this glob matches and lists not only the files and
+  /// directories it explicitly matches, but anything beneath those as well.
+  ///
+  /// If [caseSensitive] is true, this glob matches and lists only files whose
+  /// case matches that of the characters in the glob. Otherwise, it matches
+  /// regardless of case. This defaults to `false` when [context] is Windows and
+  /// `true` otherwise.
+  factory Glob(String pattern, {p.Context context, bool recursive: false,
+      bool caseSensitive}) {
+    context ??= p.context;
+    caseSensitive ??= context.style == p.Style.windows ? false : true;
+    if (recursive) pattern += "{,/**}";
 
-  // 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();
+    var parser = new Parser(pattern, context, caseSensitive: caseSensitive);
+    return new Glob._(pattern, context, parser.parse(), recursive);
+  }
+
+  Glob._(this.pattern, this.context, this._ast, this.recursive);
 
   /// 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.
   ///
@@ skipping 55 matching lines @@
     return null;
   }
 
   Iterable<Match> allMatches(String path, [int start = 0]) {
     var match = matchAsPrefix(path, start);
     return match == null ? [] : [match];
   }
 
   String toString() => pattern;
 }