Fix an edge case in the dependency computer.

lib/src/barback/dependency_computer.dart

 // Copyright (c) 2014, 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.
 
 library pub.barback.dependency_computer;
 
 import 'package:barback/barback.dart';
 import 'package:path/path.dart' as p;
 
 import '../dart.dart';
@@ skipping 154 matching lines @@
 
     traversePackage(packageName) {
       if (seen.contains(packageName)) return;
       seen.add(packageName);
 
       var package = _graph.packages[packageName];
       for (var phase in package.pubspec.transformers) {
         for (var config in phase) {
           var id = config.id;
           if (id.isBuiltInTransformer) continue;
+          if (packageName != _graph.entrypoint.root.name &&
+              !config.canTransformPublicFiles) {
+            continue;
+          }
+
           if (_loadingPackageComputers.contains(id.package)) {
             throw new CycleException("$packageName is transformed by $id");
           }
+
           results.add(id);
         }
       }
 
       var dependencies = packageName == _graph.entrypoint.root.name ?
           package.immediateDependencies : package.dependencies;
       for (var dep in dependencies) {
         try {
           traversePackage(dep.name);
         } on CycleException catch (error) {
@@ skipping 69 matching lines @@
     var isRootPackage =
         packageName == _dependencyComputer._graph.entrypoint.root.name;
 
     // If [_package] uses its own transformers, there will be fewer transformers
     // running on [_package] while its own transformers are loading than there
     // will be once all its transformers are finished loading. To handle this,
     // we run [_transformersNeededByTransformer] to pre-populate
     // [_transformersNeededByLibraries] while [_applicableTransformers] is
     // smaller.
     for (var phase in _package.pubspec.transformers) {
-      for (var config in phase) {
+      _applicableTransformers.addAll(phase.where((config) {
         // Ignore non-root transformers on non-public files.
-        if (!isRootPackage && !config.canTransformPublicFiles) continue;
+        if (!isRootPackage && !config.canTransformPublicFiles) return false;
 
         var id = config.id;
         try {
           if (id.package != _package.name) {
             // Probe [id]'s transformer dependencies to ensure that it doesn't
             // depend on this package. If it does, a CycleError will be thrown.
             _dependencyComputer._transformersNeededByTransformer(id);
           } else {
             // Store the transformers needed specifically with the current set
             // of [_applicableTransformers]. When reporting this transformer's
             // dependencies, [computeTransformersNeededByTransformers] will use
             // this stored set of dependencies rather than the potentially wider
             // set that would be recomputed if [transformersNeededByLibrary]
             // were called anew.
             _transformersNeededByTransformers[id] =
                 transformersNeededByLibrary(_package.transformerPath(id));
           }
         } on CycleException catch (error) {
           throw error.prependStep("$packageName is transformed by $id");
         }
-      }
+
+        return true;
+      }));
 
       // Clear the cached imports and exports because the new transformers may
       // start transforming a library whose directives were previously
       // statically analyzable.
       _transitiveExternalDirectives.clear();
-      _applicableTransformers.addAll(phase);
     }
   }
 
   /// Returns the set of all transformers that need to be loaded before [id] is
   /// loaded.
   ///
   /// [id] must refer to a transformer in [_package].
   Set<TransformerId> _transformersNeededByTransformer(TransformerId id) {
     assert(id.package == _package.name);
     if (_transformersNeededByTransformers.containsKey(id)) {
@@ skipping 130 matching lines @@
       return null;
     }
 
     _directives[libraryUri] =
         parseImportsAndExports(readTextFile(library), name: library)
         .map((directive) => Uri.parse(directive.uri.stringValue))
         .toSet();
     return _directives[libraryUri];
   }
 }