Make MemoryFileSystem support Windows-style paths (#82)

Fixes flutter#68

Author: tvolkert

CHANGELOG.md

@@ -1,6 +1,9 @@
 #### 4.0.1
 
 * General library cleanup
+* Add `style` support in `MemoryFileSystem`, so that callers can choose to
+  have a memory file system with windows-like paths. [#68]
+  (https://github.com/google/file.dart/issues/68)
 
 #### 4.0.0
 

lib/src/backends/chroot/chroot_file_system.dart

@@ -262,6 +262,10 @@ class ChrootFileSystem extends FileSystem {
     bool followLinks: true,
     _NotFoundBehavior notFound: _NotFoundBehavior.allow,
   }) {
+    if (path.isEmpty) {
+      throw common.noSuchFileOrDirectory(path);
+    }
+
     p.Context ctx = this.path;
     String root = _localRoot;
     List<String> parts, ledger;

lib/src/backends/memory.dart

@@ -3,3 +3,4 @@
 // BSD-style license that can be found in the LICENSE file.
 
 export 'memory/memory_file_system.dart' show MemoryFileSystem;
+export 'memory/style.dart' show FileSystemStyle, StyleableFileSystem;

lib/src/backends/memory/common.dart

@@ -4,9 +4,6 @@
 
 import 'package:file/src/common.dart' as common;
 
-/// The file separator.
-const String separator = '/';
-
 /// Generates a path to use in error messages.
 typedef dynamic PathGenerator();
 

lib/src/backends/memory/memory_directory.dart

@@ -14,6 +14,7 @@ import 'memory_file.dart';
 import 'memory_file_system_entity.dart';
 import 'memory_link.dart';
 import 'node.dart';
+import 'style.dart';
 import 'utils.dart' as utils;
 
 /// Internal implementation of [Directory].
@@ -30,7 +31,10 @@ class MemoryDirectory extends MemoryFileSystemEntity
   io.FileSystemEntityType get expectedType => io.FileSystemEntityType.DIRECTORY;
 
   @override
-  Uri get uri => new Uri.directory(path);
+  Uri get uri {
+    return new Uri.directory(path,
+        windows: fileSystem.style == FileSystemStyle.windows);
+  }
 
   @override
   bool existsSync() => backingOrNull?.stat?.type == expectedType;
@@ -121,7 +125,9 @@ class MemoryDirectory extends MemoryFileSystemEntity
     List<_PendingListTask> tasks = <_PendingListTask>[
       new _PendingListTask(
         node,
-        path.endsWith(separator) ? path.substring(0, path.length - 1) : path,
+        path.endsWith(fileSystem.path.separator)
+            ? path.substring(0, path.length - 1)
+            : path,
         new Set<LinkNode>(),
       ),
     ];

lib/src/backends/memory/memory_file_system.dart

@@ -14,50 +14,53 @@ import 'memory_file.dart';
 import 'memory_file_stat.dart';
 import 'memory_link.dart';
 import 'node.dart';
+import 'style.dart';
 import 'utils.dart' as utils;
 
 const String _thisDir = '.';
 const String _parentDir = '..';
 
 /// An implementation of [FileSystem] that exists entirely in memory with an
 /// internal representation loosely based on the Filesystem Hierarchy Standard.
-/// Notably, this means that this implementation will not look like a Windows
-/// file system even if it's being run on a Windows host operating system.
 ///
 /// [MemoryFileSystem] is suitable for mocking and tests, as well as for
 /// caching or staging before writing or reading to a live system.
 ///
 /// This implementation of the [FileSystem] interface does not directly use
 /// any `dart:io` APIs; it merely uses the library's enum values and interfaces.
 /// As such, it is suitable for use in the browser.
-abstract class MemoryFileSystem implements FileSystem {
+abstract class MemoryFileSystem implements StyleableFileSystem {
   /// Creates a new `MemoryFileSystem`.
   ///
   /// The file system will be empty, and the current directory will be the
   /// root directory.
-  factory MemoryFileSystem() = _MemoryFileSystem;
+  ///
+  /// If [style] is specified, the file system will use the specified path
+  /// style. The default is [FileSystemStyle.posix].
+  factory MemoryFileSystem({FileSystemStyle style}) = _MemoryFileSystem;
 }
 
 /// Internal implementation of [MemoryFileSystem].
 class _MemoryFileSystem extends FileSystem
     implements MemoryFileSystem, NodeBasedFileSystem {
   RootNode _root;
   String _systemTemp;
-  String _cwd = separator;
+  p.Context _context;
 
-  /// Creates a new `MemoryFileSystem`.
-  ///
-  /// The file system will be empty, and the current directory will be the
-  /// root directory.
-  _MemoryFileSystem() {
+  _MemoryFileSystem({this.style: FileSystemStyle.posix})
+      : assert(style != null) {
     _root = new RootNode(this);
+    _context = style.contextFor(style.root);
   }
 
+  @override
+  final FileSystemStyle style;
+
   @override
   RootNode get root => _root;
 
   @override
-  String get cwd => _cwd;
+  String get cwd => _context.current;
 
   @override
   Directory directory(dynamic path) => new MemoryDirectory(this, getPath(path));
@@ -69,19 +72,19 @@ class _MemoryFileSystem extends FileSystem
   Link link(dynamic path) => new MemoryLink(this, getPath(path));
 
   @override
-  p.Context get path => new p.Context(style: p.Style.posix, current: _cwd);
+  p.Context get path => _context;
 
   /// Gets the system temp directory. This directory will be created on-demand
   /// in the root of the file system. Once created, its location is fixed for
   /// the life of the process.
   @override
   Directory get systemTempDirectory {
-    _systemTemp ??= directory(separator).createTempSync('.tmp_').path;
+    _systemTemp ??= directory(style.root).createTempSync('.tmp_').path;
     return directory(_systemTemp)..createSync();
   }
 
   @override
-  Directory get currentDirectory => directory(_cwd);
+  Directory get currentDirectory => directory(cwd);
 
   @override
   set currentDirectory(dynamic path) {
@@ -98,8 +101,8 @@ class _MemoryFileSystem extends FileSystem
     Node node = findNode(value);
     checkExists(node, () => value);
     utils.checkIsDir(node, () => value);
-    assert(utils.isAbsolute(value));
-    _cwd = value;
+    assert(_context.isAbsolute(value));
+    _context = style.contextFor(value);
   }
 
   @override
@@ -154,7 +157,7 @@ class _MemoryFileSystem extends FileSystem
   /// Gets the node backing for the current working directory. Note that this
   /// can return null if the directory has been deleted or moved from under our
   /// feet.
-  DirectoryNode get _current => findNode(_cwd);
+  DirectoryNode get _current => findNode(cwd);
 
   @override
   Node findNode(
@@ -169,13 +172,15 @@ class _MemoryFileSystem extends FileSystem
       throw new ArgumentError.notNull('path');
     }
 
-    if (utils.isAbsolute(path)) {
+    if (_context.isAbsolute(path)) {
       reference = _root;
+      path = path.substring(style.drive.length);
     } else {
       reference ??= _current;
     }
 
-    List<String> parts = path.split(separator)..removeWhere(utils.isEmpty);
+    List<String> parts = path.split(style.separator)
+      ..removeWhere(utils.isEmpty);
     DirectoryNode directory = reference.directory;
     Node child = directory;
 
@@ -200,7 +205,9 @@ class _MemoryFileSystem extends FileSystem
         pathWithSymlinks.add(basename);
       }
 
-      PathGenerator subpath = utils.subpath(parts, 0, i);
+      // Generates a subpath for the current segment.
+      String subpath() => parts.sublist(0, i + 1).join(_context.separator);
+
       if (utils.isLink(child) && (i < finalSegment || followTailLink)) {
         if (visitLinks || segmentVisitor == null) {
           if (segmentVisitor != null) {

lib/src/backends/memory/memory_file_system_entity.dart

@@ -12,6 +12,7 @@ import 'package:meta/meta.dart';
 import 'common.dart';
 import 'memory_directory.dart';
 import 'node.dart';
+import 'style.dart';
 import 'utils.dart' as utils;
 
 /// Validator function for use with `_renameSync`. This will be invoked if the
@@ -89,7 +90,10 @@ abstract class MemoryFileSystemEntity implements FileSystemEntity {
   }
 
   @override
-  Uri get uri => new Uri.file(path);
+  Uri get uri {
+    return new Uri.file(path,
+        windows: fileSystem.style == FileSystemStyle.windows);
+  }
 
   @override
   Future<bool> exists() async => existsSync();
@@ -99,16 +103,21 @@ abstract class MemoryFileSystemEntity implements FileSystemEntity {
 
   @override
   String resolveSymbolicLinksSync() {
+    if (path.isEmpty) {
+      throw common.noSuchFileOrDirectory(path);
+    }
     List<String> ledger = <String>[];
     if (isAbsolute) {
-      ledger.add('');
+      ledger.add(fileSystem.style.drive);
     }
     Node node = fileSystem.findNode(path,
         pathWithSymlinks: ledger, followTailLink: true);
     checkExists(node, () => path);
-    String resolved = ledger.join(separator);
-    if (!utils.isAbsolute(resolved)) {
-      resolved = fileSystem.cwd + separator + resolved;
+    String resolved = ledger.join(fileSystem.path.separator);
+    if (resolved == fileSystem.style.drive) {
+      resolved = fileSystem.style.root;
+    } else if (!fileSystem.path.isAbsolute(resolved)) {
+      resolved = fileSystem.cwd + fileSystem.path.separator + resolved;
     }
     return fileSystem.path.normalize(resolved);
   }
@@ -137,12 +146,12 @@ abstract class MemoryFileSystemEntity implements FileSystemEntity {
       throw new UnsupportedError('Watching not supported in MemoryFileSystem');
 
   @override
-  bool get isAbsolute => utils.isAbsolute(path);
+  bool get isAbsolute => fileSystem.path.isAbsolute(path);
 
   @override
   FileSystemEntity get absolute {
     String absolutePath = path;
-    if (!utils.isAbsolute(absolutePath)) {
+    if (!fileSystem.path.isAbsolute(absolutePath)) {
       absolutePath = fileSystem.path.join(fileSystem.cwd, absolutePath);
     }
     return clone(absolutePath);

lib/src/backends/memory/node.dart

@@ -7,6 +7,7 @@ import 'package:file/src/io.dart' as io;
 
 import 'common.dart';
 import 'memory_file_stat.dart';
+import 'style.dart';
 
 /// Visitor callback for use with [NodeBasedFileSystem.findNode].
 ///
@@ -36,7 +37,7 @@ typedef Node SegmentVisitor(
 
 /// A [FileSystem] whose internal structure is made up of a tree of [Node]
 /// instances, rooted at a single node.
-abstract class NodeBasedFileSystem implements FileSystem {
+abstract class NodeBasedFileSystem implements StyleableFileSystem {
   /// The root node.
   RootNode get root;
 

lib/src/backends/memory/style.dart

@@ -0,0 +1,98 @@
+// Copyright (c) 2018, 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.
+
+import 'package:file/file.dart';
+import 'package:path/path.dart' as p;
+
+/// Class that represents the path style that a memory file system should
+/// adopt.
+///
+/// This is primarily useful if you want to test how your code will behave
+/// when faced with particular paths or particular path separator characters.
+/// For instance, you may want to test that your code will work on Windows,
+/// while still using a memory file system in order to gain hermeticity in your
+/// tests.
+abstract class FileSystemStyle {
+  const FileSystemStyle._();
+
+  /// Mimics the Unix file system style.
+  ///
+  /// * This style does not have the notion of drives
+  /// * All file system paths are rooted at `/`
+  /// * The path separator is `/`
+  ///
+  /// An example path in this style is `/path/to/file`.
+  static const FileSystemStyle posix = const _Posix();
+
+  /// Mimics the Windows file system style.
+  ///
+  /// * This style mounts its root folder on a single root drive (`C:`)
+  /// * All file system paths are rooted at `C:\`
+  /// * The path separator is `\`
+  ///
+  /// An example path in this style is `C:\path\to\file`.
+  static const FileSystemStyle windows = const _Windows();
+
+  /// The drive upon which the root directory is mounted.
+  ///
+  /// While real-world file systems that have the notion of drives will support
+  /// multiple drives per system, memory file system will only support one
+  /// root drive.
+  ///
+  /// This will be the empty string for styles that don't have the notion of
+  /// drives (e.g. [posix]).
+  String get drive;
+
+  /// The String that represents the delineation between a directory and its
+  /// children.
+  String get separator;
+
+  /// The string that represents the root of the file system.
+  ///
+  /// Memory file system is always single-rooted.
+  String get root => '$drive$separator';
+
+  /// Gets an object useful for manipulating paths in this style.
+  ///
+  /// Relative path manipulations will be relative to the specified [path].
+  p.Context contextFor(String path);
+}
+
+class _Posix extends FileSystemStyle {
+  const _Posix() : super._();
+
+  @override
+  String get drive => '';
+
+  @override
+  String get separator {
+    return p.Style.posix.separator; // ignore: deprecated_member_use
+  }
+
+  @override
+  p.Context contextFor(String path) =>
+      new p.Context(style: p.Style.posix, current: path);
+}
+
+class _Windows extends FileSystemStyle {
+  const _Windows() : super._();
+
+  @override
+  String get drive => 'C:';
+
+  @override
+  String get separator {
+    return p.Style.windows.separator; // ignore: deprecated_member_use
+  }
+
+  @override
+  p.Context contextFor(String path) =>
+      new p.Context(style: p.Style.windows, current: path);
+}
+
+/// A file system that supports different styles.
+abstract class StyleableFileSystem implements FileSystem {
+  /// The style used by this file system.
+  FileSystemStyle get style;
+}