Update charted to 0.4.8 and roll

packages/glob/test/list_test.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:async';
 import 'dart:io';
 
 import 'package:glob/glob.dart';
 import 'package:glob/src/utils.dart';
 import 'package:path/path.dart' as p;
@@ skipping 34 matching lines @@
     });
 
     test("reports exceptions for non-existent directories", () {
       schedule(() {
         expect(new Glob("non/existent/**").listSync,
             throwsA(new isInstanceOf<FileSystemException>()));
       });
     });
   });
 
+  group("when case-sensitive", () {
+    test("lists literals case-sensitively", () {
+      schedule(() {
+        expect(new Glob("foo/BAZ/qux", caseSensitive: true).listSync,
+            throwsA(new isInstanceOf<FileSystemException>()));
+      });
+    });
+
+    test("lists ranges case-sensitively", () {
+      schedule(() {
+        expect(new Glob("foo/[BX][A-Z]z/qux", caseSensitive: true).listSync,
+            throwsA(new isInstanceOf<FileSystemException>()));
+      });
+    });
+
+    test("options preserve case-sensitivity", () {
+      schedule(() {
+        expect(new Glob("foo/{BAZ,ZAP}/qux", caseSensitive: true).listSync,
+            throwsA(new isInstanceOf<FileSystemException>()));
+      });
+    });
+  });
+
   syncAndAsync((list) {
     group("literals", () {
       test("lists a single literal", () {
         expect(list("foo/baz/qux"),
             completion(equals([p.join("foo", "baz", "qux")])));
       });
 
       test("lists a non-matching literal", () {
         expect(list("foo/baz/nothing"), completion(isEmpty));
       });
@@ skipping 180 matching lines @@
         var pattern = separatorToForwardSlash(
             p.absolute(p.join(sandbox, 'foo/baz/**')));
 
         return list(pattern);
       }), completion(unorderedEquals([
         p.join("foo", "baz", "bang"),
         p.join("foo", "baz", "qux")
       ])));
     });
 
+    // Regression test for #4.
+    test("lists an absolute case-insensitive glob", () {
+      expect(schedule(() {
+        var pattern = separatorToForwardSlash(
+            p.absolute(p.join(sandbox, 'foo/Baz/**')));
+
+        return list(pattern, caseSensitive: false);
+      }), completion(unorderedEquals([
+        p.join("foo", "baz", "bang"),
+        p.join("foo", "baz", "qux")
+      ])));
+    });
+
     test("lists a subdirectory that sometimes exists", () {
       d.dir("top", [
         d.dir("dir1", [
           d.dir("subdir", [d.file("file")])
         ]),
         d.dir("dir2", [])
       ]).create();
 
       expect(list("top/*/subdir/**"),
           completion(equals([p.join("top", "dir1", "subdir", "file")])));
     });
+
+    group("when case-insensitive", () {
+      test("lists literals case-insensitively", () {
+        expect(list("foo/baz/qux", caseSensitive: false),
+            completion(equals([p.join("foo", "baz", "qux")])));
+        expect(list("foo/BAZ/qux", caseSensitive: false),
+            completion(equals([p.join("foo", "baz", "qux")])));
+      });
+
+      test("lists ranges case-insensitively", () {
+        expect(list("foo/[bx][a-z]z/qux", caseSensitive: false),
+            completion(equals([p.join("foo", "baz", "qux")])));
+        expect(list("foo/[BX][A-Z]z/qux", caseSensitive: false),
+            completion(equals([p.join("foo", "baz", "qux")])));
+      });
+
+      test("options preserve case-insensitivity", () {
+        expect(list("foo/{bar,baz}/qux", caseSensitive: false),
+            completion(equals([p.join("foo", "baz", "qux")])));
+        expect(list("foo/{BAR,BAZ}/qux", caseSensitive: false),
+            completion(equals([p.join("foo", "baz", "qux")])));
+      });
+    });
   });
 }
 
 typedef Future<List<String>> ListFn(String glob,
-    {bool recursive, bool followLinks});
+    {bool recursive, bool followLinks, bool caseSensitive});
 
 /// Runs [callback] in two groups with two values of [listFn]: one that uses
 /// [Glob.list], one that uses [Glob.listSync].
 void syncAndAsync(callback(ListFn listFn)) {
   group("async", () {
-    callback((glob, {recursive: false, followLinks: true}) {
+    callback((pattern, {recursive: false, followLinks: true, caseSensitive}) {
       return schedule(() {
-        return new Glob(glob, recursive: recursive)
+        var glob = new Glob(pattern,
+            recursive: recursive, caseSensitive: caseSensitive);
+
+        return glob
             .list(root: sandbox, followLinks: followLinks)
             .map((entity) => p.relative(entity.path, from: sandbox))
             .toList();
-      }, 'listing $glob');
+      }, 'listing $pattern');
     });
   });
 
   group("sync", () {
-    callback((glob, {recursive: false, followLinks: true}) {
+    callback((pattern, {recursive: false, followLinks: true, caseSensitive}) {
       return schedule(() {
-        return new Glob(glob, recursive: recursive)
+        var glob = new Glob(pattern,
+            recursive: recursive, caseSensitive: caseSensitive);
+
+        return glob
             .listSync(root: sandbox, followLinks: followLinks)
             .map((entity) => p.relative(entity.path, from: sandbox))
             .toList();
-      }, 'listing $glob');
+      }, 'listing $pattern');
     });
   });
 }
 
 void scheduleSandbox() {
   schedule(() {
     return Directory.systemTemp.createTemp('glob_').then((dir) {
       sandbox = dir.path;
       d.defaultRoot = sandbox;
     });
   }, 'creating sandbox');
 
   currentSchedule.onComplete.schedule(() {
     d.defaultRoot = null;
     if (sandbox == null) return null;
     var oldSandbox = sandbox;
     sandbox = null;
     return new Directory(oldSandbox).delete(recursive: true);
   });
 }