Beginning of CSS parser using frog parsering infrastructure.

utils/tests/css/src/ExpressionTest.dart

Index: utils/tests/css/src/ExpressionTest.dart
diff --git a/utils/tests/css/src/ExpressionTest.dart b/utils/tests/css/src/ExpressionTest.dart
new file mode 100644
index 0000000000000000000000000000000000000000..885bd2cd4c0ba0bfd2ea6d2ebc5b9e445f3b8d8a
--- /dev/null
+++ b/utils/tests/css/src/ExpressionTest.dart
@@ -0,0 +1,440 @@
+// Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+#import('../../../../frog/lang.dart', prefix:'lang');
+#import("../../../css/css.dart");
+
+class SelectorLiteralTest {
+
+  static testMain() {
+    initCssWorld();
+
+    testClass();
+    testId();
+    testElement();
+    testNamespace();
+    testSelectorGroups();
+    testCombinator();
+    testWildcard();
+    testPseudo();
+    testAttribute();
+    testNegation();
+  }
+
+  static void testClass() {
+    Parser parser0 = new Parser(new lang.SourceFile(

[jimhug, 2011/11/10 17:58:56]

Am I missing something, or could you split this into two methods and avoid the
need for parser0/parser1 and exprTree0/exprTree1?

[terry, 2011/11/16 14:00:22]

I don't expect this to be how it's used but I've hooked this up for now to test
the current completeness of the CSS selector parsing outside of @{} syntax.  As
I add the next part of full CSS I'll change this.  The entry point expression is
 also not quite right yet other than it's a different entry point to test
general parsing.

On 2011/11/10 17:58:56, jimhug wrote:

+        lang.SourceFile.IN_MEMORY_FILE, ".foobar"));
+
+    List<SelectorGroup> exprTree0 = parser0.expression();
+    Expect.isNotNull(exprTree0);
+    Expect.equals(exprTree0.length, 1);
+    for (selectorGroup in exprTree0) {
+      Expect.equals(selectorGroup.selectors.length, 1);
+      for (selector in selectorGroup.selectors) {
+        Expect.isTrue(selector is ClassSelector);
+        Expect.isTrue(selector.isCombinatorNone());
+        Expect.equals(selector.name, "foobar");
+      }
+    }
+
+    Parser parser1 = new Parser(new lang.SourceFile(
+        lang.SourceFile.IN_MEMORY_FILE, ".foobar .bar .no-story"));
+
+    List<SelectorGroup> exprTree1 = parser1.expression();
+    Expect.isNotNull(exprTree1);
+    Expect.equals(exprTree1.length, 1);
+    for (selectorGroup in exprTree1) {
+      var idx = 0;
+      for (selector in selectorGroup.selectors) {
+        if (idx == 0) {
+          Expect.isTrue(selector is ClassSelector);
+          Expect.isTrue(selector.isCombinatorNone());
+          Expect.equals(selector.name, "foobar");
+        } else if (idx == 1) {
+          Expect.isTrue(selector is ClassSelector);
+          Expect.isTrue(selector.isCombinatorNone());
+          Expect.equals(selector.name, "bar");
+        } else if (idx == 2) {
+          Expect.isTrue(selector is ClassSelector);
+          Expect.isTrue(selector.isCombinatorNone());
+          Expect.equals(selector.name, "no-story");
+        } else {
+          Expect.fail("unexpected expression");
+        }
+
+        idx++;
+      }
+    }
+  }
+
+  static void testId() {
+    Parser parser0 = new Parser(new lang.SourceFile(
+        lang.SourceFile.IN_MEMORY_FILE, "#elemId"));
+
+    List<SelectorGroup> exprTree = parser0.expression();
+    Expect.isNotNull(exprTree);
+    Expect.equals(exprTree.length, 1);
+    Expect.isNotNull(exprTree);
+    for (selectorGroup in exprTree) {
+      Expect.equals(selectorGroup.selectors.length, 1);
+      for (selector in selectorGroup.selectors) {
+        Expect.isTrue(selector is IdSelector);
+        Expect.isTrue(selector.isCombinatorNone());
+        Expect.equals(selector.name, "elemId");
+      }
+    }
+  }
+
+  static void testElement() {
+    Parser parser0 = new Parser(new lang.SourceFile(
+        lang.SourceFile.IN_MEMORY_FILE, "div"));
+    List<SelectorGroup> exprTree0 = parser0.expression();
+    Expect.isNotNull(exprTree0);
+    Expect.equals(exprTree0.length, 1);
+    for (selectorGroup in exprTree0) {
+      Expect.equals(selectorGroup.selectors.length, 1);
+      for (selector in selectorGroup.selectors) {
+        Expect.isTrue(selector is ElementSelector);
+        Expect.isTrue(selector.isCombinatorNone());
+        Expect.equals(selector.name, "div");
+      }
+    }
+
+    Parser parser1 = new Parser(new lang.SourceFile(
+        lang.SourceFile.IN_MEMORY_FILE, "div div span"));
+    List<SelectorGroup> exprTree1 = parser1.expression();
+    Expect.isNotNull(exprTree1);
+    Expect.equals(exprTree1.length, 1);
+    for (selectorGroup in exprTree1) {
+      var idx = 0;
+      for (selector in selectorGroup.selectors) {
+        if (idx == 0) {
+          Expect.isTrue(selector is ElementSelector);
+          Expect.isTrue(selector.isCombinatorNone());
+          Expect.equals(selector.name, "div");
+        } else if (idx == 1) {
+          Expect.isTrue(selector is ElementSelector);
+          Expect.isTrue(selector.isCombinatorNone());
+          Expect.equals(selector.name, "div");
+        } else if (idx == 2) {
+          Expect.isTrue(selector is ElementSelector);
+          Expect.isTrue(selector.isCombinatorNone());
+          Expect.equals(selector.name, "span");
+        } else {
+          Expect.fail("unexpected expression");
+        }
+  
+        idx++;
+      }
+    }
+  }
+
+  static void testNamespace() {
+    Parser parser0 = new Parser(new lang.SourceFile(
+        lang.SourceFile.IN_MEMORY_FILE, "ns1|div"));
+    List<SelectorGroup> exprTree0 = parser0.expression();
+    Expect.isNotNull(exprTree0);
+    Expect.equals(exprTree0.length, 1);
+    for (selectorGroup in exprTree0) {
+      Expect.equals(selectorGroup.selectors.length, 1);
+      for (selector in selectorGroup.selectors) {
+        Expect.isTrue(selector is NamespaceSelector);
+        Expect.isTrue(selector.isCombinatorNone());
+        Expect.isFalse(selector.isNamespaceWildcard());
+        Expect.equals(selector.namespace, "ns1");
+        ElementSelector elementSelector = selector.nameAsElementSelector;
+        Expect.isTrue(elementSelector is ElementSelector);
+        Expect.isFalse(elementSelector.isWildcard());
+        Expect.equals(elementSelector.name, "div");
+      }
+    }
+
+    Parser parser1 = new Parser(new lang.SourceFile(
+        lang.SourceFile.IN_MEMORY_FILE, "ns1|div div ns2|span .foobar"));
+    List<SelectorGroup> exprTree1 = parser1.expression();
+    Expect.isNotNull(exprTree1);
+    Expect.equals(exprTree1.length, 1);
+    for (selectorGroup in exprTree1) {
+      var idx = 0;
+      for (selector in selectorGroup.selectors) {
+        if (idx == 0) {
+          Expect.isTrue(selector is NamespaceSelector);
+          Expect.isTrue(selector.isCombinatorNone());
+          Expect.equals(selector.namespace, "ns1");
+          ElementSelector elementSelector = selector.nameAsElementSelector;
+          Expect.isTrue(elementSelector is ElementSelector);
+          Expect.isFalse(elementSelector.isWildcard());
+          Expect.equals(elementSelector.name, "div");
+        } else if (idx == 1) {
+          Expect.isTrue(selector is ElementSelector);
+          Expect.isTrue(selector.isCombinatorNone());
+          Expect.equals(selector.name, "div");
+        } else if (idx == 2) {
+          Expect.isTrue(selector is NamespaceSelector);
+          Expect.isTrue(selector.isCombinatorNone());
+          Expect.equals(selector.namespace, "ns2");
+          ElementSelector elementSelector = selector.nameAsElementSelector;
+          Expect.isTrue(elementSelector is ElementSelector);
+          Expect.isFalse(elementSelector.isWildcard());
+          Expect.equals(elementSelector.name, "span");
+        } else if (idx == 3) {
+          Expect.isTrue(selector is ClassSelector);
+          Expect.isTrue(selector.isCombinatorNone());
+          Expect.equals(selector.name, "foobar");
+        } else {
+          Expect.fail("unexpected expression");
+        }
+  
+        idx++;
+      }
+    }
+  }
+
+  static void testSelectorGroups() {
+    Parser parser0 = new Parser(new lang.SourceFile(
+        lang.SourceFile.IN_MEMORY_FILE,
+        "div, .foobar ,#elemId, .xyzzy .test, ns1|div div #elemId .foobar"));
+    List<SelectorGroup> exprTree0 = parser0.expression();
+    Expect.isNotNull(exprTree0);
+    Expect.equals(exprTree0.length, 5);
+    var groupIdx = 0;
+    for (selectorGroup in exprTree0) {
+      var idx = 0;
+      for (selector in selectorGroup.selectors) {
+        switch (groupIdx) {
+          case 0:                       // First selector group.
+            Expect.equals(selectorGroup.selectors.length, 1);
+            Expect.isTrue(selector is ElementSelector);
+            Expect.isTrue(selector.isCombinatorNone());
+            Expect.equals(selector.name, "div");
+            break;
+          case 1:                       // Second selector group.
+            Expect.equals(selectorGroup.selectors.length, 1);
+            Expect.isTrue(selector is ClassSelector);
+            Expect.isTrue(selector.isCombinatorNone());
+            Expect.equals(selector.name, "foobar");
+            break;
+          case 2:                       // Third selector group.
+            Expect.equals(selectorGroup.selectors.length, 1);
+            Expect.isTrue(selector is IdSelector);
+            Expect.isTrue(selector.isCombinatorNone());
+            Expect.equals(selector.name, "elemId");
+            break;
+          case 3:                       // Fourth selector group.
+            Expect.equals(selectorGroup.selectors.length, 2);
+            if (idx == 0) {
+              Expect.isTrue(selector is ClassSelector);
+              Expect.isTrue(selector.isCombinatorNone());
+              Expect.equals(selector.name, "xyzzy");
+            } else if (idx == 1) {
+              Expect.isTrue(selector is ClassSelector);
+              Expect.isTrue(selector.isCombinatorNone());
+              Expect.equals(selector.name, "test");
+            } else {
+              Expect.fail("unexpected expression");
+            }
+            break;
+          case 4:                       // Fifth selector group.
+            Expect.equals(selectorGroup.selectors.length, 4);
+            if (idx == 0) {
+              Expect.isTrue(selector is NamespaceSelector);
+              Expect.isTrue(selector.isCombinatorNone());
+              Expect.equals(selector.namespace, "ns1");
+              ElementSelector elementSelector = selector.nameAsElementSelector;
+              Expect.isTrue(elementSelector is ElementSelector);
+              Expect.isFalse(elementSelector.isWildcard());
+              Expect.equals(elementSelector.name, "div");
+            } else if (idx == 1) {
+              Expect.isTrue(selector is ElementSelector);
+              Expect.isTrue(selector.isCombinatorNone());
+              Expect.equals(selector.name, "div");
+            } else if (idx == 2) {
+              Expect.isTrue(selector is IdSelector);
+              Expect.isTrue(selector.isCombinatorNone());
+              Expect.equals(selector.name, "elemId");
+            } else if (idx == 3) {
+              Expect.isTrue(selector is ClassSelector);
+              Expect.isTrue(selector.isCombinatorNone());
+              Expect.equals(selector.name, "foobar");
+            } else {
+              Expect.fail("unexpected expression");
+            }
+            break;
+        }
+        idx++;
+      }
+      groupIdx++;
+    }
+  }
+
+  static void testCombinator() {
+    Parser parser = new Parser(new lang.SourceFile(
+        lang.SourceFile.IN_MEMORY_FILE,
+        ".foobar > .bar + .no-story ~ myNs|div #elemId"));
+
+    List<SelectorGroup> exprTree = parser.expression();
+    Expect.isNotNull(exprTree);
+    Expect.equals(exprTree.length, 1);
+    for (selectorGroup in exprTree) {
+      var idx = 0;
+      Expect.equals(selectorGroup.selectors.length, 5);
+      for (selector in selectorGroup.selectors) {
+        if (idx == 0) {
+          Expect.isTrue(selector is ClassSelector);
+          Expect.isTrue(selector.isCombinatorNone());
+          Expect.equals(selector.name, "foobar");
+        } else if (idx == 1) {
+          Expect.isTrue(selector is ClassSelector);
+          Expect.isTrue(selector.isCombinatorGreater());
+          Expect.equals(selector.name, "bar");
+        } else if (idx == 2) {
+          Expect.isTrue(selector is ClassSelector);
+          Expect.isTrue(selector.isCombinatorPlus());
+          Expect.equals(selector.name, "no-story");
+        } else if (idx == 3) {
+          Expect.isTrue(selector is NamespaceSelector);
+          Expect.isTrue(selector.isCombinatorTilde());
+          Expect.equals(selector.namespace, "myNs");
+          ElementSelector elementSelector = selector.nameAsElementSelector;
+          Expect.isTrue(elementSelector is ElementSelector);
+          Expect.isFalse(elementSelector.isWildcard());
+          Expect.equals(elementSelector.name, "div");
+        } else if (idx == 4) {
+          Expect.isTrue(selector is IdSelector);
+          Expect.isTrue(selector.isCombinatorNone());
+          Expect.equals(selector.name, "elemId");
+        } else {
+          Expect.fail("unexpected expression");
+        }
+
+        idx++;
+      }
+    }
+  }
+
+  static void testWildcard() {
+    Parser parser0 = new Parser(new lang.SourceFile(
+        lang.SourceFile.IN_MEMORY_FILE, "*"));
+
+    List<SelectorGroup> exprTree0 = parser0.expression();
+    Expect.isNotNull(exprTree0);
+    Expect.equals(exprTree0.length, 1);
+    for (selectorGroup in exprTree0) {
+      Expect.equals(selectorGroup.selectors.length, 1);
+      for (selector in selectorGroup.selectors) {
+        Expect.isTrue(selector is ElementSelector);
+        Expect.isTrue(selector.isCombinatorNone());
+        Expect.isTrue(selector.isWildcard());
+        Expect.equals(selector.name, "*");
+      }
+    }
+
+    Parser parser1 = new Parser(new lang.SourceFile(
+        lang.SourceFile.IN_MEMORY_FILE, "*.foobar"));
+
+    List<SelectorGroup> exprTree1 = parser1.expression();
+    Expect.isNotNull(exprTree1);
+    Expect.equals(exprTree1.length, 1);
+    for (selectorGroup in exprTree1) {
+      var idx = 0;
+      for (selector in selectorGroup.selectors) {
+        Expect.equals(selectorGroup.selectors.length, 2);
+        if (idx == 0) {
+          Expect.isTrue(selector is ElementSelector);
+          Expect.isTrue(selector.isCombinatorNone());
+          Expect.isTrue(selector.isWildcard());
+          Expect.equals(selector.name, "*");
+        } else if (idx == 1) {
+          Expect.isTrue(selector is ClassSelector);
+          Expect.isTrue(selector.isCombinatorNone());
+          Expect.equals(selector.name, "foobar");
+        } else {
+          Expect.fail("unexpected expression");
+        }
+
+        idx++;
+      }
+    }
+
+    Parser parser2 = new Parser(new lang.SourceFile(
+        lang.SourceFile.IN_MEMORY_FILE, "myNs|*.foobar"));
+
+    List<SelectorGroup> exprTree2 = parser2.expression();
+    Expect.isNotNull(exprTree2);
+    Expect.equals(exprTree2.length, 1);
+    for (selectorGroup in exprTree2) {
+      var idx = 0;
+      for (selector in selectorGroup.selectors) {
+        Expect.equals(selectorGroup.selectors.length, 2);
+        if (idx == 0) {
+          Expect.isTrue(selector is NamespaceSelector);
+          Expect.isTrue(selector.isCombinatorNone());
+          Expect.isFalse(selector.isNamespaceWildcard());
+          Expect.isTrue(selector.isWildcardElement());
+          Expect.equals(selector.namespace, "myNs");
+          ElementSelector elementSelector = selector.nameAsElementSelector;
+          Expect.isTrue(elementSelector.isWildcard());
+          Expect.equals(elementSelector.name, "*");
+        } else if (idx == 1) {
+          Expect.isTrue(selector is ClassSelector);
+          Expect.isTrue(selector.isCombinatorNone());
+          Expect.equals(selector.name, "foobar");
+        } else {
+          Expect.fail("unexpected expression");
+        }
+
+        idx++;
+      }
+    }
+
+    Parser parser3 = new Parser(new lang.SourceFile(
+        lang.SourceFile.IN_MEMORY_FILE, "*|*.foobar"));
+
+    List<SelectorGroup> exprTree3 = parser3.expression();
+    Expect.isNotNull(exprTree3);
+    Expect.equals(exprTree3.length, 1);
+    for (selectorGroup in exprTree3) {
+      var idx = 0;
+      for (selector in selectorGroup.selectors) {
+        Expect.equals(selectorGroup.selectors.length, 2);
+        if (idx == 0) {
+          Expect.isTrue(selector is NamespaceSelector);
+          Expect.isTrue(selector.isCombinatorNone());
+          Expect.isTrue(selector.isNamespaceWildcard());
+          Expect.equals(selector.namespace, "*");
+          Expect.isTrue(selector.isWildcardElement());
+          ElementSelector elementSelector = selector.nameAsElementSelector;
+          Expect.isTrue(elementSelector.isWildcard());
+          Expect.equals(elementSelector.name, "*");
+        } else if (idx == 1) {
+          Expect.isTrue(selector is ClassSelector);
+          Expect.isTrue(selector.isCombinatorNone());
+          Expect.equals(selector.name, "foobar");
+        } else {
+          Expect.fail("unexpected expression");
+        }
+
+        idx++;
+      }
+    }
+  }
+
+  static void testPseudo() {
+    // TODO(terry): Implement
+  }
+
+  static void testAttribute() {
+    // TODO(terry): Implement
+  }
+
+  static void testNegation() {
+    // TODO(terry): Implement
+  }
+
+}
+
+
+main() {
+  SelectorLiteralTest.testMain();
+}