cache pub list results

pkg/analyzer/lib/file_system/memory_file_system.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 memory_file_system;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/engine.dart' show TimestampedData;
@@ skipping 29 matching lines @@
       new HashMap<String, _MemoryResource>();
   final Map<String, String> _pathToContent = new HashMap<String, String>();
   final Map<String, int> _pathToTimestamp = new HashMap<String, int>();
   final Map<String, List<StreamController<WatchEvent>>> _pathToWatchers =
       new HashMap<String, List<StreamController<WatchEvent>>>();
   int nextStamp = 0;
 
   @override
   Context get pathContext => posix;
 
+  /**
+   * Simulate revoked file access
+   * and return an object that can be passed to [restore].
+   */
+  clear() {
+    var restorePoint = new _MemoryRestorePoint(this);
+    _pathToResource.clear();
+    _pathToContent.clear();
+    _pathToTimestamp.clear();
+    // TODO(danrubel) notify watchers
+    return restorePoint;
+  }
+
+  /**
+   * Simulate restored file access based upon some earlier call to [clear].
+   */
+  void restore(var restorePoint) {
+    _pathToResource.clear();
+    _pathToContent.clear();
+    _pathToTimestamp.clear();
+    (restorePoint as _MemoryRestorePoint).restore(this);
+    // TODO(danrubel) notify watchers
+  }
+
   void deleteFile(String path) {
     _checkFileAtPath(path);
     _pathToResource.remove(path);
     _pathToContent.remove(path);
     _pathToTimestamp.remove(path);
     _notifyWatchers(path, ChangeType.REMOVE);
   }
 
   @override
   Resource getResource(String path) {
@@ skipping 82 matching lines @@
             {
           streamController.add(new WatchEvent(changeType, path));
         }
       }
     });
   }
 }
 
 
 /**
+ * A restore point captures the [MemoryResourceProvider] state
+ * so that it can be restored at later point.
+ */
+class _MemoryRestorePoint {

[Paul Berry, 2015/02/20 22:00:26]

I'm not really comfortable adding this level of transactional support to the
memory file system, especially given that (a) I don't see it being used very
often, and (b) it doesn't notify watchers properly.

How about if instead we just add optional "timestamp" arguments to the newFile
and newFolder functions above, which allow specifying the timestamp of the
files/folders to be created.  That would be sufficient for the testing you're
trying to do in this CL, and it would preserve correct file watching semantics.

[danrubel, 2015/02/21 03:09:30]

How do we simulate revoked and restored access? That's what I'm trying to test
with this code.

[Paul Berry, 2015/02/23 18:54:58]

I was imagining that in the 'project removed then restored' test, before the
call to resProvider.clear(), we would make a note of the timestamps of
/tmp/proj1/packages/foo, /tmp/proj1/pubspec.yaml, and the parent directories
/tmp/proj1/packages and /tmp/proj1.  Then, instead of calling
resProvider.restore(restorePoint), we would simply call resProvider.newFile and
resProvider.newFolder to recreate the files and folders, supplying the old
timestamps so that they files and folders don't look new.

It should behave precisely the same as what you've written, with the
disadvantage that it's a little less general (since you have to hardcode the
specific files and folders to be created/destroyed in the test) and the
advantage that the watchers will be notified properly.

[danrubel, 2015/02/24 02:29:45]

I have moved this functionality into the test itself.

+  final Map<String, _MemoryResource> _pathToResource =
+      new HashMap<String, _MemoryResource>();
+  final Map<String, String> _pathToContent = new HashMap<String, String>();
+  final Map<String, int> _pathToTimestamp = new HashMap<String, int>();
+
+  _MemoryRestorePoint(MemoryResourceProvider provider) {
+    _pathToResource.addAll(provider._pathToResource);
+    _pathToContent.addAll(provider._pathToContent);
+    _pathToTimestamp.addAll(provider._pathToTimestamp);
+  }
+
+  void restore(MemoryResourceProvider provider) {
+    provider._pathToResource.addAll(_pathToResource);
+    provider._pathToContent.addAll(_pathToContent);
+    provider._pathToTimestamp.addAll(_pathToTimestamp);
+  }
+}
+
+
+/**
  * An in-memory implementation of [File] which acts like a symbolic link to a
  * non-existent file.
  */
 class _MemoryDummyLink extends _MemoryResource implements File {
   _MemoryDummyLink(MemoryResourceProvider provider, String path)
       : super(provider, path);
 
   @override
   bool get exists => false;
 
@@ skipping 214 matching lines @@
   bool operator ==(other) {
     if (runtimeType != other.runtimeType) {
       return false;
     }
     return path == other.path;
   }
 
   @override
   String toString() => path;
 }