Roll Observatory deps (charted -> ^0.3.0)

packages/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_span/source_span.dart';
 
@@ skipping 46 matching lines @@
 
   _createMessages(errors: errors, options: options);
 
   var file = new SourceFile(source);
 
   var tree = new _Parser(file, source).parse();
 
   analyze([tree], errors: errors, options: options);
 
   if (polyfill) {
-    var processCss = new PolyFill(messages, true);
+    var processCss = new PolyFill(messages);
     processCss.process(tree, includes: includes);
   }
 
   return tree;
 }
 
 /** Analyze the CSS file. */
 void analyze(List<StyleSheet> styleSheets,
     {List<Message> errors, PreprocessorOptions options}) {
   _createMessages(errors: errors, options: options);
@@ skipping 345 matching lines @@
         andOp = TokenKind.matchMediaOperator(op, 0, opLen) ==
             TokenKind.MEDIA_OP_AND;
         if (!andOp) break;
         _next();
       }
     }
 
     if (unaryOp != -1 || type != null || exprs.length > 0) {
       return new MediaQuery(unaryOp, type, exprs, _makeSpan(start));
     }
+    return null;
   }
 
   MediaExpression processMediaExpression([bool andOperator = false]) {
     var start = _peekToken.span;
 
     // Grammar: '(' S* media_feature S* [ ':' S* expr ]? ')' S*
     if (_maybeEat(TokenKind.LPAREN)) {
       if (_peekIdentifier()) {
         var feature = identifier(); // Media feature.
         while (_maybeEat(TokenKind.COLON)) {
           var startExpr = _peekToken.span;
           var exprs = processExpr();
           if (_maybeEat(TokenKind.RPAREN)) {
             return new MediaExpression(
                 andOperator, feature, exprs, _makeSpan(startExpr));
           } else if (isChecked) {
             _warning("Missing parenthesis around media expression",
                 _makeSpan(start));
             return null;
           }
         }
       } else if (isChecked) {
         _warning("Missing media feature in media expression", _makeSpan(start));
-        return null;
       }
     }
+    return null;
   }
 
   /**
    * Directive grammar:
    *
    *  import:             '@import' [string | URI] media_list?
    *  media:              '@media' media_query_list '{' ruleset '}'
    *  page:               '@page' [':' IDENT]? '{' declarations '}'
    *  stylet:             '@stylet' IDENT '{' ruleset '}'
    *  media_query_list:   IDENT [',' IDENT]
@@ skipping 322 matching lines @@
           mustHaveParam = true;
           continue;
         }
         keepGoing = !_maybeEat(TokenKind.RPAREN);
       }
     }
 
     _eat(TokenKind.LBRACE);
 
     List<TreeNode> productions = [];
-    List<TreeNode> declarations = [];
     var mixinDirective;
 
     var start = _peekToken.span;
     while (!_maybeEat(TokenKind.END_OF_FILE)) {
       var directive = processDirective();
       if (directive != null) {
         productions.add(directive);
         continue;
       }
 
@@ skipping 165 matching lines @@
   }
 
   RuleSet processRuleSet([SelectorGroup selectorGroup]) {
     if (selectorGroup == null) {
       selectorGroup = processSelectorGroup();
     }
     if (selectorGroup != null) {
       return new RuleSet(
           selectorGroup, processDeclarations(), selectorGroup.span);
     }
+    return null;
   }
 
   /**
    * Look ahead to see if what should be a declaration is really a selector.
    * If it's a selector than it's a nested selector.  This support's Less'
    * nested selector syntax (requires a look ahead). E.g.,
    *
    *    div {
    *      width : 20px;
    *      span {
@@ skipping 187 matching lines @@
     do {
       Selector selector = processSelector();
       if (selector != null) {
         selectors.add(selector);
       }
     } while (_maybeEat(TokenKind.COMMA));
 
     if (selectors.length > 0) {
       return new SelectorGroup(selectors, _makeSpan(start));
     }
+    return null;
   }
 
   /**
    * Return list of selectors
    */
   Selector processSelector() {
     var simpleSequences = <SimpleSelectorSequence>[];
     var start = _peekToken.span;
     while (true) {
       // First item is never descendant make sure it's COMBINATOR_NONE.
@@ skipping 391 matching lines @@
 
         if (value == null) {
           _error('expected attribute value string or ident', _peekToken.span);
         }
       }
 
       _eat(TokenKind.RBRACK);
 
       return new AttributeSelector(attrName, op, value, _makeSpan(start));
     }
+    return null;
   }
 
   //  Declaration grammar:
   //
   //  declaration:  property ':' expr prio?
   //
   //  property:  IDENT [or IE hacks]
   //  prio:      !important
   //  expr:      (see processExpr)
   //
@@ skipping 141 matching lines @@
   };
 
   static int _findStyle(String styleName) => _stylesToDart[styleName];
 
   DartStyleExpression _styleForDart(
       Identifier property, Expressions exprs, List dartStyles) {
     var styleType = _findStyle(property.name.toLowerCase());
     if (styleType != null) {
       return buildDartStyleNode(styleType, exprs, dartStyles);
     }
+    return null;
   }
 
   FontExpression _mergeFontStyles(FontExpression fontExpr, List dartStyles) {
     // Merge all font styles for this class selector.
     for (var dartStyle in dartStyles) {
       if (dartStyle.isFont) {
         fontExpr = new FontExpression.merge(dartStyle, fontExpr);
       }
     }
 
@@ skipping 127 matching lines @@
       case _heightPart:
       case _widthPart:
       case _paddingPartLeft:
       case _paddingPartTop:
       case _paddingPartRight:
       case _paddingPartBottom:
         if (exprs.expressions.length > 0) {
           return processOneNumber(exprs, styleType);
         }
         break;
-      default:
-        // Don't handle it.
-        return null;
     }
+    return null;
   }
 
   // TODO(terry): Look at handling width of thin, thick, etc. any none numbers
   //              to convert to a number.
   DartStyleExpression processOneNumber(Expressions exprs, int part) {
     var value = marginValue(exprs.expressions[0]);
     if (value != null) {
       switch (part) {
         case _marginPartLeft:
           return new MarginExpression(exprs.span, left: value);
@@ skipping 22 matching lines @@
         case _paddingPartLeft:
           return new PaddingExpression(exprs.span, left: value);
         case _paddingPartTop:
           return new PaddingExpression(exprs.span, top: value);
         case _paddingPartRight:
           return new PaddingExpression(exprs.span, right: value);
         case _paddingPartBottom:
           return new PaddingExpression(exprs.span, bottom: value);
       }
     }
+    return null;
   }
 
   /**
    * Margins are of the format:
    *
    *   top,right,bottom,left      (4 parameters)
    *   top,right/left, bottom     (3 parameters)
    *   top/bottom,right/left      (2 parameters)
    *   top/right/bottom/left      (1 parameter)
    *
@@ skipping 209 matching lines @@
           _error('Expecting a positive number', _makeSpan(start));
         }
 
         _eat(TokenKind.RBRACK);
 
         return new ItemTerm(term.value, term.text, _makeSpan(start));
       case TokenKind.IDENTIFIER:
         var nameValue = identifier(); // Snarf up the ident we'll remap, maybe.
 
         if (!ieFilter && _maybeEat(TokenKind.LPAREN)) {
+          var calc = processCalc(nameValue);
+          if (calc != null) return calc;
           // FUNCTION
           return processFunction(nameValue);
         }
         if (ieFilter) {
           if (_maybeEat(TokenKind.COLON) &&
               nameValue.name.toLowerCase() == 'progid') {
             // IE filter:progid:
             return processIEFilter(start);
           } else {
             // Handle filter:<name> where name is any filter e.g., alpha, chroma,
@@ skipping 234 matching lines @@
                 startAfterProgidColon.start.offset, _peekToken.start);
             return new LiteralTerm(tok.text, tok.text, tok.span);
           }
           break;
         default:
           _eat(_peek());
       }
     }
   }
 
+  //  TODO(terry): Hack to gobble up the calc expression as a string looking
+  //               for the matching RPAREN the expression is not parsed into the
+  //               AST.
+  //
+  //  grammar should be:
+  //
+  //    <calc()> = calc( <calc-sum> )
+  //    <calc-sum> = <calc-product> [ [ '+' | '-' ] <calc-product> ]*
+  //    <calc-product> = <calc-value> [ '*' <calc-value> | '/' <number> ]*
+  //    <calc-value> = <number> | <dimension> | <percentage> | ( <calc-sum> )
+  //
+  String processCalcExpression() {
+    var inString = tokenizer._inString;
+    tokenizer._inString = false;
+
+    // Gobble up everything until we hit our stop token.
+    var stringValue = new StringBuffer();
+    var left = 1;
+    var matchingParens = false;
+    while (_peek() != TokenKind.END_OF_FILE && !matchingParens) {
+      var token = _peek();
+      if (token == TokenKind.LPAREN)
+        left++;
+      else if (token == TokenKind.RPAREN)
+        left--;
+
+      matchingParens = left == 0;
+      if (!matchingParens) stringValue.write(_next().text);
+    }
+
+    if (!matchingParens) {
+      _error("problem parsing function expected ), ", _peekToken.span);
+    }
+
+    tokenizer._inString = inString;
+
+    return stringValue.toString();
+  }
+
+  CalcTerm processCalc(Identifier func) {
+    var start = _peekToken.span;
+
+    var name = func.name;
+    if (name == 'calc') {
+      // TODO(terry): Implement expression parsing properly.
+      String expression = processCalcExpression();
+      var calcExpr = new LiteralTerm(expression, expression, _makeSpan(start));
+
+      if (!_maybeEat(TokenKind.RPAREN)) {
+        _error("problem parsing function expected ), ", _peekToken.span);
+      }
+
+      return new CalcTerm(name, name, calcExpr, _makeSpan(start));
+    }
+
+    return null;
+  }
+
   //  Function grammar:
   //
   //  function:     IDENT '(' expr ')'
   //
   processFunction(Identifier func) {
     var start = _peekToken.span;
 
     var name = func.name;
 
     switch (name) {
       case 'url':
         // URI term sucks up everything inside of quotes(' or ") or between parens
         var urlParam = processQuotedString(true);
 
         // TODO(terry): Better error messge and checking for mismatched quotes.
         if (_peek() == TokenKind.END_OF_FILE) {
           _error("problem parsing URI", _peekToken.span);
         }
 
         if (_peek() == TokenKind.RPAREN) {
           _next();
         }
 
         return new UriTerm(urlParam, _makeSpan(start));
-      case 'calc':
-        // TODO(terry): Implement expression handling...
-        break;
       case 'var':
         // TODO(terry): Consider handling var in IE specific filter/progid.  This
         //              will require parsing entire IE specific syntax e.g.,
         //              param = value or progid:com_id, etc. for example:
         //
         //    var-blur: Blur(Add = 0, Direction = 225, Strength = 10);
         //    var-gradient: progid:DXImageTransform.Microsoft.gradient"
         //      (GradientType=0,StartColorStr='#9d8b83', EndColorStr='#847670');
         var expr = processExpr();
         if (!_maybeEat(TokenKind.RPAREN)) {
@@ skipping 207 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();
 }