Update charted to 0.4.8 and roll

packages/watcher/lib/src/directory_watcher/mac_os.dart

 // Copyright (c) 2013, 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 watcher.directory_watcher.mac_os;
-
 import 'dart:async';
 import 'dart:io';
 
 import '../directory_watcher.dart';
 import '../constructable_file_system_event.dart';
 import '../path_set.dart';
 import '../resubscribable.dart';
 import '../utils.dart';
 import '../watch_event.dart';
 
@@ skipping 34 matching lines @@
   /// The state of files on the filesystem is compared against this to determine
   /// the real change that occurred when working around issue 14373. This is
   /// also used to emit REMOVE events when subdirectories are moved out of the
   /// watched directory.
   final PathSet _files;
 
   /// The subscription to the stream returned by [Directory.watch].
   ///
   /// This is separate from [_subscriptions] because this stream occasionally
   /// needs to be resubscribed in order to work around issue 14849.
-  StreamSubscription<FileSystemEvent> _watchSubscription;
+  StreamSubscription<List<FileSystemEvent>> _watchSubscription;
 
   /// The subscription to the [Directory.list] call for the initial listing of
   /// the directory to determine its initial state.
   StreamSubscription<FileSystemEntity> _initialListSubscription;
 
   /// The subscriptions to [Directory.list] calls for listing the contents of a
   /// subdirectory that was moved into the watched directory.
   final _listSubscriptions = new Set<StreamSubscription<FileSystemEntity>>();
 
   /// The timer for tracking how long we wait for an initial batch of bogus
@@ skipping 37 matching lines @@
     // it's probable that it's a batch of pre-watcher events (see issue 14373).
     // Ignore those events and re-list the directory.
     if (!isReady) {
       // Cancel the timer because bogus events only occur in the first batch, so
       // we can fire [ready] as soon as we're done listing the directory.
       _bogusEventTimer.cancel();
       _listDir().then((_) => _readyCompleter.complete());
       return;
     }
 
-    _sortEvents(batch).forEach((path, events) {
-      var canonicalEvent = _canonicalEvent(events);
-      events = canonicalEvent == null ?
+    _sortEvents(batch).forEach((path, eventSet) {
+      var canonicalEvent = _canonicalEvent(eventSet);
+      var events = canonicalEvent == null ?
           _eventsBasedOnFileSystem(path) : [canonicalEvent];
 
       for (var event in events) {
         if (event is FileSystemCreateEvent) {
           if (!event.isDirectory) {
             // If we already know about the file, treat it like a modification.
             // This can happen if a file is copied on top of an existing one.
             // We'll see an ADD event for the latter file when from the user's
             // perspective, the file's contents just changed.
             var type = _files.contains(path)
                 ? ChangeType.MODIFY
                 : ChangeType.ADD;
 
             _emitEvent(type, path);
             _files.add(path);
             continue;
           }
 
           if (_files.containsDir(path)) continue;
 
-          var subscription;
+          StreamSubscription<FileSystemEntity> subscription;
           subscription = new Directory(path).list(recursive: true)
               .listen((entity) {
             if (entity is Directory) return;
             if (_files.contains(path)) return;
 
             _emitEvent(ChangeType.ADD, entity.path);
             _files.add(entity.path);
           }, onError: (e, stackTrace) {
             _emitError(e, stackTrace);
           }, onDone: () {
@@ skipping 15 matching lines @@
 
   /// Sort all the events in a batch into sets based on their path.
   ///
   /// A single input event may result in multiple events in the returned map;
   /// for example, a MOVE event becomes a DELETE event for the source and a
   /// CREATE event for the destination.
   ///
   /// The returned events won't contain any [FileSystemMoveEvent]s, nor will it
   /// contain any events relating to [path].
   Map<String, Set<FileSystemEvent>> _sortEvents(List<FileSystemEvent> batch) {
-    var eventsForPaths = {};
+    var eventsForPaths = <String, Set>{};
 
     // FSEvents can report past events, including events on the root directory
     // such as it being created. We want to ignore these. If the directory is
     // really deleted, that's handled by [_onDone].
     batch = batch.where((event) => event.path != path).toList();
 
     // Events within directories that already have events are superfluous; the
     // directory's full contents will be examined anyway, so we ignore such
     // events. Emitting them could cause useless or out-of-order events.
     var directories = unionAll(batch.map((event) {
       if (!event.isDirectory) return new Set();
-      if (event is! FileSystemMoveEvent) return new Set.from([event.path]);
-      return new Set.from([event.path, event.destination]);
+      if (event is FileSystemMoveEvent) {
+        return new Set.from([event.path, event.destination]);
+      }
+      return new Set.from([event.path]);
     }));
 
     isInModifiedDirectory(path) =>
         directories.any((dir) => path != dir && path.startsWith(dir));
 
     addEvent(path, event) {
       if (isInModifiedDirectory(path)) return;
       var set = eventsForPaths.putIfAbsent(path, () => new Set());
       set.add(event);
     }
@@ skipping 85 matching lines @@
   /// This returns a list whose order should be reflected in the events emitted
   /// to the user, unlike the batched events from [Directory.watch]. The
   /// returned list may be empty, indicating that no changes occurred to [path]
   /// (probably indicating that it was created and then immediately deleted).
   List<FileSystemEvent> _eventsBasedOnFileSystem(String path) {
     var fileExisted = _files.contains(path);
     var dirExisted = _files.containsDir(path);
     var fileExists = new File(path).existsSync();
     var dirExists = new Directory(path).existsSync();
 
-    var events = [];
+    var events = <FileSystemEvent>[];
     if (fileExisted) {
       if (fileExists) {
         events.add(new ConstructableFileSystemModifyEvent(path, false, false));
       } else {
         events.add(new ConstructableFileSystemDeleteEvent(path, false));
       }
     } else if (dirExisted) {
       if (dirExists) {
         // If we got contradictory events for a directory that used to exist and
         // still exists, we need to rescan the whole thing in case it was
@@ skipping 22 matching lines @@
     // this is probably issue 14849 rather than a real close event. We should
     // just restart the watcher.
     if (!isReady && new Directory(path).existsSync()) {
       _startWatch();
       return;
     }
 
     // FSEvents can fail to report the contents of the directory being removed
     // when the directory itself is removed, so we need to manually mark the
     // files as removed.
-    for (var file in _files.toSet()) {
+    for (var file in _files.paths) {
       _emitEvent(ChangeType.REMOVE, file);
     }
     _files.clear();
     close();
   }
 
   /// Start or restart the underlying [Directory.watch] stream.
   void _startWatch() {
     // Batch the FSEvent changes together so that we can dedup events.
     var innerStream = new Directory(path).watch(recursive: true)
@@ skipping 39 matching lines @@
     if (!isReady) return;
     _eventsController.add(new WatchEvent(type, path));
   }
 
   /// Emit an error, then close the watcher.
   void _emitError(error, StackTrace stackTrace) {
     _eventsController.addError(error, stackTrace);
     close();
   }
 }