Allow physical folder resources to be watched for changes to their contents.

pkg/analysis_server/lib/src/resource.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 resource;
 
+import 'dart:async';
 import 'dart:io' as io;
 
 import 'package:analyzer/src/generated/engine.dart' show TimestampedData;
 import 'package:analyzer/src/generated/java_io.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:path/path.dart';
+import 'package:watcher/watcher.dart';
 
 
 /**
  * [File]s are leaf [Resource]s which contain data.
  */
 abstract class File extends Resource {
   /**
    * Create a new [Source] instance that serves this file.
    */
   Source createSource(UriKind uriKind);
 }
 
 
 /**
  * [Folder]s are [Resource]s which may contain files and/or other folders.
  */
 abstract class Folder extends Resource {
   /**
    * Return an existing child [Resource] with the given [relPath].
    * Return a not existing [File] if no such child exist.
    */
   Resource getChild(String relPath);
 
   /**
    * Return a list of existing direct children [Resource]s (folders and files)
    * in this folder, in no particular order.
    */
   List<Resource> getChildren();
+
+  /**
+   * Watch for changes to the files inside this folder (and in any nested
+   * folders, including folders reachable via links).
+   */
+  Stream<WatchEvent> get changes;
 }
 
 
 /**
  * The abstract class [Resource] is an abstraction of file or folder.
  */
 abstract class Resource {
   /**
    * Return `true` if this resource exists.
    */
@@ skipping 175 matching lines @@
   @override
   List<Resource> getChildren() {
     List<Resource> children = <Resource>[];
     _provider._pathToResource.forEach((path, resource) {
       if (posix.dirname(path) == _path) {
         children.add(resource);
       }
     });
     return children;
   }
+
+  @override
+  Stream<WatchEvent> get changes {
+    // TODO(paulberry): implement.
+    return new StreamController<WatchEvent>().stream;
+  }
 }
 
 
 /**
  * An in-memory implementation of [ResourceProvider].
  * Use `/` as a path separator.
  */
 class MemoryResourceProvider implements ResourceProvider {
   final Map<String, _MemoryResource> _pathToResource = <String, _MemoryResource>{};
   final Map<String, String> _pathToContent = <String, String>{};
@@ skipping 90 matching lines @@
     for (int i = 0; i < numEntries; i++) {
       io.FileSystemEntity entity = entries[i];
       if (entity is io.Directory) {
         children.add(new _PhysicalFolder(entity));
       } else if (entity is io.File) {
         children.add(new _PhysicalFile(entity));
       }
     }
     return children;
   }
+
+  @override
+  Stream<WatchEvent> get changes => new DirectoryWatcher(_entry.path).events;
 }
 
 
 /**
  * A `dart:io` based implementation of [Resource].
  */
 abstract class _PhysicalResource implements Resource {
   final io.FileSystemEntity _entry;
 
   _PhysicalResource(this._entry);
@@ skipping 27 matching lines @@
   Resource getResource(String path) {
     if (io.FileSystemEntity.isDirectorySync(path)) {
       io.Directory directory = new io.Directory(path);
       return new _PhysicalFolder(directory);
     } else {
       io.File file = new io.File(path);
       return new _PhysicalFile(file);
     }
   }
 }