Implement "analysis.reanalyze" in analysis server.

pkg/analysis_server/test/context_manager_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.
 
 library test.context.directory.manager;
 
 import 'package:analysis_server/src/context_manager.dart';
 import 'reflective_tests.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/memory_file_system.dart';
@@ skipping 60 matching lines @@
   void test_isInAnalysisRoot_inRoot() {
     manager.setRoots(<String>[projPath], <String>[]);
     expect(manager.isInAnalysisRoot('$projPath/test.dart'), isTrue);
   }
 
   void test_isInAnalysisRoot_notInRoot() {
     manager.setRoots(<String>[projPath], <String>[]);
     expect(manager.isInAnalysisRoot('/test.dart'), isFalse);
   }
 
+  test_refresh_folder_with_pubspec() {
+    // create a context with a pubspec.yaml file
+    String pubspecPath = posix.join(projPath, 'pubspec.yaml');
+    resourceProvider.newFile(pubspecPath, 'pubspec');
+    manager.setRoots(<String>[projPath], <String>[]);
+    return pumpEventQueue().then((_) {
+      expect(manager.currentContextPaths.toList(), [projPath]);
+      manager.now++;
+      manager.refresh();
+      return pumpEventQueue().then((_) {
+        expect(manager.currentContextPaths.toList(), [projPath]);
+        expect(manager.currentContextTimestamps[projPath], manager.now);
+      });
+    });
+  }
+
+  test_refresh_folder_with_pubspec_subfolders() {
+    // Create a folder with no pubspec.yaml, containing two subfolders with
+    // pubspec.yaml files.
+    String subdir1Path = posix.join(projPath, 'subdir1');
+    String subdir2Path = posix.join(projPath, 'subdir2');
+    String pubspec1Path = posix.join(subdir1Path, 'pubspec.yaml');
+    String pubspec2Path = posix.join(subdir2Path, 'pubspec.yaml');
+    resourceProvider.newFile(pubspec1Path, 'pubspec');
+    resourceProvider.newFile(pubspec2Path, 'pubspec');
+    manager.setRoots(<String>[projPath], <String>[]);
+    return pumpEventQueue().then((_) {
+      expect(manager.currentContextPaths.toSet(),
+          [projPath, subdir1Path, subdir2Path].toSet());
+      manager.now++;
+      manager.refresh();
+      return pumpEventQueue().then((_) {
+        expect(manager.currentContextPaths.toSet(),
+          [projPath, subdir1Path, subdir2Path].toSet());
+        expect(manager.currentContextTimestamps[projPath], manager.now);
+        expect(manager.currentContextTimestamps[subdir1Path], manager.now);
+        expect(manager.currentContextTimestamps[subdir2Path], manager.now);
+      });
+    });
+  }
+
   void test_setRoots_addFolderWithDartFile() {
     String filePath = posix.join(projPath, 'foo.dart');
     resourceProvider.newFile(filePath, 'contents');
     manager.setRoots(<String>[projPath], <String>[]);
     // verify
     var filePaths = manager.currentContextFilePaths[projPath];
     expect(filePaths, hasLength(1));
     expect(filePaths, contains(filePath));
   }
 
@@ skipping 540 matching lines @@
   }
 }
 
 
 class TestContextManager extends ContextManager {
   /**
    * Source of timestamps stored in [currentContextFilePaths].
    */
   int now = 0;
 
-  final Set<String> currentContextPaths = new Set<String>();
+  /**
+   * Map from context to the timestamp when the context was created.
+   */
+  Map<String, int> currentContextTimestamps = <String, int>{};
+
+  /**
+   * Iterable of the paths to contexts that currently exist.
+   */
+  Iterable<String> get currentContextPaths => currentContextTimestamps.keys;
 
   /**
    * Map from context to (map from file path to timestamp of last event).
    */
   final Map<String, Map<String, int>> currentContextFilePaths = <String,
       Map<String, int>>{};
 
   /**
    * Map from context to package map.
    */
   final Map<String, Map<String, List<Folder>>> currentContextPackageMaps =
       <String, Map<String, List<Folder>>>{};
 
   TestContextManager(MemoryResourceProvider resourceProvider,
       PackageMapProvider packageMapProvider)
       : super(resourceProvider, packageMapProvider);
 
   @override
   void addContext(Folder folder, Map<String, List<Folder>> packageMap) {
     String path = folder.path;
-    currentContextPaths.add(path);
+    expect(currentContextPaths, isNot(contains(path)));
+    currentContextTimestamps[path] = now;
     currentContextFilePaths[path] = <String, int>{};
     currentContextPackageMaps[path] = packageMap;
   }
 
   @override
   void applyChangesToContext(Folder contextFolder, ChangeSet changeSet) {
     Map<String, int> filePaths = currentContextFilePaths[contextFolder.path];
     for (Source source in changeSet.addedSources) {
       expect(filePaths, isNot(contains(source.fullName)));
       filePaths[source.fullName] = now;
@@ skipping 13 matching lines @@
     expect(actualFiles, unorderedEquals(expectedFiles));
   }
 
   void assertContextPaths(List<String> expected) {
     expect(currentContextPaths, unorderedEquals(expected));
   }
 
   @override
   void removeContext(Folder folder) {
     String path = folder.path;
-    currentContextPaths.remove(path);
+    expect(currentContextPaths, contains(path));
+    currentContextTimestamps.remove(path);
     currentContextFilePaths.remove(path);
     currentContextPackageMaps.remove(path);
   }
 
   @override
   void updateContextPackageMap(Folder contextFolder, Map<String,
       List<Folder>> packageMap) {
     currentContextPackageMaps[contextFolder.path] = packageMap;
   }
 }