Introduce TestReaderWriter with test-specific API.

Move `FilesystemCache` and `AssetPathProvider` out of `Filesystem` and into
the `Reader` classes.

Author: davidmorgan

_test_common/lib/in_memory_reader_writer.dart

@@ -7,6 +7,8 @@ import 'dart:convert';
 import 'package:build/build.dart';
 import 'package:build_runner_core/build_runner_core.dart';
 import 'package:build_test/build_test.dart';
+// ignore: implementation_imports
+import 'package:build_test/src/in_memory_reader_writer.dart';
 import 'package:path/path.dart' as p;
 import 'package:watcher/watcher.dart';
 
@@ -26,7 +28,7 @@ class InMemoryRunnerAssetReaderWriter extends InMemoryAssetReaderWriter
 
   @override
   Future writeAsBytes(AssetId id, List<int> bytes) async {
-    var type = assets.containsKey(id) ? ChangeType.MODIFY : ChangeType.ADD;
+    var type = testing.exists(id) ? ChangeType.MODIFY : ChangeType.ADD;
     await super.writeAsBytes(id, bytes);
     FakeWatcher.notifyWatchers(
       WatchEvent(type, p.absolute(id.package, p.fromUri(id.path))),
@@ -39,7 +41,7 @@ class InMemoryRunnerAssetReaderWriter extends InMemoryAssetReaderWriter
     String contents, {
     Encoding encoding = utf8,
   }) async {
-    var type = assets.containsKey(id) ? ChangeType.MODIFY : ChangeType.ADD;
+    var type = testing.exists(id) ? ChangeType.MODIFY : ChangeType.ADD;
     await super.writeAsString(id, contents, encoding: encoding);
     FakeWatcher.notifyWatchers(
       WatchEvent(type, p.absolute(id.package, p.fromUri(id.path))),
@@ -49,7 +51,7 @@ class InMemoryRunnerAssetReaderWriter extends InMemoryAssetReaderWriter
   @override
   Future delete(AssetId id) async {
     onDelete?.call(id);
-    assets.remove(id);
+    testing.delete(id);
     FakeWatcher.notifyWatchers(
       WatchEvent(ChangeType.REMOVE, p.absolute(id.package, p.fromUri(id.path))),
     );

_test_common/lib/test_phases.dart

@@ -116,9 +116,9 @@ Future<TestBuildersResult> testBuilders(
   inputs.forEach((serializedId, contents) {
     var id = makeAssetId(serializedId);
     if (contents is String) {
-      readerWriter.filesystem.writeAsStringSync(id, contents);
+      readerWriter.testing.writeString(id, contents);
     } else if (contents is List<int>) {
-      readerWriter.filesystem.writeAsBytesSync(id, contents);
+      readerWriter.testing.writeBytes(id, contents);
     }
   });
 
@@ -179,7 +179,7 @@ Future<TestBuildersResult> testBuilders(
 void checkBuild(
   BuildResult result, {
   Map<String, Object>? outputs,
-  required InMemoryAssetReaderWriter readerWriter,
+  required TestReaderWriter readerWriter,
   BuildStatus status = BuildStatus.success,
   String rootPackage = 'a',
   String expectedGeneratedDir = 'generated',

build/lib/src/builder/build_step_impl.dart

@@ -100,6 +100,9 @@ class BuildStepImpl implements BuildStep, AssetReaderState {
   @override
   Filesystem get filesystem => _reader.filesystem;
 
+  @override
+  FilesystemCache get cache => _reader.cache;
+
   @override
   AssetFinder get assetFinder => _reader.assetFinder;
 

build/lib/src/state/filesystem.dart

@@ -8,58 +8,44 @@ import 'dart:typed_data';
 
 import 'package:pool/pool.dart';
 
-import '../asset/id.dart';
-import 'asset_path_provider.dart';
-import 'filesystem_cache.dart';
-
 /// The filesystem the build is running on.
 ///
 /// Methods behave as the `dart:io` methods with the same names, with some
 /// exceptions noted in the docs.
-///
-/// Some methods cache, all uses of the cache are noted in the docs.
-///
-/// The cache might be a [PassthroughFilesystemCache] in which case it has no
-/// effect.
-///
-/// TODO(davidmorgan): extend caching to sync methods, deletes, writes.
 abstract interface class Filesystem {
-  FilesystemCache get cache;
-
-  /// Returns a new instance with optionally updated [cache].
-  Filesystem copyWith({FilesystemCache? cache});
+  /// Whether the file exists.
+  Future<bool> exists(String path);
 
   /// Whether the file exists.
-  ///
-  /// Uses [cache].
-  Future<bool> exists(AssetId id);
+  bool existsSync(String path);
 
   /// Reads a file as a string.
-  ///
-  /// Uses [cache]. For `utf8`, the `String` is cached; for any other encoding
-  /// the bytes are cached but the conversion runs on every read.
-  Future<String> readAsString(AssetId id, {Encoding encoding = utf8});
+  Future<String> readAsString(String path, {Encoding encoding = utf8});
+
+  /// Reads a file as a string.
+  String readAsStringSync(String path, {Encoding encoding = utf8});
 
   /// Reads a file as bytes.
-  ///
-  /// Uses [cache].
-  Future<Uint8List> readAsBytes(AssetId id);
+  Future<Uint8List> readAsBytes(String path);
+
+  /// Reads a file as bytes.
+  Uint8List readAsBytesSync(String path);
 
   /// Deletes a file.
   ///
   /// If the file does not exist, does nothing.
-  Future<void> delete(AssetId id);
+  Future<void> delete(String path);
 
   /// Deletes a file.
   ///
   /// If the file does not exist, does nothing.
-  void deleteSync(AssetId id);
+  void deleteSync(String path);
 
   /// Writes a file.
   ///
   /// Creates enclosing directories as needed if they don't exist.
   void writeAsStringSync(
-    AssetId id,
+    String path,
     String contents, {
     Encoding encoding = utf8,
   });
@@ -68,205 +54,165 @@ abstract interface class Filesystem {
   ///
   /// Creates enclosing directories as needed if they don't exist.
   Future<void> writeAsString(
-    AssetId id,
+    String path,
     String contents, {
     Encoding encoding = utf8,
   });
 
   /// Writes a file.
   ///
   /// Creates enclosing directories as needed if they don't exist.
-  void writeAsBytesSync(AssetId id, List<int> contents);
+  void writeAsBytesSync(String path, List<int> contents);
 
   /// Writes a file.
   ///
   /// Creates enclosing directories as needed if they don't exist.
-  Future<void> writeAsBytes(AssetId id, List<int> contents);
+  Future<void> writeAsBytes(String path, List<int> contents);
 }
 
-/// A filesystem using [assetPathProvider] to map to the `dart:io` filesystem.
+/// The `dart:io` filesystem.
 class IoFilesystem implements Filesystem {
-  @override
-  final FilesystemCache cache;
-
-  final AssetPathProvider assetPathProvider;
-
   /// Pool for async file operations.
   final _pool = Pool(32);
 
-  IoFilesystem({
-    required this.assetPathProvider,
-    this.cache = const PassthroughFilesystemCache(),
-  });
+  @override
+  Future<bool> exists(String path) => _pool.withResource(File(path).exists);
 
   @override
-  IoFilesystem copyWith({FilesystemCache? cache}) => IoFilesystem(
-    assetPathProvider: assetPathProvider,
-    cache: cache ?? this.cache,
-  );
+  bool existsSync(String path) => File(path).existsSync();
 
   @override
-  Future<bool> exists(AssetId id) =>
-      cache.exists(id, ifAbsent: () => _pool.withResource(_fileFor(id).exists));
+  Future<Uint8List> readAsBytes(String path) =>
+      _pool.withResource(File(path).readAsBytes);
 
   @override
-  Future<Uint8List> readAsBytes(AssetId id) => cache.readAsBytes(
-    id,
-    ifAbsent: () => _pool.withResource(_fileFor(id).readAsBytes),
-  );
+  Uint8List readAsBytesSync(String path) => File(path).readAsBytesSync();
 
   @override
-  Future<String> readAsString(AssetId id, {Encoding encoding = utf8}) async {
-    // The cache only directly supports utf8, for other encodings get the
-    // bytes via the cache then convert.
-    if (encoding == utf8) {
-      return cache.readAsString(
-        id,
-        ifAbsent: () => _pool.withResource(_fileFor(id).readAsString),
-      );
-    } else {
-      return encoding.decode(await readAsBytes(id));
-    }
-  }
+  Future<String> readAsString(String path, {Encoding encoding = utf8}) =>
+      _pool.withResource(() => File(path).readAsString(encoding: encoding));
 
   @override
-  void deleteSync(AssetId id) {
-    final file = _fileFor(id);
+  String readAsStringSync(String path, {Encoding encoding = utf8}) =>
+      File(path).readAsStringSync(encoding: encoding);
+
+  @override
+  void deleteSync(String path) {
+    final file = File(path);
     if (file.existsSync()) file.deleteSync();
   }
 
   @override
-  Future<void> delete(AssetId id) {
+  Future<void> delete(String path) {
     return _pool.withResource(() async {
-      final file = _fileFor(id);
+      final file = File(path);
       if (await file.exists()) await file.delete();
     });
   }
 
   @override
   void writeAsBytesSync(
-    AssetId id,
+    String path,
     List<int> contents, {
     Encoding encoding = utf8,
   }) {
-    final file = _fileFor(id);
+    final file = File(path);
     file.parent.createSync(recursive: true);
     file.writeAsBytesSync(contents);
   }
 
   @override
-  Future<void> writeAsBytes(AssetId id, List<int> contents) {
+  Future<void> writeAsBytes(String path, List<int> contents) {
     return _pool.withResource(() async {
-      final file = _fileFor(id);
+      final file = File(path);
       await file.parent.create(recursive: true);
       await file.writeAsBytes(contents);
     });
   }
 
   @override
   void writeAsStringSync(
-    AssetId id,
+    String path,
     String contents, {
     Encoding encoding = utf8,
   }) {
-    final file = _fileFor(id);
+    final file = File(path);
     file.parent.createSync(recursive: true);
     file.writeAsStringSync(contents, encoding: encoding);
   }
 
   @override
   Future<void> writeAsString(
-    AssetId id,
+    String path,
     String contents, {
     Encoding encoding = utf8,
   }) {
     return _pool.withResource(() async {
-      final file = _fileFor(id);
+      final file = File(path);
       await file.parent.create(recursive: true);
       await file.writeAsString(contents, encoding: encoding);
     });
   }
-
-  /// Returns a [File] for [id] for the current [assetPathProvider].
-  File _fileFor(AssetId id) {
-    return File(assetPathProvider.pathFor(id));
-  }
 }
 
 /// An in-memory [Filesystem].
 class InMemoryFilesystem implements Filesystem {
-  @override
-  FilesystemCache cache;
+  final Map<String, Uint8List> _files = {};
 
-  final Map<AssetId, List<int>> assets;
+  /// The paths to all files present on the filesystem.
+  Iterable<String> get filePaths => _files.keys;
 
-  InMemoryFilesystem({FilesystemCache? cache})
-    : cache = cache ?? const PassthroughFilesystemCache(),
-      assets = {};
+  @override
+  Future<bool> exists(String path) async => _files.containsKey(path);
 
-  InMemoryFilesystem._({required this.cache, required this.assets});
+  @override
+  bool existsSync(String path) => _files.containsKey(path);
 
   @override
-  InMemoryFilesystem copyWith({FilesystemCache? cache}) =>
-      InMemoryFilesystem._(assets: assets, cache: cache ?? this.cache);
+  Future<Uint8List> readAsBytes(String path) async => _files[path]!;
 
   @override
-  Future<bool> exists(AssetId id) async =>
-      cache.exists(id, ifAbsent: () async => assets.containsKey(id));
+  Uint8List readAsBytesSync(String path) => _files[path]!;
 
   @override
-  Future<Uint8List> readAsBytes(AssetId id) async =>
-      cache.readAsBytes(id, ifAbsent: () async => assets[id] as Uint8List);
+  Future<String> readAsString(String path, {Encoding encoding = utf8}) async =>
+      encoding.decode(_files[path]!);
 
   @override
-  Future<String> readAsString(AssetId id, {Encoding encoding = utf8}) async {
-    // The cache only directly supports utf8, for other encodings get the
-    // bytes via the cache then convert.
-    if (encoding == utf8) {
-      return cache.readAsString(
-        id,
-        ifAbsent: () async => encoding.decode(assets[id]!),
-      );
-    } else {
-      return encoding.decode(await readAsBytes(id));
-    }
-  }
+  String readAsStringSync(String path, {Encoding encoding = utf8}) =>
+      encoding.decode(_files[path]!);
 
   @override
-  Future<void> delete(AssetId id) async {
-    assets.remove(id);
-  }
+  Future<void> delete(String path) async => _files.remove(path);
 
   @override
-  void deleteSync(AssetId id) async {
-    assets.remove(id);
-  }
+  void deleteSync(String path) async => _files.remove(path);
 
   @override
-  void writeAsBytesSync(AssetId id, List<int> contents) {
-    assets[id] = contents;
+  void writeAsBytesSync(String path, List<int> contents) {
+    _files[path] = Uint8List.fromList(contents);
   }
 
   @override
-  Future<void> writeAsBytes(AssetId id, List<int> contents) async {
-    assets[id] = contents;
+  Future<void> writeAsBytes(String path, List<int> contents) async {
+    _files[path] = Uint8List.fromList(contents);
   }
 
   @override
   void writeAsStringSync(
-    AssetId id,
+    String path,
     String contents, {
     Encoding encoding = utf8,
   }) {
-    assets[id] = encoding.encode(contents);
+    _files[path] = Uint8List.fromList(encoding.encode(contents));
   }
 
   @override
   Future<void> writeAsString(
-    AssetId id,
+    String path,
     String contents, {
     Encoding encoding = utf8,
   }) async {
-    assets[id] = encoding.encode(contents);
+    _files[path] = Uint8List.fromList(encoding.encode(contents));
   }
 }