feat(core): support Injection by Type via reflect-metadata design:paramtypes

 - from now on you can DI via typescript type information if you want to inject a class instance
 instead of using @Inject() for everything

Closes: #41

BREAKING CHANGES:

- from now on ngMetadata leverages reflect-metadata polyfill, so you need to include it to your app
 - also you need to add `"emitDecoratorMetadata": true` to your tsconfig.json

Author: Hotell

package.json

@@ -37,6 +37,7 @@
     "ghooks": "1.0.1",
     "live-server": "0.8.2",
     "mocha": "2.3.4",
+    "reflect-metadata": "0.1.3",
     "sinon": "1.17.2",
     "systemjs": "0.19.6",
     "systemjs-builder": "0.14.11",
@@ -45,7 +46,8 @@
     "validate-commit-msg": "2.0.0"
   },
   "peerDependencies": {
-    "angular": ">=1.4.x"
+    "angular": ">=1.4.x",
+    "reflect-metadata": "0.1.x"
   },
   "dependencies": {},
   "czConfig": {

src/core/di/provider.ts

@@ -24,6 +24,7 @@ import { pipeProvider } from '../pipes/pipe_provider';
 import { directiveProvider } from '../directives/directive_provider';
 import { ListWrapper } from '../../facade/collections';
 import { resolveForwardRef } from './forward_ref';
+import { getErrorMsg } from '../../facade/exceptions';
 
 
 export type PropMetaInst =  InputMetadata | OutputMetadata | HostBindingMetadata | HostListenerMetadata;
@@ -161,13 +162,14 @@ export function _dependenciesFor(typeOrFunc: Type): string[] {
 
   if ( isBlank( params ) ) return [];
 
-  if ( params.some( isBlank ) ) {
+  if ( params.some( ( param ) => isBlank( param ) || ListWrapper.isEmpty( param ) ) ) {
 
-    throw new Error( `
-      ${ stringify( typeOrFunc ) } :
-      -------------------------------------------------
-      you cannot have holes in constructor DI injection
-      ` );
+    throw new Error(
+      getErrorMsg(
+        typeOrFunc,
+        `you cannot have holes in constructor DI injection`
+      )
+    );
 
   }
 
@@ -184,16 +186,19 @@ export function _dependenciesFor(typeOrFunc: Type): string[] {
  */
 export function _extractToken( metadata: ParamMetaInst[] ): string {
 
-  const [injectMetadata] = metadata
-    .filter( paramMetadata=>paramMetadata instanceof InjectMetadata ) as InjectMetadata[];
+  // this is token obtained via design:paramtypes via Reflect.metadata
+  const [paramMetadata] = metadata.filter( isType );
+  // this is token obtained from @Inject() usage  for DI
+  const [injectMetadata] = metadata.filter( isInjectMetadata ) as InjectMetadata[];
 
-  if(isBlank(injectMetadata)){
+  if(isBlank(injectMetadata) && isBlank(paramMetadata)){
     return;
   }
 
-  const {token} = injectMetadata;
+  const { token=undefined } = injectMetadata || {};
+  const injectable = resolveForwardRef( token ) || paramMetadata;
 
-  return getInjectableName( resolveForwardRef( token ) );
+  return getInjectableName( injectable );
 
 }
 
@@ -239,6 +244,7 @@ export function getInjectableName(injectable: ProviderType): string{
   // class SomeService(){}
   //
   // @Inject(SomeService) someSvc
+  // someSvc: SomeService
   if ( isType( injectable ) ) {
 
     // only the first class annotations is injectable
@@ -318,3 +324,6 @@ function isService(annotation: InjectableMetadata): boolean{
 function isPipe(annotation: PipeMetadata): boolean{
   return isString(annotation.name) && annotation instanceof PipeMetadata;
 }
+function isInjectMetadata( injectMeta: any ): injectMeta is InjectMetadata {
+  return injectMeta instanceof InjectMetadata;
+}

src/core/linker/directive_resolver.ts

@@ -19,6 +19,7 @@ import {
 import { InjectMetadata, HostMetadata, SelfMetadata, SkipSelfMetadata, OptionalMetadata } from '../di/metadata';
 import { ParamMetaInst, PropMetaInst, getInjectableName } from '../di/provider';
 import { resolveForwardRef } from '../di/forward_ref';
+import { getErrorMsg } from '../../facade/exceptions';
 
 function _isDirectiveMetadata( type: any ): boolean {
   return type instanceof DirectiveMetadata;
@@ -27,49 +28,82 @@ function _isDirectiveMetadata( type: any ): boolean {
 /**
  * return required string map for provided local DI
  * ```typescript
- * // for constructor(@Inject('ngModel') @Self() @Optional() ngModel){}
+ * // for
+ * constructor(@Inject('ngModel') @Self() @Optional() ngModel){}
  * // it returns:
  * { ngModel: '?ngModel' }
+ *
+ * // when MyComponent is
+ * @Component({ selector: 'myCoolCmp', template:`hello`})
+ * class MyComponent{}
+ * // for
+ * constructor(@Host() @Optional() myCmp: MyComponent){}
+ * // it returns:
+ * { myCmp: '^myCoolCmp' }
  * ```
  * @param paramsMeta
+ * @param idx
+ * @param typeOrFunc
  * @returns {{[directiveName]:string}}
  * @private
  */
-function _transformInjectedDirectivesMeta( paramsMeta: ParamMetaInst[], idx: number ): StringMap {
+function _transformInjectedDirectivesMeta( paramsMeta: ParamMetaInst[], idx: number, typeOrFunc: Type ): StringMap {
 
-  // if there is just @Inject return
-  if ( paramsMeta.length < 2 ) {
-    return;
-  }
+  if ( !_isInjectableParamsDirective( paramsMeta ) ) { return }
 
+  // @TODO unite this with _extractToken from provider.ts
   const injectInst = ListWrapper.find( paramsMeta, param=>param instanceof InjectMetadata ) as InjectMetadata;
-
-  if ( !injectInst.token ) {
-    throw new Error( `no Directive instance name provided within @Inject()` );
+  const injectType = ListWrapper.find( paramsMeta, isType ) as Type;
+  const { token=undefined } = injectInst || { token: injectType };
+  // we need to decrement param count if user uses both @Inject() and :MyType
+  const paramsMetaLength = (injectInst && injectType)
+    ? paramsMeta.length - 1
+    : paramsMeta.length;
+
+  if ( !token ) {
+    throw new Error(
+      getErrorMsg(
+        typeOrFunc,
+        `no Directive instance name provided within @Inject() or :DirectiveClass annotation missing`
+      )
+    );
   }
 
   const isHost = ListWrapper.findIndex( paramsMeta, param=>param instanceof HostMetadata ) !== -1;
   const isOptional = ListWrapper.findIndex( paramsMeta, param=>param instanceof OptionalMetadata ) !== -1;
   const isSelf = ListWrapper.findIndex( paramsMeta, param=>param instanceof SelfMetadata ) !== -1;
   const isSkipSelf = ListWrapper.findIndex( paramsMeta, param=>param instanceof SkipSelfMetadata ) !== -1;
 
-  if ( isOptional && paramsMeta.length !== 3 ) {
-    throw new Error( `
-    you cannot use @Optional() without related decorator for injecting Directives. use one of @Host|@Self()|@SkipSelf() + @Optional()`
+  if ( isOptional && paramsMetaLength !== 3 ) {
+    throw new Error(
+      getErrorMsg(
+        typeOrFunc,
+        `you cannot use @Optional() without related decorator for injecting Directives. use one of @Host|@Self()|@SkipSelf() + @Optional()`
+      )
     );
   }
   if ( isSelf && isSkipSelf ) {
-    throw new Error( `you cannot provide both @Self() and @SkipSelf() with @Inject(${injectInst.token}) for Directive Injection` );
+    throw new Error(
+      getErrorMsg(
+        typeOrFunc,
+        `you cannot provide both @Self() and @SkipSelf() with @Inject(${getFuncName( token )}) for Directive Injection`
+      )
+    );
   }
   if( (isHost && isSelf) || (isHost && isSkipSelf)){
-    throw new Error( `you cannot provide both @Host(),@SkipSelf() or @Host(),@Self() with @Inject(${getFuncName(injectInst.token)}) for Directive Injections` );
+    throw new Error(
+      getErrorMsg(
+        typeOrFunc,
+        `you cannot provide both @Host(),@SkipSelf() or @Host(),@Self() with @Inject(${getFuncName( token )}) for Directive Injections`
+      )
+    );
   }
 
   const locateType = _getLocateTypeSymbol();
   const optionalType = isOptional ? '?' : '';
 
   const requireExpressionPrefix = `${ optionalType }${ locateType }`;
-  const directiveName = _getDirectiveName( injectInst.token );
+  const directiveName = _getDirectiveName( token );
 
   // we need to generate unique names because if we require same directive controllers,
   // with different locale decorators it would merge to one which is wrong
@@ -99,6 +133,25 @@ function _transformInjectedDirectivesMeta( paramsMeta: ParamMetaInst[], idx: num
 
   }
 
+  // exit if user uses both @Inject() and :Type for DI because this is not directive injection
+  function _isInjectableParamsDirective( paramsMeta: ParamMetaInst[] ): boolean {
+
+    // if there is just @Inject or Type from design:paramtypes return
+    if ( paramsMeta.length < 2 ) {
+      return false;
+    }
+
+    if ( paramsMeta.length === 2 ) {
+      const injectableParamCount = paramsMeta.filter( inj => inj instanceof InjectMetadata || isType( inj ) ).length;
+      if ( injectableParamCount === 2 ) {
+        return false;
+      }
+    }
+
+    return true;
+
+  }
+
 }
 
 /**
@@ -148,7 +201,7 @@ export class DirectiveResolver {
       return paramMetadata
         .reduce( ( acc, paramMetaArr, idx )=> {
 
-          const requireExp = _transformInjectedDirectivesMeta( paramMetaArr, idx );
+          const requireExp = _transformInjectedDirectivesMeta( paramMetaArr, idx, type );
           if ( isPresent( requireExp ) ) {
             assign( acc, requireExp );
           }

src/core/reflection/platform_reflection_capabilities.ts

@@ -0,0 +1,24 @@
+import { Type } from '../../facade/lang';
+import { GetterFn, SetterFn, MethodFn } from './types';
+
+export interface PlatformReflectionCapabilities {
+  isReflectionEnabled(): boolean;
+  factory( type: Type ): Function;
+  interfaces( type: Type ): any[];
+
+  parameters( type: any ): any[][],
+  rawParameters(typeOrFunc: Type): any[][],
+  registerParameters( parameters, type: Type ): void,
+
+  annotations( type: any ): any[],
+  ownAnnotations(typeOrFunc: Type): any[],
+  registerAnnotations( annotations, typeOrFunc: Type ): void,
+
+  propMetadata( typeOrFunc: any ): {[key: string]: any[]},
+  ownPropMetadata( typeOrFunc: Type ): {[key: string]: any[]},
+  registerPropMetadata( propMetadata, typeOrFunc: Type ): void,
+
+  getter( name: string ): GetterFn;
+  setter( name: string ): SetterFn;
+  method( name: string ): MethodFn;
+}

src/core/reflection/reflection.ts

@@ -1,7 +1,8 @@
-import {Reflector} from './reflector';
+import { Reflector } from './reflector';
+import { ReflectionCapabilities } from './reflection_capabilities';
 
 /**
  * The {@link Reflector} used internally in Angular to access metadata
  * about symbols.
  */
-export const reflector = new Reflector();
+export const reflector = new Reflector( new ReflectionCapabilities() );