cargdev/angular
1
0
Fork 0
Code Issues 11 Pull Requests Actions Packages Projects Releases Wiki Activity

feat(Reflection): extract reflection capabilities into a separate module

Browse Source
This commit is contained in:
vsavkin
2014-11-20 12:07:48 -08:00
parent 044625a098
commit 6e8175a816
46 changed files with 637 additions and 416 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
modules/core/test/compiler/compiler_spec.js
View File

@ -4,7 +4,7 @@ import {List} from 'facade/collection';
import {Compiler} from 'core/compiler/compiler';
import {ProtoView} from 'core/compiler/view';
import {Reflector} from 'core/compiler/reflector';
import {DirectiveMetadataReader} from 'core/compiler/directive_metadata_reader';
import {TemplateLoader} from 'core/compiler/template_loader';
import {Component} from 'core/annotations/annotations';
import {TemplateConfig} from 'core/annotations/template_config';
@ -14,20 +14,18 @@ import {CompileControl} from 'core/compiler/pipeline/compile_control';
import {Parser} from 'change_detection/parser/parser';
import {Lexer} from 'change_detection/parser/lexer';
import {ClosureMap} from 'change_detection/parser/closure_map';
export function main() {
describe('compiler', function() {
var compiler, reflector;
var compiler, reader;
beforeEach( () => {
reflector = new Reflector();
reader = new DirectiveMetadataReader();
});
function createCompiler(processClosure) {
var closureMap = new ClosureMap();
var steps = [new MockStep(processClosure)];
return new TestableCompiler(null, reflector, new Parser(new Lexer(), closureMap), closureMap, steps);
return new TestableCompiler(null, reader, new Parser(new Lexer()), steps);
}
it('should run the steps and return the ProtoView of the root element', (done) => {
@ -68,7 +66,7 @@ export function main() {
current.inheritedProtoView = new ProtoView(current.element, null);
current.inheritedElementBinder = current.inheritedProtoView.bindElement(null);
if (current.element === mainEl) {
current.componentDirective = reflector.annotatedType(NestedComponent);
current.componentDirective = reader.annotatedType(NestedComponent);
}
});
compiler.compile(MainComponent, mainEl).then( (protoView) => {
@ -99,8 +97,8 @@ class NestedComponent {}
class TestableCompiler extends Compiler {
steps:List;
constructor(templateLoader:TemplateLoader, reflector:Reflector, parser, closureMap, steps:List<CompileStep>) {
super(templateLoader, reflector, parser, closureMap);
constructor(templateLoader:TemplateLoader, reader:DirectiveMetadataReader, parser, steps:List<CompileStep>) {
super(templateLoader, reader, parser);
this.steps = steps;
}
createSteps(component):List<CompileStep> {

12
modules/core/test/compiler/reflector_spec.js → modules/core/test/compiler/directive_metadata_reader_spec.js
View File

@ -1,5 +1,5 @@
import {ddescribe, describe, it, iit, expect, beforeEach} from 'test_lib/test_lib';
import {Reflector} from 'core/compiler/reflector';
import {DirectiveMetadataReader} from 'core/compiler/directive_metadata_reader';
import {Decorator} from 'core/annotations/annotations';
import {AnnotatedType} from 'core/compiler/annotated_type';
@ -13,22 +13,22 @@ class SomeDirectiveWithoutAnnotation {
}
export function main() {
describe("reflector", () => {
var reflector;
describe("DirectiveMetadataReader", () => {
var rader;
beforeEach( () => {
reflector = new Reflector();
rader = new DirectiveMetadataReader();
});
it('should read out the annotation', () => {
var annoatedDirective = reflector.annotatedType(SomeDirective);
var annoatedDirective = rader.annotatedType(SomeDirective);
expect(annoatedDirective).toEqual(
new AnnotatedType(SomeDirective, new Decorator({selector: 'someSelector'})));
});
it('should throw if not matching annotation is found', () => {
expect(() => {
reflector.annotatedType(SomeDirectiveWithoutAnnotation);
rader.annotatedType(SomeDirectiveWithoutAnnotation);
}).toThrowError('No Directive annotation found on SomeDirectiveWithoutAnnotation');
});

6
modules/core/test/compiler/integration_spec.js
View File

@ -5,11 +5,10 @@ import {DOM} from 'facade/dom';
import {Injector} from 'di/di';
import {ChangeDetector} from 'change_detection/change_detector';
import {Parser} from 'change_detection/parser/parser';
import {ClosureMap} from 'change_detection/parser/closure_map';
import {Lexer} from 'change_detection/parser/lexer';
import {Compiler} from 'core/compiler/compiler';
import {Reflector} from 'core/compiler/reflector';
import {DirectiveMetadataReader} from 'core/compiler/directive_metadata_reader';
import {Component} from 'core/annotations/annotations';
import {Decorator} from 'core/annotations/annotations';
@ -20,8 +19,7 @@ export function main() {
var compiler;
beforeEach( () => {
var closureMap = new ClosureMap();
compiler = new Compiler(null, new Reflector(), new Parser(new Lexer(), closureMap), closureMap);
compiler = new Compiler(null, new DirectiveMetadataReader(), new Parser(new Lexer()));
});
describe('react to record changes', function() {

30
modules/core/test/compiler/pipeline/directive_parser_spec.js
View File

@ -11,26 +11,24 @@ import {Component} from 'core/annotations/annotations';
import {Decorator} from 'core/annotations/annotations';
import {Template} from 'core/annotations/annotations';
import {TemplateConfig} from 'core/annotations/template_config';
import {Reflector} from 'core/compiler/reflector';
import {DirectiveMetadataReader} from 'core/compiler/directive_metadata_reader';
import {Parser} from 'change_detection/parser/parser';
import {Lexer} from 'change_detection/parser/lexer';
import {ClosureMap} from 'change_detection/parser/closure_map';
export function main() {
describe('DirectiveParser', () => {
var reflector, directives;
var reader, directives;
beforeEach( () => {
reflector = new Reflector();
reader = new DirectiveMetadataReader();
directives = [SomeDecorator, SomeTemplate, SomeTemplate2, SomeComponent, SomeComponent2];
});
function createPipeline({propertyBindings, variableBindings}={}) {
var closureMap = new ClosureMap();
var parser = new Parser(new Lexer(), closureMap);
var parser = new Parser(new Lexer());
var annotatedDirectives = ListWrapper.create();
for (var i=0; i<directives.length; i++) {
ListWrapper.push(annotatedDirectives, reflector.annotatedType(directives[i]));
ListWrapper.push(annotatedDirectives, reader.annotatedType(directives[i]));
}
return new CompilePipeline([new MockStep((parent, current, control) => {
@ -55,7 +53,7 @@ export function main() {
describe('component directives', () => {
it('should detect them in attributes', () => {
var results = createPipeline().process(createElement('<div some-comp></div>'));
expect(results[0].componentDirective).toEqual(reflector.annotatedType(SomeComponent));
expect(results[0].componentDirective).toEqual(reader.annotatedType(SomeComponent));
});
it('should detect them in property bindings', () => {
@ -63,7 +61,7 @@ export function main() {
'some-comp': 'someExpr'
}});
var results = pipeline.process(createElement('<div></div>'));
expect(results[0].componentDirective).toEqual(reflector.annotatedType(SomeComponent));
expect(results[0].componentDirective).toEqual(reader.annotatedType(SomeComponent));
});
it('should detect them in variable bindings', () => {
@ -71,7 +69,7 @@ export function main() {
'some-comp': 'someExpr'
}});
var results = pipeline.process(createElement('<div></div>'));
expect(results[0].componentDirective).toEqual(reflector.annotatedType(SomeComponent));
expect(results[0].componentDirective).toEqual(reader.annotatedType(SomeComponent));
});
it('should not allow multiple component directives on the same element', () => {
@ -94,7 +92,7 @@ export function main() {
describe('template directives', () => {
it('should detect them in attributes', () => {
var results = createPipeline().process(createElement('<template some-templ></template>'));
expect(results[0].templateDirective).toEqual(reflector.annotatedType(SomeTemplate));
expect(results[0].templateDirective).toEqual(reader.annotatedType(SomeTemplate));
});
it('should detect them in property bindings', () => {
@ -102,7 +100,7 @@ export function main() {
'some-templ': 'someExpr'
}});
var results = pipeline.process(createElement('<template></template>'));
expect(results[0].templateDirective).toEqual(reflector.annotatedType(SomeTemplate));
expect(results[0].templateDirective).toEqual(reader.annotatedType(SomeTemplate));
});
it('should detect them in variable bindings', () => {
@ -110,7 +108,7 @@ export function main() {
'some-templ': 'someExpr'
}});
var results = pipeline.process(createElement('<template></template>'));
expect(results[0].templateDirective).toEqual(reflector.annotatedType(SomeTemplate));
expect(results[0].templateDirective).toEqual(reader.annotatedType(SomeTemplate));
});
it('should not allow multiple template directives on the same element', () => {
@ -133,7 +131,7 @@ export function main() {
describe('decorator directives', () => {
it('should detect them in attributes', () => {
var results = createPipeline().process(createElement('<div some-decor></div>'));
expect(results[0].decoratorDirectives).toEqual([reflector.annotatedType(SomeDecorator)]);
expect(results[0].decoratorDirectives).toEqual([reader.annotatedType(SomeDecorator)]);
});
it('should detect them in property bindings', () => {
@ -141,7 +139,7 @@ export function main() {
'some-decor': 'someExpr'
}});
var results = pipeline.process(createElement('<div></div>'));
expect(results[0].decoratorDirectives).toEqual([reflector.annotatedType(SomeDecorator)]);
expect(results[0].decoratorDirectives).toEqual([reader.annotatedType(SomeDecorator)]);
});
it('should detect them in variable bindings', () => {
@ -149,7 +147,7 @@ export function main() {
'some-decor': 'someExpr'
}});
var results = pipeline.process(createElement('<div></div>'));
expect(results[0].decoratorDirectives).toEqual([reflector.annotatedType(SomeDecorator)]);
expect(results[0].decoratorDirectives).toEqual([reader.annotatedType(SomeDecorator)]);
});
it('should not allow decorator directives on <template> elements', () => {

10
modules/core/test/compiler/pipeline/element_binder_builder_spec.js
View File

@ -14,12 +14,11 @@ import {Template} from 'core/annotations/annotations';
import {Component} from 'core/annotations/annotations';
import {ProtoView, ElementPropertyMemento, DirectivePropertyMemento} from 'core/compiler/view';
import {ProtoElementInjector} from 'core/compiler/element_injector';
import {Reflector} from 'core/compiler/reflector';
import {DirectiveMetadataReader} from 'core/compiler/directive_metadata_reader';
import {ProtoRecordRange} from 'change_detection/record_range';
import {Parser} from 'change_detection/parser/parser';
import {Lexer} from 'change_detection/parser/lexer';
import {ClosureMap} from 'change_detection/parser/closure_map';
import {ChangeDetector} from 'change_detection/change_detector';
import {Injector} from 'di/di';
@ -29,9 +28,8 @@ export function main() {
function createPipeline({textNodeBindings, propertyBindings, eventBindings, directives, protoElementInjector
}={}) {
var reflector = new Reflector();
var closureMap = new ClosureMap();
var parser = new Parser(new Lexer(), closureMap);
var reflector = new DirectiveMetadataReader();
var parser = new Parser(new Lexer());
return new CompilePipeline([
new MockStep((parent, current, control) => {
if (isPresent(current.element.getAttribute('viewroot'))) {
@ -74,7 +72,7 @@ export function main() {
current.hasBindings = true;
DOM.addClass(current.element, 'ng-binding');
}
}), new ElementBinderBuilder(closureMap)
}), new ElementBinderBuilder()
]);
}

10
modules/core/test/compiler/pipeline/element_binding_marker_spec.js
View File

@ -8,16 +8,14 @@ import {CompilePipeline} from 'core/compiler/pipeline/compile_pipeline';
import {CompileElement} from 'core/compiler/pipeline/compile_element';
import {CompileStep} from 'core/compiler/pipeline/compile_step'
import {CompileControl} from 'core/compiler/pipeline/compile_control';
import {Reflector} from 'core/compiler/reflector';
import {Template} from 'core/annotations/annotations';
import {Decorator} from 'core/annotations/annotations';
import {Component} from 'core/annotations/annotations';
import {DirectiveMetadataReader} from 'core/compiler/directive_metadata_reader';
import {Template, Decorator, Component} from 'core/annotations/annotations';
export function main() {
describe('ElementBindingMarker', () => {
function createPipeline({textNodeBindings, propertyBindings, variableBindings, eventBindings, directives}={}) {
var reflector = new Reflector();
var reader = new DirectiveMetadataReader();
return new CompilePipeline([
new MockStep((parent, current, control) => {
if (isPresent(textNodeBindings)) {
@ -34,7 +32,7 @@ export function main() {
}
if (isPresent(directives)) {
for (var i=0; i<directives.length; i++) {
current.addDirective(reflector.annotatedType(directives[i]));
current.addDirective(reader.annotatedType(directives[i]));
}
}
}), new ElementBindingMarker()

3
modules/core/test/compiler/pipeline/property_binding_parser_spec.js
View File

@ -5,13 +5,12 @@ import {DOM} from 'facade/dom';
import {MapWrapper} from 'facade/collection';
import {Parser} from 'change_detection/parser/parser';
import {ClosureMap} from 'change_detection/parser/closure_map';
import {Lexer} from 'change_detection/parser/lexer';
export function main() {
describe('PropertyBindingParser', () => {
function createPipeline() {
return new CompilePipeline([new PropertyBindingParser(new Parser(new Lexer(), new ClosureMap()))]);
return new CompilePipeline([new PropertyBindingParser(new Parser(new Lexer()))]);
}
it('should detect [] syntax', () => {

10
modules/core/test/compiler/pipeline/proto_element_injector_builder_spec.js
View File

@ -9,10 +9,8 @@ import {CompileElement} from 'core/compiler/pipeline/compile_element';
import {CompileStep} from 'core/compiler/pipeline/compile_step'
import {CompileControl} from 'core/compiler/pipeline/compile_control';
import {ProtoView} from 'core/compiler/view';
import {Reflector} from 'core/compiler/reflector';
import {Template} from 'core/annotations/annotations';
import {Decorator} from 'core/annotations/annotations';
import {Component} from 'core/annotations/annotations';
import {DirectiveMetadataReader} from 'core/compiler/directive_metadata_reader';
import {Template, Decorator, Component} from 'core/annotations/annotations';
import {ProtoElementInjector} from 'core/compiler/element_injector';
export function main() {
@ -27,14 +25,14 @@ export function main() {
if (isBlank(directives)) {
directives = [];
}
var reflector = new Reflector();
var reader = new DirectiveMetadataReader();
return new CompilePipeline([new MockStep((parent, current, control) => {
if (isPresent(current.element.getAttribute('viewroot'))) {
current.isViewRoot = true;
}
if (isPresent(current.element.getAttribute('directives'))) {
for (var i=0; i<directives.length; i++) {
current.addDirective(reflector.annotatedType(directives[i]));
current.addDirective(reader.annotatedType(directives[i]));
}
}
current.inheritedProtoView = protoView;

3
modules/core/test/compiler/pipeline/text_interpolation_parser_spec.js
View File

@ -5,13 +5,12 @@ import {DOM} from 'facade/dom';
import {MapWrapper} from 'facade/collection';
import {Parser} from 'change_detection/parser/parser';
import {ClosureMap} from 'change_detection/parser/closure_map';
import {Lexer} from 'change_detection/parser/lexer';
export function main() {
describe('TextInterpolationParser', () => {
function createPipeline() {
return new CompilePipeline([new TextInterpolationParser(new Parser(new Lexer(), new ClosureMap()))]);
return new CompilePipeline([new TextInterpolationParser(new Parser(new Lexer()))]);
}
it('should find text interpolation in normal elements', () => {

3
modules/core/test/compiler/pipeline/view_splitter_spec.js
View File

@ -7,14 +7,13 @@ import {CompilePipeline} from 'core/compiler/pipeline/compile_pipeline';
import {DOM, TemplateElement} from 'facade/dom';
import {Parser} from 'change_detection/parser/parser';
import {ClosureMap} from 'change_detection/parser/closure_map';
import {Lexer} from 'change_detection/parser/lexer';
export function main() {
describe('ViewSplitter', () => {
function createPipeline() {
return new CompilePipeline([new ViewSplitter(new Parser(new Lexer(), new ClosureMap()))]);
return new CompilePipeline([new ViewSplitter(new Parser(new Lexer()))]);
}
it('should mark root elements as viewRoot', () => {

16
modules/core/test/compiler/view_spec.js
View File

@ -1,28 +1,26 @@
import {describe, xit, it, expect, beforeEach, ddescribe, iit} from 'test_lib/test_lib';
import {ProtoView, ElementPropertyMemento, DirectivePropertyMemento} from 'core/compiler/view';
import {ProtoElementInjector, ElementInjector} from 'core/compiler/element_injector';
import {Reflector} from 'core/compiler/reflector';
import {Component} from 'core/annotations/annotations';
import {Decorator} from 'core/annotations/annotations';
import {DirectiveMetadataReader} from 'core/compiler/directive_metadata_reader';
import {Component, Decorator} from 'core/annotations/annotations';
import {ProtoRecordRange} from 'change_detection/record_range';
import {ChangeDetector} from 'change_detection/change_detector';
import {TemplateConfig} from 'core/annotations/template_config';
import {Parser} from 'change_detection/parser/parser';
import {ClosureMap} from 'change_detection/parser/closure_map';
import {Lexer} from 'change_detection/parser/lexer';
import {DOM, Element} from 'facade/dom';
import {FIELD} from 'facade/lang';
import {Injector} from 'di/di';
import {View} from 'core/compiler/view';
import {reflector} from 'reflection/reflection';
export function main() {
describe('view', function() {
var parser, closureMap, someComponentDirective;
var parser, someComponentDirective;
beforeEach(() => {
closureMap = new ClosureMap();
parser = new Parser(new Lexer(), closureMap);
someComponentDirective = new Reflector().annotatedType(SomeComponent);
parser = new Parser(new Lexer());
someComponentDirective = new DirectiveMetadataReader().annotatedType(SomeComponent);
});
@ -263,7 +261,7 @@ export function main() {
var pv = new ProtoView(createElement('<div class="ng-binding"></div>'),
new ProtoRecordRange());
pv.bindElement(new ProtoElementInjector(null, 0, [SomeDirective]));
pv.bindDirectiveProperty( 0, parser.parseBinding('foo').ast, 'prop', closureMap.setter('prop'));
pv.bindDirectiveProperty( 0, parser.parseBinding('foo').ast, 'prop', reflector.setter('prop'));
createView(pv);
ctx.foo = 'buz';