refactor(injector): moved things into private libraries to reduce visibility

Author: pavelgj

lib/annotations.dart

@@ -8,4 +8,12 @@ library di.annotations;
 class Injectables {
   final List<Type> types;
   const Injectables(this.types);
-}
+}
+
+/**
+ * Annotation that can be applied to a class for which type factories
+ * should be generated to be used by StaticInjector.
+ */
+class Injectable {
+  const Injectable();
+}

lib/di.dart

@@ -1,12 +1,9 @@
 library di;
 
-import 'dart:collection';
-import 'package:collection/wrappers.dart';
-import 'error_helper.dart';
+import 'src/provider.dart';
+import 'key.dart';
 
-part 'injector.dart';
-part 'injector_delagate.dart';
-part 'key.dart';
-part 'module.dart';
-part 'errors.dart';
+part 'src/injector.dart';
+part 'src/module.dart';
+part 'src/errors.dart';
 

lib/dynamic_injector.dart

@@ -1,8 +1,12 @@
 library di.dynamic_injector;
 
 import 'di.dart';
-import 'mirrors.dart';
-import 'error_helper.dart';
+import 'key.dart';
+import 'src/mirrors.dart';
+import 'src/base_injector.dart';
+import 'src/error_helper.dart';
+
+export 'di.dart';
 
 /**
  * Dynamic implementation of [Injector] that uses mirrors.

lib/generator.dart

@@ -13,16 +13,19 @@ import 'dart:io';
 
 const String PACKAGE_PREFIX = 'package:';
 const String DART_PACKAGE_PREFIX = 'dart:';
+const List<String> _DEFAULT_INJECTABLE_ANNOTATIONS =
+    const ['di.annotations.Injectable'];
 
-main(args) {
+main(List<String> args) {
   if (args.length < 4) {
     print('Usage: generator path_to_sdk file_to_resolve annotations output [package_roots+]');
     exit(0);
   }
 
   var pathToSdk = args[0];
   var entryPoint = args[1];
-  var classAnnotations = args[2].split(',');
+  var classAnnotations = args[2].split(',')
+      ..addAll(_DEFAULT_INJECTABLE_ANNOTATIONS);
   var output = args[3];
   var packageRoots = (args.length < 5) ? [Platform.packageRoot] : args.sublist(4);
 

lib/key.dart

@@ -1,6 +1,8 @@
-part of di;
+library di.key;
 
 int _lastKeyId = 0;
+int get lastKeyId => _lastKeyId;
+
 Map<int, int> _hashToKey = {};
 
 class Key {

lib/injector.dart renamed to lib/src/base_injector.dart

@@ -1,84 +1,18 @@
-part of di;
+library di.base_injector;
+
+import 'provider.dart';
+import 'error_helper.dart';
+
+import 'package:collection/collection.dart';
+import 'package:di/key.dart';
+import 'package:di/di.dart';
 
 List<Key> _PRIMITIVE_TYPES = new UnmodifiableListView(<Key>[
   new Key(num), new Key(int), new Key(double), new Key(String),
   new Key(bool)
 ]);
 
-abstract class ObjectFactory {
-  Object getInstanceByKey(Key key, Injector requester, List resolving);
-}
-
-abstract class Injector implements ObjectFactory {
-  /**
-   * Name of the injector or null of none is given.
-   */
-  String get name;
-
-  /**
-   * The parent injector or null if root.
-   */
-  Injector get parent;
-
-  /**
-   * The root injector.
-   */
-  Injector get root;
-
-  /**
-   * List of all types which the injector can return
-   */
-  Set<Type> get types;
-
-  /**
-   * Indicates whether injector allows implicit injection -- resolving types
-   * that were not explicitly bound in the module(s).
-   */
-  bool get allowImplicitInjection;
-
-  /**
-   * Get an instance for given token ([Type]).
-   *
-   * If the injector already has an instance for this token, it returns this
-   * instance. Otherwise, injector resolves all its dependencies, instantiates
-   * new instance and returns this instance.
-   *
-   * If there is no binding for given token, injector asks parent injector.
-   *
-   * If there is no parent injector, an implicit binding is used. That is,
-   * the token ([Type]) is instantiated.
-   */
-  dynamic get(Type type, [Type annotation]);
-
-  /**
-   * Get an instance for given key ([Key]).
-   *
-   * If the injector already has an instance for this key, it returns this
-   * instance. Otherwise, injector resolves all its dependencies, instantiates
-   * new instance and returns this instance.
-   *
-   * If there is no binding for given key, injector asks parent injector.
-   */
-  dynamic getByKey(Key key);
-
-  /**
-   * Create a child injector.
-   *
-   * Child injector can override any bindings by adding additional modules.
-   *
-   * It also accepts a list of tokens that a new instance should be forced.
-   * That means, even if some parent injector already has an instance for this
-   * token, there will be a new instance created in the child injector.
-   */
-  Injector createChild(List<Module> modules,
-                       {List forceNewInstances, String name});
-
-
-  newFromParent(List<Module> modules, String name);
-
-  Object newInstanceOf(Type type, ObjectFactory factory, Injector requestor,
-                       resolving);
-}
+bool _defaultVisibility(_, __) => true;
 
 abstract class BaseInjector implements Injector {
 
@@ -90,7 +24,7 @@ abstract class BaseInjector implements Injector {
 
   Injector _root;
 
-  List<_Provider> _providers;
+  List<Provider> _providers;
   int _providersLen = 0;
 
   final Map<Key, Object> _instances = <Key, Object>{};
@@ -120,16 +54,16 @@ abstract class BaseInjector implements Injector {
       BaseInjector this.parent, {this.name, this.allowImplicitInjection}) {
     _root = parent == null ? this : parent._root;
     var injectorId = new Key(Injector).id;
-    _providers = new List(_lastKeyId + 1);
-    _providersLen = _lastKeyId + 1;
+    _providers = new List(lastKeyId + 1);
+    _providersLen = lastKeyId + 1;
     if (modules != null) {
       modules.forEach((module) {
-        module._bindings.forEach((k, v) {
+        module.bindings.forEach((k, v) {
           _providers[k] = v;
         });
       });
     }
-    _providers[injectorId] = new _ValueProvider(Injector, this);
+    _providers[injectorId] = new ValueProvider(Injector, this);
   }
 
   @override
@@ -204,7 +138,7 @@ abstract class BaseInjector implements Injector {
 
     if (allowImplicitInjection) {
       return new _ProviderWithDefiningInjector(
-          new _TypeProvider(key.type), this);
+          new TypeProvider(key.type), this);
     }
 
     throw new NoProviderError(error(resolving, 'No provider found for ${key}!', key));
@@ -228,11 +162,11 @@ abstract class BaseInjector implements Injector {
   @override
   Injector createChild(List<Module> modules,
                        {List forceNewInstances, String name}) =>
-      _createChildWithResolvingHistory(modules, BaseInjector.ZERO_DEPTH_RESOLVING,
+      createChildWithResolvingHistory(modules, BaseInjector.ZERO_DEPTH_RESOLVING,
           forceNewInstances: forceNewInstances,
           name: name);
 
-  Injector _createChildWithResolvingHistory(
+  Injector createChildWithResolvingHistory(
                         List<Module> modules,
                         resolving,
                         {List forceNewInstances, String name}) {
@@ -247,7 +181,7 @@ abstract class BaseInjector implements Injector {
         assert(key is Key);
         var providerWithInjector = _getProviderWithInjectorForKey(key, resolving);
         var provider = providerWithInjector.provider;
-        forceNew._keyedFactory(key, (Injector inj) => provider.get(this,
+        forceNew.factoryByKey(key, (Injector inj) => provider.get(this,
             inj, inj, resolving),
             visibility: provider.visibility);
       });
@@ -261,7 +195,7 @@ abstract class BaseInjector implements Injector {
 }
 
 class _ProviderWithDefiningInjector {
-  final _Provider provider;
+  final Provider provider;
   final BaseInjector injector;
   _ProviderWithDefiningInjector(this.provider, this.injector);
 }

lib/error_helper.dart renamed to lib/src/error_helper.dart

@@ -1,6 +1,6 @@
 library di.error_helper;
 
-import 'package:di/di.dart';
+import 'package:di/key.dart';
 
 String error(List resolving, message, [appendDependency]) {
   if (appendDependency != null) {

lib/errors.dart renamed to lib/src/errors.dart

@@ -0,0 +1,76 @@
+part of di;
+
+abstract class ObjectFactory {
+  Object getInstanceByKey(Key key, Injector requester, List resolving);
+}
+
+abstract class Injector implements ObjectFactory {
+  /**
+   * Name of the injector or null of none is given.
+   */
+  String get name;
+
+  /**
+   * The parent injector or null if root.
+   */
+  Injector get parent;
+
+  /**
+   * The root injector.
+   */
+  Injector get root;
+
+  /**
+   * List of all types which the injector can return
+   */
+  Set<Type> get types;
+
+  /**
+   * Indicates whether injector allows implicit injection -- resolving types
+   * that were not explicitly bound in the module(s).
+   */
+  bool get allowImplicitInjection;
+
+  /**
+   * Get an instance for given token ([Type]).
+   *
+   * If the injector already has an instance for this token, it returns this
+   * instance. Otherwise, injector resolves all its dependencies, instantiates
+   * new instance and returns this instance.
+   *
+   * If there is no binding for given token, injector asks parent injector.
+   *
+   * If there is no parent injector, an implicit binding is used. That is,
+   * the token ([Type]) is instantiated.
+   */
+  dynamic get(Type type, [Type annotation]);
+
+  /**
+   * Get an instance for given key ([Key]).
+   *
+   * If the injector already has an instance for this key, it returns this
+   * instance. Otherwise, injector resolves all its dependencies, instantiates
+   * new instance and returns this instance.
+   *
+   * If there is no binding for given key, injector asks parent injector.
+   */
+  dynamic getByKey(Key key);
+
+  /**
+   * Create a child injector.
+   *
+   * Child injector can override any bindings by adding additional modules.
+   *
+   * It also accepts a list of tokens that a new instance should be forced.
+   * That means, even if some parent injector already has an instance for this
+   * token, there will be a new instance created in the child injector.
+   */
+  Injector createChild(List<Module> modules,
+                       {List forceNewInstances, String name});
+
+
+  newFromParent(List<Module> modules, String name);
+
+  Object newInstanceOf(Type type, ObjectFactory factory, Injector requestor,
+                       resolving);
+}

lib/src/injector.dart

@@ -1,10 +1,14 @@
-part of di;
+library di.injector_delegate;
 
-class _InjectorDelagate implements Injector, ObjectFactory {
+import 'base_injector.dart';
+import 'package:di/di.dart';
+import 'package:di/key.dart';
+
+class InjectorDelagate implements Injector, ObjectFactory {
   BaseInjector _injector;
   List<Key> _resolving;
 
-  _InjectorDelagate(this._injector, this._resolving);
+  InjectorDelagate(this._injector, this._resolving);
 
   @override
   bool get allowImplicitInjection => _injector.allowImplicitInjection;
@@ -36,18 +40,16 @@ class _InjectorDelagate implements Injector, ObjectFactory {
   @override
   Injector createChild(List<Module> modules,
                        {List forceNewInstances, String name}) =>
-      _injector._createChildWithResolvingHistory(modules, _resolving,
+      _injector.createChildWithResolvingHistory(modules, _resolving,
           forceNewInstances: forceNewInstances,
           name: name);
 
   @override
-  newFromParent(List<Module> modules, String name) {
-    throw new UnimplementedError();
-  }
+  newFromParent(List<Module> modules, String name) =>
+      _injector.newFromParent(modules, name);
 
   @override
   Object newInstanceOf(Type type, ObjectFactory factory,
-                       Injector requestor, resolving) {
-    throw new UnimplementedError();
-  }
+                       Injector requestor, resolving) =>
+      _injector.newInstanceOf(type, factory, requestor, resolving);
 }