chore(packaging): move files to match target file structure

modules/angular2/src/reflection/reflection.dart

@@ -0,0 +1,34 @@
+library reflection.reflection;
+
+import 'reflector.dart';
+import 'types.dart';
+export 'reflector.dart';
+import 'package:facade/src/lang.dart';
+
+class NoReflectionCapabilities {
+  Function factory(Type type){
+    throw "Cannot find reflection information on ${stringify(type)}";
+  }
+
+  List parameters(Type type) {
+    throw "Cannot find reflection information on ${stringify(type)}";
+  }
+
+  List annotations(Type type) {
+    throw "Cannot find reflection information on ${stringify(type)}";
+  }
+
+  GetterFn getter(String name) {
+    throw "Cannot find getter ${name}";
+  }
+
+  SetterFn setter(String name) {
+    throw "Cannot find setter ${name}";
+  }
+
+  MethodFn method(String name) {
+    throw "Cannot find method ${name}";
+  }
+}
+
+final Reflector reflector = new Reflector(new NoReflectionCapabilities());

modules/angular2/src/reflection/reflection.es6

@@ -0,0 +1,7 @@
+import {Type, isPresent} from 'facade/src/lang';
+import {List, ListWrapper} from 'facade/src/collection';
+import {Reflector} from './reflector';
+export {Reflector} from './reflector';
+import {ReflectionCapabilities} from './reflection_capabilities';
+
+export var reflector = new Reflector(new ReflectionCapabilities());

modules/angular2/src/reflection/reflection_capabilities.dart

@@ -0,0 +1,89 @@
+library reflection.reflection_capabilities;
+
+import 'reflection.dart';
+import 'types.dart';
+import 'dart:mirrors';
+
+class ReflectionCapabilities {
+  Function factory(Type type) {
+    ClassMirror classMirror = reflectType(type);
+    MethodMirror ctor = classMirror.declarations[classMirror.simpleName];
+    Function create = classMirror.newInstance;
+    Symbol name = ctor.constructorName;
+    int length = ctor.parameters.length;
+
+    switch (length) {
+      case 0: return () => create(name, []).reflectee;
+      case 1: return (a1) => create(name, [a1]).reflectee;
+      case 2: return (a1, a2) => create(name, [a1, a2]).reflectee;
+      case 3: return (a1, a2, a3) => create(name, [a1, a2, a3]).reflectee;
+      case 4: return (a1, a2, a3, a4) => create(name, [a1, a2, a3, a4]).reflectee;
+      case 5: return (a1, a2, a3, a4, a5) => create(name, [a1, a2, a3, a4, a5]).reflectee;
+      case 6: return (a1, a2, a3, a4, a5, a6) => create(name, [a1, a2, a3, a4, a5, a6]).reflectee;
+      case 7: return (a1, a2, a3, a4, a5, a6, a7) => create(name, [a1, a2, a3, a4, a5, a6, a7]).reflectee;
+      case 8: return (a1, a2, a3, a4, a5, a6, a7, a8) => create(name, [a1, a2, a3, a4, a5, a6, a7, a8]).reflectee;
+      case 9: return (a1, a2, a3, a4, a5, a6, a7, a8, a9) => create(name, [a1, a2, a3, a4, a5, a6, a7, a8, a9]).reflectee;
+      case 10: return (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) => create(name, [a1, a2, a3, a4, a5, a6, a7, a8, a9, a10]).reflectee;
+    };
+
+    throw "Factory cannot take more than 10 arguments";
+  }
+
+  List<List> parameters(typeOrFunc) {
+    final parameters = typeOrFunc is Type ?
+      _constructorParameters(typeOrFunc) :
+      _functionParameters(typeOrFunc);
+    return parameters.map(_convertParameter).toList();
+  }
+
+  List _convertParameter(ParameterMirror p) {
+    var t = p.type.reflectedType;
+    var res = t == dynamic ? [] : [t];
+    res.addAll(p.metadata.map((m) => m.reflectee));
+    return res;
+  }
+
+  List annotations(typeOrFunc) {
+    final meta = typeOrFunc is Type ?
+      _constructorMetadata(typeOrFunc) :
+      _functionMetadata(typeOrFunc);
+
+    return meta.map((m) => m.reflectee).toList();
+  }
+
+  GetterFn getter(String name) {
+    var symbol = new Symbol(name);
+    return (receiver) => reflect(receiver).getField(symbol).reflectee;
+  }
+
+  SetterFn setter(String name) {
+    var symbol = new Symbol(name);
+    return (receiver, value) => reflect(receiver).setField(symbol, value).reflectee;
+  }
+
+  MethodFn method(String name) {
+    var symbol = new Symbol(name);
+    return (receiver, posArgs) => reflect(receiver).invoke(symbol, posArgs).reflectee;
+  }
+
+  List _functionParameters(Function func) {
+    var closureMirror = reflect(func);
+    return closureMirror.function.parameters;
+  }
+
+  List _constructorParameters(Type type) {
+    ClassMirror classMirror = reflectType(type);
+    MethodMirror ctor = classMirror.declarations[classMirror.simpleName];
+    return ctor.parameters;
+  }
+
+  List _functionMetadata(Function func) {
+    var closureMirror = reflect(func);
+    return closureMirror.function.metadata;
+  }
+
+  List _constructorMetadata(Type type) {
+    ClassMirror classMirror = reflectType(type);
+    return classMirror.metadata;
+  }
+}

modules/angular2/src/reflection/reflection_capabilities.es6

@@ -0,0 +1,59 @@
+import {Type, isPresent} from 'facade/src/lang';
+import {List, ListWrapper} from 'facade/src/collection';
+import {GetterFn, SetterFn, MethodFn} from './types';
+
+export class ReflectionCapabilities {
+  factory(type:Type):Function {
+    switch (type.length) {
+      case 0:
+        return function(){return new type();};
+      case 1:
+        return function(a1){return new type(a1);};
+      case 2:
+        return function(a1, a2){return new type(a1, a2);};
+      case 3:
+        return function(a1, a2, a3){return new type(a1, a2, a3);};
+      case 4:
+        return function(a1, a2, a3, a4){return new type(a1, a2, a3, a4);};
+      case 5:
+        return function(a1, a2, a3, a4, a5){return new type(a1, a2, a3, a4, a5);};
+      case 6:
+        return function(a1, a2, a3, a4, a5, a6){return new type(a1, a2, a3, a4, a5, a6);};
+      case 7:
+        return function(a1, a2, a3, a4, a5, a6, a7){return new type(a1, a2, a3, a4, a5, a6, a7);};
+      case 8:
+        return function(a1, a2, a3, a4, a5, a6, a7, a8){return new type(a1, a2, a3, a4, a5, a6, a7, a8);};
+      case 9:
+        return function(a1, a2, a3, a4, a5, a6, a7, a8, a9){return new type(a1, a2, a3, a4, a5, a6, a7, a8, a9);};
+      case 10:
+        return function(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10){return new type(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);};
+    };
+
+    throw new Error("Factory cannot take more than 10 arguments");
+  }
+
+  parameters(typeOfFunc):List<List> {
+    return isPresent(typeOfFunc.parameters) ?
+      typeOfFunc.parameters :
+      ListWrapper.createFixedSize(typeOfFunc.length);
+  }
+
+  annotations(typeOfFunc):List {
+    return isPresent(typeOfFunc.annotations) ? typeOfFunc.annotations : [];
+  }
+
+  getter(name:string):GetterFn {
+    return new Function('o', 'return o.' + name + ';');
+  }
+
+  setter(name:string):SetterFn {
+    return new Function('o', 'v', 'return o.' + name + ' = v;');
+  }
+
+  method(name:string):MethodFn {
+    var method = `o.${name}`;
+    return new Function('o', 'args',
+      `if (!${method}) throw new Error('"${name}" is undefined');` +
+      `return ${method}.apply(o, args);`);
+  }
+}

modules/angular2/src/reflection/reflector.js

@@ -0,0 +1,88 @@
+import {Type, isPresent, stringify, BaseException} from 'facade/src/lang';
+import {List, ListWrapper, Map, MapWrapper, StringMapWrapper} from 'facade/src/collection';
+import {SetterFn, GetterFn, MethodFn} from './types';
+export {SetterFn, GetterFn, MethodFn} from './types';
+
+export class Reflector {
+  _typeInfo:Map;
+  _getters:Map;
+  _setters:Map;
+  _methods:Map;
+  reflectionCapabilities:any;
+
+  constructor(reflectionCapabilities) {
+    this._typeInfo = MapWrapper.create();
+    this._getters = MapWrapper.create();
+    this._setters = MapWrapper.create();
+    this._methods = MapWrapper.create();
+    this.reflectionCapabilities = reflectionCapabilities;
+  }
+
+  registerType(type, typeInfo){
+    MapWrapper.set(this._typeInfo, type, typeInfo);
+  }
+
+  registerGetters(getters){
+    _mergeMaps(this._getters, getters);
+  }
+
+  registerSetters(setters){
+    _mergeMaps(this._setters, setters);
+  }
+
+  registerMethods(methods){
+    _mergeMaps(this._methods, methods);
+  }
+
+  factory(type:Type):Function {
+    if(MapWrapper.contains(this._typeInfo, type)) {
+      return MapWrapper.get(this._typeInfo, type)["factory"];
+    } else {
+      return this.reflectionCapabilities.factory(type);
+    }
+  }
+
+  parameters(typeOfFunc):List {
+    if(MapWrapper.contains(this._typeInfo, typeOfFunc)) {
+      return MapWrapper.get(this._typeInfo, typeOfFunc)["parameters"];
+    } else {
+      return this.reflectionCapabilities.parameters(typeOfFunc);
+    }
+  }
+
+  annotations(typeOfFunc):List {
+    if(MapWrapper.contains(this._typeInfo, typeOfFunc)) {
+      return MapWrapper.get(this._typeInfo, typeOfFunc)["annotations"];
+    } else {
+      return this.reflectionCapabilities.annotations(typeOfFunc);
+    }
+  }
+
+  getter(name:string):GetterFn {
+    if(MapWrapper.contains(this._getters, name)) {
+      return MapWrapper.get(this._getters, name);
+    } else {
+      return this.reflectionCapabilities.getter(name);
+    }
+  }
+
+  setter(name:string):SetterFn {
+    if(MapWrapper.contains(this._setters, name)) {
+      return MapWrapper.get(this._setters, name);
+    } else {
+      return this.reflectionCapabilities.setter(name);
+    }
+  }
+
+  method(name:string):MethodFn {
+    if(MapWrapper.contains(this._methods, name)) {
+      return MapWrapper.get(this._methods, name);
+    } else {
+      return this.reflectionCapabilities.method(name);
+    }
+  }
+}
+
+function _mergeMaps(target:Map, config) {
+  StringMapWrapper.forEach(config, (v, k) => MapWrapper.set(target, k, v));
+}

modules/angular2/src/reflection/types.dart

@@ -0,0 +1,5 @@
+library reflection.types;
+
+typedef SetterFn(Object obj, value);
+typedef GetterFn(Object obj);
+typedef MethodFn(Object obj, List args);

modules/angular2/src/reflection/types.es6

@@ -0,0 +1,3 @@
+export var SetterFn = Function;
+export var GetterFn = Function;
+export var MethodFn = Function;