pkg/csslib: formatting

lib/src/analyzer.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.
 
 part of csslib.parser;
 
-
 // TODO(terry): Add optimizing phase to remove duplicated selectors in the same
 //              selector group (e.g., .btn, .btn { color: red; }).  Also, look
 //              at simplifying selectors expressions too (much harder).
 // TODO(terry): Detect invalid directive usage.  All @imports must occur before
 //              all rules other than @charset directive.  Any @import directive
 //              after any non @charset or @import directive are ignored. e.g.,
 //                  @import "a.css";
 //                  div { color: red; }
 //                  @import "b.css";
 //              becomes:
 //                  @import "a.css";
 //                  div { color: red; }
 // <http://www.w3.org/TR/css3-syntax/#at-rules>
 
 /**
  * Analysis phase will validate/fixup any new CSS feature or any SASS style
  * feature.
  */
 class Analyzer {
   final List<StyleSheet> _styleSheets;
   final Messages _messages;
 
   Analyzer(this._styleSheets, this._messages);
 
   // TODO(terry): Currently each feature walks the AST each time.  Once we have
   //               our complete feature set consider benchmarking the cost and
   //               possibly combine in one walk.
   void run() {
     // Expand top-level @include.
-    _styleSheets.forEach((styleSheet) =>
-        TopLevelIncludes.expand(_messages, _styleSheets));
+    _styleSheets.forEach(
+        (styleSheet) => TopLevelIncludes.expand(_messages, _styleSheets));
 
     // Expand @include in declarations.
-    _styleSheets.forEach((styleSheet) =>
-        DeclarationIncludes.expand(_messages, _styleSheets));
+    _styleSheets.forEach(
+        (styleSheet) => DeclarationIncludes.expand(_messages, _styleSheets));
 
     // Remove all @mixin and @include
     _styleSheets.forEach((styleSheet) => MixinsAndIncludes.remove(styleSheet));
 
     // Expand any nested selectors using selector desendant combinator to
     // signal CSS inheritance notation.
     _styleSheets.forEach((styleSheet) => new ExpandNestedSelectors()
-        ..visitStyleSheet(styleSheet)
-        ..flatten(styleSheet));
+      ..visitStyleSheet(styleSheet)
+      ..flatten(styleSheet));
 
     // Expand any @extend.
     _styleSheets.forEach((styleSheet) {
-        var allExtends = new AllExtends()..visitStyleSheet(styleSheet);
-        new InheritExtends(_messages, allExtends)..visitStyleSheet(styleSheet);
+      var allExtends = new AllExtends()..visitStyleSheet(styleSheet);
+      new InheritExtends(_messages, allExtends)..visitStyleSheet(styleSheet);
     });
   }
 }
 
 /**
  * Traverse all rulesets looking for nested ones.  If a ruleset is in a
  * declaration group (implies nested selector) then generate new ruleset(s) at
  * level 0 of CSS using selector inheritance syntax (flattens the nesting).
  *
  * How the AST works for a rule [RuleSet] and nested rules.  First of all a
@@ skipping 141 matching lines @@
       _nestedSelectorGroup = _mergeToFlatten(node);
     }
 
     _parentRuleSet = node;
 
     super.visitRuleSet(node);
 
     _parentRuleSet = oldParent;
 
     // Remove nested rules; they're all flatten and in the _expandedRuleSets.
-    node.declarationGroup.declarations.removeWhere((declaration) =>
-        declaration is RuleSet);
+    node.declarationGroup.declarations
+        .removeWhere((declaration) => declaration is RuleSet);
 
     _nestedSelectorGroup = oldNestedSelectorGroups;
 
     // If any expandedRuleSets and we're back at the top-level rule set then
     // there were nested rule set(s).
     if (_parentRuleSet == null) {
       if (!_expandedRuleSets.isEmpty) {
         // Remember ruleset to replace with these flattened rulesets.
         _expansions[node] = _expandedRuleSets;
         _expandedRuleSets = [];
@@ skipping 68 matching lines @@
    * descendant.  Used for nested selectors when the parent selector needs to
    * be prefixed to a nested selector or to substitute the this (&) with the
    * parent selector.
    */
   List<SimpleSelectorSequence> _convertToDescendentSequence(
       List<SimpleSelectorSequence> sequences) {
     if (sequences.isEmpty) return sequences;
 
     var newSequences = [];
     var first = sequences.first;
-    newSequences.add(new SimpleSelectorSequence(first.simpleSelector,
-        first.span, TokenKind.COMBINATOR_DESCENDANT));
+    newSequences.add(new SimpleSelectorSequence(
+        first.simpleSelector, first.span, TokenKind.COMBINATOR_DESCENDANT));
     newSequences.addAll(sequences.skip(1));
 
     return newSequences;
   }
 
   void visitDeclarationGroup(DeclarationGroup node) {
     var span = node.span;
 
     var currentGroup = new DeclarationGroup([], span);
 
@@ skipping 80 matching lines @@
 
 class _MediaRulesReplacer extends Visitor {
   RuleSet _ruleSet;
   List<RuleSet> _newRules;
   bool _foundAndReplaced = false;
 
   /**
    * Look for the [ruleSet] inside of an @media directive; if found then replace
    * with the [newRules].  If [ruleSet] is found and replaced return true.
    */
-  static bool replace(StyleSheet styleSheet, RuleSet ruleSet,
-                      List<RuleSet>newRules) {
+  static bool replace(
+      StyleSheet styleSheet, RuleSet ruleSet, List<RuleSet> newRules) {
     var visitor = new _MediaRulesReplacer(ruleSet, newRules);
     visitor.visitStyleSheet(styleSheet);
     return visitor._foundAndReplaced;
   }
 
   _MediaRulesReplacer(this._ruleSet, this._newRules);
 
   visitMediaDirective(MediaDirective node) {
     var index = node.rulesets.indexOf(_ruleSet);
     if (index != -1) {
@@ skipping 30 matching lines @@
   void visitStyleSheet(StyleSheet ss) {
     _styleSheet = ss;
     super.visitStyleSheet(ss);
     _styleSheet = null;
   }
 
   void visitIncludeDirective(IncludeDirective node) {
     if (map.containsKey(node.name)) {
       var mixinDef = map[node.name];
       if (mixinDef is MixinRulesetDirective) {
-        _TopLevelIncludeReplacer.replace(_messages, _styleSheet, node,
-            mixinDef.rulesets);
+        _TopLevelIncludeReplacer.replace(
+            _messages, _styleSheet, node, mixinDef.rulesets);
       } else if (currDef is MixinRulesetDirective && _anyRulesets(currDef)) {
         // currDef is MixinRulesetDirective
         MixinRulesetDirective mixinRuleset = currDef;
         int index = mixinRuleset.rulesets.indexOf(node as dynamic);
         mixinRuleset.rulesets.replaceRange(index, index + 1, [new NoOp()]);
         _messages.warning(
             'Using declaration mixin ${node.name} as top-level mixin',
             node.span);
       }
     } else {
@@ skipping 38 matching lines @@
   final Messages _messages;
   final IncludeDirective _include;
   final List<RuleSet> _newRules;
   bool _foundAndReplaced = false;
 
   /**
    * Look for the [ruleSet] inside of an @media directive; if found then replace
    * with the [newRules].  If [ruleSet] is found and replaced return true.
    */
   static bool replace(Messages messages, StyleSheet styleSheet,
-      IncludeDirective include, List<RuleSet>newRules) {
+      IncludeDirective include, List<RuleSet> newRules) {
     var visitor = new _TopLevelIncludeReplacer(messages, include, newRules);
     visitor.visitStyleSheet(styleSheet);
     return visitor._foundAndReplaced;
   }
 
   _TopLevelIncludeReplacer(this._messages, this._include, this._newRules);
 
   visitStyleSheet(StyleSheet node) {
     var index = node.topLevels.indexOf(_include);
     if (index != -1) {
@@ skipping 15 matching lines @@
     super.visitMixinRulesetDirective(node);
   }
 }
 
 /**
  * Utility function to match an include to a list of either Declarations or
  * RuleSets, depending on type of mixin (ruleset or declaration).  The include
  * can be an include in a declaration or an include directive (top-level).
  */
 int _findInclude(List list, var node) {
-  IncludeDirective matchNode = (node is IncludeMixinAtDeclaration) ?
-      node.include : node;
+  IncludeDirective matchNode =
+      (node is IncludeMixinAtDeclaration) ? node.include : node;
 
   var index = 0;
   for (var item in list) {
-    var includeNode = (item is IncludeMixinAtDeclaration) ?
-        item.include : item;
+    var includeNode = (item is IncludeMixinAtDeclaration) ? item.include : item;
     if (includeNode == matchNode) return index;
     index++;
   }
   return -1;
 }
 
 /**
  * Stamp out a mixin with the defined args substituted with the user's
  * parameters.
  */
@@ skipping 142 matching lines @@
   DeclarationIncludes(this._messages, List<StyleSheet> styleSheets) {
     for (var styleSheet in styleSheets) {
       visitTree(styleSheet);
     }
   }
 
   bool _allIncludes(rulesets) =>
       rulesets.every((rule) => rule is IncludeDirective || rule is NoOp);
 
   CallMixin _createCallDeclMixin(MixinDefinition mixinDef) {
-    callMap.putIfAbsent(mixinDef.name, () =>
-        callMap[mixinDef.name] = new CallMixin(mixinDef, varDefs));
+    callMap.putIfAbsent(mixinDef.name,
+        () => callMap[mixinDef.name] = new CallMixin(mixinDef, varDefs));
     return callMap[mixinDef.name];
   }
 
   void visitStyleSheet(StyleSheet ss) {
     _styleSheet = ss;
     super.visitStyleSheet(ss);
     _styleSheet = null;
   }
 
   void visitDeclarationGroup(DeclarationGroup node) {
     currDeclGroup = node;
     super.visitDeclarationGroup(node);
     currDeclGroup = null;
   }
 
   void visitIncludeMixinAtDeclaration(IncludeMixinAtDeclaration node) {
     if (map.containsKey(node.include.name)) {
       var mixinDef = map[node.include.name];
 
       // Fix up any mixin that is really a Declaration but has includes.
       if (mixinDef is MixinRulesetDirective) {
         if (!_allIncludes(mixinDef.rulesets) && currDeclGroup != null) {
           var index = _findInclude(currDeclGroup.declarations, node);
           if (index != -1) {
-            currDeclGroup.declarations.replaceRange(index, index + 1,
-                [new NoOp()]);
+            currDeclGroup.declarations.replaceRange(
+                index, index + 1, [new NoOp()]);
           }
           _messages.warning(
               "Using top-level mixin ${node.include.name} as a declaration",
               node.span);
         } else {
           // We're a list of @include(s) inside of a mixin ruleset - convert
           // to a list of IncludeMixinAtDeclaration(s).
           var origRulesets = mixinDef.rulesets;
           var rulesets = [];
           if (origRulesets.every((ruleset) => ruleset is IncludeDirective)) {
             origRulesets.forEach((ruleset) {
-              rulesets.add(new IncludeMixinAtDeclaration(ruleset,
-                  ruleset.span));
+              rulesets
+                  .add(new IncludeMixinAtDeclaration(ruleset, ruleset.span));
             });
             _IncludeReplacer.replace(_styleSheet, node, rulesets);
           }
         }
       }
 
-      if ( mixinDef.definedArgs.length > 0 && node.include.args.length > 0) {
+      if (mixinDef.definedArgs.length > 0 && node.include.args.length > 0) {
         var callMixin = _createCallDeclMixin(mixinDef);
         mixinDef = callMixin.transform(node.include.args);
       }
 
       if (mixinDef is MixinDeclarationDirective) {
-        _IncludeReplacer.replace(_styleSheet, node,
-            mixinDef.declarations.declarations);
+        _IncludeReplacer.replace(
+            _styleSheet, node, mixinDef.declarations.declarations);
       }
     } else {
       _messages.warning("Undefined mixin ${node.include.name}", node.span);
     }
 
     super.visitIncludeMixinAtDeclaration(node);
   }
 
   void visitIncludeDirective(IncludeDirective node) {
     if (map.containsKey(node.name)) {
       var mixinDef = map[node.name];
       if (currDef is MixinDeclarationDirective &&
           mixinDef is MixinDeclarationDirective) {
-        _IncludeReplacer.replace(_styleSheet, node,
-            mixinDef.declarations.declarations);
+        _IncludeReplacer.replace(
+            _styleSheet, node, mixinDef.declarations.declarations);
       } else if (currDef is MixinDeclarationDirective) {
-        var decls = (currDef as MixinDeclarationDirective)
-            .declarations.declarations;
+        var decls =
+            (currDef as MixinDeclarationDirective).declarations.declarations;
         var index = _findInclude(decls, node);
         if (index != -1) {
           decls.replaceRange(index, index + 1, [new NoOp()]);
         }
       }
     }
 
     super.visitIncludeDirective(node);
   }
 
@@ skipping 18 matching lines @@
   }
 
   void visitVarDefinition(VarDefinition node) {
     // Only record var definitions that have multiple expressions (comma
     // separated for mixin parameter substitution.
     var exprs = (node.expression as Expressions).expressions;
     if (exprs.length > 1) {
       varDefs[node.definedName] = node;
     }
     super.visitVarDefinition(node);
- }
+  }
 
   void visitVarDefinitionDirective(VarDefinitionDirective node) {
     visitVarDefinition(node.def);
   }
 }
 
 /** @include as a top-level with ruleset(s). */
 class _IncludeReplacer extends Visitor {
   final _include;
   final List<Declaration> _newDeclarations;
   bool _foundAndReplaced = false;
 
   /**
    * Look for the [ruleSet] inside of a @media directive; if found then replace
    * with the [newRules].
    */
-  static void replace(StyleSheet ss, var include,
-      List<Declaration> newDeclarations) {
+  static void replace(
+      StyleSheet ss, var include, List<Declaration> newDeclarations) {
     var visitor = new _IncludeReplacer(include, newDeclarations);
     visitor.visitStyleSheet(ss);
   }
 
   _IncludeReplacer(this._include, this._newDeclarations);
 
   void visitDeclarationGroup(DeclarationGroup node) {
     var index = _findInclude(node.declarations, _include);
     if (index != -1) {
       node.declarations.insertAll(index + 1, _newDeclarations);
@@ skipping 99 matching lines @@
 /**
  * Changes any selector that matches @extend.
  */
 class InheritExtends extends Visitor {
   final Messages _messages;
   final AllExtends _allExtends;
 
   InheritExtends(this._messages, this._allExtends);
 
   void visitSelectorGroup(SelectorGroup node) {
-    for (var selectorsIndex = 0; selectorsIndex < node.selectors.length;
+    for (var selectorsIndex = 0;
+        selectorsIndex < node.selectors.length;
         selectorsIndex++) {
       var selectors = node.selectors[selectorsIndex];
       var isLastNone = false;
       var selectorName = "";
-      for (var index = 0; index < selectors.simpleSelectorSequences.length;
+      for (var index = 0;
+          index < selectors.simpleSelectorSequences.length;
           index++) {
         var simpleSeq = selectors.simpleSelectorSequences[index];
         var namePart = simpleSeq.simpleSelector.toString();
         selectorName = (isLastNone) ? (selectorName + namePart) : namePart;
         List<SelectorGroup> matches = _allExtends.inherits[selectorName];
         if (matches != null) {
           for (var match in matches) {
             // Create a new group.
             var newSelectors = selectors.clone();
             var newSeq = match.selectors[0].clone();
             if (isLastNone) {
               // Add the inherited selector.
               node.selectors.add(newSeq);
             } else {
               // Replace the selector sequence to the left of the pseudo class
               // or pseudo element.
 
               // Make new selector seq combinator the same as the original.
               var orgCombinator =
                   newSelectors.simpleSelectorSequences[index].combinator;
               newSeq.simpleSelectorSequences[0].combinator = orgCombinator;
 
-              newSelectors.simpleSelectorSequences.replaceRange(index,
-                  index + 1, newSeq.simpleSelectorSequences);
+              newSelectors.simpleSelectorSequences.replaceRange(
+                  index, index + 1, newSeq.simpleSelectorSequences);
               node.selectors.add(newSelectors);
             }
             isLastNone = false;
           }
         } else {
           isLastNone = simpleSeq.isCombinatorNone;
         }
       }
     }
     super.visitSelectorGroup(node);
   }
 }