added plugin transformer which initializers can extend to do additional post-processing during tran…

lib/plugin_transformer.dart

Index: lib/plugin_transformer.dart
diff --git a/lib/plugin_transformer.dart b/lib/plugin_transformer.dart
new file mode 100644
index 0000000000000000000000000000000000000000..a7ecb8931dd3e2caa5c22e3d2dfe0fe2ceaaa5a4
--- /dev/null
+++ b/lib/plugin_transformer.dart
@@ -0,0 +1,87 @@
+// Copyright (c) 2015, 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 initialize.plugin_transformer;
+
+import 'dart:async';
+import 'package:analyzer/analyzer.dart';
+import 'package:barback/barback.dart';
+import 'package:source_maps/refactor.dart';
+import 'package:source_span/source_span.dart';
+
+/// Abstract transformer which will call [initEntry] for every [InitEntry]

[Jennifer Messerly, 2015/01/30 20:34:26]

could we do the initEntry here instead? it would save writing and re-parsing:
https://github.com/dart-lang/initialize/blob/master/lib/transformer.dart#L355

it seems like we'd need some way for webcomponents to "register" that it wants
to do an init transform.

is the issue that it's hard to do plugins/dependency injection in Dart?

[jakemac, 2015/01/30 22:16:17]

Yes, especially with transforms since they are just declared in the
pubspec.yaml. We could do this if we required everybody to make their own
transformer which extended the initialize transformer and mixed in some sort of
plugins, but I don't think normal people are going to want to do that.

Alternatively the web_components package could release an html_imports aware
transformer, but then if another package wants to do the same thing I don't see
how those would play nicely.

While not necessarily the most efficient solution, I think this is the easiest
for people to use, they can just list any of these plugin transformers after
their initialize transformer, and they should all play nicely together.

+/// expression found in the bootstrap file. This is used to centralize logic
+/// for initializers which want to do something special at transform time.
+abstract class InitializePluginTransformer extends AggregateTransformer {
+  // Path to the bootstrap file created by the initialize transformer.
+  final String _bootstrapFile;
+
+  // All the extra assets that were found, if child classes override
+  // classifyPrimary this lets them get at the other assets easily.
+  final allAssets = <Asset>[];
+
+  TransformLogger _logger;
+
+  InitializePluginTransformer(this._bootstrapFile);
+
+  classifyPrimary(AssetId id) {
+    if (_bootstrapFile == id.path) return _bootstrapFile;

[Jennifer Messerly, 2015/01/30 20:34:26]

silly, but I'd usually format this as: 

=> _bootstrapFile == id.path ? _bootstrapFile : null;

[jakemac, 2015/01/30 22:16:18]

Done.

+    return null;
+  }
+
+  Future apply(AggregateTransform transform) {
+    _logger = transform.logger;
+    var done = new Completer();
+    var listener = transform.primaryInputs.listen((Asset asset) {
+      allAssets.add(asset);
+      var id = asset.id;
+      if (id.path != _bootstrapFile) return;
+      // Calls initEntry for each InitEntry expression.
+      asset.readAsString().then((dartCode) {
+        var url = id.path.startsWith('lib/')
+            ? 'package:${id.package}/${id.path.substring(4)}'
+            : id.path;
+        var source = new SourceFile(dartCode, url: url);
+        var transaction = new TextEditTransaction(dartCode, source);
+        (parseCompilationUnit(dartCode,
+                    suppressErrors: true) as dynamic).declarations.firstWhere(

[Jennifer Messerly, 2015/01/30 20:34:26]

is there a reason for `as dynamic`?

[jakemac, 2015/01/30 22:16:18]

This is just to get rid of a bunch of casts and type checks that would be
required otherwise. We know the structure of the file already, and if that
changes this will break appropriately.

+                (d) => d.name.toString() ==

[Jennifer Messerly, 2015/01/30 20:34:26]

in general not all CompilationUnitMembers have names (e.g.
TopLevelVariableDeclaration because `var x,y,z;) ... perhaps change this to: 

(d) => d is FunctionDeclaration && d.name.name == 'main'


this isn't strictly needed because you know you're parsing a file with a
particular format :), but seems like it wouldn't hurt

[jakemac, 2015/01/30 22:16:17]

Related to the previous comment, I did start going down this path originally but
it ended up meaning like 3-4 type checks and casts throughout this expression.
Overall I think its more readable without all of that.

+                    'main').functionExpression.body.block.statements.firstWhere(
+            (statement) {
+          return statement.expression.target.toString() == 'initializers' &&
+              statement.expression.methodName.toString() == 'addAll';
+        }).expression.argumentList.arguments[0].elements
+            .where((arg) => arg is InstanceCreationExpression)
+            .forEach((e) => initEntry(e, transaction));
+
+        // Apply any transformations.
+        if (!transaction.hasEdits) {
+          transform.addOutput(asset);
+        } else {
+          var printer = transaction.commit();
+          printer.build(url);
+          transform.addOutput(new Asset.fromString(id, printer.text));
+        }
+        done.complete();
+      });
+    });
+
+    // Make sure all the assets are read before returning.
+    return Future.wait([done.future, listener.asFuture()]);

[Jennifer Messerly, 2015/01/30 20:34:26]

if you're returning listener.asFuture(), do you need `done` at all?

[jakemac, 2015/01/30 22:16:17]

Looks like you are right, removed it.

+  }
+
+  /// Gets called once for each generated [InitEntry] expression in the
+  /// bootstrap file. A [TextEditTransaction] is supplied so that the user can
+  /// modify the expression however they see fit.
+  void initEntry(
+      InstanceCreationExpression expression, TextEditTransaction transaction);
+
+  /// Convenience method to delete an Initializer expression completely.
+  void removeInitializer(
+      InstanceCreationExpression expression, TextEditTransaction transaction) {
+    // Delete the entire line.
+    var line = transaction.file.getLine(expression.offset);
+    transaction.edit(transaction.file.getOffset(line),
+        transaction.file.getOffset(line + 1), '');
+  }
+}