not translatable
translatable element with placeholders {{ interpolation}}
foo
+', }); }); }); diff --git a/modules/@angular/compiler/test/i18n/serializers/xmb_spec.ts b/modules/@angular/compiler/test/i18n/serializers/xmb_spec.ts index 817351737c7d..89a5daa75ca9 100644 --- a/modules/@angular/compiler/test/i18n/serializers/xmb_spec.ts +++ b/modules/@angular/compiler/test/i18n/serializers/xmb_spec.ts @@ -6,12 +6,10 @@ * found in the LICENSE file at https://angular.io/license */ +import {MessageBundle} from '@angular/compiler/src/i18n/message_bundle'; import {Xmb} from '@angular/compiler/src/i18n/serializers/xmb'; -import {beforeEach, ddescribe, describe, expect, iit, inject, it, xdescribe, xit} from '@angular/core/testing/testing_internal'; - -import {MessageBundle} from '../../../src/i18n/message_bundle'; -import {HtmlParser} from '../../../src/ml_parser/html_parser'; -import {DEFAULT_INTERPOLATION_CONFIG} from '../../../src/ml_parser/interpolation_config'; +import {HtmlParser} from '@angular/compiler/src/ml_parser/html_parser'; +import {DEFAULT_INTERPOLATION_CONFIG} from '@angular/compiler/src/ml_parser/interpolation_config'; export function main(): void { describe('XMB serializer', () => { @@ -49,7 +47,8 @@ export function main(): void {
', [
- ]))).toEqual([[ElementAst, 'div'], [AttrAst, 'a', 'b']]);
- });
- });
+ it('should parse elements with attributes', () => {
+ expect(humanizeTplAst(parse('
', [
+ ]))).toEqual([[ElementAst, 'div'], [AttrAst, 'a', 'b']]);
+ });
+ });
- it('should parse ngContent', () => {
- var parsed = parse('', []);
- expect(humanizeTplAst(parsed)).toEqual([[NgContentAst]]);
- });
+ it('should parse ngContent', () => {
+ var parsed = parse('', []);
+ expect(humanizeTplAst(parsed)).toEqual([[NgContentAst]]);
+ });
- it('should parse ngContent regardless the namespace', () => {
- var parsed = parse('', []);
- expect(humanizeTplAst(parsed)).toEqual([
- [ElementAst, ':svg:svg'],
- [NgContentAst],
- ]);
- });
+ it('should parse ngContent regardless the namespace', () => {
+ var parsed = parse('', []);
+ expect(humanizeTplAst(parsed)).toEqual([
+ [ElementAst, ':svg:svg'],
+ [NgContentAst],
+ ]);
+ });
- it('should parse bound text nodes', () => {
- expect(humanizeTplAst(parse('{{a}}', []))).toEqual([[BoundTextAst, '{{ a }}']]);
- });
+ it('should parse bound text nodes', () => {
+ expect(humanizeTplAst(parse('{{a}}', []))).toEqual([[BoundTextAst, '{{ a }}']]);
+ });
- it('should parse with custom interpolation config',
- inject([TemplateParser], (parser: TemplateParser) => {
- const component = CompileDirectiveMetadata.create({
- selector: 'test',
- type: new CompileTypeMetadata(
- {moduleUrl: someModuleUrl, name: 'Test', reference: {} as Type}),
- isComponent: true,
- template: new CompileTemplateMetadata({interpolation: ['{%', '%}']})
- });
- expect(humanizeTplAst(parser.parse(component, '{%a%}', [], [], [], 'TestComp'), {
- start: '{%',
- end: '%}'
- })).toEqual([[BoundTextAst, '{% a %}']]);
- }));
-
- describe('bound properties', () => {
-
- it('should parse mixed case bound properties', () => {
- expect(humanizeTplAst(parse('
', []))).toEqual([
- [ElementAst, 'div'],
- [BoundElementPropertyAst, PropertyBindingType.Property, 'someProp', 'v', null]
- ]);
- });
+ it('should parse with custom interpolation config',
+ inject([TemplateParser], (parser: TemplateParser) => {
+ const component = CompileDirectiveMetadata.create({
+ selector: 'test',
+ type: new CompileTypeMetadata(
+ {moduleUrl: someModuleUrl, name: 'Test', reference: {} as Type}),
+ isComponent: true,
+ template: new CompileTemplateMetadata({interpolation: ['{%', '%}']})
+ });
+ expect(humanizeTplAst(parser.parse(component, '{%a%}', [], [], [], 'TestComp'), {
+ start: '{%',
+ end: '%}'
+ })).toEqual([[BoundTextAst, '{% a %}']]);
+ }));
+
+ describe('bound properties', () => {
+
+ it('should parse mixed case bound properties', () => {
+ expect(humanizeTplAst(parse('
', []))).toEqual([
+ [ElementAst, 'div'],
+ [BoundElementPropertyAst, PropertyBindingType.Property, 'someProp', 'v', null]
+ ]);
+ });
- it('should parse dash case bound properties', () => {
- expect(humanizeTplAst(parse('
', []))).toEqual([
- [ElementAst, 'div'],
- [BoundElementPropertyAst, PropertyBindingType.Property, 'some-prop', 'v', null]
- ]);
- });
+ it('should parse dash case bound properties', () => {
+ expect(humanizeTplAst(parse('
', []))).toEqual([
+ [ElementAst, 'div'],
+ [BoundElementPropertyAst, PropertyBindingType.Property, 'some-prop', 'v', null]
+ ]);
+ });
- it('should normalize property names via the element schema', () => {
- expect(humanizeTplAst(parse('
', []))).toEqual([
- [ElementAst, 'div'],
- [BoundElementPropertyAst, PropertyBindingType.Property, 'mappedProp', 'v', null]
- ]);
- });
+ it('should normalize property names via the element schema', () => {
+ expect(humanizeTplAst(parse('
', []))).toEqual([
+ [ElementAst, 'div'],
+ [BoundElementPropertyAst, PropertyBindingType.Property, 'mappedProp', 'v', null]
+ ]);
+ });
- it('should parse mixed case bound attributes', () => {
- expect(humanizeTplAst(parse('
', []))).toEqual([
- [ElementAst, 'div'],
- [BoundElementPropertyAst, PropertyBindingType.Attribute, 'someAttr', 'v', null]
- ]);
- });
+ it('should parse mixed case bound attributes', () => {
+ expect(humanizeTplAst(parse('
', []))).toEqual([
+ [ElementAst, 'div'],
+ [BoundElementPropertyAst, PropertyBindingType.Attribute, 'someAttr', 'v', null]
+ ]);
+ });
- it('should parse and dash case bound classes', () => {
- expect(humanizeTplAst(parse('
', []))).toEqual([
- [ElementAst, 'div'],
- [BoundElementPropertyAst, PropertyBindingType.Class, 'some-class', 'v', null]
- ]);
- });
+ it('should parse and dash case bound classes', () => {
+ expect(humanizeTplAst(parse('
', []))).toEqual([
+ [ElementAst, 'div'],
+ [BoundElementPropertyAst, PropertyBindingType.Class, 'some-class', 'v', null]
+ ]);
+ });
- it('should parse mixed case bound classes', () => {
- expect(humanizeTplAst(parse('
', []))).toEqual([
- [ElementAst, 'div'],
- [BoundElementPropertyAst, PropertyBindingType.Class, 'someClass', 'v', null]
- ]);
- });
+ it('should parse mixed case bound classes', () => {
+ expect(humanizeTplAst(parse('
', []))).toEqual([
+ [ElementAst, 'div'],
+ [BoundElementPropertyAst, PropertyBindingType.Class, 'someClass', 'v', null]
+ ]);
+ });
- it('should parse mixed case bound styles', () => {
- expect(humanizeTplAst(parse('
', []))).toEqual([
- [ElementAst, 'div'],
- [BoundElementPropertyAst, PropertyBindingType.Style, 'someStyle', 'v', null]
- ]);
- });
+ it('should parse mixed case bound styles', () => {
+ expect(humanizeTplAst(parse('
', []))).toEqual([
+ [ElementAst, 'div'],
+ [BoundElementPropertyAst, PropertyBindingType.Style, 'someStyle', 'v', null]
+ ]);
+ });
- it('should report invalid prefixes', () => {
- expect(() => parse('
', [])) - .toThrowError( - `Template parse errors:\nInvalid property name 'atTr.foo' ("
][atTr.foo]>"): TestComp@0:3`); - expect(() => parse('
', [])) - .toThrowError( - `Template parse errors:\nInvalid property name 'sTyle.foo' ("
][sTyle.foo]>"): TestComp@0:3`); - expect(() => parse('
', [])) - .toThrowError( - `Template parse errors:\nInvalid property name 'Class.foo' ("
][Class.foo]>"): TestComp@0:3`); - expect(() => parse('
', [])) - .toThrowError( - `Template parse errors:\nInvalid property name 'bar.foo' ("
][bar.foo]>"): TestComp@0:3`); - }); + it('should report invalid prefixes', () => { + expect(() => parse('
', [])) + .toThrowError( + `Template parse errors:\nInvalid property name 'atTr.foo' ("
][atTr.foo]>"): TestComp@0:3`); + expect(() => parse('
', [])) + .toThrowError( + `Template parse errors:\nInvalid property name 'sTyle.foo' ("
][sTyle.foo]>"): TestComp@0:3`); + expect(() => parse('
', [])) + .toThrowError( + `Template parse errors:\nInvalid property name 'Class.foo' ("
][Class.foo]>"): TestComp@0:3`); + expect(() => parse('
', [])) + .toThrowError( + `Template parse errors:\nInvalid property name 'bar.foo' ("
][bar.foo]>"): TestComp@0:3`);
+ });
- describe('errors', () => {
- it('should throw error when binding to an unknown property', () => {
- expect(() => parse('
', []))).toEqual([
- [ElementAst, 'div'],
- [BoundElementPropertyAst, PropertyBindingType.Property, 'prop', 'v', null]
- ]);
- });
+ });
+
+ it('should throw error when binding to an invalid property', () => {
+ expect(() => parse('][onEvent]="bar"> "): TestComp@0:14`);
+ });
+
+ it('should throw error when binding to an invalid attribute', () => {
+ expect(() => parse('][attr.onEvent]="bar"> "): TestComp@0:14`);
+ });
+ });
- it('should parse bound properties via bind- and not report them as attributes', () => {
- expect(humanizeTplAst(parse('
', []))).toEqual([
- [ElementAst, 'div'],
- [BoundElementPropertyAst, PropertyBindingType.Property, 'prop', 'v', null]
- ]);
- });
+ it('should parse bound properties via [...] and not report them as attributes', () => {
+ expect(humanizeTplAst(parse('
', []))).toEqual([
+ [ElementAst, 'div'],
+ [BoundElementPropertyAst, PropertyBindingType.Property, 'prop', 'v', null]
+ ]);
+ });
- it('should parse bound properties via {{...}} and not report them as attributes', () => {
- expect(humanizeTplAst(parse('
', []))).toEqual([
- [ElementAst, 'div'],
- [BoundElementPropertyAst, PropertyBindingType.Property, 'prop', '{{ v }}', null]
- ]);
- });
+ it('should parse bound properties via bind- and not report them as attributes', () => {
+ expect(humanizeTplAst(parse('
', []))).toEqual([
+ [ElementAst, 'div'],
+ [BoundElementPropertyAst, PropertyBindingType.Property, 'prop', 'v', null]
+ ]);
+ });
- it('should parse bound properties via bind-animate- and not report them as animation properties',
- () => {
- expect(humanizeTplAst(parse('
', []))).toEqual([
- [ElementAst, 'div'],
- [
- BoundElementPropertyAst, PropertyBindingType.Animation, 'something', 'value2', null
- ]
- ]);
- });
-
- it('should throw an error when parsing detects non-bound properties via @ that contain a value',
- () => {
- expect(() => { parse('
', []); })
- .toThrowError(
- /Assigning animation triggers via @prop="exp" attributes with an expression is invalid. Use property bindings \(e.g. \[@prop\]="exp"\) or use an attribute without a value \(e.g. @prop\) instead. \("
\]@something="value2">"\): TestComp@0:5/);
- });
-
- it('should not issue a warning when host attributes contain a valid property-bound animation trigger',
- () => {
- var dirA = CompileDirectiveMetadata.create({
- selector: 'div',
- type: new CompileTypeMetadata(
- {moduleUrl: someModuleUrl, name: 'DirA', reference: {} as Type}),
- host: {'[@prop]': 'expr'}
- });
+ it('should parse bound properties via {{...}} and not report them as attributes',
+ () => {
+ expect(humanizeTplAst(parse('
', []))).toEqual([
+ [ElementAst, 'div'],
+ [
+ BoundElementPropertyAst, PropertyBindingType.Property, 'prop', '{{ v }}', null
+ ]
+ ]);
+ });
+
+ it('should parse bound properties via bind-animate- and not report them as attributes',
+ () => {
+ expect(
+ humanizeTplAst(parse('
', [], [], [])))
+ .toEqual([
+ [ElementAst, 'div'],
+ [
+ BoundElementPropertyAst, PropertyBindingType.Animation, 'someAnimation',
+ 'value2', null
+ ]
+ ]);
+ });
+
+ it('should throw an error when parsing detects non-bound properties via @ that contain a value',
+ () => {
+ expect(() => { parse('
', [], [], []); })
+ .toThrowError(
+ /Assigning animation triggers via @prop="exp" attributes with an expression is invalid. Use property bindings \(e.g. \[@prop\]="exp"\) or use an attribute without a value \(e.g. @prop\) instead. \("
\]@someAnimation="value2">"\): TestComp@0:5/);
+ });
+
+ it('should not issue a warning when host attributes contain a valid property-bound animation trigger',
+ () => {
+ const animationEntries = [new CompileAnimationEntryMetadata('prop', [])];
+ var dirA = CompileDirectiveMetadata.create({
+ selector: 'div',
+ template: new CompileTemplateMetadata({animations: animationEntries}),
+ type: new CompileTypeMetadata(
+ {moduleUrl: someModuleUrl, name: 'DirA', reference: {} as Type}),
+ host: {'[@prop]': 'expr'}
+ });
+
+ humanizeTplAst(parse('', [dirA]));
+ expect(console.warnings.length).toEqual(0);
+ });
+
+ it('should throw descriptive error when a host binding is not a string expression', () => {
+ var dirA = CompileDirectiveMetadata.create({
+ selector: 'broken',
+ type: new CompileTypeMetadata(
+ {moduleUrl: someModuleUrl, name: 'DirA', reference: {} as Type}),
+ host: {'[class.foo]': null}
+ });
+
+ expect(() => { parse('}),
+ host: {'(click)': null}
+ });
+
+ expect(() => { parse('}),
- host: {'[class.foo]': null}
+ it('should not issue a warning when an animation property is bound without an expression',
+ () => {
+ humanizeTplAst(parse('
', [], [], []));
+ expect(console.warnings.length).toEqual(0);
+ });
+
+ it('should parse bound properties via [@] and not report them as attributes', () => {
+ expect(humanizeTplAst(parse('
', [], [], []))).toEqual([
+ [ElementAst, 'div'],
+ [
+ BoundElementPropertyAst, PropertyBindingType.Animation, 'someAnimation', 'value2',
+ null
+ ]
+ ]);
+ });
});
- expect(() => { parse('}),
- host: {'(click)': null}
- });
+ it('should parse bound events with a target', () => {
+ expect(humanizeTplAst(parse('
', []))).toEqual([
+ [ElementAst, 'div'],
+ [BoundEventAst, 'event', 'window', 'v'],
+ ]);
+ });
- expect(() => { parse('
', []))
+ .toThrowError(/Empty expressions are not allowed/);
- it('should not issue a warning when an animation property is bound without an expression',
- () => {
- humanizeTplAst(parse('
', []));
- expect(console.warnings.length).toEqual(0);
- });
-
- it('should parse bound properties via [@] and not report them as attributes', () => {
- expect(humanizeTplAst(parse('
', []))).toEqual([
- [ElementAst, 'div'],
- [BoundElementPropertyAst, PropertyBindingType.Animation, 'something', 'value2', null]
- ]);
- });
- });
+ expect(() => parse('
', []))
+ .toThrowError(/Empty expressions are not allowed/);
+ });
- describe('events', () => {
+ it('should parse bound events via (...) and not report them as attributes', () => {
+ expect(humanizeTplAst(parse('
', [
+ ]))).toEqual([[ElementAst, 'div'], [BoundEventAst, 'event', null, 'v']]);
+ });
- it('should parse bound events with a target', () => {
- expect(humanizeTplAst(parse('
', []))).toEqual([
- [ElementAst, 'div'],
- [BoundEventAst, 'event', 'window', 'v'],
- ]);
- });
+ it('should parse event names case sensitive', () => {
+ expect(humanizeTplAst(parse('
', [
+ ]))).toEqual([[ElementAst, 'div'], [BoundEventAst, 'some-event', null, 'v']]);
+ expect(humanizeTplAst(parse('
', [
+ ]))).toEqual([[ElementAst, 'div'], [BoundEventAst, 'someEvent', null, 'v']]);
+ });
- it('should report an error on empty expression', () => {
- expect(() => parse('
', []))
- .toThrowError(/Empty expressions are not allowed/);
+ it('should parse bound events via on- and not report them as attributes', () => {
+ expect(humanizeTplAst(parse('
', [
+ ]))).toEqual([[ElementAst, 'div'], [BoundEventAst, 'event', null, 'v']]);
+ });
- expect(() => parse('
', []))
- .toThrowError(/Empty expressions are not allowed/);
- });
+ it('should allow events on explicit embedded templates that are emitted by a directive',
+ () => {
+ var dirA = CompileDirectiveMetadata.create({
+ selector: 'template',
+ outputs: ['e'],
+ type: new CompileTypeMetadata(
+ {moduleUrl: someModuleUrl, name: 'DirA', reference: {} as Type})
+ });
+ expect(humanizeTplAst(parse('', [dirA]))).toEqual([
+ [EmbeddedTemplateAst],
+ [BoundEventAst, 'e', null, 'f'],
+ [DirectiveAst, dirA],
+ ]);
+ });
+ });
- it('should parse bound events via (...) and not report them as attributes', () => {
- expect(humanizeTplAst(parse('
', [
- ]))).toEqual([[ElementAst, 'div'], [BoundEventAst, 'event', null, 'v']]);
- });
+ describe('bindon', () => {
+ it('should parse bound events and properties via [(...)] and not report them as attributes',
+ () => {
+ expect(humanizeTplAst(parse('
', []))).toEqual([
+ [ElementAst, 'div'],
+ [BoundElementPropertyAst, PropertyBindingType.Property, 'prop', 'v', null],
+ [BoundEventAst, 'propChange', null, 'v = $event']
+ ]);
+ });
+
+ it('should parse bound events and properties via bindon- and not report them as attributes',
+ () => {
+ expect(humanizeTplAst(parse('
', []))).toEqual([
+ [ElementAst, 'div'],
+ [BoundElementPropertyAst, PropertyBindingType.Property, 'prop', 'v', null],
+ [BoundEventAst, 'propChange', null, 'v = $event']
+ ]);
+ });
- it('should parse event names case sensitive', () => {
- expect(humanizeTplAst(parse('
', [
- ]))).toEqual([[ElementAst, 'div'], [BoundEventAst, 'some-event', null, 'v']]);
- expect(humanizeTplAst(parse('
', [
- ]))).toEqual([[ElementAst, 'div'], [BoundEventAst, 'someEvent', null, 'v']]);
- });
+ });
- it('should parse bound events via on- and not report them as attributes', () => {
- expect(humanizeTplAst(parse('
', [
- ]))).toEqual([[ElementAst, 'div'], [BoundEventAst, 'event', null, 'v']]);
- });
+ describe('directives', () => {
+ it('should order directives by the directives array in the View and match them only once',
+ () => {
+ var dirA = CompileDirectiveMetadata.create({
+ selector: '[a]',
+ type: new CompileTypeMetadata(
+ {moduleUrl: someModuleUrl, name: 'DirA', reference: {} as Type})
+ });
+ var dirB = CompileDirectiveMetadata.create({
+ selector: '[b]',
+ type: new CompileTypeMetadata(
+ {moduleUrl: someModuleUrl, name: 'DirB', reference: {} as Type})
+ });
+ var dirC = CompileDirectiveMetadata.create({
+ selector: '[c]',
+ type: new CompileTypeMetadata(
+ {moduleUrl: someModuleUrl, name: 'DirC', reference: {} as Type})
+ });
+ expect(humanizeTplAst(parse('
', [dirA, dirB, dirC]))).toEqual([
+ [ElementAst, 'div'], [AttrAst, 'a', ''], [AttrAst, 'c', ''], [AttrAst, 'b', ''],
+ [AttrAst, 'a', ''], [AttrAst, 'b', ''], [DirectiveAst, dirA],
+ [DirectiveAst, dirB], [DirectiveAst, dirC]
+ ]);
+ });
+
+ it('should locate directives in property bindings', () => {
+ var dirA = CompileDirectiveMetadata.create({
+ selector: '[a=b]',
+ type: new CompileTypeMetadata(
+ {moduleUrl: someModuleUrl, name: 'DirA', reference: {} as Type})
+ });
+ var dirB = CompileDirectiveMetadata.create({
+ selector: '[b]',
+ type: new CompileTypeMetadata(
+ {moduleUrl: someModuleUrl, name: 'DirB', reference: {} as Type})
+ });
+ expect(humanizeTplAst(parse('
', [dirA, dirB]))).toEqual([
+ [ElementAst, 'div'],
+ [BoundElementPropertyAst, PropertyBindingType.Property, 'a', 'b', null],
+ [DirectiveAst, dirA]
+ ]);
+ });
- it('should allow events on explicit embedded templates that are emitted by a directive',
- () => {
- var dirA = CompileDirectiveMetadata.create({
- selector: 'template',
- outputs: ['e'],
- type: new CompileTypeMetadata(
- {moduleUrl: someModuleUrl, name: 'DirA', reference: {} as Type})
- });
- expect(humanizeTplAst(parse('', [dirA]))).toEqual([
- [EmbeddedTemplateAst],
- [BoundEventAst, 'e', null, 'f'],
- [DirectiveAst, dirA],
- ]);
- });
- });
+ it('should locate directives in event bindings', () => {
+ var dirA = CompileDirectiveMetadata.create({
+ selector: '[a]',
+ type: new CompileTypeMetadata(
+ {moduleUrl: someModuleUrl, name: 'DirB', reference: {} as Type})
+ });
- describe('bindon', () => {
- it('should parse bound events and properties via [(...)] and not report them as attributes',
- () => {
- expect(humanizeTplAst(parse('
', []))).toEqual([
- [ElementAst, 'div'],
- [BoundElementPropertyAst, PropertyBindingType.Property, 'prop', 'v', null],
- [BoundEventAst, 'propChange', null, 'v = $event']
- ]);
- });
-
- it('should parse bound events and properties via bindon- and not report them as attributes',
- () => {
- expect(humanizeTplAst(parse('
', []))).toEqual([
- [ElementAst, 'div'],
- [BoundElementPropertyAst, PropertyBindingType.Property, 'prop', 'v', null],
- [BoundEventAst, 'propChange', null, 'v = $event']
- ]);
- });
+ expect(humanizeTplAst(parse('
', [dirA]))).toEqual([
+ [ElementAst, 'div'], [BoundEventAst, 'a', null, 'b'], [DirectiveAst, dirA]
+ ]);
+ });
- });
+ it('should parse directive host properties', () => {
+ var dirA = CompileDirectiveMetadata.create({
+ selector: 'div',
+ type: new CompileTypeMetadata(
+ {moduleUrl: someModuleUrl, name: 'DirA', reference: {} as Type}),
+ host: {'[a]': 'expr'}
+ });
+ expect(humanizeTplAst(parse('', [dirA]))).toEqual([
+ [ElementAst, 'div'], [DirectiveAst, dirA],
+ [BoundElementPropertyAst, PropertyBindingType.Property, 'a', 'expr', null]
+ ]);
+ });
- describe('directives', () => {
- it('should order directives by the directives array in the View and match them only once',
- () => {
- var dirA = CompileDirectiveMetadata.create({
- selector: '[a]',
- type: new CompileTypeMetadata(
- {moduleUrl: someModuleUrl, name: 'DirA', reference: {} as Type})
- });
- var dirB = CompileDirectiveMetadata.create({
- selector: '[b]',
- type: new CompileTypeMetadata(
- {moduleUrl: someModuleUrl, name: 'DirB', reference: {} as Type})
- });
- var dirC = CompileDirectiveMetadata.create({
- selector: '[c]',
- type: new CompileTypeMetadata(
- {moduleUrl: someModuleUrl, name: 'DirC', reference: {} as Type})
- });
- expect(humanizeTplAst(parse('
', [dirA, dirB, dirC]))).toEqual([
- [ElementAst, 'div'], [AttrAst, 'a', ''], [AttrAst, 'c', ''], [AttrAst, 'b', ''],
- [AttrAst, 'a', ''], [AttrAst, 'b', ''], [DirectiveAst, dirA], [DirectiveAst, dirB],
- [DirectiveAst, dirC]
- ]);
- });
-
- it('should locate directives in property bindings', () => {
- var dirA = CompileDirectiveMetadata.create({
- selector: '[a=b]',
- type: new CompileTypeMetadata(
- {moduleUrl: someModuleUrl, name: 'DirA', reference: {} as Type})
- });
- var dirB = CompileDirectiveMetadata.create({
- selector: '[b]',
- type: new CompileTypeMetadata(
- {moduleUrl: someModuleUrl, name: 'DirB', reference: {} as Type})
- });
- expect(humanizeTplAst(parse('
', [dirA, dirB]))).toEqual([
- [ElementAst, 'div'],
- [BoundElementPropertyAst, PropertyBindingType.Property, 'a', 'b', null],
- [DirectiveAst, dirA]
- ]);
- });
+ it('should parse directive host listeners', () => {
+ var dirA = CompileDirectiveMetadata.create({
+ selector: 'div',
+ type: new CompileTypeMetadata(
+ {moduleUrl: someModuleUrl, name: 'DirA', reference: {} as Type}),
+ host: {'(a)': 'expr'}
+ });
+ expect(humanizeTplAst(parse('', [dirA]))).toEqual([
+ [ElementAst, 'div'], [DirectiveAst, dirA], [BoundEventAst, 'a', null, 'expr']
+ ]);
+ });
- it('should locate directives in event bindings', () => {
- var dirA = CompileDirectiveMetadata.create({
- selector: '[a]',
- type: new CompileTypeMetadata(
- {moduleUrl: someModuleUrl, name: 'DirB', reference: {} as Type})
- });
+ it('should parse directive properties', () => {
+ var dirA = CompileDirectiveMetadata.create({
+ selector: 'div',
+ type: new CompileTypeMetadata(
+ {moduleUrl: someModuleUrl, name: 'DirA', reference: {} as Type}),
+ inputs: ['aProp']
+ });
+ expect(humanizeTplAst(parse('', [dirA]))).toEqual([
+ [ElementAst, 'div'], [DirectiveAst, dirA],
+ [BoundDirectivePropertyAst, 'aProp', 'expr']
+ ]);
+ });
- expect(humanizeTplAst(parse('
', [dirA]))).toEqual([
- [ElementAst, 'div'], [BoundEventAst, 'a', null, 'b'], [DirectiveAst, dirA]
- ]);
- });
+ it('should parse renamed directive properties', () => {
+ var dirA = CompileDirectiveMetadata.create({
+ selector: 'div',
+ type: new CompileTypeMetadata(
+ {moduleUrl: someModuleUrl, name: 'DirA', reference: {} as Type}),
+ inputs: ['b:a']
+ });
+ expect(humanizeTplAst(parse('', [dirA]))).toEqual([
+ [ElementAst, 'div'], [DirectiveAst, dirA],
+ [BoundDirectivePropertyAst, 'b', 'expr']
+ ]);
+ });
- it('should parse directive host properties', () => {
- var dirA = CompileDirectiveMetadata.create({
- selector: 'div',
- type: new CompileTypeMetadata(
- {moduleUrl: someModuleUrl, name: 'DirA', reference: {} as Type}),
- host: {'[a]': 'expr'}
- });
- expect(humanizeTplAst(parse('', [dirA]))).toEqual([
- [ElementAst, 'div'], [DirectiveAst, dirA],
- [BoundElementPropertyAst, PropertyBindingType.Property, 'a', 'expr', null]
- ]);
- });
+ it('should parse literal directive properties', () => {
+ var dirA = CompileDirectiveMetadata.create({
+ selector: 'div',
+ type: new CompileTypeMetadata(
+ {moduleUrl: someModuleUrl, name: 'DirA', reference: {} as Type}),
+ inputs: ['a']
+ });
+ expect(humanizeTplAst(parse('', [dirA]))).toEqual([
+ [ElementAst, 'div'], [AttrAst, 'a', 'literal'], [DirectiveAst, dirA],
+ [BoundDirectivePropertyAst, 'a', '"literal"']
+ ]);
+ });
- it('should parse directive host listeners', () => {
- var dirA = CompileDirectiveMetadata.create({
- selector: 'div',
- type: new CompileTypeMetadata(
- {moduleUrl: someModuleUrl, name: 'DirA', reference: {} as Type}),
- host: {'(a)': 'expr'}
- });
- expect(humanizeTplAst(parse('', [dirA]))).toEqual([
- [ElementAst, 'div'], [DirectiveAst, dirA], [BoundEventAst, 'a', null, 'expr']
- ]);
- });
+ it('should favor explicit bound properties over literal properties', () => {
+ var dirA = CompileDirectiveMetadata.create({
+ selector: 'div',
+ type: new CompileTypeMetadata(
+ {moduleUrl: someModuleUrl, name: 'DirA', reference: {} as Type}),
+ inputs: ['a']
+ });
+ expect(humanizeTplAst(parse('', [dirA])))
+ .toEqual([
+ [ElementAst, 'div'], [AttrAst, 'a', 'literal'], [DirectiveAst, dirA],
+ [BoundDirectivePropertyAst, 'a', '"literal2"']
+ ]);
+ });
- it('should parse directive properties', () => {
- var dirA = CompileDirectiveMetadata.create({
- selector: 'div',
- type: new CompileTypeMetadata(
- {moduleUrl: someModuleUrl, name: 'DirA', reference: {} as Type}),
- inputs: ['aProp']
- });
- expect(humanizeTplAst(parse('', [dirA]))).toEqual([
- [ElementAst, 'div'], [DirectiveAst, dirA],
- [BoundDirectivePropertyAst, 'aProp', 'expr']
- ]);
- });
+ it('should support optional directive properties', () => {
+ var dirA = CompileDirectiveMetadata.create({
+ selector: 'div',
+ type: new CompileTypeMetadata(
+ {moduleUrl: someModuleUrl, name: 'DirA', reference: {} as Type}),
+ inputs: ['a']
+ });
+ expect(humanizeTplAst(parse('', [dirA]))).toEqual([
+ [ElementAst, 'div'], [DirectiveAst, dirA]
+ ]);
+ });
- it('should parse renamed directive properties', () => {
- var dirA = CompileDirectiveMetadata.create({
- selector: 'div',
- type: new CompileTypeMetadata(
- {moduleUrl: someModuleUrl, name: 'DirA', reference: {} as Type}),
- inputs: ['b:a']
});
- expect(humanizeTplAst(parse('', [dirA]))).toEqual([
- [ElementAst, 'div'], [DirectiveAst, dirA], [BoundDirectivePropertyAst, 'b', 'expr']
- ]);
- });
- it('should parse literal directive properties', () => {
- var dirA = CompileDirectiveMetadata.create({
- selector: 'div',
- type: new CompileTypeMetadata(
- {moduleUrl: someModuleUrl, name: 'DirA', reference: {} as Type}),
- inputs: ['a']
- });
- expect(humanizeTplAst(parse('', [dirA]))).toEqual([
- [ElementAst, 'div'], [AttrAst, 'a', 'literal'], [DirectiveAst, dirA],
- [BoundDirectivePropertyAst, 'a', '"literal"']
- ]);
- });
+ describe('providers', () => {
+ var nextProviderId: number;
+
+ function createToken(value: string): CompileTokenMetadata {
+ let token: CompileTokenMetadata;
+ if (value.startsWith('type:')) {
+ const name = value.substring(5);
+ token = new CompileTokenMetadata({
+ identifier: new CompileTypeMetadata(
+ {moduleUrl: someModuleUrl, name, reference: name as any as Type})
+ });
+ } else {
+ token = new CompileTokenMetadata({value: value});
+ }
+ return token;
+ }
- it('should favor explicit bound properties over literal properties', () => {
- var dirA = CompileDirectiveMetadata.create({
- selector: 'div',
- type: new CompileTypeMetadata(
- {moduleUrl: someModuleUrl, name: 'DirA', reference: {} as Type}),
- inputs: ['a']
- });
- expect(humanizeTplAst(parse('', [dirA])))
- .toEqual([
- [ElementAst, 'div'], [AttrAst, 'a', 'literal'], [DirectiveAst, dirA],
- [BoundDirectivePropertyAst, 'a', '"literal2"']
- ]);
- });
+ function createDep(value: string): CompileDiDependencyMetadata {
+ var isOptional = false;
+ if (value.startsWith('optional:')) {
+ isOptional = true;
+ value = value.substring(9);
+ }
+ var isSelf = false;
+ if (value.startsWith('self:')) {
+ isSelf = true;
+ value = value.substring(5);
+ }
+ var isHost = false;
+ if (value.startsWith('host:')) {
+ isHost = true;
+ value = value.substring(5);
+ }
+ return new CompileDiDependencyMetadata({
+ token: createToken(value),
+ isOptional: isOptional,
+ isSelf: isSelf,
+ isHost: isHost
+ });
+ }
- it('should support optional directive properties', () => {
- var dirA = CompileDirectiveMetadata.create({
- selector: 'div',
- type: new CompileTypeMetadata(
- {moduleUrl: someModuleUrl, name: 'DirA', reference: {} as Type}),
- inputs: ['a']
- });
- expect(humanizeTplAst(parse('', [dirA]))).toEqual([
- [ElementAst, 'div'], [DirectiveAst, dirA]
- ]);
- });
+ function createProvider(
+ token: string, {multi = false, deps = []}: {multi?: boolean, deps?: string[]} = {}):
+ CompileProviderMetadata {
+ const name = `provider${nextProviderId++}`;
+ return new CompileProviderMetadata({
+ token: createToken(token),
+ multi: multi,
+ useClass: new CompileTypeMetadata({name, reference: name as any as Type}),
+ deps: deps.map(createDep)
+ });
+ }
- });
+ function createDir(
+ selector: string,
+ {providers = null, viewProviders = null, deps = [], queries = []}: {
+ providers?: CompileProviderMetadata[],
+ viewProviders?: CompileProviderMetadata[],
+ deps?: string[],
+ queries?: string[]
+ } = {}): CompileDirectiveMetadata {
+ var isComponent = !selector.startsWith('[');
+ return CompileDirectiveMetadata.create({
+ selector: selector,
+ type: new CompileTypeMetadata({
+ moduleUrl: someModuleUrl,
+ name: selector,
+ diDeps: deps.map(createDep),
+ reference: selector as any as Type
+ }),
+ isComponent: isComponent,
+ template: new CompileTemplateMetadata({ngContentSelectors: []}),
+ providers: providers,
+ viewProviders: viewProviders,
+ queries: queries.map(
+ (value) => new CompileQueryMetadata({selectors: [createToken(value)]}))
+ });
+ }
- describe('providers', () => {
- var nextProviderId: number;
+ beforeEach(() => { nextProviderId = 0; });
- function createToken(value: string): CompileTokenMetadata {
- let token: CompileTokenMetadata;
- if (value.startsWith('type:')) {
- const name = value.substring(5);
- token = new CompileTokenMetadata({
- identifier: new CompileTypeMetadata(
- {moduleUrl: someModuleUrl, name, reference: name as any as Type})
+ it('should provide a component', () => {
+ var comp = createDir('my-comp');
+ var elAst: ElementAst = parse('', [comp])[0];
+ expect(elAst.providers.length).toBe(1);
+ expect(elAst.providers[0].providerType).toBe(ProviderAstType.Component);
+ expect(elAst.providers[0].providers[0].useClass).toBe(comp.type);
});
- } else {
- token = new CompileTokenMetadata({value: value});
- }
- return token;
- }
-
- function createDep(value: string): CompileDiDependencyMetadata {
- var isOptional = false;
- if (value.startsWith('optional:')) {
- isOptional = true;
- value = value.substring(9);
- }
- var isSelf = false;
- if (value.startsWith('self:')) {
- isSelf = true;
- value = value.substring(5);
- }
- var isHost = false;
- if (value.startsWith('host:')) {
- isHost = true;
- value = value.substring(5);
- }
- return new CompileDiDependencyMetadata(
- {token: createToken(value), isOptional: isOptional, isSelf: isSelf, isHost: isHost});
- }
-
- function createProvider(
- token: string, {multi = false, deps = []}: {multi?: boolean, deps?: string[]} = {}):
- CompileProviderMetadata {
- const name = `provider${nextProviderId++}`;
- return new CompileProviderMetadata({
- token: createToken(token),
- multi: multi,
- useClass: new CompileTypeMetadata({name, reference: name as any as Type}),
- deps: deps.map(createDep)
- });
- }
-
- function createDir(
- selector: string, {providers = null, viewProviders = null, deps = [], queries = []}: {
- providers?: CompileProviderMetadata[],
- viewProviders?: CompileProviderMetadata[],
- deps?: string[],
- queries?: string[]
- } = {}): CompileDirectiveMetadata {
- var isComponent = !selector.startsWith('[');
- return CompileDirectiveMetadata.create({
- selector: selector,
- type: new CompileTypeMetadata({
- moduleUrl: someModuleUrl,
- name: selector,
- diDeps: deps.map(createDep),
- reference: selector as any as Type
- }),
- isComponent: isComponent,
- template: new CompileTemplateMetadata({ngContentSelectors: []}),
- providers: providers,
- viewProviders: viewProviders,
- queries: queries.map(
- (value) => new CompileQueryMetadata({selectors: [createToken(value)]}))
- });
- }
-
- beforeEach(() => { nextProviderId = 0; });
-
- it('should provide a component', () => {
- var comp = createDir('my-comp');
- var elAst: ElementAst = parse('', [comp])[0];
- expect(elAst.providers.length).toBe(1);
- expect(elAst.providers[0].providerType).toBe(ProviderAstType.Component);
- expect(elAst.providers[0].providers[0].useClass).toBe(comp.type);
- });
- it('should provide a directive', () => {
- var dirA = createDir('[dirA]');
- var elAst: ElementAst = parse('
', [dirA])[0];
- expect(elAst.providers.length).toBe(1);
- expect(elAst.providers[0].providerType).toBe(ProviderAstType.Directive);
- expect(elAst.providers[0].providers[0].useClass).toBe(dirA.type);
- });
+ it('should provide a directive', () => {
+ var dirA = createDir('[dirA]');
+ var elAst: ElementAst = parse('
', [dirA])[0];
+ expect(elAst.providers.length).toBe(1);
+ expect(elAst.providers[0].providerType).toBe(ProviderAstType.Directive);
+ expect(elAst.providers[0].providers[0].useClass).toBe(dirA.type);
+ });
- it('should use the public providers of a directive', () => {
- var provider = createProvider('service');
- var dirA = createDir('[dirA]', {providers: [provider]});
- var elAst: ElementAst = parse('
', [dirA])[0];
- expect(elAst.providers.length).toBe(2);
- expect(elAst.providers[1].providerType).toBe(ProviderAstType.PublicService);
- expect(elAst.providers[1].providers).toEqual([provider]);
- });
+ it('should use the public providers of a directive', () => {
+ var provider = createProvider('service');
+ var dirA = createDir('[dirA]', {providers: [provider]});
+ var elAst: ElementAst = parse('
', [dirA])[0];
+ expect(elAst.providers.length).toBe(2);
+ expect(elAst.providers[1].providerType).toBe(ProviderAstType.PublicService);
+ expect(elAst.providers[1].providers).toEqual([provider]);
+ });
- it('should use the private providers of a component', () => {
- var provider = createProvider('service');
- var comp = createDir('my-comp', {viewProviders: [provider]});
- var elAst: ElementAst = parse('', [comp])[0];
- expect(elAst.providers.length).toBe(2);
- expect(elAst.providers[1].providerType).toBe(ProviderAstType.PrivateService);
- expect(elAst.providers[1].providers).toEqual([provider]);
- });
+ it('should use the private providers of a component', () => {
+ var provider = createProvider('service');
+ var comp = createDir('my-comp', {viewProviders: [provider]});
+ var elAst: ElementAst = parse('', [comp])[0];
+ expect(elAst.providers.length).toBe(2);
+ expect(elAst.providers[1].providerType).toBe(ProviderAstType.PrivateService);
+ expect(elAst.providers[1].providers).toEqual([provider]);
+ });
- it('should support multi providers', () => {
- var provider0 = createProvider('service0', {multi: true});
- var provider1 = createProvider('service1', {multi: true});
- var provider2 = createProvider('service0', {multi: true});
- var dirA = createDir('[dirA]', {providers: [provider0, provider1]});
- var dirB = createDir('[dirB]', {providers: [provider2]});
- var elAst: ElementAst = parse('
', [dirA, dirB])[0];
- expect(elAst.providers.length).toBe(4);
- expect(elAst.providers[2].providers).toEqual([provider0, provider2]);
- expect(elAst.providers[3].providers).toEqual([provider1]);
- });
+ it('should support multi providers', () => {
+ var provider0 = createProvider('service0', {multi: true});
+ var provider1 = createProvider('service1', {multi: true});
+ var provider2 = createProvider('service0', {multi: true});
+ var dirA = createDir('[dirA]', {providers: [provider0, provider1]});
+ var dirB = createDir('[dirB]', {providers: [provider2]});
+ var elAst: ElementAst = parse('
', [dirA, dirB])[0];
+ expect(elAst.providers.length).toBe(4);
+ expect(elAst.providers[2].providers).toEqual([provider0, provider2]);
+ expect(elAst.providers[3].providers).toEqual([provider1]);
+ });
- it('should overwrite non multi providers', () => {
- var provider1 = createProvider('service0');
- var provider2 = createProvider('service1');
- var provider3 = createProvider('service0');
- var dirA = createDir('[dirA]', {providers: [provider1, provider2]});
- var dirB = createDir('[dirB]', {providers: [provider3]});
- var elAst: ElementAst = parse('
', [dirA, dirB])[0];
- expect(elAst.providers.length).toBe(4);
- expect(elAst.providers[2].providers).toEqual([provider3]);
- expect(elAst.providers[3].providers).toEqual([provider2]);
- });
+ it('should overwrite non multi providers', () => {
+ var provider1 = createProvider('service0');
+ var provider2 = createProvider('service1');
+ var provider3 = createProvider('service0');
+ var dirA = createDir('[dirA]', {providers: [provider1, provider2]});
+ var dirB = createDir('[dirB]', {providers: [provider3]});
+ var elAst: ElementAst = parse('
', [dirA, dirB])[0];
+ expect(elAst.providers.length).toBe(4);
+ expect(elAst.providers[2].providers).toEqual([provider3]);
+ expect(elAst.providers[3].providers).toEqual([provider2]);
+ });
- it('should overwrite component providers by directive providers', () => {
- var compProvider = createProvider('service0');
- var dirProvider = createProvider('service0');
- var comp = createDir('my-comp', {providers: [compProvider]});
- var dirA = createDir('[dirA]', {providers: [dirProvider]});
- var elAst: ElementAst = parse('', [dirA, comp])[0];
- expect(elAst.providers.length).toBe(3);
- expect(elAst.providers[2].providers).toEqual([dirProvider]);
- });
+ it('should overwrite component providers by directive providers', () => {
+ var compProvider = createProvider('service0');
+ var dirProvider = createProvider('service0');
+ var comp = createDir('my-comp', {providers: [compProvider]});
+ var dirA = createDir('[dirA]', {providers: [dirProvider]});
+ var elAst: ElementAst = parse('', [dirA, comp])[0];
+ expect(elAst.providers.length).toBe(3);
+ expect(elAst.providers[2].providers).toEqual([dirProvider]);
+ });
- it('should overwrite view providers by directive providers', () => {
- var viewProvider = createProvider('service0');
- var dirProvider = createProvider('service0');
- var comp = createDir('my-comp', {viewProviders: [viewProvider]});
- var dirA = createDir('[dirA]', {providers: [dirProvider]});
- var elAst: ElementAst = parse('', [dirA, comp])[0];
- expect(elAst.providers.length).toBe(3);
- expect(elAst.providers[2].providers).toEqual([dirProvider]);
- });
+ it('should overwrite view providers by directive providers', () => {
+ var viewProvider = createProvider('service0');
+ var dirProvider = createProvider('service0');
+ var comp = createDir('my-comp', {viewProviders: [viewProvider]});
+ var dirA = createDir('[dirA]', {providers: [dirProvider]});
+ var elAst: ElementAst = parse('', [dirA, comp])[0];
+ expect(elAst.providers.length).toBe(3);
+ expect(elAst.providers[2].providers).toEqual([dirProvider]);
+ });
- it('should overwrite directives by providers', () => {
- var dirProvider = createProvider('type:my-comp');
- var comp = createDir('my-comp', {providers: [dirProvider]});
- var elAst: ElementAst = parse('', [comp])[0];
- expect(elAst.providers.length).toBe(1);
- expect(elAst.providers[0].providers).toEqual([dirProvider]);
- });
+ it('should overwrite directives by providers', () => {
+ var dirProvider = createProvider('type:my-comp');
+ var comp = createDir('my-comp', {providers: [dirProvider]});
+ var elAst: ElementAst = parse('', [comp])[0];
+ expect(elAst.providers.length).toBe(1);
+ expect(elAst.providers[0].providers).toEqual([dirProvider]);
+ });
- it('if mixing multi and non multi providers', () => {
- var provider0 = createProvider('service0');
- var provider1 = createProvider('service0', {multi: true});
- var dirA = createDir('[dirA]', {providers: [provider0]});
- var dirB = createDir('[dirB]', {providers: [provider1]});
- expect(() => parse('
', [dirA, dirB]))
- .toThrowError(
- `Template parse errors:\n` +
- `Mixing multi and non multi provider is not possible for token service0 ("[ERROR ->]
"): TestComp@0:0`);
- });
+ it('if mixing multi and non multi providers', () => {
+ var provider0 = createProvider('service0');
+ var provider1 = createProvider('service0', {multi: true});
+ var dirA = createDir('[dirA]', {providers: [provider0]});
+ var dirB = createDir('[dirB]', {providers: [provider1]});
+ expect(() => parse('
', [dirA, dirB]))
+ .toThrowError(
+ `Template parse errors:\n` +
+ `Mixing multi and non multi provider is not possible for token service0 ("[ERROR ->]
"): TestComp@0:0`);
+ });
- it('should sort providers by their DI order', () => {
- var provider0 = createProvider('service0', {deps: ['type:[dir2]']});
- var provider1 = createProvider('service1');
- var dir2 = createDir('[dir2]', {deps: ['service1']});
- var comp = createDir('my-comp', {providers: [provider0, provider1]});
- var elAst: ElementAst = parse('', [comp, dir2])[0];
- expect(elAst.providers.length).toBe(4);
- expect(elAst.providers[0].providers[0].useClass).toEqual(comp.type);
- expect(elAst.providers[1].providers).toEqual([provider1]);
- expect(elAst.providers[2].providers[0].useClass).toEqual(dir2.type);
- expect(elAst.providers[3].providers).toEqual([provider0]);
- });
+ it('should sort providers by their DI order', () => {
+ var provider0 = createProvider('service0', {deps: ['type:[dir2]']});
+ var provider1 = createProvider('service1');
+ var dir2 = createDir('[dir2]', {deps: ['service1']});
+ var comp = createDir('my-comp', {providers: [provider0, provider1]});
+ var elAst: ElementAst = parse('', [comp, dir2])[0];
+ expect(elAst.providers.length).toBe(4);
+ expect(elAst.providers[0].providers[0].useClass).toEqual(comp.type);
+ expect(elAst.providers[1].providers).toEqual([provider1]);
+ expect(elAst.providers[2].providers[0].useClass).toEqual(dir2.type);
+ expect(elAst.providers[3].providers).toEqual([provider0]);
+ });
- it('should sort directives by their DI order', () => {
- var dir0 = createDir('[dir0]', {deps: ['type:my-comp']});
- var dir1 = createDir('[dir1]', {deps: ['type:[dir0]']});
- var dir2 = createDir('[dir2]', {deps: ['type:[dir1]']});
- var comp = createDir('my-comp');
- var elAst: ElementAst =
- parse('', [comp, dir2, dir0, dir1])[0];
- expect(elAst.providers.length).toBe(4);
- expect(elAst.directives[0].directive).toBe(comp);
- expect(elAst.directives[1].directive).toBe(dir0);
- expect(elAst.directives[2].directive).toBe(dir1);
- expect(elAst.directives[3].directive).toBe(dir2);
- });
+ it('should sort directives by their DI order', () => {
+ var dir0 = createDir('[dir0]', {deps: ['type:my-comp']});
+ var dir1 = createDir('[dir1]', {deps: ['type:[dir0]']});
+ var dir2 = createDir('[dir2]', {deps: ['type:[dir1]']});
+ var comp = createDir('my-comp');
+ var elAst: ElementAst =
+ parse('', [comp, dir2, dir0, dir1])[0];
+ expect(elAst.providers.length).toBe(4);
+ expect(elAst.directives[0].directive).toBe(comp);
+ expect(elAst.directives[1].directive).toBe(dir0);
+ expect(elAst.directives[2].directive).toBe(dir1);
+ expect(elAst.directives[3].directive).toBe(dir2);
+ });
- it('should mark directives and dependencies of directives as eager', () => {
- var provider0 = createProvider('service0');
- var provider1 = createProvider('service1');
- var dirA = createDir('[dirA]', {providers: [provider0, provider1], deps: ['service0']});
- var elAst: ElementAst = parse('
', [dirA])[0];
- expect(elAst.providers.length).toBe(3);
- expect(elAst.providers[0].providers).toEqual([provider0]);
- expect(elAst.providers[0].eager).toBe(true);
- expect(elAst.providers[1].providers[0].useClass).toEqual(dirA.type);
- expect(elAst.providers[1].eager).toBe(true);
- expect(elAst.providers[2].providers).toEqual([provider1]);
- expect(elAst.providers[2].eager).toBe(false);
- });
+ it('should mark directives and dependencies of directives as eager', () => {
+ var provider0 = createProvider('service0');
+ var provider1 = createProvider('service1');
+ var dirA =
+ createDir('[dirA]', {providers: [provider0, provider1], deps: ['service0']});
+ var elAst: ElementAst = parse('
', [dirA])[0];
+ expect(elAst.providers.length).toBe(3);
+ expect(elAst.providers[0].providers).toEqual([provider0]);
+ expect(elAst.providers[0].eager).toBe(true);
+ expect(elAst.providers[1].providers[0].useClass).toEqual(dirA.type);
+ expect(elAst.providers[1].eager).toBe(true);
+ expect(elAst.providers[2].providers).toEqual([provider1]);
+ expect(elAst.providers[2].eager).toBe(false);
+ });
- it('should mark dependencies on parent elements as eager', () => {
- var provider0 = createProvider('service0');
- var provider1 = createProvider('service1');
- var dirA = createDir('[dirA]', {providers: [provider0, provider1]});
- var dirB = createDir('[dirB]', {deps: ['service0']});
- var elAst: ElementAst =
- parse('parse('parse('', [dirA])[0];
- expect(elAst.providers.length).toBe(3);
- expect(elAst.providers[0].providers[0].useClass).toEqual(dirA.type);
- expect(elAst.providers[0].eager).toBe(true);
- expect(elAst.providers[1].providers).toEqual([provider0]);
- expect(elAst.providers[1].eager).toBe(true);
- expect(elAst.providers[2].providers).toEqual([provider1]);
- expect(elAst.providers[2].eager).toBe(false);
- });
+ it('should mark queried providers as eager', () => {
+ var provider0 = createProvider('service0');
+ var provider1 = createProvider('service1');
+ var dirA =
+ createDir('[dirA]', {providers: [provider0, provider1], queries: ['service0']});
+ var elAst: ElementAst = parse('', [dirA])[0];
+ expect(elAst.providers.length).toBe(3);
+ expect(elAst.providers[0].providers[0].useClass).toEqual(dirA.type);
+ expect(elAst.providers[0].eager).toBe(true);
+ expect(elAst.providers[1].providers).toEqual([provider0]);
+ expect(elAst.providers[1].eager).toBe(true);
+ expect(elAst.providers[2].providers).toEqual([provider1]);
+ expect(elAst.providers[2].eager).toBe(false);
+ });
- it('should not mark dependencies accross embedded views as eager', () => {
- var provider0 = createProvider('service0');
- var dirA = createDir('[dirA]', {providers: [provider0]});
- var dirB = createDir('[dirB]', {deps: ['service0']});
- var elAst: ElementAst =
- parse('parse('parse('', [dirA])[0];
- expect(elAst.providers[0].providers[0].deps[0].isValue).toBe(true);
- expect(elAst.providers[0].providers[0].deps[0].value).toBe(null);
- });
+ it('should change missing @Self() that are optional to nulls', () => {
+ var dirA = createDir('[dirA]', {deps: ['optional:self:provider0']});
+ var elAst: ElementAst = parse('', [dirA])[0];
+ expect(elAst.providers[0].providers[0].deps[0].isValue).toBe(true);
+ expect(elAst.providers[0].providers[0].deps[0].value).toBe(null);
+ });
- it('should report missing @Host() deps as errors', () => {
- var dirA = createDir('[dirA]', {deps: ['host:provider0']});
- expect(() => parse('', [dirA]))
- .toThrowError(
- 'Template parse errors:\nNo provider for provider0 ("[ERROR ->]"): TestComp@0:0');
- });
+ it('should report missing @Host() deps as errors', () => {
+ var dirA = createDir('[dirA]', {deps: ['host:provider0']});
+ expect(() => parse('', [dirA]))
+ .toThrowError(
+ 'Template parse errors:\nNo provider for provider0 ("[ERROR ->]"): TestComp@0:0');
+ });
- it('should change missing @Host() that are optional to nulls', () => {
- var dirA = createDir('[dirA]', {deps: ['optional:host:provider0']});
- var elAst: ElementAst = parse('', [dirA])[0];
- expect(elAst.providers[0].providers[0].deps[0].isValue).toBe(true);
- expect(elAst.providers[0].providers[0].deps[0].value).toBe(null);
- });
- });
+ it('should change missing @Host() that are optional to nulls', () => {
+ var dirA = createDir('[dirA]', {deps: ['optional:host:provider0']});
+ var elAst: ElementAst = parse('', [dirA])[0];
+ expect(elAst.providers[0].providers[0].deps[0].isValue).toBe(true);
+ expect(elAst.providers[0].providers[0].deps[0].value).toBe(null);
+ });
+ });
- describe('references', () => {
+ describe('references', () => {
- it('should parse references via #... and not report them as attributes', () => {
- expect(humanizeTplAst(parse('
', [dirA, dirB])[0];
- expect(elAst.providers.length).toBe(3);
- expect(elAst.providers[0].providers[0].useClass).toEqual(dirA.type);
- expect(elAst.providers[0].eager).toBe(true);
- expect(elAst.providers[1].providers).toEqual([provider0]);
- expect(elAst.providers[1].eager).toBe(true);
- expect(elAst.providers[2].providers).toEqual([provider1]);
- expect(elAst.providers[2].eager).toBe(false);
- });
+ it('should mark dependencies on parent elements as eager', () => {
+ var provider0 = createProvider('service0');
+ var provider1 = createProvider('service1');
+ var dirA = createDir('[dirA]', {providers: [provider0, provider1]});
+ var dirB = createDir('[dirB]', {deps: ['service0']});
+ var elAst: ElementAst =
+
', [dirA, dirB])[0];
+ expect(elAst.providers.length).toBe(3);
+ expect(elAst.providers[0].providers[0].useClass).toEqual(dirA.type);
+ expect(elAst.providers[0].eager).toBe(true);
+ expect(elAst.providers[1].providers).toEqual([provider0]);
+ expect(elAst.providers[1].eager).toBe(true);
+ expect(elAst.providers[2].providers).toEqual([provider1]);
+ expect(elAst.providers[2].eager).toBe(false);
+ });
- it('should mark queried providers as eager', () => {
- var provider0 = createProvider('service0');
- var provider1 = createProvider('service1');
- var dirA =
- createDir('[dirA]', {providers: [provider0, provider1], queries: ['service0']});
- var elAst: ElementAst =
', [dirA, dirB])[0];
- expect(elAst.providers.length).toBe(2);
- expect(elAst.providers[0].providers[0].useClass).toEqual(dirA.type);
- expect(elAst.providers[0].eager).toBe(true);
- expect(elAst.providers[1].providers).toEqual([provider0]);
- expect(elAst.providers[1].eager).toBe(false);
- });
+ it('should not mark dependencies accross embedded views as eager', () => {
+ var provider0 = createProvider('service0');
+ var dirA = createDir('[dirA]', {providers: [provider0]});
+ var dirB = createDir('[dirB]', {deps: ['service0']});
+ var elAst: ElementAst =
+
', [dirA, dirB])[0];
+ expect(elAst.providers.length).toBe(2);
+ expect(elAst.providers[0].providers[0].useClass).toEqual(dirA.type);
+ expect(elAst.providers[0].eager).toBe(true);
+ expect(elAst.providers[1].providers).toEqual([provider0]);
+ expect(elAst.providers[1].eager).toBe(false);
+ });
- it('should report missing @Self() deps as errors', () => {
- var dirA = createDir('[dirA]', {deps: ['self:provider0']});
- expect(() => parse('', [dirA]))
- .toThrowError(
- 'Template parse errors:\nNo provider for provider0 ("[ERROR ->]"): TestComp@0:0');
- });
+ it('should report missing @Self() deps as errors', () => {
+ var dirA = createDir('[dirA]', {deps: ['self:provider0']});
+ expect(() => parse('', [dirA]))
+ .toThrowError(
+ 'Template parse errors:\nNo provider for provider0 ("[ERROR ->]"): TestComp@0:0');
+ });
- it('should change missing @Self() that are optional to nulls', () => {
- var dirA = createDir('[dirA]', {deps: ['optional:self:provider0']});
- var elAst: ElementAst =
', [
- ]))).toEqual([[ElementAst, 'div'], [ReferenceAst, 'a', null]]);
- });
+ it('should parse references via #... and not report them as attributes', () => {
+ expect(humanizeTplAst(parse('
', [
+ ]))).toEqual([[ElementAst, 'div'], [ReferenceAst, 'a', null]]);
+ });
- it('should parse references via ref-... and not report them as attributes', () => {
- expect(humanizeTplAst(parse('
', [
- ]))).toEqual([[ElementAst, 'div'], [ReferenceAst, 'a', null]]);
- });
+ it('should parse references via ref-... and not report them as attributes', () => {
+ expect(humanizeTplAst(parse('
', [
+ ]))).toEqual([[ElementAst, 'div'], [ReferenceAst, 'a', null]]);
+ });
- it('should parse camel case references', () => {
- expect(humanizeTplAst(parse('
', [
- ]))).toEqual([[ElementAst, 'div'], [ReferenceAst, 'someA', null]]);
- });
+ it('should parse camel case references', () => {
+ expect(humanizeTplAst(parse('
', [
+ ]))).toEqual([[ElementAst, 'div'], [ReferenceAst, 'someA', null]]);
+ });
- it('should assign references with empty value to the element', () => {
- expect(humanizeTplAst(parse('', [
- ]))).toEqual([[ElementAst, 'div'], [ReferenceAst, 'a', null]]);
- });
+ it('should assign references with empty value to the element', () => {
+ expect(humanizeTplAst(parse('', [
+ ]))).toEqual([[ElementAst, 'div'], [ReferenceAst, 'a', null]]);
+ });
- it('should assign references to directives via exportAs', () => {
- var dirA = CompileDirectiveMetadata.create({
- selector: '[a]',
- type: new CompileTypeMetadata(
- {moduleUrl: someModuleUrl, name: 'DirA', reference: {} as Type}),
- exportAs: 'dirA'
- });
- expect(humanizeTplAst(parse('', [dirA]))).toEqual([
- [ElementAst, 'div'],
- [AttrAst, 'a', ''],
- [ReferenceAst, 'a', identifierToken(dirA.type)],
- [DirectiveAst, dirA],
- ]);
- });
+ it('should assign references to directives via exportAs', () => {
+ var dirA = CompileDirectiveMetadata.create({
+ selector: '[a]',
+ type: new CompileTypeMetadata(
+ {moduleUrl: someModuleUrl, name: 'DirA', reference: {} as Type}),
+ exportAs: 'dirA'
+ });
+ expect(humanizeTplAst(parse('', [dirA]))).toEqual([
+ [ElementAst, 'div'],
+ [AttrAst, 'a', ''],
+ [ReferenceAst, 'a', identifierToken(dirA.type)],
+ [DirectiveAst, dirA],
+ ]);
+ });
- it('should report references with values that dont match a directive as errors', () => {
- expect(() => parse('', [])).toThrowError(`Template parse errors:
+ it('should report references with values that dont match a directive as errors', () => {
+ expect(() => parse('', [])).toThrowError(`Template parse errors:
There is no directive with "exportAs" set to "dirA" ("}),
- exportAs: 'dirA',
- template: new CompileTemplateMetadata({ngContentSelectors: []})
- });
- expect(humanizeTplAst(parse('', [dirA]))).toEqual([
- [ElementAst, 'div'],
- [AttrAst, 'a', ''],
- [ReferenceAst, 'a', identifierToken(dirA.type)],
- [DirectiveAst, dirA],
- ]);
- });
+ it('should not throw error when there is same reference name in different templates',
+ () => {
+ expect(() => parse('}),
+ exportAs: 'dirA',
+ template: new CompileTemplateMetadata({ngContentSelectors: []})
+ });
+ expect(humanizeTplAst(parse('', [dirA]))).toEqual([
+ [ElementAst, 'div'],
+ [AttrAst, 'a', ''],
+ [ReferenceAst, 'a', identifierToken(dirA.type)],
+ [DirectiveAst, dirA],
+ ]);
+ });
- it('should not locate directives in references', () => {
- var dirA = CompileDirectiveMetadata.create({
- selector: '[a]',
- type: new CompileTypeMetadata(
- {moduleUrl: someModuleUrl, name: 'DirA', reference: {} as Type})
+ it('should not locate directives in references', () => {
+ var dirA = CompileDirectiveMetadata.create({
+ selector: '[a]',
+ type: new CompileTypeMetadata(
+ {moduleUrl: someModuleUrl, name: 'DirA', reference: {} as Type})
+ });
+ expect(humanizeTplAst(parse('
]#a="dirA">
"): TestComp@0:5`);
- });
+ });
- it('should report invalid reference names', () => {
- expect(() => parse('', [])).toThrowError(`Template parse errors:
+ it('should report invalid reference names', () => {
+ expect(() => parse('', [])).toThrowError(`Template parse errors:
"-" is not allowed in reference names ("]#a-b>
"): TestComp@0:5`);
- });
+ });
- it('should report variables as errors', () => {
- expect(() => parse('', [])).toThrowError(`Template parse errors:
+ it('should report variables as errors', () => {
+ expect(() => parse('', [])).toThrowError(`Template parse errors:
"let-" is only supported on template elements. ("]let-a>
"): TestComp@0:5`);
- });
+ });
- it('should report duplicate reference names', () => {
- expect(() => parse('', []))
- .toThrowError(`Template parse errors:
+ it('should report duplicate reference names', () => {
+ expect(() => parse('', []))
+ .toThrowError(`Template parse errors:
Reference "#a" is defined several times ("]#a>
"): TestComp@0:19`);
- });
+ });
- it('should not throw error when there is same reference name in different templates',
- () => {
- expect(() => parse('OK
', []))
- .not.toThrowError();
-
- });
-
- it('should assign references with empty value to components', () => {
- var dirA = CompileDirectiveMetadata.create({
- selector: '[a]',
- isComponent: true,
- type: new CompileTypeMetadata(
- {moduleUrl: someModuleUrl, name: 'DirA', reference: {} as TypeOK
', []))
+ .not.toThrowError();
+
+ });
+
+ it('should assign references with empty value to components', () => {
+ var dirA = CompileDirectiveMetadata.create({
+ selector: '[a]',
+ isComponent: true,
+ type: new CompileTypeMetadata(
+ {moduleUrl: someModuleUrl, name: 'DirA', reference: {} as Type', [dirA]))).toEqual([
+ [ElementAst, 'div'], [ReferenceAst, 'a', null]
+ ]);
+ });
});
- expect(humanizeTplAst(parse('
', [dirA]))).toEqual([
- [ElementAst, 'div'], [ReferenceAst, 'a', null]
- ]);
- });
- });
- describe('explicit templates', () => {
- it('should create embedded templates for elements', () => {
- expect(humanizeTplAst(parse('', [
- ]))).toEqual([[EmbeddedTemplateAst]]);
- expect(humanizeTplAst(parse('', [
- ]))).toEqual([[EmbeddedTemplateAst]]);
- });
-
- it('should create embedded templates for elements regardless the namespace',
- () => {
- expect(humanizeTplAst(parse('', []))).toEqual([
- [ElementAst, ':svg:svg'],
- [EmbeddedTemplateAst],
- ]);
- });
-
- it('should support references via #...', () => {
- expect(humanizeTplAst(parse('', []))).toEqual([
- [EmbeddedTemplateAst],
- [ReferenceAst, 'a', resolveIdentifierToken(Identifiers.TemplateRef)]
- ]);
- });
+ describe('explicit templates', () => {
+ it('should create embedded templates for elements', () => {
+ expect(humanizeTplAst(parse('', [
+ ]))).toEqual([[EmbeddedTemplateAst]]);
+ expect(humanizeTplAst(parse('', [
+ ]))).toEqual([[EmbeddedTemplateAst]]);
+ });
- it('should support references via ref-...', () => {
- expect(humanizeTplAst(parse('', []))).toEqual([
- [EmbeddedTemplateAst],
- [ReferenceAst, 'a', resolveIdentifierToken(Identifiers.TemplateRef)]
- ]);
- });
+ it('should create embedded templates for elements regardless the namespace',
+ () => {
+ expect(humanizeTplAst(parse('', []))).toEqual([
+ [ElementAst, ':svg:svg'],
+ [EmbeddedTemplateAst],
+ ]);
+ });
- it('should parse variables via let-...', () => {
- expect(humanizeTplAst(parse('', [
- ]))).toEqual([[EmbeddedTemplateAst], [VariableAst, 'a', 'b']]);
- });
+ it('should support references via #...', () => {
+ expect(humanizeTplAst(parse('', []))).toEqual([
+ [EmbeddedTemplateAst],
+ [ReferenceAst, 'a', resolveIdentifierToken(Identifiers.TemplateRef)]
+ ]);
+ });
- it('should not locate directives in variables', () => {
- var dirA = CompileDirectiveMetadata.create({
- selector: '[a]',
- type: new CompileTypeMetadata(
- {moduleUrl: someModuleUrl, name: 'DirA', reference: {} as Type})
- });
- expect(humanizeTplAst(parse('', [dirA]))).toEqual([
- [EmbeddedTemplateAst], [VariableAst, 'a', 'b']
- ]);
- });
+ it('should support references via ref-...', () => {
+ expect(humanizeTplAst(parse('', []))).toEqual([
+ [EmbeddedTemplateAst],
+ [ReferenceAst, 'a', resolveIdentifierToken(Identifiers.TemplateRef)]
+ ]);
+ });
- });
+ it('should parse variables via let-...', () => {
+ expect(humanizeTplAst(parse('', [
+ ]))).toEqual([[EmbeddedTemplateAst], [VariableAst, 'a', 'b']]);
+ });
- describe('inline templates', () => {
- it('should wrap the element into an EmbeddedTemplateAST', () => {
- expect(humanizeTplAst(parse('
', [
- ]))).toEqual([[EmbeddedTemplateAst], [ElementAst, 'div']]);
- });
+ it('should not locate directives in variables', () => {
+ var dirA = CompileDirectiveMetadata.create({
+ selector: '[a]',
+ type: new CompileTypeMetadata(
+ {moduleUrl: someModuleUrl, name: 'DirA', reference: {} as Type})
+ });
+ expect(humanizeTplAst(parse('', [dirA]))).toEqual([
+ [EmbeddedTemplateAst], [VariableAst, 'a', 'b']
+ ]);
+ });
- it('should wrap the element with data-template attribute into an EmbeddedTemplateAST ',
- () => {
- expect(humanizeTplAst(parse('
', [
- ]))).toEqual([[EmbeddedTemplateAst], [ElementAst, 'div']]);
- });
-
- it('should parse bound properties', () => {
- expect(humanizeTplAst(parse('
', [ngIf]))).toEqual([
- [EmbeddedTemplateAst], [DirectiveAst, ngIf],
- [BoundDirectivePropertyAst, 'ngIf', 'test'], [ElementAst, 'div']
- ]);
- });
+ });
- it('should report an error on variables declared with #', () => {
- expect(() => humanizeTplAst(parse('
', [])))
- .toThrowError(/Parser Error: Unexpected token # at column 6/);
- });
+ describe('inline templates', () => {
+ it('should wrap the element into an EmbeddedTemplateAST', () => {
+ expect(humanizeTplAst(parse('
', [
+ ]))).toEqual([[EmbeddedTemplateAst], [ElementAst, 'div']]);
+ });
- it('should parse variables via let ...', () => {
- expect(humanizeTplAst(parse('
', [
- ]))).toEqual([[EmbeddedTemplateAst], [VariableAst, 'a', 'b'], [ElementAst, 'div']]);
- });
+ it('should wrap the element with data-template attribute into an EmbeddedTemplateAST ',
+ () => {
+ expect(humanizeTplAst(parse('
', [
+ ]))).toEqual([[EmbeddedTemplateAst], [ElementAst, 'div']]);
+ });
- describe('directives', () => {
- it('should locate directives in property bindings', () => {
- var dirA = CompileDirectiveMetadata.create({
- selector: '[a=b]',
- type: new CompileTypeMetadata(
- {moduleUrl: someModuleUrl, name: 'DirA', reference: {} as Type}),
- inputs: ['a']
+ it('should parse bound properties', () => {
+ expect(humanizeTplAst(parse('
', [ngIf]))).toEqual([
+ [EmbeddedTemplateAst], [DirectiveAst, ngIf],
+ [BoundDirectivePropertyAst, 'ngIf', 'test'], [ElementAst, 'div']
+ ]);
});
- var dirB = CompileDirectiveMetadata.create({
- selector: '[b]',
- type: new CompileTypeMetadata(
- {moduleUrl: someModuleUrl, name: 'DirB', reference: {} as Type})
+
+ it('should report an error on variables declared with #', () => {
+ expect(() => humanizeTplAst(parse('
', [])))
+ .toThrowError(/Parser Error: Unexpected token # at column 6/);
});
- expect(humanizeTplAst(parse('
', [dirA, dirB]))).toEqual([
- [EmbeddedTemplateAst], [DirectiveAst, dirA], [BoundDirectivePropertyAst, 'a', 'b'],
- [ElementAst, 'div'], [AttrAst, 'b', ''], [DirectiveAst, dirB]
- ]);
- });
- it('should not locate directives in variables', () => {
- var dirA = CompileDirectiveMetadata.create({
- selector: '[a]',
- type: new CompileTypeMetadata(
- {moduleUrl: someModuleUrl, name: 'DirA', reference: {} as Type})
+ it('should parse variables via let ...', () => {
+ expect(humanizeTplAst(parse('