[html5lib] implement querySelector/querySelectorAll

pkg/csslib/lib/parser.dart

 // Copyright (c) 2012, 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.
 
 library csslib.parser;
 
 import 'dart:math' as math;
 
 import 'package:source_maps/span.dart' show SourceFile, Span, FileSpan;
 
@@ skipping 12 matching lines @@
 
 /** Used for parser lookup ahead (used for nested selectors Less support). */
 class ParserState extends TokenizerState {
   final Token peekToken;
   final Token previousToken;
 
   ParserState(this.peekToken, this.previousToken, Tokenizer tokenizer)
       : super(tokenizer);
 }
 
+// TODO(jmesserly): this should not be global
 void _createMessages({List<Message> errors, List<String> options}) {
   if (errors == null) errors = [];
 
   if (options == null) {
     options = ['--no-colors', 'memory'];
   }
   var opt = PreprocessorOptions.parse(options);
   messages = new Messages(options: opt, printHandler: errors.add);
 }
 
 /** CSS checked mode enabled. */
 bool get isChecked => messages.options.checked;
 
 // TODO(terry): Remove nested name parameter.
 /** Parse and analyze the CSS file. */
-StyleSheet compile(var input, {List<Message> errors, List<String> options,
+StyleSheet compile(input, {List<Message> errors, List<String> options,
     bool nested: true,
     bool polyfill: false,
     List<StyleSheet> includes: null}) {
 
   if (includes == null) {
     includes = [];
   }
 
   var source = _inputAsString(input);
 
@@ skipping 19 matching lines @@
 
   _createMessages(errors: errors, options: options);
   new Analyzer(styleSheets, messages).run();
 }
 
 /**
  * Parse the [input] CSS stylesheet into a tree. The [input] can be a [String],
  * or [List<int>] of bytes and returns a [StyleSheet] AST.  The optional
  * [errors] list will contain each error/warning as a [Message].
  */
-StyleSheet parse(var input, {List<Message> errors, List<String> options}) {
+StyleSheet parse(input, {List<Message> errors, List<String> options}) {
   var source = _inputAsString(input);
 
   _createMessages(errors: errors, options: options);
 
   var file = new SourceFile.text(null, source);
-
   return new _Parser(file, source).parse();
 }
 
 /**
  * Parse the [input] CSS selector into a tree. The [input] can be a [String],
  * or [List<int>] of bytes and returns a [StyleSheet] AST.  The optional
  * [errors] list will contain each error/warning as a [Message].
  */
-StyleSheet selector(var input, {List<Message> errors}) {
+// TODO(jmesserly): should rename "parseSelector" and return Selector
+StyleSheet selector(input, {List<Message> errors}) {
   var source = _inputAsString(input);
 
   _createMessages(errors: errors);
 
   var file = new SourceFile.text(null, source);
-
-  return new _Parser(file, source).parseSelector();
+  return (new _Parser(file, source)
+      ..tokenizer.inSelector = true)
+      .parseSelector();
 }
 
-String _inputAsString(var input) {
+SelectorGroup parseSelectorGroup(input, {List<Message> errors}) {
+  var source = _inputAsString(input);
+
+  _createMessages(errors: errors);
+
+  var file = new SourceFile.text(null, source);
+  return (new _Parser(file, source)
+      // TODO(jmesserly): this fix should be applied to the parser. It's tricky
+      // because by the time the flag is set one token has already been fetched.
+      ..tokenizer.inSelector = true)
+      .processSelectorGroup();
+}
+
+String _inputAsString(input) {
   String source;
 
   if (input is String) {
     source = input;
   } else if (input is List<int>) {
     // TODO(terry): The parse function needs an "encoding" argument and will
     //              default to whatever encoding CSS defaults to.
     //
     // Here's some info about CSS encodings:
     // http://www.w3.org/International/questions/qa-css-charset.en.php
@@ skipping 16 matching lines @@
 
   return source;
 }
 
 // TODO(terry): Consider removing this class when all usages can be eliminated
 //               or replaced with compile API.
 /** Public parsing interface for csslib. */
 class Parser {
   final _Parser _parser;
 
+  // TODO(jmesserly): having file and text is redundant.
   Parser(SourceFile file, String text, {int start: 0, String baseUrl}) :
     _parser = new _Parser(file, text, start: start, baseUrl: baseUrl);
 
   StyleSheet parse() => _parser.parse();
 }
 
 /** A simple recursive descent parser for CSS. */
 class _Parser {
   final Tokenizer tokenizer;
 
@@ skipping 1007 matching lines @@
     if (decls.length > 0) {
       groups.add(new DeclarationGroup(decls, _makeSpan(start)));
     }
 
     return groups;
   }
 
   SelectorGroup processSelectorGroup() {
     List<Selector> selectors = [];
     int start = _peekToken.start;
+
     do {
       Selector selector = processSelector();
       if (selector != null) {
         selectors.add(selector);
       }
     } while (_maybeEat(TokenKind.COMMA));
 
     if (selectors.length > 0) {
       return new SelectorGroup(selectors, _makeSpan(start));
     }
@@ skipping 219 matching lines @@
     //              : or :: and making this a normal selector.  For now,
     //              create an empty pseudoName.
     var pseudoName;
     if (_peekIdentifier()) {
       pseudoName = identifier();
     } else {
       return null;
     }
 
     // Functional pseudo?
-    if (_maybeEat(TokenKind.LPAREN)) {
+
+    if (_peekToken.kind == TokenKind.LPAREN) {
+
       if (!pseudoElement && pseudoName.name.toLowerCase() == 'not') {
+        _eat(TokenKind.LPAREN);
+
         // Negation :   ':NOT(' S* negation_arg S* ')'
         var negArg = simpleSelector();
 
         _eat(TokenKind.RPAREN);
         return new NegationSelector(negArg, _makeSpan(start));
       } else {
+        // Special parsing for expressions in pseudo functions.  Minus is used
+        // as operator not identifier.
+        // TODO(jmesserly): we need to flip this before we eat the "(" as the
+        // next token will be fetched when we do that. I think we should try to
+        // refactor so we don't need this boolean; it seems fragile.
+        tokenizer.inSelectorExpression = true;
+        _eat(TokenKind.LPAREN);
+
         // Handle function expression.
         var span = _makeSpan(start);
         var expr = processSelectorExpression();
 
+        tokenizer.inSelectorExpression = false;
+
         // Used during selector look-a-head if not a SelectorExpression is
         // bad.
         if (expr is! SelectorExpression) {
           _errorExpected("CSS expression");
           return null;
         }
 
         _eat(TokenKind.RPAREN);
         return (pseudoElement) ?
             new PseudoElementFunctionSelector(pseudoName, expr, span) :
@@ skipping 18 matching lines @@
    *    : [ [ PLUS | '-' | DIMENSION | NUMBER | STRING | IDENT ] S* ]+
    *
    *    num               [0-9]+|[0-9]*\.[0-9]+
    *    PLUS              '+'
    *    DIMENSION         {num}{ident}
    *    NUMBER            {num}
    */
   processSelectorExpression() {
     var start = _peekToken.start;
 
-    var expression = new SelectorExpression(_makeSpan(start));
+    var expressions = [];
 
     Token termToken;
     var value;
 
-    // Special parsing for expressions in pseudo functions.  Minus is used as
-    // operator not identifier.
-    tokenizer.selectorExpression = true;
-
     var keepParsing = true;
     while (keepParsing) {
       switch (_peek()) {
         case TokenKind.PLUS:
           start = _peekToken.start;
           termToken = _next();
-          expression.add(new OperatorPlus(_makeSpan(start)));
+          expressions.add(new OperatorPlus(_makeSpan(start)));
           break;
         case TokenKind.MINUS:
           start = _peekToken.start;
           termToken = _next();
-          expression.add(new OperatorMinus(_makeSpan(start)));
+          expressions.add(new OperatorMinus(_makeSpan(start)));
           break;
         case TokenKind.INTEGER:
           termToken = _next();
           value = int.parse(termToken.text);
           break;
         case TokenKind.DOUBLE:
           termToken = _next();
           value = double.parse(termToken.text);
           break;
         case TokenKind.SINGLE_QUOTE:
@@ skipping 13 matching lines @@
 
       if (keepParsing && value != null) {
         var unitTerm;
         // Don't process the dimension if MINUS or PLUS is next.
         if (_peek() != TokenKind.MINUS && _peek() != TokenKind.PLUS) {
           unitTerm = processDimension(termToken, value, _makeSpan(start));
         }
         if (unitTerm == null) {
           unitTerm = new LiteralTerm(value, value.name, _makeSpan(start));
         }
-        expression.add(unitTerm);
+        expressions.add(unitTerm);
 
         value = null;
       }
     }
 
-    tokenizer.selectorExpression = false;
-
-    return expression;
+    return new SelectorExpression(expressions, _makeSpan(start));
   }
 
   //  Attribute grammar:
   //
   //  attributes :
   //    '[' S* IDENT S* [ ATTRIB_MATCHES S* [ IDENT | STRING ] S* ]? ']'
   //
   //  ATTRIB_MATCHES :
   //    [ '=' | INCLUDES | DASHMATCH | PREFIXMATCH | SUFFIXMATCH | SUBSTRMATCH ]
   //
@@ skipping 797 matching lines @@
     }
 
     return term;
   }
 
   String processQuotedString([bool urlString = false]) {
     var start = _peekToken.start;
 
     // URI term sucks up everything inside of quotes(' or ") or between parens
     var stopToken = urlString ? TokenKind.RPAREN : -1;
+
+    // Note: disable skipping whitespace tokens inside a string.
+    // TODO(jmesserly): the layering here feels wrong.
+    var skipWhitespace = tokenizer._skipWhitespace;
+    tokenizer._skipWhitespace = false;
+
     switch (_peek()) {
     case TokenKind.SINGLE_QUOTE:
       stopToken = TokenKind.SINGLE_QUOTE;
       start = _peekToken.start + 1;   // Skip the quote might have whitespace.
       _next();    // Skip the SINGLE_QUOTE.
       break;
     case TokenKind.DOUBLE_QUOTE:
       stopToken = TokenKind.DOUBLE_QUOTE;
       start = _peekToken.start + 1;   // Skip the quote might have whitespace.
       _next();    // Skip the DOUBLE_QUOTE.
       break;
     default:
       if (urlString) {
         if (_peek() == TokenKind.LPAREN) {
           _next();    // Skip the LPAREN.
           start = _peekToken.start;
         }
         stopToken = TokenKind.RPAREN;
       } else {
         _error('unexpected string', _makeSpan(start));
       }
       break;
     }
 
     // Gobble up everything until we hit our stop token.
     var runningStart = _peekToken.start;
+
+    var stringValue = new StringBuffer();
     while (_peek() != stopToken && _peek() != TokenKind.END_OF_FILE) {
-      var tok = _next();
+      stringValue.write(_next().text);
     }
 
+    tokenizer._skipWhitespace = skipWhitespace;
+
     // All characters between quotes is the string.
-    var end = _peekToken.end;
-    var stringValue = (_peekToken.span as FileSpan).file.getText(start,
-        end - 1);
-
     if (stopToken != TokenKind.RPAREN) {
       _next();    // Skip the SINGLE_QUOTE or DOUBLE_QUOTE;
     }
 
-    return stringValue;
+    return stringValue.toString();
   }
 
   // TODO(terry): Should probably understand IE's non-standard filter syntax to
   //              fully support calc, var(), etc.
   /**
    * IE's filter property breaks CSS value parsing.  IE's format can be:
    *
    *    filter: progid:DXImageTransform.MS.gradient(Type=0, Color='#9d8b83');
    *
    * We'll just parse everything after the 'progid:' look for the left paren
@@ skipping 268 matching lines @@
 
     if (replace != null && result == null) {
       result = new StringBuffer(text.substring(0, i));
     }
 
     if (result != null) result.write(replace != null ? replace : text[i]);
   }
 
   return result == null ? text : result.toString();
 }