Add some stricter analysis (dart-lang/watcher#64) - Enable errors that would fail internally - Add `comment_references` lint - this makes DartDocs output more usable and there isn't any reason to have unclickable references. - Add `prefer_typing_uninitialized_variables` lint - this prevents some unintentionally dynamic behavior. - Disable implicit casts. - Use function type syntax for the ManuallyClosedWatcher factory. - Remove some unused utilities.
diff --git a/pkgs/watcher/analysis_options.yaml b/pkgs/watcher/analysis_options.yaml new file mode 100644 index 0000000..4c9f811 --- /dev/null +++ b/pkgs/watcher/analysis_options.yaml
@@ -0,0 +1,14 @@ +analyzer: + strong-mode: + implicit-casts: false + errors: + todo: ignore + unused_import: error + unused_element: error + unused_local_variable: error + dead_code: error + +linter: + rules: + - comment_references + - prefer_typing_uninitialized_variables
diff --git a/pkgs/watcher/benchmark/path_set.dart b/pkgs/watcher/benchmark/path_set.dart index aba3ed7..bf9f5fc 100644 --- a/pkgs/watcher/benchmark/path_set.dart +++ b/pkgs/watcher/benchmark/path_set.dart
@@ -31,7 +31,7 @@ /// Each virtual directory contains ten entries: either subdirectories or /// files. void walkTree(int depth, callback(String path)) { - recurse(path, remainingDepth) { + recurse(String path, remainingDepth) { for (var i = 0; i < 10; i++) { var padded = i.toString().padLeft(2, '0'); if (remainingDepth == 0) {
diff --git a/pkgs/watcher/lib/src/directory_watcher/linux.dart b/pkgs/watcher/lib/src/directory_watcher/linux.dart index 354ddc0..5eeed23 100644 --- a/pkgs/watcher/lib/src/directory_watcher/linux.dart +++ b/pkgs/watcher/lib/src/directory_watcher/linux.dart
@@ -79,13 +79,14 @@ .transform(new BatchedStreamTransformer<FileSystemEvent>()); _listen(innerStream, _onBatch, onError: _eventsController.addError); - _listen(new Directory(path).list(recursive: true), (entity) { + _listen(new Directory(path).list(recursive: true), + (FileSystemEntity entity) { if (entity is Directory) { _watchSubdir(entity.path); } else { _files.add(entity.path); } - }, onError: (error, stackTrace) { + }, onError: (error, StackTrace stackTrace) { _eventsController.addError(error, stackTrace); close(); }, onDone: () { @@ -207,14 +208,15 @@ /// Emits [ChangeType.ADD] events for the recursive contents of [path]. void _addSubdir(String path) { - _listen(new Directory(path).list(recursive: true), (entity) { + _listen(new Directory(path).list(recursive: true), + (FileSystemEntity entity) { if (entity is Directory) { _watchSubdir(entity.path); } else { _files.add(entity.path); _emit(ChangeType.ADD, entity.path); } - }, onError: (error, stackTrace) { + }, onError: (error, StackTrace stackTrace) { // Ignore an exception caused by the dir not existing. It's fine if it // was added and then quickly removed. if (error is FileSystemException) return; @@ -252,7 +254,7 @@ /// [_subscriptions] so that it can be canceled when [close] is called. void _listen<T>(Stream<T> stream, void onData(T event), {Function onError, void onDone(), bool cancelOnError}) { - var subscription; + StreamSubscription subscription; subscription = stream.listen(onData, onError: onError, onDone: () { _subscriptions.remove(subscription); if (onDone != null) onDone();
diff --git a/pkgs/watcher/lib/src/directory_watcher/mac_os.dart b/pkgs/watcher/lib/src/directory_watcher/mac_os.dart index b0e3326..61531c5 100644 --- a/pkgs/watcher/lib/src/directory_watcher/mac_os.dart +++ b/pkgs/watcher/lib/src/directory_watcher/mac_os.dart
@@ -54,8 +54,8 @@ /// The subscription to the stream returned by [Directory.watch]. /// - /// This is separate from [_subscriptions] because this stream occasionally - /// needs to be resubscribed in order to work around issue 14849. + /// This is separate from [_listSubscriptions] because this stream + /// occasionally needs to be resubscribed in order to work around issue 14849. StreamSubscription<List<FileSystemEvent>> _watchSubscription; /// The subscription to the [Directory.list] call for the initial listing of @@ -143,7 +143,7 @@ _emitEvent(ChangeType.ADD, entity.path); _files.add(entity.path); - }, onError: (e, stackTrace) { + }, onError: (e, StackTrace stackTrace) { _emitError(e, stackTrace); }, onDone: () { _listSubscriptions.remove(subscription); @@ -212,7 +212,7 @@ /// one exists. /// /// If [batch] doesn't contain any contradictory events (e.g. DELETE and - /// CREATE, or events with different values for [isDirectory]), this returns a + /// CREATE, or events with different values for `isDirectory`), this returns a /// single event that describes what happened to the path in question. /// /// If [batch] does contain contradictory events, this returns `null` to
diff --git a/pkgs/watcher/lib/src/directory_watcher/polling.dart b/pkgs/watcher/lib/src/directory_watcher/polling.dart index fa72a2f..790d0b9 100644 --- a/pkgs/watcher/lib/src/directory_watcher/polling.dart +++ b/pkgs/watcher/lib/src/directory_watcher/polling.dart
@@ -19,7 +19,7 @@ /// Creates a new polling watcher monitoring [directory]. /// - /// If [_pollingDelay] is passed, it specifies the amount of time the watcher + /// If [pollingDelay] is passed, it specifies the amount of time the watcher /// will pause between successive polls of the directory contents. Making this /// shorter will give more immediate feedback at the expense of doing more IO /// and higher CPU usage. Defaults to one second. @@ -68,13 +68,13 @@ /// The set of files that have been seen in the current directory listing. /// - /// Used to tell which files have been removed: files that are in [_statuses] - /// but not in here when a poll completes have been removed. + /// Used to tell which files have been removed: files that are in + /// [_lastModifieds] but not in here when a poll completes have been removed. final _polledFiles = new Set<String>(); _PollingDirectoryWatcher(this.path, this._pollingDelay) { - _filesToProcess = - new AsyncQueue<String>(_processFile, onError: (e, stackTrace) { + _filesToProcess = new AsyncQueue<String>(_processFile, + onError: (e, StackTrace stackTrace) { if (!_events.isClosed) _events.addError(e, stackTrace); }); @@ -113,7 +113,7 @@ if (entity is! File) return; _filesToProcess.add(entity.path); - }, onError: (error, stackTrace) { + }, onError: (error, StackTrace stackTrace) { if (!isDirectoryNotFoundException(error)) { // It's some unknown error. Pipe it over to the event stream so the // user can see it.
diff --git a/pkgs/watcher/lib/src/directory_watcher/windows.dart b/pkgs/watcher/lib/src/directory_watcher/windows.dart index 0e550ae..baeaf23 100644 --- a/pkgs/watcher/lib/src/directory_watcher/windows.dart +++ b/pkgs/watcher/lib/src/directory_watcher/windows.dart
@@ -188,7 +188,7 @@ _files.add(entity.path); }, onDone: () { _listSubscriptions.remove(subscription); - }, onError: (e, stackTrace) { + }, onError: (e, StackTrace stackTrace) { _listSubscriptions.remove(subscription); _emitError(e, stackTrace); }, cancelOnError: true); @@ -253,7 +253,7 @@ /// one exists. /// /// If [batch] doesn't contain any contradictory events (e.g. DELETE and - /// CREATE, or events with different values for [isDirectory]), this returns a + /// CREATE, or events with different values for `isDirectory`), this returns a /// single event that describes what happened to the path in question. /// /// If [batch] does contain contradictory events, this returns `null` to @@ -382,7 +382,7 @@ _files.clear(); var completer = new Completer(); var stream = new Directory(path).list(recursive: true); - void handleEntity(entity) { + void handleEntity(FileSystemEntity entity) { if (entity is! Directory) _files.add(entity.path); }
diff --git a/pkgs/watcher/lib/src/file_watcher.dart b/pkgs/watcher/lib/src/file_watcher.dart index 17c5f2e..09065bc 100644 --- a/pkgs/watcher/lib/src/file_watcher.dart +++ b/pkgs/watcher/lib/src/file_watcher.dart
@@ -15,7 +15,7 @@ /// it will emit a single [ChangeType.REMOVE] event and then close the stream. /// /// If the file is deleted and quickly replaced (when a new file is moved in its -/// place, for example) this will emit a [ChangeTime.MODIFY] event. +/// place, for example) this will emit a [ChangeType.MODIFY] event. abstract class FileWatcher implements Watcher { /// Creates a new [FileWatcher] monitoring [file]. ///
diff --git a/pkgs/watcher/lib/src/file_watcher/polling.dart b/pkgs/watcher/lib/src/file_watcher/polling.dart index 97a4f95..960b11b 100644 --- a/pkgs/watcher/lib/src/file_watcher/polling.dart +++ b/pkgs/watcher/lib/src/file_watcher/polling.dart
@@ -58,7 +58,7 @@ return; } - var modified; + DateTime modified; try { try { modified = await getModificationTime(path);
diff --git a/pkgs/watcher/lib/src/path_set.dart b/pkgs/watcher/lib/src/path_set.dart index 3726e1f..77737f8 100644 --- a/pkgs/watcher/lib/src/path_set.dart +++ b/pkgs/watcher/lib/src/path_set.dart
@@ -49,13 +49,13 @@ /// empty set. Set<String> remove(String path) { path = _normalize(path); - var parts = new Queue.from(p.split(path)); + var parts = new Queue.of(p.split(path)); // Remove the children of [dir], as well as [dir] itself if necessary. // // [partialPath] is the path to [dir], and a prefix of [path]; the remaining // components of [path] are in [parts]. - Set<String> recurse(dir, partialPath) { + Set<String> recurse(_Entry dir, String partialPath) { if (parts.length > 1) { // If there's more than one component left in [path], recurse down to // the next level. @@ -97,7 +97,7 @@ /// [dirPath] should be the path to [dir]. Set<String> _explicitPathsWithin(_Entry dir, String dirPath) { var paths = new Set<String>(); - recurse(dir, path) { + recurse(_Entry dir, String path) { dir.contents.forEach((name, entry) { var entryPath = p.join(path, name); if (entry.isExplicit) paths.add(p.join(root, entryPath)); @@ -110,9 +110,9 @@ return paths; } - /// Returns whether [this] contains [path]. + /// Returns whether this set contains [path]. /// - /// This only returns true for paths explicitly added to [this]. + /// This only returns true for paths explicitly added to this set. /// Implicitly-added directories can be inspected using [containsDir]. bool contains(String path) { path = _normalize(path); @@ -126,7 +126,7 @@ return entry.isExplicit; } - /// Returns whether [this] contains paths beneath [path]. + /// Returns whether this set contains paths beneath [path]. bool containsDir(String path) { path = _normalize(path); var entry = _entries; @@ -143,7 +143,7 @@ List<String> get paths { var result = <String>[]; - recurse(dir, path) { + recurse(_Entry dir, String path) { for (var name in dir.contents.keys) { var entry = dir.contents[name]; var entryPath = p.join(path, name); @@ -156,7 +156,7 @@ return result; } - /// Removes all paths from [this]. + /// Removes all paths from this set. void clear() { _entries.contents.clear(); }
diff --git a/pkgs/watcher/lib/src/resubscribable.dart b/pkgs/watcher/lib/src/resubscribable.dart index 28c425f..e96b918 100644 --- a/pkgs/watcher/lib/src/resubscribable.dart +++ b/pkgs/watcher/lib/src/resubscribable.dart
@@ -7,8 +7,6 @@ import '../watcher.dart'; import 'watch_event.dart'; -typedef ManuallyClosedWatcher WatcherFactory(); - /// A wrapper for [ManuallyClosedWatcher] that encapsulates support for closing /// the watcher when it has no subscribers and re-opening it when it's /// re-subscribed. @@ -24,7 +22,7 @@ /// takes a factory function that produces instances of the inner class. abstract class ResubscribableWatcher implements Watcher { /// The factory function that produces instances of the inner class. - final WatcherFactory _factory; + final ManuallyClosedWatcher Function() _factory; final String path; @@ -39,8 +37,8 @@ /// Creates a new [ResubscribableWatcher] wrapping the watchers /// emitted by [_factory]. ResubscribableWatcher(this.path, this._factory) { - var watcher; - var subscription; + ManuallyClosedWatcher watcher; + StreamSubscription subscription; _eventsController = new StreamController<WatchEvent>.broadcast( onListen: () {
diff --git a/pkgs/watcher/lib/src/utils.dart b/pkgs/watcher/lib/src/utils.dart index 62d8e0f..30fbaae 100644 --- a/pkgs/watcher/lib/src/utils.dart +++ b/pkgs/watcher/lib/src/utils.dart
@@ -6,8 +6,6 @@ import 'dart:io'; import 'dart:collection'; -import 'package:async/async.dart'; - /// Returns `true` if [error] is a [FileSystemException] for a missing /// directory. bool isDirectoryNotFoundException(error) { @@ -22,55 +20,6 @@ Set<T> unionAll<T>(Iterable<Set<T>> sets) => sets.fold(new Set<T>(), (union, set) => union.union(set)); -/// Returns a buffered stream that will emit the same values as the stream -/// returned by [future] once [future] completes. -/// -/// If [future] completes to an error, the return value will emit that error and -/// then close. -/// -/// If [broadcast] is true, a broadcast stream is returned. This assumes that -/// the stream returned by [future] will be a broadcast stream as well. -/// [broadcast] defaults to false. -Stream<T> futureStream<T>(Future<Stream<T>> future, {bool broadcast: false}) { - var subscription; - StreamController<T> controller; - - future = DelegatingFuture.typed(future.catchError((e, stackTrace) { - // Since [controller] is synchronous, it's likely that emitting an error - // will cause it to be cancelled before we call close. - if (controller != null) controller.addError(e, stackTrace); - if (controller != null) controller.close(); - controller = null; - })); - - onListen() { - future.then((stream) { - if (controller == null) return; - subscription = stream.listen(controller.add, - onError: controller.addError, onDone: controller.close); - }); - } - - onCancel() { - if (subscription != null) subscription.cancel(); - subscription = null; - controller = null; - } - - if (broadcast) { - controller = new StreamController.broadcast( - sync: true, onListen: onListen, onCancel: onCancel); - } else { - controller = new StreamController( - sync: true, onListen: onListen, onCancel: onCancel); - } - return controller.stream; -} - -/// Like [new Future], but avoids around issue 11911 by using [new Future.value] -/// under the covers. -Future newFuture(callback()) => new Future.value().then((_) => callback()); - /// A stream transformer that batches all events that are sent at the same time. /// /// When multiple events are synchronously added to a stream controller, the
diff --git a/pkgs/watcher/test/path_set_test.dart b/pkgs/watcher/test/path_set_test.dart index be15c77..fe91d41 100644 --- a/pkgs/watcher/test/path_set_test.dart +++ b/pkgs/watcher/test/path_set_test.dart
@@ -7,83 +7,84 @@ import 'package:watcher/src/path_set.dart'; Matcher containsPath(String path) => predicate( - (set) => set is PathSet && set.contains(path), 'set contains "$path"'); + (paths) => paths is PathSet && paths.contains(path), + 'set contains "$path"'); Matcher containsDir(String path) => predicate( - (set) => set is PathSet && set.containsDir(path), + (paths) => paths is PathSet && paths.containsDir(path), 'set contains directory "$path"'); void main() { - var set; - setUp(() => set = new PathSet("root")); + PathSet paths; + setUp(() => paths = new PathSet("root")); group("adding a path", () { test("stores the path in the set", () { - set.add("root/path/to/file"); - expect(set, containsPath("root/path/to/file")); + paths.add("root/path/to/file"); + expect(paths, containsPath("root/path/to/file")); }); test("that's a subdir of another path keeps both in the set", () { - set.add("root/path"); - set.add("root/path/to/file"); - expect(set, containsPath("root/path")); - expect(set, containsPath("root/path/to/file")); + paths.add("root/path"); + paths.add("root/path/to/file"); + expect(paths, containsPath("root/path")); + expect(paths, containsPath("root/path/to/file")); }); test("that's not normalized normalizes the path before storing it", () { - set.add("root/../root/path/to/../to/././file"); - expect(set, containsPath("root/path/to/file")); + paths.add("root/../root/path/to/../to/././file"); + expect(paths, containsPath("root/path/to/file")); }); test("that's absolute normalizes the path before storing it", () { - set.add(p.absolute("root/path/to/file")); - expect(set, containsPath("root/path/to/file")); + paths.add(p.absolute("root/path/to/file")); + expect(paths, containsPath("root/path/to/file")); }); }); group("removing a path", () { test("that's in the set removes and returns that path", () { - set.add("root/path/to/file"); - expect(set.remove("root/path/to/file"), + paths.add("root/path/to/file"); + expect(paths.remove("root/path/to/file"), unorderedEquals([p.normalize("root/path/to/file")])); - expect(set, isNot(containsPath("root/path/to/file"))); + expect(paths, isNot(containsPath("root/path/to/file"))); }); test("that's not in the set returns an empty set", () { - set.add("root/path/to/file"); - expect(set.remove("root/path/to/nothing"), isEmpty); + paths.add("root/path/to/file"); + expect(paths.remove("root/path/to/nothing"), isEmpty); }); test("that's a directory removes and returns all files beneath it", () { - set.add("root/outside"); - set.add("root/path/to/one"); - set.add("root/path/to/two"); - set.add("root/path/to/sub/three"); + paths.add("root/outside"); + paths.add("root/path/to/one"); + paths.add("root/path/to/two"); + paths.add("root/path/to/sub/three"); expect( - set.remove("root/path"), + paths.remove("root/path"), unorderedEquals([ "root/path/to/one", "root/path/to/two", "root/path/to/sub/three" ].map(p.normalize))); - expect(set, containsPath("root/outside")); - expect(set, isNot(containsPath("root/path/to/one"))); - expect(set, isNot(containsPath("root/path/to/two"))); - expect(set, isNot(containsPath("root/path/to/sub/three"))); + expect(paths, containsPath("root/outside")); + expect(paths, isNot(containsPath("root/path/to/one"))); + expect(paths, isNot(containsPath("root/path/to/two"))); + expect(paths, isNot(containsPath("root/path/to/sub/three"))); }); test( "that's a directory in the set removes and returns it and all files " "beneath it", () { - set.add("root/path"); - set.add("root/path/to/one"); - set.add("root/path/to/two"); - set.add("root/path/to/sub/three"); + paths.add("root/path"); + paths.add("root/path/to/one"); + paths.add("root/path/to/two"); + paths.add("root/path/to/sub/three"); expect( - set.remove("root/path"), + paths.remove("root/path"), unorderedEquals([ "root/path", "root/path/to/one", @@ -91,113 +92,113 @@ "root/path/to/sub/three" ].map(p.normalize))); - expect(set, isNot(containsPath("root/path"))); - expect(set, isNot(containsPath("root/path/to/one"))); - expect(set, isNot(containsPath("root/path/to/two"))); - expect(set, isNot(containsPath("root/path/to/sub/three"))); + expect(paths, isNot(containsPath("root/path"))); + expect(paths, isNot(containsPath("root/path/to/one"))); + expect(paths, isNot(containsPath("root/path/to/two"))); + expect(paths, isNot(containsPath("root/path/to/sub/three"))); }); test("that's not normalized removes and returns the normalized path", () { - set.add("root/path/to/file"); - expect(set.remove("root/../root/path/to/../to/./file"), + paths.add("root/path/to/file"); + expect(paths.remove("root/../root/path/to/../to/./file"), unorderedEquals([p.normalize("root/path/to/file")])); }); test("that's absolute removes and returns the normalized path", () { - set.add("root/path/to/file"); - expect(set.remove(p.absolute("root/path/to/file")), + paths.add("root/path/to/file"); + expect(paths.remove(p.absolute("root/path/to/file")), unorderedEquals([p.normalize("root/path/to/file")])); }); }); group("containsPath()", () { test("returns false for a non-existent path", () { - set.add("root/path/to/file"); - expect(set, isNot(containsPath("root/path/to/nothing"))); + paths.add("root/path/to/file"); + expect(paths, isNot(containsPath("root/path/to/nothing"))); }); test("returns false for a directory that wasn't added explicitly", () { - set.add("root/path/to/file"); - expect(set, isNot(containsPath("root/path"))); + paths.add("root/path/to/file"); + expect(paths, isNot(containsPath("root/path"))); }); test("returns true for a directory that was added explicitly", () { - set.add("root/path"); - set.add("root/path/to/file"); - expect(set, containsPath("root/path")); + paths.add("root/path"); + paths.add("root/path/to/file"); + expect(paths, containsPath("root/path")); }); test("with a non-normalized path normalizes the path before looking it up", () { - set.add("root/path/to/file"); - expect(set, containsPath("root/../root/path/to/../to/././file")); + paths.add("root/path/to/file"); + expect(paths, containsPath("root/../root/path/to/../to/././file")); }); test("with an absolute path normalizes the path before looking it up", () { - set.add("root/path/to/file"); - expect(set, containsPath(p.absolute("root/path/to/file"))); + paths.add("root/path/to/file"); + expect(paths, containsPath(p.absolute("root/path/to/file"))); }); }); group("containsDir()", () { test("returns true for a directory that was added implicitly", () { - set.add("root/path/to/file"); - expect(set, containsDir("root/path")); - expect(set, containsDir("root/path/to")); + paths.add("root/path/to/file"); + expect(paths, containsDir("root/path")); + expect(paths, containsDir("root/path/to")); }); test("returns true for a directory that was added explicitly", () { - set.add("root/path"); - set.add("root/path/to/file"); - expect(set, containsDir("root/path")); + paths.add("root/path"); + paths.add("root/path/to/file"); + expect(paths, containsDir("root/path")); }); test("returns false for a directory that wasn't added", () { - expect(set, isNot(containsDir("root/nothing"))); + expect(paths, isNot(containsDir("root/nothing"))); }); test("returns false for a non-directory path that was added", () { - set.add("root/path/to/file"); - expect(set, isNot(containsDir("root/path/to/file"))); + paths.add("root/path/to/file"); + expect(paths, isNot(containsDir("root/path/to/file"))); }); test( "returns false for a directory that was added implicitly and then " "removed implicitly", () { - set.add("root/path/to/file"); - set.remove("root/path/to/file"); - expect(set, isNot(containsDir("root/path"))); + paths.add("root/path/to/file"); + paths.remove("root/path/to/file"); + expect(paths, isNot(containsDir("root/path"))); }); test( "returns false for a directory that was added explicitly whose " "children were then removed", () { - set.add("root/path"); - set.add("root/path/to/file"); - set.remove("root/path/to/file"); - expect(set, isNot(containsDir("root/path"))); + paths.add("root/path"); + paths.add("root/path/to/file"); + paths.remove("root/path/to/file"); + expect(paths, isNot(containsDir("root/path"))); }); test("with a non-normalized path normalizes the path before looking it up", () { - set.add("root/path/to/file"); - expect(set, containsDir("root/../root/path/to/../to/.")); + paths.add("root/path/to/file"); + expect(paths, containsDir("root/../root/path/to/../to/.")); }); test("with an absolute path normalizes the path before looking it up", () { - set.add("root/path/to/file"); - expect(set, containsDir(p.absolute("root/path"))); + paths.add("root/path/to/file"); + expect(paths, containsDir(p.absolute("root/path"))); }); }); group("paths", () { test("returns paths added to the set", () { - set.add("root/path"); - set.add("root/path/to/one"); - set.add("root/path/to/two"); + paths.add("root/path"); + paths.add("root/path/to/one"); + paths.add("root/path/to/two"); expect( - set.paths, + paths.paths, unorderedEquals([ "root/path", "root/path/to/one", @@ -206,22 +207,22 @@ }); test("doesn't return paths removed from the set", () { - set.add("root/path/to/one"); - set.add("root/path/to/two"); - set.remove("root/path/to/two"); + paths.add("root/path/to/one"); + paths.add("root/path/to/two"); + paths.remove("root/path/to/two"); - expect(set.paths, unorderedEquals([p.normalize("root/path/to/one")])); + expect(paths.paths, unorderedEquals([p.normalize("root/path/to/one")])); }); }); group("clear", () { test("removes all paths from the set", () { - set.add("root/path"); - set.add("root/path/to/one"); - set.add("root/path/to/two"); + paths.add("root/path"); + paths.add("root/path/to/one"); + paths.add("root/path/to/two"); - set.clear(); - expect(set.paths, isEmpty); + paths.clear(); + expect(paths.paths, isEmpty); }); }); }
diff --git a/pkgs/watcher/test/utils.dart b/pkgs/watcher/test/utils.dart index 637eacf..7462c99 100644 --- a/pkgs/watcher/test/utils.dart +++ b/pkgs/watcher/test/utils.dart
@@ -35,10 +35,6 @@ /// Creates a new [Watcher] that watches a temporary file or directory. /// -/// Normally, this will pause the schedule until the watcher is done scanning -/// and is polling for changes. If you pass `false` for [waitForReady], it will -/// not schedule this delay. -/// /// If [path] is provided, watches a subdirectory in the sandbox with that name. Watcher createWatcher({String path}) { if (path == null) { @@ -202,7 +198,7 @@ /// Schedules writing a file in the sandbox at [path] with [contents]. /// -/// If [contents] is omitted, creates an empty file. If [updatedModified] is +/// If [contents] is omitted, creates an empty file. If [updateModified] is /// `false`, the mock file modification time is not changed. void writeFile(String path, {String contents, bool updateModified}) { if (contents == null) contents = ""; @@ -232,8 +228,6 @@ } /// Schedules renaming a file in the sandbox from [from] to [to]. -/// -/// If [contents] is omitted, creates an empty file. void renameFile(String from, String to) { new File(p.join(d.sandbox, from)).renameSync(p.join(d.sandbox, to)); @@ -259,8 +253,8 @@ new Directory(p.join(d.sandbox, path)).deleteSync(recursive: true); } -/// Runs [callback] with every permutation of non-negative [i], [j], and [k] -/// less than [limit]. +/// Runs [callback] with every permutation of non-negative numbers for each +/// argument less than [limit]. /// /// Returns a set of all values returns by [callback]. ///