add basic constructor that doesn't take BarbackSettings

lib/transformer.dart

 // 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.transformer;
 
 import 'dart:async';
 import 'dart:collection' show Queue;
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:barback/barback.dart';
 import 'package:code_transformers/resolver.dart';
 import 'package:path/path.dart' as path;
 
 /// Removes the mirror-based initialization logic and replaces it with static
 /// logic.
 class InitializeTransformer extends Transformer {
-  final BarbackSettings _settings;
   final Resolvers _resolvers;
+  final String _entryPoint;
+  final String _newEntryPoint;
 
-  InitializeTransformer.asPlugin(this._settings)
+  InitializeTransformer(this._entryPoint, this._newEntryPoint)
       : _resolvers = new Resolvers.fromMock({
         // The list of types below is derived from:
         //   * types that are used internally by the resolver (see
         //   _initializeFrom in resolver.dart).
         // TODO(jakemac): Move this into code_transformers so it can be shared.
         'dart:core': '''
             library dart.core;
             class Object {}
             class Function {}
             class StackTrace {}
@@ skipping 20 matching lines @@
 
             class List<V> extends Object {}
             class Map<K, V> extends Object {}
             ''',
         'dart:html': '''
             library dart.html;
             class HtmlElement {}
             ''',
       });
 
-  String get _entryPoint => _settings.configuration['entryPoint'];
-  String get _newEntryPoint {
-    var val = _settings.configuration['newEntryPoint'];
-    if (val == null) val = _entryPoint.replaceFirst('.dart', '.bootstrap.dart');
-    return val;
+  factory InitializeTransformer.asPlugin(BarbackSettings settings) {
+    var entryPoint = settings.configuration['entryPoint'];
+    var newEntryPoint = settings.configuration['newEntryPoint'];
+    if (newEntryPoint == null) {
+      newEntryPoint = entryPoint.replaceFirst('.dart', '.bootstrap.dart');
+    }
+    return new InitializeTransformer(entryPoint, newEntryPoint);
   }
 
   bool isPrimary(AssetId id) => _entryPoint == id.path;
 
   Future apply(Transform transform) {
     var newEntryPointId =
         new AssetId(transform.primaryInput.id.package, _newEntryPoint);
     return transform.hasInput(newEntryPointId).then((exists) {
       if (exists) {
         transform.logger
@@ skipping 22 matching lines @@
   /// Queue for intialization annotations.
   final _initQueue = new Queue<_InitializerData>();
   /// All the annotations we have seen for each element
   final _seenAnnotations = new Map<Element, Set<ElementAnnotation>>();
 
   TransformLogger _logger;
 
   _BootstrapFileBuilder(
       this._resolver, this._transform, this._entryPoint, this._newEntryPoint) {
     _logger = _transform.logger;
-    _initializeLibrary = _resolver
-        .getLibrary(new AssetId('initialize', 'lib/initialize.dart'));
+    _initializeLibrary =
+        _resolver.getLibrary(new AssetId('initialize', 'lib/initialize.dart'));
     _initializer = _initializeLibrary.getType('Initializer');
   }
 
   /// Adds the new entry point file to the transform. Should only be ran once.
   void run() {
     var entryLib = _resolver.getLibrary(_entryPoint);
     _readLibraries(entryLib);
 
     _transform.addOutput(
         new Asset.fromString(_newEntryPoint, _buildNewEntryPoint(entryLib)));
@@ skipping 56 matching lines @@
     });
     return found;
   }
 
   String _buildNewEntryPoint(LibraryElement entryLib) {
     var importsBuffer = new StringBuffer();
     var initializersBuffer = new StringBuffer();
     var libraryPrefixes = new Map<LibraryElement, String>();
 
     // Import the static_loader and original entry point.
-    importsBuffer.writeln(
-        "import 'package:initialize/src/static_loader.dart';");
+    importsBuffer
+        .writeln("import 'package:initialize/src/static_loader.dart';");
     _maybeWriteImport(entryLib, libraryPrefixes, importsBuffer);
 
     initializersBuffer.writeln('  initializers.addAll([');
     while (_initQueue.isNotEmpty) {
       var next = _initQueue.removeFirst();
 
       _maybeWriteImport(next.element.library, libraryPrefixes, importsBuffer);
       _maybeWriteImport(
           next.annotation.element.library, libraryPrefixes, importsBuffer);
 
@@ skipping 173 matching lines @@
     })).map((import) => import.importedLibrary);
 }
 
 // Element/ElementAnnotation pair.
 class _InitializerData {
   final Element element;
   final ElementAnnotation annotation;
 
   _InitializerData(this.element, this.annotation);
 }