Unique names

.gitignore

@@ -8,5 +8,7 @@ test/main.dart.js.deps
 test/main.dart.js.map
 test/main.dart.precompiled.js
 test/transformer/build
+benchmark/generated_files/
+examples/build
 out
 build

CHANGELOG.md

@@ -1,3 +1,66 @@
+# 2.0.0-alpha.1
+
+## Breaking Changes
+
+### Calls to StaticInjector and DynamicInjector should be replaced with ModuleInjector
+  - There are no longer `StaticInjectors` and `DynamicInjectors`. They have been replaced
+    by a new `ModuleInjector` class that acts as both types of injectors.
+
+### ModuleInjectors have no visibility
+  - All bindings and instances of parent injectors are now visible in child injectors.
+  - The optional argument `forceNewInstances` of `Injector.createChild` has been removed
+    Instead, create a new module with bindings of the types that require new instances
+    and pass that to the child injector, and the child injector will create new
+    instances instead of returning the instance of the parent injector.
+
+### Use “new ModuleInjector(modules, parent)” instead of “Injector.createChild(modules)”
+  - The latter is still available but deprecated.
+  - Injectors with no parent now have a dummy RootInjector instance as the parent
+    Instead of checking “parent == null”, check for “parent == rootInjector”.
+
+### Injectors no longer have a name field
+
+### typeFactories have changed
+  - Old type factories had the form `(injector) => new Instance(injector.get(dep1), … )`
+  - New factories have one of these two forms:
+    - `toFactory(a0, a1, …) => new Instance(a0, a1, …)`
+    - `toFactoryPos(List<dependency instances> p) => new Instance(p[0], p[1] …)`
+  - When calling `Module.bind(toFactory: factory)`, there is an additional argument `inject`
+    of a list of types or keys (preferred for performance) whose instances should be
+    passed to the factory. The array `p` passed to the factory function will be instances
+    of the types in `inject`.
+
+    Example:
+    - Old code `module.bind(Car, toFactory: (i) => new Car(i.get(Engine)));`
+    - New code
+      - `module.bind(Car, toFactoryPos: (p) => new Car(p[0]), inject: [Engine]);`
+      - `module.bind(Car, toFactory: (engine) => new Car(engine), inject: [Engine]);`
+
+    There is also some syntactic sugar for this special case.
+    - Old code `module.bind(Engine, toFactory: (i) => i.get(Engine));`
+    - New code `module.bind(Engine, toFactory: (e) => e, inject: [Engine]);`
+    - With sugar `module.bind(Engine, inject: [Engine]);`
+
+### Modules have a TypeReflector instance attached
+  - The `TypeReflector` is how the module will find the `toFactoryPos` and `inject`
+    arguments when not explicitly specified. This is either done with mirroring or code
+    generation via transformers. Typical use will not need to worry about this at all, and
+    should initialize it as shown below. If needed, implement `TypeReflector` and use
+    `new Module.withReflector(reflector)`.
+  - Modules need a `TypeReflector` instance initialized:
+
+        import 'package:di/di_dynamic.dart';
+        main() {
+          setupModuleTypeReflector();
+        }
+
+### The transformer has been updated
+  - Running the transformer will do the necessary code generation and edits to switch the
+    default `TypeReflector` from mirroring to static factories. Enable transformer to use
+    static factories, disable to use mirrors. More docs on the transformer can be found in
+    `transformer.dart`
+  - Annotating types for injection has not changed.
+
 # 1.0.0
 
 Starting with this release DI is following [semver](http://semver.org).

LICENSE

@@ -1,6 +1,6 @@
 The MIT License
 
-Copyright (c) 2013 Google, Inc.
+Copyright (c) 2014 Google, Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -7,20 +7,19 @@
 Add dependency to your pubspec.yaml.
 
     dependencies:
-      di: ">=0.0.39 <0.1.0"
+      di: ">=2.0.0 <3.0.0"
 
 Then, run `pub install`.
 
 Import di.
 
     import 'package:di/di.dart';
-    import 'package:di/auto_injector.dart';
 
 ## Example
 
 ```dart
 import 'package:di/di.dart';
-import 'package:di/auto_injector.dart';
+import 'package:di/di_dynamic.dart';
 
 abstract class Engine {
   go();
@@ -64,14 +63,18 @@ class ElectricCar {
 }
 
 void main() {
-  var injector = defaultInjector(modules: [new Module()
+  setupModuleTypeReflector();
+  var injector = new ModuleInjector(modules: [new Module()
       ..bind(GenericCar)
       ..bind(ElectricCar)
-      ..bind(Engine, toFactory: (i) => new V8Engine())
+      ..bind(Engine, toFactory: () => new V8Engine())
       ..bind(Engine, toImplementation: ElectricEngine, withAnnotation: Electric)
   ]);
-  injector.get(GenericCar).drive();
-  injector.get(ElectricCar).drive();
+  injector.get(GenericCar).drive(); // Vroom...
+  injector.get(ElectricCar).drive(); // Hum...
 }
 ```
 
+## Contributing
+
+Refer to the guidelines for [contributing to AngularDart](http://goo.gl/nrXVgm).

benchmark/dynamic_injector_benchmark.dart

@@ -1,10 +1,8 @@
 import 'package:benchmark_harness/benchmark_harness.dart';
-import 'package:di/dynamic_injector.dart';
 
 import 'injector_benchmark_common.dart';
 
-
 main() {
   new InjectorBenchmark('DynamicInjectorBenchmark',
-      (m) => new DynamicInjector(modules: m)).report();
-}
+      new DynamicTypeFactories()).report();
+}

benchmark/injector_benchmark_common.dart

@@ -6,32 +6,43 @@ import 'package:di/di.dart';
 int count = 0;
 
 class InjectorBenchmark extends BenchmarkBase {
-  var injectorFactory;
   var module;
+  var typeReflector;
+  Key KEY_A;
+  Key KEY_B;
+  Key KEY_C;
+  Key KEY_D;
+  Key KEY_E;
 
-  InjectorBenchmark(name, this.injectorFactory) : super(name);
+  InjectorBenchmark(name, this.typeReflector) : super(name);
 
   void run() {
-    Injector injector = injectorFactory([module]);
-    injector.get(A);
-    injector.get(B);
+    Injector injector = new ModuleInjector([module]);
+    injector.getByKey(KEY_A);
+    injector.getByKey(KEY_B);
 
-    var childInjector = injector.createChild([module]);
-    childInjector.get(A);
-    childInjector.get(B);
+    var childInjector = new ModuleInjector([module], injector);
+    childInjector.getByKey(KEY_A);
+    childInjector.getByKey(KEY_B);
   }
 
   setup() {
-    module = new Module()
-      ..type(A)
-      ..type(B)
-      ..type(C)
-      ..type(C, withAnnotation: AnnOne, implementedBy: COne )
-      ..type(D)
-      ..type(E)
-      ..type(E, withAnnotation: AnnTwo, implementedBy: ETwo )
-      ..type(F)
-      ..type(G);
+    module = new Module.withReflector(typeReflector)
+      ..bind(A)
+      ..bind(B)
+      ..bind(C)
+      ..bind(C, withAnnotation: AnnOne, toImplementation: COne )
+      ..bind(D)
+      ..bind(E)
+      ..bind(E, withAnnotation: AnnTwo, toImplementation: ETwo )
+      ..bind(F)
+      ..bind(G);
+
+    KEY_A = new Key(A);
+    KEY_B = new Key(B);
+    KEY_C = new Key(C);
+    KEY_D = new Key(D);
+    KEY_E = new Key(E);
   }
 
   teardown() {
@@ -96,7 +107,31 @@ class F {
 }
 
 class G {
-  G(@AnnTwo() E) {
+  G(@AnnTwo() E e) {
     count++;
   }
 }
+
+var typeFactories = {
+    A: (p) => new A(p[0], p[1]),
+    B: (p) => new B(p[0], p[1]),
+    C: (p) => new C(),
+    D: (p) => new D(),
+    E: (p) => new E(),
+    COne: (p) => new COne(),
+    ETwo: (p) => new ETwo(),
+    F: (p) => new F(p[0], p[1]),
+    G: (p) => new G(p[0]),
+};
+
+var paramKeys = {
+    A: [new Key(B), new Key(C)],
+    B: [new Key(D), new Key(E)],
+    C: const [],
+    D: const [],
+    E: const [],
+    COne: const [],
+    ETwo: const [],
+    F: [new Key(C, AnnOne), new Key(D)],
+    G: [new Key(G, AnnTwo)],
+};

benchmark/instance_benchmark.dart

@@ -1,29 +1,22 @@
-import 'package:di/static_injector.dart';
+import 'package:di/di.dart';
+import 'package:di/di_static.dart';
 
 import 'injector_benchmark_common.dart';
 
 // tests the speed of cached getInstanceByKey requests
 class InstanceBenchmark extends InjectorBenchmark{
-  InstanceBenchmark(name, injectorFactory) : super(name, injectorFactory);
+  InstanceBenchmark(name, typeReflector) : super(name, typeReflector);
 
   void run(){
-    Injector injector = injectorFactory([module]);
+    Injector injector = new ModuleInjector([module]);
     for (var i = 0; i < 30; i++) {
       injector.get(A);
     }
   }
 }
 
 main() {
-  var typeFactories = {
-      A: (f) => new A(f(B), f(C)),
-      B: (f) => new B(f(D), f(E)),
-      C: (f) => new C(),
-      D: (f) => new D(),
-      E: (f) => new E(),
-  };
-
   new InstanceBenchmark('InstanceBenchmark',
-      (m) => new StaticInjector(modules: m, typeFactories: typeFactories)
+      new GeneratedTypeFactories(typeFactories, paramKeys)
   ).report();
 }

benchmark/large_benchmark.dart

@@ -0,0 +1,70 @@
+import 'package:benchmark_harness/benchmark_harness.dart';
+import 'package:di/di.dart';
+import 'package:di/di_static.dart';
+import 'generated_files/factories.dart';
+
+import 'dart:math';
+
+class LargeBenchmark extends BenchmarkBase {
+  var injectorFactory;
+  Injector rootInjector;
+  Injector leafInjector;
+  var leafKey;
+  var rng = new Random();
+  var numInjectors = 1;
+  var allLeaves = [];
+
+  LargeBenchmark(name, this.injectorFactory) : super("Large" + name);
+
+  setup() {
+    var rootModule = new Module()
+      ..bindByKey(key999)
+      ..bindByKey(key998)
+      ..bindByKey(key997)
+      ..bindByKey(key996)
+      ..bindByKey(key995);
+    rootInjector = injectorFactory([rootModule]);
+
+    createChildren (injector, depth, width) {
+      if (depth <= 0){
+        allLeaves.add(injector);
+        return;
+      }
+      for (var i=0; i<width; i++){
+        var module = new Module();
+        for (var j=0; j<5; j++){
+          leafKey = allKeys[rng.nextInt(995)];
+          module.bindByKey(leafKey);
+        }
+        leafInjector = injector.createChild([module]);
+        numInjectors++;
+        createChildren(leafInjector, depth-1, width);
+      }
+    }
+
+    createChildren(rootInjector, 5, 5);
+    print("$numInjectors injectors created.");
+  }
+}
+
+class GetFromRoot extends LargeBenchmark {
+  GetFromRoot() : super('FromRoot', (m) => new ModuleInjector(m));
+
+  run() {
+    leafInjector.getByKey(key999);
+  }
+}
+
+class GetFromLeaf extends LargeBenchmark {
+  GetFromLeaf() : super('FromLeaf', (m) => new ModuleInjector(m));
+
+  run() {
+    leafInjector.getByKey(leafKey);
+  }
+}
+
+main() {
+  Module.DEFAULT_REFLECTOR = new GeneratedTypeFactories(typeFactories, parameterKeys);
+  new GetFromRoot().report();
+  new GetFromLeaf().report();
+}

benchmark/module_benchmark.dart

@@ -3,21 +3,26 @@ import 'package:di/di.dart';
 
 import 'injector_benchmark_common.dart';
 
+/**
+ * tests the speed of looking up typeFactories and binding them to
+ * a module. Mirroring time is not counted because DynamicTypeFactories
+ * caches the results.
+ */
 class ModuleBenchmark extends BenchmarkBase {
   var injectorFactory;
 
   ModuleBenchmark() : super('ModuleBenchmark');
 
   void run() {
     var m = new Module()
-      ..type(A)
-      ..type(B)
-      ..type(C)
-      ..type(D)
-      ..type(E);
+      ..bind(A)
+      ..bind(B)
+      ..bind(C)
+      ..bind(D)
+      ..bind(E);
   }
 }
 
 main() {
   new ModuleBenchmark().report();
-}
+}