Enable and fix a number of lints, test on the oldest supported SDK (#19)

Author: kevmoo

.travis.yml

@@ -2,23 +2,25 @@ language: dart
 
 dart:
   - dev
+  - 2.0.0
 
 dart_task:
   - test
 
-# Only run one instance of the formatter and the analyzer, rather than running
-# them against each Dart version.
 matrix:
   include:
   - dart: dev
     dart_task: dartfmt
   - dart: dev
-    dart_task: dartanalyzer
+    dart_task:
+      dartanalyzer: --fatal-infos --fatal-warnings .
+  - dart: 2.0.0
+    dart_task:
+      dartanalyzer: --fatal-warnings .
 
-# Only building master means that we don't run two builds for each pull request.
 branches:
   only: [master]
 
 cache:
- directories:
-   - $HOME/.pub-cache
+  directories:
+    - $HOME/.pub-cache

analysis_options.yaml

@@ -0,0 +1,65 @@
+include: package:pedantic/analysis_options.yaml
+analyzer:
+  strong-mode:
+    implicit-casts: false
+  errors:
+    unused_element: error
+    unused_import: error
+    unused_local_variable: error
+    dead_code: error
+linter:
+  rules:
+    #- annotate_overrides
+    - avoid_function_literals_in_foreach_calls
+    - avoid_init_to_null
+    - avoid_null_checks_in_equality_operators
+    - avoid_relative_lib_imports
+    - avoid_returning_null
+    - avoid_unused_constructor_parameters
+    - await_only_futures
+    - camel_case_types
+    - cancel_subscriptions
+    - comment_references
+    - constant_identifier_names
+    - control_flow_in_finally
+    - directives_ordering
+    - empty_catches
+    - empty_constructor_bodies
+    - empty_statements
+    - hash_and_equals
+    - implementation_imports
+    - invariant_booleans
+    - iterable_contains_unrelated_type
+    - library_names
+    - library_prefixes
+    - list_remove_unrelated_type
+    - no_adjacent_strings_in_list
+    - non_constant_identifier_names
+    - omit_local_variable_types
+    - only_throw_errors
+    - overridden_fields
+    - package_api_docs
+    - package_names
+    - package_prefixed_library_names
+    - prefer_adjacent_string_concatenation
+    - prefer_collection_literals
+    - prefer_conditional_assignment
+    - prefer_const_constructors
+    - prefer_final_fields
+    - prefer_generic_function_type_aliases
+    - prefer_initializing_formals
+    - prefer_interpolation_to_compose_strings
+    #- prefer_single_quotes
+    - prefer_typing_uninitialized_variables
+    - slash_for_doc_comments
+    - test_types_in_equals
+    - throw_in_finally
+    - type_init_formals
+    - unnecessary_brace_in_string_interps
+    - unnecessary_const
+    - unnecessary_getters_setters
+    - unnecessary_lambdas
+    - unnecessary_new
+    - unnecessary_null_aware_assignments
+    - unnecessary_statements
+    - unnecessary_this

lib/src/descriptor.dart

@@ -4,6 +4,8 @@
 
 import 'dart:async';
 
+import 'sandbox.dart';
+
 /// A declarative description of a filesystem entry.
 ///
 /// This may be extended outside this package.

lib/src/directory_descriptor.dart

@@ -29,7 +29,7 @@ class DirectoryDescriptor extends Descriptor {
 
   /// Returns a `dart:io` [Directory] object that refers to this file within
   /// [sandbox].
-  Directory get io => new Directory(p.join(sandbox, name));
+  Directory get io => Directory(p.join(sandbox, name));
 
   DirectoryDescriptor(String name, Iterable<Descriptor> contents)
       : contents = contents.toList(),
@@ -38,17 +38,17 @@ class DirectoryDescriptor extends Descriptor {
   /// Creates a directory descriptor named [name] that describes the physical
   /// directory at [path].
   factory DirectoryDescriptor.fromFilesystem(String name, String path) {
-    return new DirectoryDescriptor(
+    return DirectoryDescriptor(
         name,
-        new Directory(path).listSync().map((entity) {
+        Directory(path).listSync().map((entity) {
           // Ignore hidden files.
           if (p.basename(entity.path).startsWith(".")) return null;
 
           if (entity is Directory) {
-            return new DirectoryDescriptor.fromFilesystem(
+            return DirectoryDescriptor.fromFilesystem(
                 p.basename(entity.path), entity.path);
           } else if (entity is File) {
-            return new FileDescriptor(
+            return FileDescriptor(
                 p.basename(entity.path), entity.readAsBytesSync());
           }
           // Ignore broken symlinks.
@@ -57,13 +57,13 @@ class DirectoryDescriptor extends Descriptor {
 
   Future create([String parent]) async {
     var fullPath = p.join(parent ?? sandbox, name);
-    await new Directory(fullPath).create(recursive: true);
+    await Directory(fullPath).create(recursive: true);
     await Future.wait(contents.map((entry) => entry.create(fullPath)));
   }
 
   Future validate([String parent]) async {
     var fullPath = p.join(parent ?? sandbox, name);
-    if (!(await new Directory(fullPath).exists())) {
+    if (!(await Directory(fullPath).exists())) {
       fail('Directory not found: "${prettyPath(fullPath)}".');
     }
 
@@ -75,7 +75,7 @@ class DirectoryDescriptor extends Descriptor {
   /// contents of the [FileDescriptor] at the given relative [url], which may be
   /// a [Uri] or a [String].
   ///
-  /// The [parent] parameter should only be passed by subclasses of
+  /// The [parents] parameter should only be passed by subclasses of
   /// [DirectoryDescriptor] that are recursively calling [load]. It's the
   /// URL-format path of the directories that have been loaded so far.
   Stream<List<int>> load(url, [String parents]) {
@@ -85,15 +85,15 @@ class DirectoryDescriptor extends Descriptor {
     } else if (url is Uri) {
       path = url.toString();
     } else {
-      throw new ArgumentError.value(url, "url", "must be a Uri or a String.");
+      throw ArgumentError.value(url, "url", "must be a Uri or a String.");
     }
 
     if (!p.url.isWithin('.', path)) {
-      throw new ArgumentError.value(
+      throw ArgumentError.value(
           url, "url", "must be relative and beneath the base URL.");
     }
 
-    return StreamCompleter.fromFuture(new Future.sync(() {
+    return StreamCompleter.fromFuture(Future.sync(() {
       var split = p.url.split(p.url.normalize(path));
       var file = split.length == 1;
       var matchingEntries = contents.where((entry) {
@@ -124,7 +124,7 @@ class DirectoryDescriptor extends Descriptor {
   String describe() {
     if (contents.isEmpty) return name;
 
-    var buffer = new StringBuffer();
+    var buffer = StringBuffer();
     buffer.writeln(name);
     for (var entry in contents.take(contents.length - 1)) {
       var entryString =

lib/src/file_descriptor.dart

@@ -36,33 +36,33 @@ abstract class FileDescriptor extends Descriptor {
   /// To match a [Matcher] against a file's binary contents, use [new
   /// FileDescriptor.binaryMatcher] instead.
   factory FileDescriptor(String name, contents) {
-    if (contents is String) return new _StringFileDescriptor(name, contents);
+    if (contents is String) return _StringFileDescriptor(name, contents);
     if (contents is List) {
-      return new _BinaryFileDescriptor(name, contents.cast<int>());
+      return _BinaryFileDescriptor(name, contents.cast<int>());
     }
-    if (contents == null) return new _BinaryFileDescriptor(name, []);
-    return new _MatcherFileDescriptor(name, contents);
+    if (contents == null) return _BinaryFileDescriptor(name, []);
+    return _MatcherFileDescriptor(name, contents as Matcher);
   }
 
   /// Returns a `dart:io` [File] object that refers to this file within
   /// [sandbox].
-  File get io => new File(p.join(sandbox, name));
+  File get io => File(p.join(sandbox, name));
 
   /// Creates a new binary [FileDescriptor] with [name] that matches its binary
   /// contents against [matcher].
   ///
   /// The [create], [read], and [readAsBytes] methods are unsupported for this
   /// descriptor.
   factory FileDescriptor.binaryMatcher(String name, Matcher matcher) =>
-      new _MatcherFileDescriptor(name, matcher, isBinary: true);
+      _MatcherFileDescriptor(name, matcher, isBinary: true);
 
   /// A protected constructor that's only intended for subclasses.
   FileDescriptor.protected(String name) : super(name);
 
   Future create([String parent]) async {
     // Create the stream before we call [File.openWrite] because it may fail
     // fast (e.g. if this is a matcher file).
-    var file = new File(p.join(parent ?? sandbox, name)).openWrite();
+    var file = File(p.join(parent ?? sandbox, name)).openWrite();
     try {
       await readAsBytes().listen(file.add).asFuture();
     } finally {
@@ -73,11 +73,11 @@ abstract class FileDescriptor extends Descriptor {
   Future validate([String parent]) async {
     var fullPath = p.join(parent ?? sandbox, name);
     var pretty = prettyPath(fullPath);
-    if (!(await new File(fullPath).exists())) {
+    if (!(await File(fullPath).exists())) {
       fail('File not found: "$pretty".');
     }
 
-    await _validate(pretty, await new File(fullPath).readAsBytes());
+    await _validate(pretty, await File(fullPath).readAsBytes());
   }
 
   /// Validates that [binaryContents] matches the expected contents of
@@ -106,7 +106,7 @@ class _BinaryFileDescriptor extends FileDescriptor {
 
   _BinaryFileDescriptor(String name, this._contents) : super.protected(name);
 
-  Stream<List<int>> readAsBytes() => new Stream.fromIterable([_contents]);
+  Stream<List<int>> readAsBytes() => Stream.fromIterable([_contents]);
 
   Future _validate(String prettPath, List<int> actualContents) async {
     if (const IterableEquality().equals(_contents, actualContents)) return null;
@@ -124,12 +124,12 @@ class _StringFileDescriptor extends FileDescriptor {
   Future<String> read() async => _contents;
 
   Stream<List<int>> readAsBytes() =>
-      new Stream.fromIterable([utf8.encode(_contents)]);
+      Stream.fromIterable([utf8.encode(_contents)]);
 
   Future _validate(String prettyPath, List<int> actualContents) {
     var actualContentsText = utf8.decode(actualContents);
     if (_contents == actualContentsText) return null;
-    throw fail(_textMismatchMessage(prettyPath, _contents, actualContentsText));
+    fail(_textMismatchMessage(prettyPath, _contents, actualContentsText));
   }
 
   String _textMismatchMessage(
@@ -177,20 +177,19 @@ class _MatcherFileDescriptor extends FileDescriptor {
   /// contents.
   final bool _isBinary;
 
-  _MatcherFileDescriptor(String name, this._matcher, {bool isBinary: false})
+  _MatcherFileDescriptor(String name, this._matcher, {bool isBinary = false})
       : _isBinary = isBinary,
         super.protected(name);
 
   Stream<List<int>> readAsBytes() =>
-      throw new UnsupportedError("Matcher files can't be created or read.");
+      throw UnsupportedError("Matcher files can't be created or read.");
 
   Future _validate(String prettyPath, List<int> actualContents) async {
     try {
       expect(
           _isBinary ? actualContents : utf8.decode(actualContents), _matcher);
     } on TestFailure catch (error) {
-      throw new TestFailure(
-          'Invalid contents for file "$prettyPath":\n' + error.message);
+      fail('Invalid contents for file "$prettyPath":\n${error.message}');
     }
   }
 }

lib/src/nothing_descriptor.dart

@@ -23,11 +23,11 @@ class NothingDescriptor extends Descriptor {
   Future validate([String parent]) async {
     var fullPath = p.join(parent ?? sandbox, name);
     var pretty = prettyPath(fullPath);
-    if (new File(fullPath).existsSync()) {
+    if (File(fullPath).existsSync()) {
       fail('Expected nothing to exist at "$pretty", but found a file.');
-    } else if (new Directory(fullPath).existsSync()) {
+    } else if (Directory(fullPath).existsSync()) {
       fail('Expected nothing to exist at "$pretty", but found a directory.');
-    } else if (new Link(fullPath).existsSync()) {
+    } else if (Link(fullPath).existsSync()) {
       fail('Expected nothing to exist at "$pretty", but found a link.');
     }
   }

lib/src/pattern_descriptor.dart

@@ -16,7 +16,7 @@ import 'utils.dart';
 /// A function that takes a name for a [Descriptor] and returns a [Descriptor].
 /// This is used for [PatternDescriptor]s, where the name isn't known
 /// ahead-of-time.
-typedef Descriptor _EntryCreator(String name);
+typedef _EntryCreator = Descriptor Function(String name);
 
 /// A descriptor that matches filesystem entity names by [Pattern] rather than
 /// by exact [String].
@@ -31,20 +31,19 @@ class PatternDescriptor extends Descriptor {
   /// matching [pattern].
   final _EntryCreator _fn;
 
-  PatternDescriptor(Pattern pattern, Descriptor child(String basename))
-      : pattern = pattern,
-        _fn = child,
+  PatternDescriptor(this.pattern, Descriptor child(String basename))
+      : _fn = child,
         super('$pattern');
 
   /// Validates that there is some filesystem entity in [parent] that matches
   /// [pattern] and the child entry. This finds all entities in [parent]
-  /// matching [pattern], then passes each of their names to the [EntityCreator]
-  /// and validates the result. If exactly one succeeds, [this] is considered
-  /// valid.
+  /// matching [pattern], then passes each of their names to `child` provided
+  /// in the constructor and validates the result. If exactly one succeeds,
+  /// `this` is considered valid.
   Future validate([String parent]) async {
     var inSandbox = parent == null;
     parent ??= sandbox;
-    var matchingEntries = await new Directory(parent)
+    var matchingEntries = await Directory(parent)
         .list()
         .map((entry) =>
             entry is File ? entry.resolveSymbolicLinksSync() : entry.path)
@@ -54,13 +53,13 @@ class PatternDescriptor extends Descriptor {
 
     var location = inSandbox ? "sandbox" : '"${prettyPath(parent)}"';
     if (matchingEntries.isEmpty) {
-      fail('No entries found in $location matching ${_patternDescription}.');
+      fail('No entries found in $location matching $_patternDescription.');
     }
 
     var results = await Future.wait(matchingEntries.map((entry) {
       var basename = p.basename(entry);
       return runZoned(() {
-        return Result.capture(new Future.sync(() async {
+        return Result.capture(Future.sync(() async {
           await _fn(basename).validate(parent);
           return basename;
         }));
@@ -72,7 +71,7 @@ class PatternDescriptor extends Descriptor {
     }).toList());
 
     var successes = results.where((result) => result.isValue).toList();
-    if (successes.length == 0) {
+    if (successes.isEmpty) {
       await waitAndReportErrors(results.map((result) => result.asFuture));
     } else if (successes.length > 1) {
       fail('Multiple valid entries found in $location matching '
@@ -88,13 +87,13 @@ class PatternDescriptor extends Descriptor {
     if (pattern is! RegExp) return '$pattern';
 
     var regExp = pattern as RegExp;
-    var flags = new StringBuffer();
+    var flags = StringBuffer();
     if (!regExp.isCaseSensitive) flags.write('i');
     if (regExp.isMultiLine) flags.write('m');
     return '/${regExp.pattern}/$flags';
   }
 
   Future create([String parent]) {
-    throw new UnsupportedError("Pattern descriptors don't support create().");
+    throw UnsupportedError("Pattern descriptors don't support create().");
   }
 }

lib/src/sandbox.dart

@@ -23,7 +23,7 @@ String get sandbox {
   addTearDown(() async {
     var sandbox = _sandbox;
     _sandbox = null;
-    await new Directory(sandbox).delete(recursive: true);
+    await Directory(sandbox).delete(recursive: true);
   });
 
   return _sandbox;