add some basic build tests to get started, as well as a basic test framework

lib/build.dart

@@ -11,5 +11,9 @@ export 'src/asset/writer.dart';
 export 'src/builder/build_step.dart';
 export 'src/builder/builder.dart';
 export 'src/builder/exceptions.dart';
+export 'src/generate/build.dart';
+export 'src/generate/build_result.dart';
+export 'src/generate/input_set.dart';
+export 'src/generate/phase.dart';
 export 'src/package_graph/package_graph.dart';
 export 'src/transformer/transformer.dart';

lib/src/asset/cache.dart

@@ -4,6 +4,7 @@
 import 'dart:async';
 import 'dart:convert';
 
+import '../generate/input_set.dart';
 import 'asset.dart';
 import 'id.dart';
 import 'reader.dart';
@@ -74,6 +75,10 @@ class CachedAssetReader extends AssetReader {
     });
     return _pendingReads[id];
   }
+
+  @override
+  Stream<AssetId> listAssetIds(List<InputSet> inputSets) =>
+      _reader.listAssetIds(inputSets);
 }
 
 /// An [AssetWriter] which takes both an [AssetCache] and an [AssetWriter]. It

lib/src/asset/file_based.dart

@@ -12,15 +12,17 @@ import '../asset/exceptions.dart';
 import '../asset/id.dart';
 import '../asset/reader.dart';
 import '../asset/writer.dart';
+import '../generate/input_set.dart';
 import '../package_graph/package_graph.dart';
 import 'exceptions.dart';
 
 /// Basic [AssetReader] which uses a [PackageGraph] to look up where to read
 /// files from disk.
 class FileBasedAssetReader implements AssetReader {
   final PackageGraph packageGraph;
+  final ignoredDirs;
 
-  FileBasedAssetReader(this.packageGraph);
+  FileBasedAssetReader(this.packageGraph, {this.ignoredDirs: const ['build']});
 
   @override
   Future<bool> hasInput(AssetId id) async {
@@ -46,6 +48,37 @@ class FileBasedAssetReader implements AssetReader {
       throw new InvalidInputException(id);
     }
   }
+
+  /// Searches for all [AssetId]s matching [inputSet]s.
+  Stream<AssetId> listAssetIds(Iterable<InputSet> inputSets) async* {
+    var seenAssets = new Set<AssetId>();
+    for (var inputSet in inputSets) {
+      var packageNode = packageGraph[inputSet.package];
+      var packagePath = packageNode.location.toFilePath();
+      for (var glob in inputSet.globs) {
+        var fileStream = glob
+            .list(followLinks: false, root: packagePath)
+            .where((e) =>
+                e is File && !ignoredDirs.contains(path.split(e.path)[1]));
+        await for (var entity in fileStream) {
+          var id = _fileToAssetId(entity, packageNode);
+          if (!seenAssets.add(id)) continue;
+          yield id;
+        }
+      }
+    }
+  }
+}
+
+/// Creates an [AssetId] for [file], which is a part of [packageNode].
+AssetId _fileToAssetId(File file, PackageNode packageNode) {
+  var filePath = path.normalize(file.absolute.path);
+  var packageUri = packageNode.location;
+  var packagePath = path.normalize(packageUri.isAbsolute
+      ? packageUri.toFilePath()
+      : path.absolute(packageUri.toFilePath()));
+  var relativePath = path.relative(filePath, from: packagePath);
+  return new AssetId(packageNode.name, relativePath);
 }
 
 /// Basic [AssetWriter] which uses a [PackageGraph] to look up where to write

lib/src/asset/reader.dart

@@ -4,10 +4,13 @@
 import 'dart:async';
 import 'dart:convert';
 
+import '../generate/input_set.dart';
 import 'id.dart';
 
 abstract class AssetReader {
   Future<String> readAsString(AssetId id, {Encoding encoding: UTF8});
 
   Future<bool> hasInput(AssetId id);
+
+  Stream<AssetId> listAssetIds(List<InputSet> inputSets);
 }

lib/src/generate/build.dart

@@ -2,7 +2,6 @@
 // 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 'dart:async';
-import 'dart:io';
 
 import 'package:logging/logging.dart';
 import 'package:path/path.dart' as path;
@@ -17,7 +16,6 @@ import '../builder/builder.dart';
 import '../builder/build_step_impl.dart';
 import '../package_graph/package_graph.dart';
 import 'build_result.dart';
-import 'input_set.dart';
 import 'phase.dart';
 
 /// Runs all of the [Phases] in [phaseGroups].
@@ -43,14 +41,14 @@ Future<BuildResult> build(List<List<Phase>> phaseGroups,
   Logger.root.level = logLevel;
   onLog ??= print;
   var logListener = Logger.root.onRecord.listen(onLog);
+  // No need to create a package graph if we were supplied a reader/writer.
   packageGraph ??= new PackageGraph.forThisPackage();
   var cache = new AssetCache();
   reader ??=
       new CachedAssetReader(cache, new FileBasedAssetReader(packageGraph));
   writer ??=
       new CachedAssetWriter(cache, new FileBasedAssetWriter(packageGraph));
   var result = runZoned(() {
-    _validatePhases(phaseGroups);
     return _runPhases(phaseGroups);
   }, onError: (e, s) {
     return new BuildResult(BuildStatus.Failure, BuildType.Full, [],
@@ -74,23 +72,14 @@ AssetReader get _reader => Zone.current[_assetReaderKey];
 AssetWriter get _writer => Zone.current[_assetWriterKey];
 PackageGraph get _packageGraph => Zone.current[_packageGraphKey];
 
-/// Validates the phases.
-void _validatePhases(List<List<Phase>> phaseGroups) {
-  if (phaseGroups.length > 1) {
-    // Don't support using generated files as inputs yet, so we only support
-    // one phase.
-    throw new UnimplementedError(
-        'Only one phase group is currently supported.');
-  }
-}
-
 /// Runs the [phaseGroups] and returns a [Future<BuildResult>] which completes
 /// once all [Phase]s are done.
 Future<BuildResult> _runPhases(List<List<Phase>> phaseGroups) async {
   var outputs = [];
   for (var group in phaseGroups) {
     for (var phase in group) {
-      var inputs = _assetIdsFor(phase.inputSets);
+      var inputs = (await _reader.listAssetIds(phase.inputSets).toList())
+          .where(_isValidInput);
       for (var builder in phase.builders) {
         // TODO(jakemac): Optimize, we can run all the builders in a phase
         // at the same time instead of sequentially.
@@ -103,36 +92,17 @@ Future<BuildResult> _runPhases(List<List<Phase>> phaseGroups) async {
   return new BuildResult(BuildStatus.Success, BuildType.Full, outputs);
 }
 
-/// Gets all [AssetId]s matching [inputSets] in the current package.
-List<AssetId> _assetIdsFor(List<InputSet> inputSets) {
-  var ids = [];
-  for (var inputSet in inputSets) {
-    var files = _filesMatching(inputSet);
-    for (var file in files) {
-      var segments = file.uri.pathSegments;
-      var newPath = path.joinAll(segments.getRange(
-          segments.indexOf(inputSet.package) + 1, segments.length));
-      ids.add(new AssetId(inputSet.package, newPath));
-    }
-  }
-  return ids;
+/// Checks if an [input] is valid.
+bool _isValidInput(AssetId input) {
+  var parts = path.split(input.path);
+  // Files must be in a top level directory.
+  if (parts.length == 1) return false;
+  if (input.package != _packageGraph.root.name) return parts[0] == 'lib';
+  return true;
 }
 
-/// Returns all files matching [inputSet].
-Set<File> _filesMatching(InputSet inputSet) {
-  var files = new Set<File>();
-  var root = _packageGraph[inputSet.package].location.toFilePath();
-  for (var glob in inputSet.globs) {
-    files.addAll(glob.listSync(followLinks: false, root: root).where(
-        (e) => e is File && !_ignoredDirs.contains(path.split(e.path)[1])));
-  }
-  return files;
-}
-
-const _ignoredDirs = const ['build'];
-
 /// Runs [builder] with [inputs] as inputs.
-Stream<Asset> _runBuilder(Builder builder, List<AssetId> inputs) async* {
+Stream<Asset> _runBuilder(Builder builder, Iterable<AssetId> inputs) async* {
   for (var input in inputs) {
     var expectedOutputs = builder.declareOutputs(input);
     var inputAsset = new Asset(input, await _reader.readAsString(input));

lib/src/generate/build_result.dart

@@ -9,8 +9,8 @@ class BuildResult {
   /// The status of this build.
   final BuildStatus status;
 
-  /// The [Exception] that was thrown during this build if it failed.
-  final Exception exception;
+  /// The error that was thrown during this build if it failed.
+  final Object exception;
 
   /// The [StackTrace] for [exception] if non-null.
   final StackTrace stackTrace;

lib/src/generate/input_set.dart

@@ -17,6 +17,11 @@ class InputSet {
   final List<Glob> globs;
 
   InputSet(this.package, {Iterable<String> filePatterns})
-      : this.globs = new List.unmodifiable(
-            filePatterns.map((pattern) => new Glob(pattern)));
+      : this.globs = _globsFor(filePatterns);
+}
+
+List<Glob> _globsFor(Iterable<String> filePatterns) {
+  filePatterns ??= ['**/*'];
+  return new List.unmodifiable(
+      filePatterns.map((pattern) => new Glob(pattern)));
 }

lib/src/transformer/transformer.dart

@@ -97,6 +97,10 @@ class _TransformAssetReader implements AssetReader {
   @override
   Future<String> readAsString(build.AssetId id, {Encoding encoding: UTF8}) =>
       transform.readInputAsString(toBarbackAssetId(id), encoding: encoding);
+
+  @override
+  /// No way to implement this, but luckily its not necessary.
+  Stream<build.AssetId> listAssetIds(_) => throw new UnimplementedError();
 }
 
 /// Very simple [AssetWriter] which uses a [Transform].

test/asset/file_based_test.dart

@@ -15,7 +15,7 @@ final packageGraph = new PackageGraph.forPath('test/fixtures/basic_pkg');
 main() {
 
   group('FileBasedAssetReader', () {
-    final reader = new FileBasedAssetReader(packageGraph);
+    final reader = new FileBasedAssetReader(packageGraph, ignoredDirs: ['pkg']);
 
     test('can read any application package files', () async {
       expect(await reader.readAsString(makeAssetId('basic_pkg|hello.txt')),
@@ -66,6 +66,29 @@ main() {
       expect(reader.readAsString(makeAssetId('foo|lib/bar.txt')),
           throwsA(packageNotFoundException));
     });
+
+    test('can list files based on simple InputSets', () async {
+      var inputSets = [
+        new InputSet('basic_pkg'),
+        new InputSet('a'),
+      ];
+      expect(await reader.listAssetIds(inputSets).toList(), unorderedEquals([
+        makeAssetId('basic_pkg|lib/hello.txt'),
+        makeAssetId('basic_pkg|web/hello.txt'),
+        makeAssetId('a|lib/a.txt'),
+      ]));
+    }, skip: 'Fails for multiple reasons.');
+
+    test('can list files based on InputSets with globs', () async {
+      var inputSets = [
+        new InputSet('basic_pkg', filePatterns: ['web/*.txt']),
+        new InputSet('a', filePatterns: ['lib/*']),
+      ];
+      expect(await reader.listAssetIds(inputSets).toList(), unorderedEquals([
+        makeAssetId('basic_pkg|web/hello.txt'),
+        makeAssetId('a|lib/a.txt'),
+      ]));
+    });
   });
 
   group('FileBasedAssetWriter', () {

test/common/copy_builder.dart

@@ -6,9 +6,11 @@ import 'dart:async';
 import 'package:build/build.dart';
 
 class CopyBuilder implements Builder {
-  int numCopies;
+  final int numCopies;
+  final String extension;
+  final String outputPackage;
 
-  CopyBuilder({this.numCopies: 1});
+  CopyBuilder({this.numCopies: 1, this.extension: 'copy', this.outputPackage});
 
   Future build(BuildStep buildStep) async {
     var ids = declareOutputs(buildStep.input.id);
@@ -24,7 +26,11 @@ class CopyBuilder implements Builder {
     }
     return outputs;
   }
-}
 
-AssetId _copiedAssetId(AssetId inputId, int copyNum) =>
-    inputId.addExtension('.copy${copyNum == null ? '' : '.$copyNum'}');
+  AssetId _copiedAssetId(AssetId inputId, int copyNum) {
+    var withExtension = inputId
+        .addExtension('.$extension${copyNum == null ? '' : '.$copyNum'}');
+    if (outputPackage == null) return withExtension;
+    return new AssetId(outputPackage, withExtension.path);
+  }
+}

test/common/in_memory_reader.dart

@@ -11,12 +11,25 @@ class InMemoryAssetReader implements AssetReader {
 
   InMemoryAssetReader(this.assets);
 
+  @override
   Future<bool> hasInput(AssetId id) {
     return new Future.value(assets.containsKey(id));
   }
 
+  @override
   Future<String> readAsString(AssetId id, {Encoding encoding: UTF8}) async {
     if (!await hasInput(id)) throw new AssetNotFoundException(id);
     return assets[id];
   }
+
+  @override
+  Stream<AssetId> listAssetIds(Iterable<InputSet> inputSets) async* {
+    for (var id in assets.keys) {
+      var matches = inputSets.any((inputSet) {
+        if (inputSet.package != id.package) return false;
+        return inputSet.globs.any((glob) => glob.matches(id.path));
+      });
+      if (matches) yield id;
+    }
+  }
 }

test/common/stub_reader.dart

@@ -7,8 +7,12 @@ import 'dart:convert';
 import 'package:build/build.dart';
 
 class StubAssetReader implements AssetReader {
+  @override
   Future<bool> hasInput(AssetId id) => new Future.value(null);
 
+  @override
   Future<String> readAsString(AssetId id, {Encoding encoding: UTF8}) =>
       new Future.value(null);
+
+  Stream<AssetId> listAssetIds(_) async* {}
 }