feat(dart/transform): Add simple ParseTemplates step

Generate methods in the ParseTemplates step.
Add a test for inline template method generation.

Author: Tim Blasi

modules/angular2/src/transform/common/names.dart

@@ -4,4 +4,6 @@ const SETUP_METHOD_NAME = 'setupReflection';
 const REFLECTOR_VAR_NAME = 'reflector';
 const DEPS_EXTENSION = '.ng_deps.dart';
 const REGISTER_TYPE_METHOD_NAME = 'registerType';
+const REGISTER_GETTERS_METHOD_NAME = 'registerGetters';
 const REGISTER_SETTERS_METHOD_NAME = 'registerSetters';
+const REGISTER_METHODS_METHOD_NAME = 'registerMethods';

modules/angular2/src/transform/template_parser/generator.dart renamed to modules/angular2/src/transform/template_compiler/generator.dart

@@ -1,29 +1,30 @@
-library angular2.src.transform.template_parser.generator;
+library angular2.src.transform.template_compiler.generator;
 
 import 'dart:async';
 
 import 'package:analyzer/analyzer.dart';
-import 'package:angular2/src/change_detection/parser/ast.dart';
 import 'package:angular2/src/change_detection/parser/lexer.dart' as ng;
 import 'package:angular2/src/change_detection/parser/parser.dart' as ng;
-import 'package:angular2/src/core/compiler/pipeline/compile_element.dart';
 import 'package:angular2/src/core/compiler/pipeline/compile_pipeline.dart';
 import 'package:angular2/src/core/compiler/pipeline/compile_step.dart';
 import 'package:angular2/src/core/compiler/pipeline/property_binding_parser.dart';
 import 'package:angular2/src/core/compiler/pipeline/text_interpolation_parser.dart';
 import 'package:angular2/src/core/compiler/pipeline/view_splitter.dart';
 import 'package:angular2/src/dom/dom_adapter.dart';
-import 'package:angular2/src/dom/html5lib_adapter.dart';
 import 'package:angular2/src/reflection/reflection.dart';
 import 'package:angular2/src/transform/common/asset_reader.dart';
 import 'package:angular2/src/transform/common/logging.dart';
 import 'package:angular2/src/transform/common/names.dart';
 import 'package:angular2/src/transform/common/parser.dart';
 import 'package:barback/barback.dart';
-import 'package:code_transformers/assets.dart';
 
 import 'recording_reflection_capabilities.dart';
 
+/// Reads the `.ng_deps.dart` file represented by `entryPoint` and parses any
+/// Angular 2 `Template` annotations it declares to generate `getter`s,
+/// `setter`s, and `method`s that would otherwise be reflectively accessed.
+///
+/// This method assumes a [DomAdapter] has been registered.
 Future<String> processTemplates(AssetReader reader, AssetId entryPoint) async {
   var parser = new Parser(reader);
   NgDeps ngDeps = await parser.parse(entryPoint);
@@ -34,66 +35,71 @@ Future<String> processTemplates(AssetReader reader, AssetId entryPoint) async {
       var values = _processTemplate(templateText);
       var calls = _generateGetters('${rType.typeName}', values.getterNames);
       if (calls.isNotEmpty) {
-        registrations.write('..registerGetters({${calls.join(', ')}})');
+        registrations.write('..${REGISTER_GETTERS_METHOD_NAME}'
+            '({${calls.join(', ')}})');
       }
       calls = _generateSetters('${rType.typeName}', values.setterNames);
       if (calls.isNotEmpty) {
-        registrations.write('..registerSetters({${calls.join(', ')}})');
+        registrations.write('..${REGISTER_SETTERS_METHOD_NAME}'
+            '({${calls.join(', ')}})');
+      }
+      calls = _generateMethods('${rType.typeName}', values.methodNames);
+      if (calls.isNotEmpty) {
+        registrations.write('..${REGISTER_METHODS_METHOD_NAME}'
+            '({${calls.join(', ')}})');
       }
     });
   });
 
-  String code = ngDeps.code;
+  var code = ngDeps.code;
   if (registrations.length == 0) return code;
   var codeInjectIdx = ngDeps.registeredTypes.last.registerMethod.end;
   return '${code.substring(0, codeInjectIdx)}'
       '${registrations}'
       '${code.substring(codeInjectIdx)}';
 }
 
+Iterable<String> _generateGetters(String typeName, List<String> getterNames) {
+  return getterNames.map((prop) {
+    // TODO(kegluneq): Include `typeName` where possible.
+    return ''''$prop': (o) => o.$prop''';
+  });
+}
+
+Iterable<String> _generateSetters(String typeName, List<String> setterName) {
+  return setterName.map((prop) {
+    return ''''$prop': (o, v) => o.$prop = v''';
+  });
+}
+
+Iterable<String> _generateMethods(String typeName, List<String> methodNames) {
+  return methodNames.map((methodName) {
+    return ''''$methodName': (o, List args) =>
+        Function.apply(o.$methodName, args)''';
+  });
+}
+
 RecordingReflectionCapabilities _processTemplate(String templateCode) {
   var recordingCapabilities = new RecordingReflectionCapabilities();
+  var savedReflectionCapabilities = reflector.reflectionCapabilities;
   reflector.reflectionCapabilities = recordingCapabilities;
 
-  var compilePipeline = new CompilePipeline(createCompileSteps());
+  var compilePipeline = new CompilePipeline(_createCompileSteps());
   var template = DOM.createTemplate(templateCode);
   // TODO(kegluneq): Need to parse this from a file when not inline.
   compilePipeline.process(template, templateCode);
 
+  reflector.reflectionCapabilities = savedReflectionCapabilities;
   return recordingCapabilities;
 }
 
-List<String> _generateGetters(String typeName, List<String> getterNames) {
-  var getters = [];
-  getterNames.forEach((prop) {
-    // TODO(kegluneq): Include `typeName` where possible.
-    getters.add('\'$prop\': (o) => o.$prop');
-  });
-  return getters;
-}
-
-List<String> _generateSetters(String typeName, List<String> setterName) {
-  var setters = [];
-  setterName.forEach((prop) {
-    // TODO(kegluneq): Include `typeName` where possible.
-    setters.add('\'$prop\': (o, String v) => o.$prop = v');
-  });
-  return setters;
-}
-
-List<CompileStep> createCompileSteps() {
+List<CompileStep> _createCompileSteps() {
   var parser = new ng.Parser(new ng.Lexer());
+  // TODO(kegluneq): Add other compile steps from default_steps.dart.
   return [
     new ViewSplitter(parser),
-//    cssProcessor.getCompileStep(
-//    compiledComponent, shadowDomStrategy, templateUrl),
     new PropertyBindingParser(parser),
-//    new DirectiveParser(directives),
     new TextInterpolationParser(parser)
-//    new ElementBindingMarker(),
-//    new ProtoViewBuilder(changeDetection, shadowDomStrategy),
-//    new ProtoElementInjectorBuilder(),
-//    new ElementBinderBuilder(parser)
   ];
 }
 
@@ -103,6 +109,8 @@ List<String> _processRegisteredType(AssetReader reader, RegisteredType t) {
   return visitor.templateText;
 }
 
+/// Visitor responsible for processing the `annotations` property of a
+/// [RegisterType] object and pulling out template text.
 class _TemplateExtractVisitor extends Object with RecursiveAstVisitor<Object> {
   final List<String> templateText = [];
   final AssetReader _reader;

modules/angular2/src/transform/template_parser/recording_reflection_capabilities.dart renamed to modules/angular2/src/transform/template_compiler/recording_reflection_capabilities.dart

@@ -1,17 +1,23 @@
-library angular2.src.transform.template_parser.recording_reflection_capabilities;
+library angular2.src.transform.template_compiler.recording_reflection_capabilities;
 
 import 'package:angular2/src/reflection/reflection_capabilities.dart';
 import 'package:angular2/src/reflection/types.dart';
 
+/// ReflectionCapabilities object that records requests for `getter`s,
+/// `setter`s, and `method`s so these can be code generated rather than
+/// reflectively accessed at runtime.
 class RecordingReflectionCapabilities implements ReflectionCapabilities {
-  void _notImplemented(String name) {
-    throw 'Not implemented: $name';
-  }
-
+  /// The names of all requested `getter`s.
   final List<String> getterNames = [];
+  /// The names of all requested `setter`s.
   final List<String> setterNames = [];
+  /// The names of all requested `method`s.
   final List<String> methodNames = [];
 
+  void _notImplemented(String name) {
+    throw 'Not implemented: $name';
+  }
+
   Function factory(Type type) => _notImplemented('factory');
 
   List<List> parameters(typeOrFunc) => _notImplemented('parameters');

modules/angular2/src/transform/template_compiler/transformer.dart

@@ -0,0 +1,46 @@
+library angular2.src.transform.template_compiler.transformer;
+
+import 'dart:async';
+
+import 'package:angular2/src/dom/html5lib_adapter.dart';
+import 'package:angular2/src/transform/common/asset_reader.dart';
+import 'package:angular2/src/transform/common/formatter.dart';
+import 'package:angular2/src/transform/common/logging.dart' as log;
+import 'package:angular2/src/transform/common/names.dart';
+import 'package:angular2/src/transform/common/options.dart';
+import 'package:barback/barback.dart';
+
+import 'generator.dart';
+
+/// [Transformer] responsible for detecting and processing Angular 2 templates.
+///
+/// [TemplateComplier] uses the Angular 2 `Compiler` to process the templates,
+/// extracting information about what reflection is necessary to render and
+/// use that template. It then generates code in place of those reflective
+/// accesses.
+class TemplateComplier extends Transformer {
+  final TransformerOptions options;
+
+  TemplateComplier(this.options);
+
+  @override
+  bool isPrimary(AssetId id) => id.path.endsWith(DEPS_EXTENSION);
+
+  @override
+  Future apply(Transform transform) async {
+    log.init(transform);
+
+    try {
+      Html5LibDomAdapter.makeCurrent();
+      var id = transform.primaryInput.id;
+      var reader = new AssetReader.fromTransform(transform);
+      var transformedCode =
+          formatter.format(await processTemplates(reader, id));
+      transform.addOutput(new Asset.fromString(id, transformedCode));
+    } catch (ex, stackTrace) {
+      log.logger.error('Parsing ng templates failed.\n'
+          'Exception: $ex\n'
+          'Stack Trace: $stackTrace');
+    }
+  }
+}

modules/angular2/src/transform/template_parser/transformer.dart

@@ -7,20 +7,20 @@ import 'directive_linker/transformer.dart';
 import 'directive_processor/transformer.dart';
 import 'bind_generator/transformer.dart';
 import 'reflection_remover/transformer.dart';
-import 'template_parser/transformer.dart';
+import 'template_compiler/transformer.dart';
 import 'common/formatter.dart' as formatter;
 import 'common/options.dart';
 
 export 'common/options.dart';
 
-/// Removes the mirror-based initialization logic and replaces it with static
-/// logic.
+/// Replaces Angular 2 mirror use with generated code.
 class AngularTransformerGroup extends TransformerGroup {
   AngularTransformerGroup(TransformerOptions options) : super([
         [new DirectiveProcessor(options)],
         [new DirectiveLinker(options)],
-        [new BindGenerator(options), new ReflectionRemover(options)],
-        [new TemplateParser(options)]
+        [new BindGenerator(options)],
+        [new TemplateComplier(options)],
+        [new ReflectionRemover(options)]
       ]) {
     formatter.init(new DartFormatter());
   }

modules/angular2/src/transform/transformer.dart

@@ -1,6 +1,7 @@
 library angular2.test.transform.integration;
 
 import 'dart:io';
+import 'package:angular2/src/dom/html5lib_adapter.dart';
 import 'package:angular2/transformer.dart';
 import 'package:code_transformers/tests.dart';
 import 'package:dart_style/dart_style.dart';
@@ -24,6 +25,8 @@ class IntegrationTestConfig {
 }
 
 void allTests() {
+  Html5LibDomAdapter.makeCurrent();
+
   /*
    * Each test has its own directory for inputs & an `expected` directory for
    * expected outputs.

modules/angular2/test/transform/integration/all_tests.dart

@@ -0,0 +1,39 @@
+library angular2.test.transform.directive_processor.all_tests;
+
+import 'package:barback/barback.dart';
+import 'package:angular2/src/dom/html5lib_adapter.dart';
+import 'package:angular2/src/transform/common/asset_reader.dart';
+import 'package:angular2/src/transform/common/formatter.dart';
+import 'package:angular2/src/transform/template_compiler/generator.dart';
+import 'package:dart_style/dart_style.dart';
+import 'package:unittest/unittest.dart';
+
+import '../common/read_file.dart';
+
+var formatter = new DartFormatter();
+
+void allTests() {
+  Html5LibDomAdapter.makeCurrent();
+  AssetReader reader = new TestAssetReader();
+
+  test('should parse simple expressions in inline templates.', () async {
+    var inputPath =
+        'template_compiler/inline_expression_files/hello.ng_deps.dart';
+    var expected = readFile(
+        'template_compiler/inline_expression_files/expected/hello.ng_deps.dart');
+    var output = await processTemplates(reader, new AssetId('a', inputPath));
+    output = formatter.format(output);
+    expected = formatter.format(expected);
+    expect(output, equals(expected));
+  });
+
+  test('should parse simple methods in inline templates.', () async {
+    var inputPath = 'template_compiler/inline_method_files/hello.ng_deps.dart';
+    var expected = readFile(
+        'template_compiler/inline_method_files/expected/hello.ng_deps.dart');
+    var output = await processTemplates(reader, new AssetId('a', inputPath));
+    output = formatter.format(output);
+    expected = formatter.format(expected);
+    expect(output, equals(expected));
+  });
+}

modules/angular2/test/transform/template_compiler/all_tests.dart

@@ -18,5 +18,5 @@ void setupReflection(reflector) {
       ]
     })
     ..registerGetters({'greeting': (o) => o.greeting})
-    ..registerSetters({'greeting': (o, String v) => o.greeting = v});
+    ..registerSetters({'greeting': (o, v) => o.greeting = v});
 }