Add a caseSensitive flag to new 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:path/path.dart' as p;
@@ skipping 216 matching lines @@
   ///
   /// 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}) {
@@ skipping 102 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);
 }