| /* |
| * Copyright (c) 2014, the Dart project authors. |
| * |
| * Licensed under the Eclipse Public License v1.0 (the "License"); you may not use this file except |
| * in compliance with the License. You may obtain a copy of the License at |
| * |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Unless required by applicable law or agreed to in writing, software distributed under the License |
| * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express |
| * or implied. See the License for the specific language governing permissions and limitations under |
| * the License. |
| */ |
| package com.google.dart.engine.internal.builder; |
| |
| import com.google.dart.engine.ast.AstFactory; |
| import com.google.dart.engine.ast.AstNode; |
| import com.google.dart.engine.ast.ClassDeclaration; |
| import com.google.dart.engine.ast.SimpleStringLiteral; |
| import com.google.dart.engine.element.ClassElement; |
| import com.google.dart.engine.element.Element; |
| import com.google.dart.engine.element.FieldElement; |
| import com.google.dart.engine.element.LocalVariableElement; |
| import com.google.dart.engine.element.ToolkitObjectElement; |
| import com.google.dart.engine.element.angular.AngularComponentElement; |
| import com.google.dart.engine.element.angular.AngularControllerElement; |
| import com.google.dart.engine.element.angular.AngularDecoratorElement; |
| import com.google.dart.engine.element.angular.AngularElement; |
| import com.google.dart.engine.element.angular.AngularFormatterElement; |
| import com.google.dart.engine.element.angular.AngularPropertyElement; |
| import com.google.dart.engine.element.angular.AngularPropertyKind; |
| import com.google.dart.engine.element.angular.AngularScopePropertyElement; |
| import com.google.dart.engine.element.angular.AngularSelectorElement; |
| import com.google.dart.engine.element.angular.AngularViewElement; |
| import com.google.dart.engine.error.AngularCode; |
| import com.google.dart.engine.html.ast.XmlTagNode; |
| import com.google.dart.engine.internal.element.angular.AngularHasClassSelectorElementImpl; |
| import com.google.dart.engine.internal.element.angular.AngularScopePropertyElementImpl; |
| import com.google.dart.engine.internal.element.angular.AngularTagSelectorElementImpl; |
| import com.google.dart.engine.internal.element.angular.HasAttributeSelectorElementImpl; |
| import com.google.dart.engine.internal.element.angular.IsTagHasAttributeSelectorElementImpl; |
| import com.google.dart.engine.internal.html.angular.AngularTest; |
| |
| import static com.google.dart.engine.html.HtmlFactory.attribute; |
| import static com.google.dart.engine.html.HtmlFactory.tagNode; |
| |
| public class AngularCompilationUnitBuilderTest extends AngularTest { |
| @SuppressWarnings("unchecked") |
| protected static <T extends AngularElement> T getAngularElement(Element element, |
| Class<T> angularElementType) { |
| ToolkitObjectElement[] toolkitObjects = null; |
| if (element instanceof ClassElement) { |
| ClassElement classElement = (ClassElement) element; |
| toolkitObjects = classElement.getToolkitObjects(); |
| } |
| if (element instanceof LocalVariableElement) { |
| LocalVariableElement variableElement = (LocalVariableElement) element; |
| toolkitObjects = variableElement.getToolkitObjects(); |
| } |
| if (toolkitObjects != null) { |
| for (ToolkitObjectElement toolkitObject : toolkitObjects) { |
| if (angularElementType.isInstance(toolkitObject)) { |
| return (T) toolkitObject; |
| } |
| } |
| } |
| return null; |
| } |
| |
| private static void assertHasAttributeSelector(AngularSelectorElement selector, String name) { |
| assertInstanceOf(HasAttributeSelectorElementImpl.class, selector); |
| assertEquals(name, ((HasAttributeSelectorElementImpl) selector).getName()); |
| } |
| |
| private static void assertIsTagSelector(AngularSelectorElement selector, String name) { |
| assertInstanceOf(AngularTagSelectorElementImpl.class, selector); |
| assertEquals(name, ((AngularTagSelectorElementImpl) selector).getName()); |
| } |
| |
| private static String createAngularSource(String... lines) { |
| String source = "import 'angular.dart';\n"; |
| source += createSource(lines); |
| return source; |
| } |
| |
| public void test_bad_notConstructorAnnotation() throws Exception { |
| String mainContent = createSource(// |
| "const MY_ANNOTATION = null;", |
| "@MY_ANNOTATION()", |
| "class MyFilter {", |
| "}"); |
| resolveMainSource(mainContent); |
| // prepare AngularFilterElement |
| ClassElement classElement = mainUnitElement.getType("MyFilter"); |
| AngularFormatterElement filter = getAngularElement(classElement, AngularFormatterElement.class); |
| assertNull(filter); |
| } |
| |
| public void test_Decorator() throws Exception { |
| String mainContent = createAngularSource(// |
| "@Decorator(selector: '[my-dir]',", |
| " map: const {", |
| " 'my-dir' : '=>myPropA',", |
| " '.' : '&myPropB',", |
| " })", |
| "class MyDirective {", |
| " set myPropA(value) {}", |
| " set myPropB(value) {}", |
| " @NgTwoWay('my-prop-c')", |
| " String myPropC;", |
| "}"); |
| resolveMainSourceNoErrors(mainContent); |
| // prepare AngularDirectiveElement |
| ClassElement classElement = mainUnitElement.getType("MyDirective"); |
| AngularDecoratorElement directive = getAngularElement( |
| classElement, |
| AngularDecoratorElement.class); |
| assertNotNull(directive); |
| // verify |
| assertEquals(null, directive.getName()); |
| assertEquals(-1, directive.getNameOffset()); |
| assertHasAttributeSelector(directive.getSelector(), "my-dir"); |
| // verify properties |
| AngularPropertyElement[] properties = directive.getProperties(); |
| assertLength(3, properties); |
| assertProperty( |
| properties[0], |
| "my-dir", |
| findMainOffset("my-dir' :"), |
| AngularPropertyKind.ONE_WAY, |
| "myPropA", |
| findMainOffset("myPropA'")); |
| assertProperty( |
| properties[1], |
| ".", |
| findMainOffset(".' :"), |
| AngularPropertyKind.CALLBACK, |
| "myPropB", |
| findMainOffset("myPropB'")); |
| assertProperty( |
| properties[2], |
| "my-prop-c", |
| findMainOffset("my-prop-c'"), |
| AngularPropertyKind.TWO_WAY, |
| "myPropC", |
| -1); |
| } |
| |
| public void test_Decorator_bad_cannotParseSelector() throws Exception { |
| String mainContent = createAngularSource(// |
| "@Decorator(selector: '~bad-selector',", |
| " map: const {", |
| " 'my-dir' : '=>myPropA',", |
| " '.' : '&myPropB',", |
| " })", |
| "class MyDirective {", |
| " set myPropA(value) {}", |
| " set myPropB(value) {}", |
| "}"); |
| resolveMainSource(mainContent); |
| // has error |
| assertMainErrors(AngularCode.CANNOT_PARSE_SELECTOR); |
| } |
| |
| public void test_Decorator_bad_missingSelector() throws Exception { |
| String mainContent = createAngularSource(// |
| "@Decorator(/*selector: '[my-dir]',*/", |
| " map: const {", |
| " 'my-dir' : '=>myPropA',", |
| " '.' : '&myPropB',", |
| " })", |
| "class MyDirective {", |
| " set myPropA(value) {}", |
| " set myPropB(value) {}", |
| "}"); |
| resolveMainSource(mainContent); |
| // has error |
| assertMainErrors(AngularCode.MISSING_SELECTOR); |
| } |
| |
| public void test_Formatter() throws Exception { |
| String mainContent = createAngularSource(// |
| "@Formatter(name: 'myFilter')", |
| "class MyFilter {", |
| " call(p1, p2) {}", |
| "}"); |
| resolveMainSourceNoErrors(mainContent); |
| // prepare AngularFilterElement |
| ClassElement classElement = mainUnitElement.getType("MyFilter"); |
| AngularFormatterElement filter = getAngularElement(classElement, AngularFormatterElement.class); |
| assertNotNull(filter); |
| // verify |
| assertEquals("myFilter", filter.getName()); |
| assertEquals(findOffset(mainContent, "myFilter'"), filter.getNameOffset()); |
| } |
| |
| public void test_Formatter_missingName() throws Exception { |
| String mainContent = createAngularSource(// |
| "@Formatter()", |
| "class MyFilter {", |
| " call(p1, p2) {}", |
| "}"); |
| resolveMainSource(mainContent); |
| // has error |
| assertMainErrors(AngularCode.MISSING_NAME); |
| // no filter |
| ClassElement classElement = mainUnitElement.getType("MyFilter"); |
| AngularFormatterElement filter = getAngularElement(classElement, AngularFormatterElement.class); |
| assertNull(filter); |
| } |
| |
| public void test_getElement_component_name() throws Exception { |
| resolveMainSource(createAngularSource(// |
| "@Component(publishAs: 'ctrl', selector: 'myComp',", |
| " templateUrl: 'my_template.html', cssUrl: 'my_styles.css')", |
| "class MyComponent {}")); |
| SimpleStringLiteral node = findMainNode("ctrl'", SimpleStringLiteral.class); |
| int offset = node.getOffset(); |
| // find AngularComponentElement |
| Element element = AngularCompilationUnitBuilder.getElement(node, offset); |
| assertInstanceOf(AngularComponentElement.class, element); |
| } |
| |
| public void test_getElement_component_property_fromFieldAnnotation() throws Exception { |
| resolveMainSource(createAngularSource(// |
| "@Component(publishAs: 'ctrl', selector: 'myComp',", |
| " templateUrl: 'my_template.html', cssUrl: 'my_styles.css')", |
| "class MyComponent {", |
| " @NgOneWay('prop')", |
| " var field;", |
| "}")); |
| // prepare node |
| SimpleStringLiteral node = findMainNode("prop'", SimpleStringLiteral.class); |
| int offset = node.getOffset(); |
| // prepare Element |
| Element element = AngularCompilationUnitBuilder.getElement(node, offset); |
| assertNotNull(element); |
| // check AngularPropertyElement |
| AngularPropertyElement property = (AngularPropertyElement) element; |
| assertEquals("prop", property.getName()); |
| } |
| |
| public void test_getElement_component_property_fromMap() throws Exception { |
| resolveMainSource(createAngularSource(// |
| "@Component(publishAs: 'ctrl', selector: 'myComp',", |
| " templateUrl: 'my_template.html', cssUrl: 'my_styles.css',", |
| " map: const {", |
| " 'prop' : '@field',", |
| " })", |
| "class MyComponent {", |
| " var field;", |
| "}")); |
| // AngularPropertyElement |
| { |
| SimpleStringLiteral node = findMainNode("prop'", SimpleStringLiteral.class); |
| int offset = node.getOffset(); |
| // prepare Element |
| Element element = AngularCompilationUnitBuilder.getElement(node, offset); |
| assertNotNull(element); |
| // check AngularPropertyElement |
| AngularPropertyElement property = (AngularPropertyElement) element; |
| assertEquals("prop", property.getName()); |
| } |
| // FieldElement |
| { |
| SimpleStringLiteral node = findMainNode("@field'", SimpleStringLiteral.class); |
| int offset = node.getOffset(); |
| // prepare Element |
| Element element = AngularCompilationUnitBuilder.getElement(node, offset); |
| assertNotNull(element); |
| // check FieldElement |
| FieldElement field = (FieldElement) element; |
| assertEquals("field", field.getName()); |
| } |
| } |
| |
| public void test_getElement_component_selector() throws Exception { |
| resolveMainSource(createAngularSource(// |
| "@Component(publishAs: 'ctrl', selector: 'myComp',", |
| " templateUrl: 'my_template.html', cssUrl: 'my_styles.css')", |
| "class MyComponent {}")); |
| SimpleStringLiteral node = findMainNode("myComp'", SimpleStringLiteral.class); |
| int offset = node.getOffset(); |
| // find AngularSelectorElement |
| Element element = AngularCompilationUnitBuilder.getElement(node, offset); |
| assertInstanceOf(AngularSelectorElement.class, element); |
| } |
| |
| public void test_getElement_controller_name() throws Exception { |
| resolveMainSource(createAngularSource(// |
| "@Controller(publishAs: 'ctrl', selector: '[myApp]')", |
| "class MyController {", |
| "}")); |
| SimpleStringLiteral node = findMainNode("ctrl'", SimpleStringLiteral.class); |
| int offset = node.getOffset(); |
| // find AngularControllerElement |
| Element element = AngularCompilationUnitBuilder.getElement(node, offset); |
| assertInstanceOf(AngularControllerElement.class, element); |
| } |
| |
| public void test_getElement_directive_property() throws Exception { |
| resolveMainSource(createAngularSource(// |
| "@Decorator(selector: '[my-dir]',", |
| " map: const {", |
| " 'my-dir' : '=>field'", |
| " })", |
| "class MyDirective {", |
| " set field(value) {}", |
| "}")); |
| // prepare node |
| SimpleStringLiteral node = findMainNode("my-dir'", SimpleStringLiteral.class); |
| int offset = node.getOffset(); |
| // prepare Element |
| Element element = AngularCompilationUnitBuilder.getElement(node, offset); |
| assertNotNull(element); |
| // check AngularPropertyElement |
| AngularPropertyElement property = (AngularPropertyElement) element; |
| assertEquals("my-dir", property.getName()); |
| } |
| |
| public void test_getElement_directive_selector() throws Exception { |
| resolveMainSource(createAngularSource(// |
| "@Decorator(selector: '[my-dir]')", |
| "class MyDirective {}")); |
| SimpleStringLiteral node = findMainNode("my-dir]'", SimpleStringLiteral.class); |
| int offset = node.getOffset(); |
| // find AngularSelectorElement |
| Element element = AngularCompilationUnitBuilder.getElement(node, offset); |
| assertInstanceOf(AngularSelectorElement.class, element); |
| } |
| |
| public void test_getElement_filter_name() throws Exception { |
| resolveMainSource(createAngularSource(// |
| "@Formatter(name: 'myFilter')", |
| "class MyFilter {", |
| " call(p1, p2) {}", |
| "}")); |
| SimpleStringLiteral node = findMainNode("myFilter'", SimpleStringLiteral.class); |
| int offset = node.getOffset(); |
| // find FilterElement |
| Element element = AngularCompilationUnitBuilder.getElement(node, offset); |
| assertInstanceOf(AngularFormatterElement.class, element); |
| } |
| |
| public void test_getElement_noClassDeclaration() throws Exception { |
| resolveMainSource("var foo = 'bar';"); |
| SimpleStringLiteral node = findMainNode("bar'", SimpleStringLiteral.class); |
| Element element = AngularCompilationUnitBuilder.getElement(node, 0); |
| assertNull(element); |
| } |
| |
| public void test_getElement_noClassElement() throws Exception { |
| resolveMainSource(createSource(// |
| "class A {", |
| " const A(p);", |
| "}", |
| "", |
| "@A('bar')", |
| "class B {}")); |
| SimpleStringLiteral node = findMainNode("bar'", SimpleStringLiteral.class); |
| // reset B element |
| node.getAncestor(ClassDeclaration.class).getName().setStaticElement(null); |
| // class is not resolved - no element |
| Element element = AngularCompilationUnitBuilder.getElement(node, 0); |
| assertNull(element); |
| } |
| |
| public void test_getElement_noNode() throws Exception { |
| Element element = AngularCompilationUnitBuilder.getElement(null, 0); |
| assertNull(element); |
| } |
| |
| public void test_getElement_notFound() throws Exception { |
| resolveMainSource(createSource(// |
| "class MyComponent {", |
| " var str = 'some string';", |
| "}")); |
| // prepare node |
| SimpleStringLiteral node = findMainNode("some string'", SimpleStringLiteral.class); |
| int offset = node.getOffset(); |
| // no Element |
| Element element = AngularCompilationUnitBuilder.getElement(node, offset); |
| assertNull(element); |
| } |
| |
| public void test_getElement_SimpleStringLiteral_withToolkitElement() throws Exception { |
| SimpleStringLiteral literal = AstFactory.string("foo"); |
| Element element = new AngularScopePropertyElementImpl("foo", 0, null); |
| literal.setToolkitElement(element); |
| assertSame(element, AngularCompilationUnitBuilder.getElement(literal, -1)); |
| } |
| |
| public void test_NgComponent_bad_cannotParseSelector() throws Exception { |
| contextHelper.addSource("/my_template.html", ""); |
| contextHelper.addSource("/my_styles.css", ""); |
| String mainContent = createAngularSource(// |
| "@Component(publishAs: 'ctrl', selector: '~myComp',", |
| " templateUrl: 'my_template.html', cssUrl: 'my_styles.css')", |
| "class MyComponent {", |
| "}"); |
| resolveMainSource(mainContent); |
| // has error |
| assertMainErrors(AngularCode.CANNOT_PARSE_SELECTOR); |
| } |
| |
| public void test_NgComponent_bad_missingSelector() throws Exception { |
| contextHelper.addSource("/my_template.html", ""); |
| contextHelper.addSource("/my_styles.css", ""); |
| String mainContent = createAngularSource(// |
| "@Component(publishAs: 'ctrl', /*selector: 'myComp',*/", |
| " templateUrl: 'my_template.html', cssUrl: 'my_styles.css')", |
| "class MyComponent {", |
| "}"); |
| resolveMainSource(mainContent); |
| // has error |
| assertMainErrors(AngularCode.MISSING_SELECTOR); |
| } |
| |
| /** |
| * <p> |
| * https://code.google.com/p/dart/issues/detail?id=16346 |
| */ |
| public void test_NgComponent_bad_notHtmlTemplate() throws Exception { |
| contextHelper.addSource("/my_template", ""); |
| contextHelper.addSource("/my_styles.css", ""); |
| addMainSource(createAngularSource(// |
| "@NgComponent(publishAs: 'ctrl', selector: 'myComp',", |
| " templateUrl: 'my_template', cssUrl: 'my_styles.css')", |
| "class MyComponent {", |
| "}")); |
| contextHelper.runTasks(); |
| // no exceptions, even though "my_template" is not an HTML file |
| } |
| |
| public void test_NgComponent_bad_properties_invalidBinding() throws Exception { |
| contextHelper.addSource("/my_template.html", ""); |
| contextHelper.addSource("/my_styles.css", ""); |
| String mainContent = createAngularSource(// |
| "@Component(publishAs: 'ctrl', selector: 'myComp',", |
| " templateUrl: 'my_template.html', cssUrl: 'my_styles.css',", |
| " map: const {'name' : '?field'})", |
| "class MyComponent {", |
| "}"); |
| resolveMainSource(mainContent); |
| // has error |
| assertMainErrors(AngularCode.INVALID_PROPERTY_KIND); |
| } |
| |
| public void test_NgComponent_bad_properties_nameNotStringLiteral() throws Exception { |
| contextHelper.addSource("/my_template.html", ""); |
| contextHelper.addSource("/my_styles.css", ""); |
| String mainContent = createAngularSource(// |
| "@Component(publishAs: 'ctrl', selector: 'myComp',", |
| " templateUrl: 'my_template.html', cssUrl: 'my_styles.css',", |
| " map: const {null : 'field'})", |
| "class MyComponent {", |
| "}"); |
| resolveMainSource(mainContent); |
| // has error |
| assertMainErrors(AngularCode.INVALID_PROPERTY_NAME); |
| } |
| |
| public void test_NgComponent_bad_properties_noSuchField() throws Exception { |
| contextHelper.addSource("/my_template.html", ""); |
| contextHelper.addSource("/my_styles.css", ""); |
| String mainContent = createAngularSource(// |
| "@Component(publishAs: 'ctrl', selector: 'myComp',", |
| " templateUrl: 'my_template.html', cssUrl: 'my_styles.css',", |
| " map: const {'name' : '=>field'})", |
| "class MyComponent {", |
| "}"); |
| resolveMainSource(mainContent); |
| // has error |
| assertMainErrors(AngularCode.INVALID_PROPERTY_FIELD); |
| } |
| |
| public void test_NgComponent_bad_properties_notMapLiteral() throws Exception { |
| contextHelper.addSource("/my_template.html", ""); |
| contextHelper.addSource("/my_styles.css", ""); |
| String mainContent = createAngularSource(// |
| "@Component(publishAs: 'ctrl', selector: 'myComp',", |
| " templateUrl: 'my_template.html', cssUrl: 'my_styles.css',", |
| " map: null)", |
| "class MyComponent {", |
| "}"); |
| resolveMainSource(mainContent); |
| // has error |
| assertMainErrors(AngularCode.INVALID_PROPERTY_MAP); |
| } |
| |
| public void test_NgComponent_bad_properties_specNotStringLiteral() throws Exception { |
| contextHelper.addSource("/my_template.html", ""); |
| contextHelper.addSource("/my_styles.css", ""); |
| String mainContent = createAngularSource(// |
| "@Component(publishAs: 'ctrl', selector: 'myComp',", |
| " templateUrl: 'my_template.html', cssUrl: 'my_styles.css',", |
| " map: const {'name' : null})", |
| "class MyComponent {", |
| "}"); |
| resolveMainSource(mainContent); |
| // has error |
| assertMainErrors(AngularCode.INVALID_PROPERTY_SPEC); |
| } |
| |
| public void test_NgComponent_no_cssUrl() throws Exception { |
| contextHelper.addSource("/my_template.html", ""); |
| contextHelper.addSource("/my_styles.css", ""); |
| String mainContent = createAngularSource(// |
| "@Component(publishAs: 'ctrl', selector: 'myComp',", |
| " templateUrl: 'my_template.html'/*, cssUrl: 'my_styles.css'*/)", |
| "class MyComponent {", |
| "}"); |
| resolveMainSource(mainContent); |
| // prepare AngularComponentElement |
| ClassElement classElement = mainUnitElement.getType("MyComponent"); |
| AngularComponentElement component = getAngularElement( |
| classElement, |
| AngularComponentElement.class); |
| assertNotNull(component); |
| // no CSS |
| assertEquals(null, component.getStyleUri()); |
| assertEquals(-1, component.getStyleUriOffset()); |
| } |
| |
| public void test_NgComponent_no_publishAs() throws Exception { |
| contextHelper.addSource("/my_template.html", ""); |
| contextHelper.addSource("/my_styles.css", ""); |
| String mainContent = createAngularSource(// |
| "@Component(/*publishAs: 'ctrl',*/ selector: 'myComp',", |
| " templateUrl: 'my_template.html', cssUrl: 'my_styles.css')", |
| "class MyComponent {", |
| "}"); |
| resolveMainSource(mainContent); |
| // prepare AngularComponentElement |
| ClassElement classElement = mainUnitElement.getType("MyComponent"); |
| AngularComponentElement component = getAngularElement( |
| classElement, |
| AngularComponentElement.class); |
| assertNotNull(component); |
| // no name |
| assertEquals(null, component.getName()); |
| assertEquals(-1, component.getNameOffset()); |
| } |
| |
| public void test_NgComponent_no_templateUrl() throws Exception { |
| contextHelper.addSource("/my_template.html", ""); |
| contextHelper.addSource("/my_styles.css", ""); |
| String mainContent = createAngularSource(// |
| "@Component(publishAs: 'ctrl', selector: 'myComp',", |
| " /*templateUrl: 'my_template.html',*/ cssUrl: 'my_styles.css')", |
| "class MyComponent {", |
| "}"); |
| resolveMainSource(mainContent); |
| // prepare AngularComponentElement |
| ClassElement classElement = mainUnitElement.getType("MyComponent"); |
| AngularComponentElement component = getAngularElement( |
| classElement, |
| AngularComponentElement.class); |
| assertNotNull(component); |
| // no template |
| assertEquals(null, component.getTemplateUri()); |
| assertEquals(null, component.getTemplateSource()); |
| assertEquals(-1, component.getTemplateUriOffset()); |
| } |
| |
| /** |
| * <p> |
| * https://code.google.com/p/dart/issues/detail?id=19023 |
| */ |
| public void test_NgComponent_notAngular() throws Exception { |
| contextHelper.addSource("/my_template.html", ""); |
| contextHelper.addSource("/my_styles.css", ""); |
| String mainContent = createSource(// |
| "class Component {", |
| " const Component(a, b);", |
| "}", |
| "", |
| "@Component('foo', 42)", |
| "class MyComponent {", |
| "}"); |
| resolveMainSource(mainContent); |
| assertNoMainErrors(); |
| } |
| |
| public void test_NgComponent_properties_fieldFromSuper() throws Exception { |
| contextHelper.addSource("/my_template.html", ""); |
| contextHelper.addSource("/my_styles.css", ""); |
| resolveMainSourceNoErrors(createAngularSource(// |
| "class MySuper {", |
| " var myPropA;", |
| "}", |
| "", |
| "", |
| "", |
| "@Component(publishAs: 'ctrl', selector: 'myComp',", |
| " templateUrl: 'my_template.html', cssUrl: 'my_styles.css',", |
| " map: const {", |
| " 'prop-a' : '@myPropA'", |
| " })", |
| "class MyComponent extends MySuper {", |
| "}")); |
| // prepare AngularComponentElement |
| ClassElement classElement = mainUnitElement.getType("MyComponent"); |
| AngularComponentElement component = getAngularElement( |
| classElement, |
| AngularComponentElement.class); |
| assertNotNull(component); |
| // verify |
| AngularPropertyElement[] properties = component.getProperties(); |
| assertLength(1, properties); |
| assertProperty( |
| properties[0], |
| "prop-a", |
| findMainOffset("prop-a' :"), |
| AngularPropertyKind.ATTR, |
| "myPropA", |
| findMainOffset("myPropA'")); |
| } |
| |
| public void test_NgComponent_properties_fromFields() throws Exception { |
| contextHelper.addSource("/my_template.html", ""); |
| contextHelper.addSource("/my_styles.css", ""); |
| resolveMainSourceNoErrors(createAngularSource(// |
| "@Component(publishAs: 'ctrl', selector: 'myComp',", |
| " templateUrl: 'my_template.html', cssUrl: 'my_styles.css')", |
| "class MyComponent {", |
| " @NgAttr('prop-a')", |
| " var myPropA;", |
| " @NgCallback('prop-b')", |
| " var myPropB;", |
| " @NgOneWay('prop-c')", |
| " var myPropC;", |
| " @NgOneWayOneTime('prop-d')", |
| " var myPropD;", |
| " @NgTwoWay('prop-e')", |
| " var myPropE;", |
| "}")); |
| // prepare AngularComponentElement |
| ClassElement classElement = mainUnitElement.getType("MyComponent"); |
| AngularComponentElement component = getAngularElement( |
| classElement, |
| AngularComponentElement.class); |
| assertNotNull(component); |
| // verify |
| AngularPropertyElement[] properties = component.getProperties(); |
| assertLength(5, properties); |
| assertProperty( |
| properties[0], |
| "prop-a", |
| findMainOffset("prop-a')"), |
| AngularPropertyKind.ATTR, |
| "myPropA", |
| -1); |
| assertProperty( |
| properties[1], |
| "prop-b", |
| findMainOffset("prop-b')"), |
| AngularPropertyKind.CALLBACK, |
| "myPropB", |
| -1); |
| assertProperty( |
| properties[2], |
| "prop-c", |
| findMainOffset("prop-c')"), |
| AngularPropertyKind.ONE_WAY, |
| "myPropC", |
| -1); |
| assertProperty( |
| properties[3], |
| "prop-d", |
| findMainOffset("prop-d')"), |
| AngularPropertyKind.ONE_WAY_ONE_TIME, |
| "myPropD", |
| -1); |
| assertProperty( |
| properties[4], |
| "prop-e", |
| findMainOffset("prop-e')"), |
| AngularPropertyKind.TWO_WAY, |
| "myPropE", |
| -1); |
| } |
| |
| public void test_NgComponent_properties_fromMap() throws Exception { |
| contextHelper.addSource("/my_template.html", ""); |
| contextHelper.addSource("/my_styles.css", ""); |
| resolveMainSourceNoErrors(createAngularSource(// |
| "@Component(publishAs: 'ctrl', selector: 'myComp',", |
| " templateUrl: 'my_template.html', cssUrl: 'my_styles.css',", |
| " map: const {", |
| " 'prop-a' : '@myPropA',", |
| " 'prop-b' : '&myPropB',", |
| " 'prop-c' : '=>myPropC',", |
| " 'prop-d' : '=>!myPropD',", |
| " 'prop-e' : '<=>myPropE'", |
| " })", |
| "class MyComponent {", |
| " var myPropA;", |
| " var myPropB;", |
| " var myPropC;", |
| " var myPropD;", |
| " var myPropE;", |
| "}")); |
| // prepare AngularComponentElement |
| ClassElement classElement = mainUnitElement.getType("MyComponent"); |
| AngularComponentElement component = getAngularElement( |
| classElement, |
| AngularComponentElement.class); |
| assertNotNull(component); |
| // verify |
| AngularPropertyElement[] properties = component.getProperties(); |
| assertLength(5, properties); |
| assertProperty( |
| properties[0], |
| "prop-a", |
| findMainOffset("prop-a' :"), |
| AngularPropertyKind.ATTR, |
| "myPropA", |
| findMainOffset("myPropA'")); |
| assertProperty( |
| properties[1], |
| "prop-b", |
| findMainOffset("prop-b' :"), |
| AngularPropertyKind.CALLBACK, |
| "myPropB", |
| findMainOffset("myPropB'")); |
| assertProperty( |
| properties[2], |
| "prop-c", |
| findMainOffset("prop-c' :"), |
| AngularPropertyKind.ONE_WAY, |
| "myPropC", |
| findMainOffset("myPropC'")); |
| assertProperty( |
| properties[3], |
| "prop-d", |
| findMainOffset("prop-d' :"), |
| AngularPropertyKind.ONE_WAY_ONE_TIME, |
| "myPropD", |
| findMainOffset("myPropD'")); |
| assertProperty( |
| properties[4], |
| "prop-e", |
| findMainOffset("prop-e' :"), |
| AngularPropertyKind.TWO_WAY, |
| "myPropE", |
| findMainOffset("myPropE'")); |
| } |
| |
| public void test_NgComponent_properties_no() throws Exception { |
| contextHelper.addSource("/my_template.html", ""); |
| contextHelper.addSource("/my_styles.css", ""); |
| String mainContent = createAngularSource(// |
| "@Component(publishAs: 'ctrl', selector: 'myComp',", |
| " templateUrl: 'my_template.html', cssUrl: 'my_styles.css')", |
| "class MyComponent {", |
| "}"); |
| resolveMainSourceNoErrors(mainContent); |
| // prepare AngularComponentElement |
| ClassElement classElement = mainUnitElement.getType("MyComponent"); |
| AngularComponentElement component = getAngularElement( |
| classElement, |
| AngularComponentElement.class); |
| assertNotNull(component); |
| // verify |
| assertEquals("ctrl", component.getName()); |
| assertEquals(findOffset(mainContent, "ctrl'"), component.getNameOffset()); |
| assertIsTagSelector(component.getSelector(), "myComp"); |
| assertEquals("my_template.html", component.getTemplateUri()); |
| assertEquals(findOffset(mainContent, "my_template.html'"), component.getTemplateUriOffset()); |
| assertEquals("my_styles.css", component.getStyleUri()); |
| assertEquals(findOffset(mainContent, "my_styles.css'"), component.getStyleUriOffset()); |
| assertLength(0, component.getProperties()); |
| } |
| |
| public void test_NgComponent_scopeProperties() throws Exception { |
| contextHelper.addSource("/my_template.html", ""); |
| contextHelper.addSource("/my_styles.css", ""); |
| String mainContent = createAngularSource(// |
| "@Component(publishAs: 'ctrl', selector: 'myComp',", |
| " templateUrl: 'my_template.html', cssUrl: 'my_styles.css')", |
| "class MyComponent {", |
| " MyComponent(Scope scope) {", |
| " scope.context['boolProp'] = true;", |
| " scope.context['intProp'] = 42;", |
| " scope.context['stringProp'] = 'foo';", |
| " // duplicate is ignored", |
| " scope.context['boolProp'] = true;", |
| " // LHS is not an IndexExpression", |
| " var v1;", |
| " v1 = 1;", |
| " // LHS is not a Scope access", |
| " var v2;", |
| " v2['name'] = 2;", |
| " }", |
| "}"); |
| resolveMainSourceNoErrors(mainContent); |
| // prepare AngularComponentElement |
| ClassElement classElement = mainUnitElement.getType("MyComponent"); |
| AngularComponentElement component = getAngularElement( |
| classElement, |
| AngularComponentElement.class); |
| assertNotNull(component); |
| // verify |
| AngularScopePropertyElement[] scopeProperties = component.getScopeProperties(); |
| assertLength(3, scopeProperties); |
| { |
| AngularScopePropertyElement property = scopeProperties[0]; |
| assertSame(property, findMainElement("boolProp")); |
| assertEquals("boolProp", property.getName()); |
| assertEquals(findOffset(mainContent, "boolProp'"), property.getNameOffset()); |
| assertEquals("bool", property.getType().getName()); |
| } |
| { |
| AngularScopePropertyElement property = scopeProperties[1]; |
| assertSame(property, findMainElement("intProp")); |
| assertEquals("intProp", property.getName()); |
| assertEquals(findOffset(mainContent, "intProp'"), property.getNameOffset()); |
| assertEquals("int", property.getType().getName()); |
| } |
| { |
| AngularScopePropertyElement property = scopeProperties[2]; |
| assertSame(property, findMainElement("stringProp")); |
| assertEquals("stringProp", property.getName()); |
| assertEquals(findOffset(mainContent, "stringProp'"), property.getNameOffset()); |
| assertEquals("String", property.getType().getName()); |
| } |
| } |
| |
| public void test_NgController() throws Exception { |
| String mainContent = createAngularSource(// |
| "@Controller(publishAs: 'ctrl', selector: '[myApp]')", |
| "class MyController {", |
| "}"); |
| resolveMainSourceNoErrors(mainContent); |
| // prepare AngularControllerElement |
| ClassElement classElement = mainUnitElement.getType("MyController"); |
| AngularControllerElement controller = getAngularElement( |
| classElement, |
| AngularControllerElement.class); |
| assertNotNull(controller); |
| // verify |
| assertEquals("ctrl", controller.getName()); |
| assertEquals(findOffset(mainContent, "ctrl'"), controller.getNameOffset()); |
| assertHasAttributeSelector(controller.getSelector(), "myApp"); |
| } |
| |
| public void test_NgController_cannotParseSelector() throws Exception { |
| String mainContent = createAngularSource(// |
| "@Controller(publishAs: 'ctrl', selector: '~unknown')", |
| "class MyController {", |
| "}"); |
| resolveMainSource(mainContent); |
| // has error |
| assertMainErrors(AngularCode.CANNOT_PARSE_SELECTOR); |
| } |
| |
| public void test_NgController_missingPublishAs() throws Exception { |
| String mainContent = createAngularSource(// |
| "@Controller(selector: '[myApp]')", |
| "class MyController {", |
| "}"); |
| resolveMainSource(mainContent); |
| // has error |
| assertMainErrors(AngularCode.MISSING_PUBLISH_AS); |
| } |
| |
| public void test_NgController_missingSelector() throws Exception { |
| String mainContent = createAngularSource(// |
| "@Controller(publishAs: 'ctrl')", |
| "class MyController {", |
| "}"); |
| resolveMainSource(mainContent); |
| // has error |
| assertMainErrors(AngularCode.MISSING_SELECTOR); |
| } |
| |
| public void test_NgController_noAnnotationArguments() throws Exception { |
| String mainContent = createAngularSource(// |
| "@NgController", |
| "class MyController {", |
| "}"); |
| resolveMainSource(mainContent); |
| // ignore errors, but there should be no exceptions |
| } |
| |
| public void test_parseSelector_hasAttribute() throws Exception { |
| AngularSelectorElement selector = AngularCompilationUnitBuilder.parseSelector(42, "[name]"); |
| assertHasAttributeSelector(selector, "name"); |
| assertEquals(42 + 1, selector.getNameOffset()); |
| } |
| |
| public void test_parseSelector_hasClass() throws Exception { |
| AngularSelectorElement selector = AngularCompilationUnitBuilder.parseSelector(42, ".my-class"); |
| AngularHasClassSelectorElementImpl classSelector = (AngularHasClassSelectorElementImpl) selector; |
| assertEquals("my-class", classSelector.getName()); |
| assertEquals(".my-class", classSelector.toString()); |
| assertEquals(42 + 1, selector.getNameOffset()); |
| // test apply() |
| { |
| XmlTagNode node = tagNode("div", attribute("class", "one two")); |
| assertFalse(classSelector.apply(node)); |
| } |
| { |
| XmlTagNode node = tagNode("div", attribute("class", "one my-class two")); |
| assertTrue(classSelector.apply(node)); |
| } |
| } |
| |
| public void test_parseSelector_isTag() throws Exception { |
| AngularSelectorElement selector = AngularCompilationUnitBuilder.parseSelector(42, "name"); |
| assertIsTagSelector(selector, "name"); |
| assertEquals(42, selector.getNameOffset()); |
| } |
| |
| public void test_parseSelector_isTag_hasAttribute() throws Exception { |
| AngularSelectorElement selector = AngularCompilationUnitBuilder.parseSelector(42, "tag[attr]"); |
| assertInstanceOf(IsTagHasAttributeSelectorElementImpl.class, selector); |
| assertEquals("tag[attr]", selector.getName()); |
| assertEquals(-1, selector.getNameOffset()); |
| assertEquals("tag", ((IsTagHasAttributeSelectorElementImpl) selector).getTagName()); |
| assertEquals("attr", ((IsTagHasAttributeSelectorElementImpl) selector).getAttributeName()); |
| } |
| |
| public void test_parseSelector_unknown() throws Exception { |
| AngularSelectorElement selector = AngularCompilationUnitBuilder.parseSelector(0, "~unknown"); |
| assertNull(selector); |
| } |
| |
| public void test_view() throws Exception { |
| contextHelper.addSource("/wrong.html", ""); |
| contextHelper.addSource("/my_templateA.html", ""); |
| contextHelper.addSource("/my_templateB.html", ""); |
| String mainContent = createAngularSource(// |
| "class MyRouteInitializer {", |
| " init(ViewFactory view, foo) {", |
| " foo.view('wrong.html'); // has target", |
| " foo(); // less than one argument", |
| " foo('wrong.html', 'bar'); // more than one argument", |
| " foo('wrong' + '.html'); // not literal", |
| " foo('wrong.html'); // not ViewFactory", |
| " view('my_templateA.html');", |
| " view('my_templateB.html');", |
| " }", |
| "}"); |
| resolveMainSourceNoErrors(mainContent); |
| // prepare AngularViewElement(s) |
| AngularViewElement[] views = mainUnitElement.getAngularViews(); |
| assertLength(2, views); |
| { |
| AngularViewElement view = views[0]; |
| assertEquals("my_templateA.html", view.getTemplateUri()); |
| assertEquals(null, view.getName()); |
| assertEquals(-1, view.getNameOffset()); |
| assertEquals(findOffset(mainContent, "my_templateA.html'"), view.getTemplateUriOffset()); |
| } |
| { |
| AngularViewElement view = views[1]; |
| assertEquals("my_templateB.html", view.getTemplateUri()); |
| assertEquals(null, view.getName()); |
| assertEquals(-1, view.getNameOffset()); |
| assertEquals(findOffset(mainContent, "my_templateB.html'"), view.getTemplateUriOffset()); |
| } |
| } |
| |
| private void assertProperty(AngularPropertyElement property, String expectedName, |
| int expectedNameOffset, AngularPropertyKind expectedKind, String expectedFieldName, |
| int expectedFieldOffset) { |
| assertEquals(expectedName, property.getName()); |
| assertEquals(expectedNameOffset, property.getNameOffset()); |
| assertSame(expectedKind, property.getPropertyKind()); |
| assertEquals(expectedFieldName, property.getField().getName()); |
| assertEquals(expectedFieldOffset, property.getFieldNameOffset()); |
| } |
| |
| /** |
| * Find {@link AstNode} of the given type in {@link #mainUnit}. |
| */ |
| private <T extends AstNode> T findMainNode(String search, Class<T> clazz) { |
| return findNode(mainUnit, mainContent, search, clazz); |
| } |
| } |
