feat(transformer): pub transformer for automatically creating static type factories

Author: Pete Blois

.gitignore

@@ -7,5 +7,6 @@ test/main.dart.js
 test/main.dart.js.deps
 test/main.dart.js.map
 test/main.dart.precompiled.js
+test/transformer/build
 out
-
+build

lib/auto_injector.dart

@@ -0,0 +1,58 @@
+/**
+ * Library for using a pub transformer to automatically switch between
+ * dynamic and static injection.
+ *
+ * ## Step 1: Hook up the build step
+ * Edit ```pubspec.yaml``` to add the di transformer to the list of
+ * transformers.
+ *
+ *     name: transformer_demo
+ *     version: 0.0.1
+ *     dependencies:
+ *       di: any
+ *       inject: any
+ *     transformers:
+ *     - di:
+ *         dart_entry: web/main.dart
+ *         injectable_annotations: transformer_demo.Injectable
+ *
+ * ## Step 2: Annotate your types
+ *
+ *     class Engine {
+ *       @inject
+ *       Engine();
+ *     }
+ *
+ * or
+ *
+ *     @Injectable // custom annotation specified in pubspec.yaml
+ *     class Car {}
+ *
+ *
+ * ## Step 3: Use the auto injector
+ * Modify your entry script to use [defaultInjector] as the injector.
+ *
+ * This must be done from the file registered as the dart_entry in pubspec.yaml
+ * as this is the only file which will be modified to include the generated
+ * injector.
+ *
+ *     import 'package:di/auto_injector' as auto;
+ *     main() {
+ *       var injector = auto.defaultInjector(modules: ...);
+ *     }
+ }
+ */
+library di.auto_injector;
+
+import 'package:di/di.dart';
+import 'package:di/dynamic_injector.dart';
+
+@MirrorsUsed(override: '*')
+import 'dart:mirrors' show MirrorsUsed;
+
+Injector defaultInjector({List<Module> modules, String name,
+    bool allowImplicitInjection: false}) =>
+    new DynamicInjector(
+      modules: modules,
+      name: name,
+      allowImplicitInjection: allowImplicitInjection);

lib/generator.dart

@@ -7,6 +7,7 @@ import 'package:analyzer/src/generated/sdk.dart' show DartSdk;
 import 'package:analyzer/src/generated/sdk_io.dart' show DirectoryBasedDartSdk;
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
+import 'package:path/path.dart' as path;
 
 import 'dart:io';
 
@@ -31,7 +32,7 @@ main(args) {
   print('output: $output');
   print('packageRoots: $packageRoots');
 
-  var code = generateCode(entryPoint, classAnnotations, pathToSdk, packageRoots);
+  var code = generateCode(entryPoint, classAnnotations, pathToSdk, packageRoots, output);
   code.forEach((chunk, code) {
     String fileName = output;
     if (chunk.library != null) {
@@ -43,14 +44,14 @@ main(args) {
 }
 
 Map<Chunk, String> generateCode(String entryPoint, List<String> classAnnotations,
-    String pathToSdk, List<String> packageRoots) {
+    String pathToSdk, List<String> packageRoots, String outputFilename) {
   var c = new SourceCrawler(pathToSdk, packageRoots);
   List<String> imports = <String>[];
   Map<Chunk, List<ClassElement>> typeFactoryTypes = <Chunk, List<ClassElement>>{};
   Map<String, String> typeToImport = new Map<String, String>();
   c.crawl(entryPoint, (CompilationUnitElement compilationUnit, SourceFile source) {
       new CompilationUnitVisitor(c.context, source, classAnnotations, imports,
-          typeToImport, typeFactoryTypes).visit(compilationUnit, source);
+          typeToImport, typeFactoryTypes, outputFilename).visit(compilationUnit, source);
   });
   return printLibraryCode(typeToImport, imports, typeFactoryTypes);
 }
@@ -131,10 +132,11 @@ class CompilationUnitVisitor {
   List<String> classAnnotations;
   SourceFile source;
   AnalysisContext context;
+  String outputFilename;
 
   CompilationUnitVisitor(this.context, this.source,
       this.classAnnotations, this.imports, this.typeToImport,
-      this.typeFactoryTypes);
+      this.typeFactoryTypes, this.outputFilename);
 
   visit(CompilationUnitElement compilationUnit, SourceFile source) {
     visitLibrary(compilationUnit.enclosingElement, source);
@@ -188,10 +190,13 @@ class CompilationUnitVisitor {
     if (classElement.name.startsWith('_')) {
       return; // ignore private classes.
     }
-    typeToImport[getCanonicalName(classElement.type)] =
-        source.entryPointImport;
-    if (!imports.contains(source.entryPointImport)) {
-      imports.add(source.entryPointImport);
+    var importUri = source.entryPointImport;
+    if (Uri.parse(importUri).scheme == '') {
+      importUri = path.relative(importUri, from: path.dirname(outputFilename));
+    }
+    typeToImport[getCanonicalName(classElement.type)] = importUri;
+    if (!imports.contains(importUri)) {
+      imports.add(importUri);
     }
     for (ElementAnnotation ann in classElement.metadata) {
       if (ann.element is ConstructorElement) {

lib/transformer.dart

@@ -0,0 +1,128 @@
+/**
+ * Transformer which generates type factories for static injection.
+ *
+ * Types which are considered injectable can be annotated in the following ways:
+ *
+ * * Use the @inject annotation on a class from `package:inject/inject.dart`
+ *     @inject
+ *     class Engine {}
+ *
+ * or on the constructor:
+ *
+ *     class Engine {
+ *       @inject
+ *       Engine();
+ *     }
+ *
+ * * Define a custom annotation in pubspec.yaml
+ *
+ *     transformers:
+ *     - di:
+ *       injectable_annotations:
+ *       - library_name.ClassName
+ *       - library_name.constInstance
+ *
+ * Annotate constructors or classes with those annotations
+ *
+ *     @ClassName()
+ *     class Engine {}
+ *
+ *     class Engine {
+ *       @constInstance
+ *       Engine();
+ *     }
+ *
+ * * Use package:di's Injectables
+ *
+ *     @Injectables(const [Engine])
+ *     library my_lib;
+ *
+ *     import 'package:di/annotations.dart';
+ *
+ *     class Engine {}
+ *
+ * * Specify injected types via pubspec.yaml
+ *
+ *     transformers:
+ *     - di:
+ *       injected_types:
+ *       - library_name.Engine
+ */
+library di.transformer;
+
+import 'dart:io';
+import 'package:barback/barback.dart';
+import 'package:code_transformers/resolver.dart';
+import 'package:di/transformer/injector_generator.dart';
+import 'package:di/transformer/options.dart';
+import 'package:path/path.dart' as path;
+
+
+/**
+ * The transformer, which will extract all classes being dependency injected
+ * into a static injector.
+ */
+class DependencyInjectorTransformerGroup implements TransformerGroup {
+  final Iterable<Iterable> phases;
+
+  DependencyInjectorTransformerGroup(TransformOptions options)
+      : phases = _createPhases(options);
+
+  DependencyInjectorTransformerGroup.asPlugin(BarbackSettings settings)
+      : this(_parseSettings(settings.configuration));
+}
+
+TransformOptions _parseSettings(Map args) {
+  var annotations = _readStringListValue(args, 'injectable_annotations');
+  var injectedTypes = _readStringListValue(args, 'injected_types');
+
+  var sdkDir = _readStringValue(args, 'dart_sdk', required: false);
+  if (sdkDir == null) {
+    // Assume the Pub executable is always coming from the SDK.
+    sdkDir =  path.dirname(path.dirname(Platform.executable));
+  }
+
+  return new TransformOptions(
+      dartEntries: _readStringListValue(args, 'dart_entries'),
+      injectableAnnotations: annotations,
+      injectedTypes: injectedTypes,
+      sdkDirectory: sdkDir);
+}
+
+_readStringValue(Map args, String name, {bool required: true}) {
+  var value = args[name];
+  if (value == null) {
+    if (required) {
+      print('di transformer "$name" has no value.');
+    }
+    return null;
+  }
+  if (value is! String) {
+    print('di transformer "$name" value is not a string.');
+    return null;
+  }
+  return value;
+}
+
+_readStringListValue(Map args, String name) {
+  var value = args[name];
+  if (value == null) return [];
+  var results = [];
+  bool error;
+  if (value is List) {
+    results = value;
+    error = value.any((e) => e is! String);
+  } else if (value is String) {
+    results = [value];
+    error = false;
+  } else {
+    error = true;
+  }
+  if (error) {
+    print('Invalid value for "$name" in di transformer .');
+  }
+  return results;
+}
+
+List<List<Transformer>> _createPhases(TransformOptions options) =>
+    [[new InjectorGenerator(options, new Resolvers(options.sdkDirectory))]];