web_dev_style: ignore --css-vars from alphabetical ordering requirement

chrome/browser/web_dev_style/css_checker.py

 # Copyright 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Presubmit script for Chromium WebUI resources.
 
 See http://dev.chromium.org/developers/how-tos/depottools/presubmit-scripts
 for more details about the presubmit API built into depot_tools, and see
 http://www.chromium.org/developers/web-development-style-guide for the rules
 we're checking against here.
@@ skipping 11 matching lines @@
     # We use this a lot, so make a nick name variable.
     re = self.input_api.re
 
     def _collapseable_hex(s):
       return (len(s) == 6 and s[0] == s[1] and s[2] == s[3] and s[4] == s[5])
 
     def _is_gray(s):
       return s[0] == s[1] == s[2] if len(s) == 3 else s[0:2] == s[2:4] == s[4:6]
 
     def _remove_all(s):
-      s = _remove_grit(s)
+      s = _remove_grit(s)  # Must be done first.

[dschuyler, 2016/09/22 18:58:44]

Thanks for this comment!

[Dan Beam, 2016/09/22 19:45:41]

Acknowledged.

       s = _remove_ats(s)
       s = _remove_comments(s)
+      s = _remove_mixins_and_valid_vars(s)
       s = _remove_template_expressions(s)
-      s = _remove_mixins(s)
       return s
 
     def _extract_inline_style(s):
       return '\n'.join(re.findall(r'<style\b[^>]*>([^<]*)<\/style>', s))
 
     def _remove_ats(s):
-      at_reg = re.compile(r"""
+      return re.sub(r"""
           @(?!apply)(?!\d+x\b)    # @at-keyword, not (apply|2x)
           \w+[^'"]*?{             # selector junk {
           (.*{.*?})+              # inner { curly } blocks, rules, and selector
           .*?}                    # stuff up to the first end curly }
-          """,
-          re.DOTALL | re.VERBOSE)
-      return at_reg.sub('\\1', s)
+          """, r'\1', s, flags=re.DOTALL | re.VERBOSE)
 
     def _remove_comments(s):
-      return re.sub(re.compile(r'/\*.*?\*/', re.DOTALL), '', s)
+      return re.sub(r'/\*.*?\*/', '', s, flags=re.DOTALL)
 
-    def _remove_mixins(s):
-      return re.sub(re.compile(r'--[\d\w-]+: {.*?};', re.DOTALL), '', s)
+    def _remove_grit(s):
+      return re.sub(r"""
+          <if[^>]+>.*?<\s*/\s*if[^>]*>|  # <if> contents </if>
+          <include[^>]+>                 # <include>
+          """, '', s, flags=re.DOTALL | re.VERBOSE)
+
+    mixin_shim_reg = r'[\w-]+_-_[\w-]+'
+
+    def _remove_mixins_and_valid_vars(s):
+      not_shim = r'--(?!' + mixin_shim_reg + r')'
+      name = r'[\w-]+:\s*'
+      mixin_or_value = r'({.*?}|[^;}]+);?\s*'
+      return re.sub(not_shim + name + mixin_or_value, '', s, flags=re.DOTALL)

[dschuyler, 2016/09/22 18:58:44]

optional: not_shim is actually '--' 
plus the not shim. 

I thought about suggesting that
the '--' be moved to line 65, but then
I also wondered if name would still be
simple enough as 
name = r'--(?!' + mixin_shim_reg + r')[\w-]+:\s*'
and skip the not_shim var.

Or maybe a different name for not_shim
which doesn't sound like a simple inverse
(complement) of shim.

Though it's not a big deal to leave it
as is. 

[Dan Beam, 2016/09/22 19:45:41]

Done.

 
     def _remove_template_expressions(s):
-      return re.sub(re.compile(r'\$i18n(Raw)?{[^}]*}', re.DOTALL), '', s)
-
-    def _remove_grit(s):
-      grit_reg = re.compile(r"""
-          <if[^>]+>.*?<\s*/\s*if[^>]*>|  # <if> contents </if>
-          <include[^>]+>                 # <include>
-          """,
-          re.DOTALL | re.VERBOSE)
-      return re.sub(grit_reg, '', s)
+      return re.sub(r'\$i18n(Raw)?{[^}]*}', '', s, flags=re.DOTALL)
 
     def _rgb_from_hex(s):
       if len(s) == 3:
         r, g, b = s[0] + s[0], s[1] + s[1], s[2] + s[2]
       else:
         r, g, b = s[0:2], s[2:4], s[4:6]
       return int(r, base=16), int(g, base=16), int(b, base=16)
 
     def _strip_prefix(s):
       return re.sub(r'^-(?:o|ms|moz|khtml|webkit)-', '', s)
@@ skipping 85 matching lines @@
       return small_seconds_reg.search(line)
 
     def suggest_ms_from_s(line):
       ms = int(float(small_seconds_reg.search(line).group(1)) * 1000)
       return ' (replace with %dms)' % ms
 
     def no_data_uris_in_source_files(line):
       return re.search(r'\(\s*\s*data:', line)
 
     def no_mixin_shims(line):
-      return re.search('\-\-[\w\-]+_\-_[\w\-]+\s*:', line)
+      return re.search(r'--' + mixin_shim_reg + r'\s*:', line)
 
     def no_quotes_in_url(line):
       return re.search('url\s*\(\s*["\']', line, re.IGNORECASE)
 
     def one_rule_per_line(line):
       one_rule_reg = re.compile(r"""
           [\w-](?<!data):  # a rule: but no data URIs
           (?!//)[^;]+;     # value; ignoring colons in protocols:// and };
           \s*[^ }]\s*      # any non-space after the end colon
           """,
@@ skipping 237 matching lines @@
                 error += check['after'](line)
               check_errors.append(error)
           if len(check_errors) > 0:
             file_errors.append('- %s\n%s' %
                 (check['desc'], '\n'.join(check_errors)))
       if file_errors:
         results.append(self.output_api.PresubmitPromptWarning(
             '%s:\n%s' % (f[0], '\n\n'.join(file_errors))))
 
     return results