[web_dev_style] Changing :pseudo-element to ::pseudo-element to match

chrome/browser/resources/web_dev_style/css_checker.py

 # Copyright (c) 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 gcl/git cl, and see
 http://www.chromium.org/developers/web-development-style-guide for the rules
 we're checking against here.
 """
 
-# TODO(dbeam): Real CSS parser? pycss? http://code.google.com/p/pycss/
+# TODO(dbeam): Real CSS parser? https://github.com/danbeam/css-py/tree/css3
 
 class CSSChecker(object):
   def __init__(self, input_api, output_api, file_filter=None):
     self.input_api = input_api
     self.output_api = output_api
     self.file_filter = file_filter
 
   def RunChecks(self):
     # We use this a lot, so make a nick name variable.
     re = self.input_api.re
@@ skipping 17 matching lines @@
       grit_reg = r'<if[^>]+>.*?<\s*/\s*if[^>]*>|<include[^>]+>'
       return re.sub(re.compile(grit_reg, re.DOTALL), '', s)
 
     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)
+
     def alphabetize_props(contents):
       errors = []
       for rule in re.finditer(r'{(.*?)}', contents, re.DOTALL):
         semis = map(lambda t: t.strip(), rule.group(1).split(';'))[:-1]
         rules = filter(lambda r: ': ' in r, semis)
         props = map(lambda r: r[0:r.find(':')], rules)
         if props != sorted(props):
           errors.append('    %s;\n' % (';\n    '.join(rules)))
       return errors
 
@@ skipping 29 matching lines @@
     small_seconds = r'(?:^|[^_a-zA-Z0-9-])(0?\.[0-9]+)s(?!-?[_a-zA-Z0-9-])'
     def milliseconds_for_small_times(line):
       return re.search(small_seconds, line)
 
     def no_data_uris_in_source_files(line):
       return re.search(r'\(\s*\'?\s*data:', line)
 
     def one_rule_per_line(line):
       return re.search(r'[_a-zA-Z0-9-](?<!data):(?!//)[^;]+;\s*[^ }]\s*', line)
 
+    pseudo_elements = ['after',

[Tyler Breisacher (Chromium), 2012/12/05 18:59:57]

Presumably more things will be added to this list eventually. Can we link to an
official list in the CSS spec or something, so that it's easy to keep this up to
date?

[Dan Beam, 2012/12/05 20:36:29]

Very few are actually official (just before, after, first-letter, first-line),
the rest are all just in webkit or non-standard impls.

+                       'before',
+                       'calendar-picker-indicator',
+                       'color-swatch',
+                       'color-swatch-wrapper',
+                       'date-and-time-container',
+                       'date-and-time-value',
+                       'datetime-edit',
+                       'datetime-edit-ampm-field',
+                       'datetime-edit-day-field',
+                       'datetime-edit-hour-field',
+                       'datetime-edit-millisecond-field',
+                       'datetime-edit-minute-field',
+                       'datetime-edit-month-field',
+                       'datetime-edit-second-field',
+                       'datetime-edit-text',
+                       'datetime-edit-week-field',
+                       'datetime-edit-year-field',
+                       'details-marker',
+                       'file-upload-button',
+                       'first-letter',
+                       'first-line',
+                       'inner-spin-button',
+                       'input-placeholder',
+                       'input-speech-button',
+                       'keygen-select',
+                       'media-slider-container',
+                       'media-slider-thumb',
+                       'meter-bar',
+                       'meter-even-less-good-value',
+                       'meter-inner-element',
+                       'meter-optimum-value',
+                       'meter-suboptimum-value',
+                       'progress-bar',
+                       'progress-inner-element',
+                       'progress-value',
+                       'resizer',
+                       'scrollbar',
+                       'scrollbar-button',
+                       'scrollbar-corner',
+                       'scrollbar-thumb',
+                       'scrollbar-track',
+                       'scrollbar-track-piece',
+                       'search-cancel-button',
+                       'search-decoration',
+                       'search-results-button',
+                       'search-results-decoration',
+                       'selection',
+                       'slider-container',
+                       'slider-runnable-track',
+                       'slider-thumb',
+                       'textfield-decoration-container',
+                       'validation-bubble',
+                       'validation-bubble-arrow',
+                       'validation-bubble-arrow-clipper',
+                       'validation-bubble-heading',
+                       'validation-bubble-message',
+                       'validation-bubble-text-block']
+    pseudo_reg = r'(?<!:):([a-z-]+)(?=[^{}]+?{)'

[Tyler Breisacher (Chromium), 2012/12/05 18:59:57]

Please consider using Python's verbose regular expressions:
http://docs.python.org/2/library/re.html#re.VERBOSE

I suspect that most people cannot remember the difference between (?<...) and
(?=...), etc. so you can save readers a lot of time with a bit of explanation.

+    def pseudo_elements_double_colon(contents):
+      errors = []
+      for p in re.finditer(re.compile(pseudo_reg, re.MULTILINE), contents):

[Tyler Breisacher (Chromium), 2012/12/05 20:45:14]

optional nit: Do the compilation when you first write the regex: pseudo_reg =
re.compile(r'(?<!:):([a-z-]+)(?=[^{}]+?{)', re.MULTILINE)

That way when someone is deciphering the regular expression, they already know
they're looking at a multi-line regex.

+        pseudo = p.group(1).strip().splitlines()[0]
+        if _strip_prefix(pseudo) in pseudo_elements:
+          errors.append('    :%s (should be ::%s)' % (pseudo, pseudo))
+      return errors
+
     any_reg = re.compile(r':(?:-webkit-)?any\(.*?\)', re.DOTALL)
     multi_sels = re.compile(r'(?:}[\n\s]*)?([^,]+,(?=[^{}]+?{).*[,{])\s*$',
                             re.MULTILINE)
     def one_selector_per_line(contents):
       errors = []
       for b in re.finditer(multi_sels, re.sub(any_reg, '', contents)):
         errors.append('    ' + b.group(1).strip().splitlines()[-1:][0])
       return errors
 
     def rgb_if_not_gray(line):
@@ skipping 18 matching lines @@
              r'(?:\.0|0(?:\.0?|px|em|%|in|cm|mm|pc|pt|ex|deg|g?rad|m?s|k?hz))'
              r'(?:\D|$)(?=[^{}]+?}).*$')
     def zero_length_values(contents):
       errors = []
       for z in re.finditer(re.compile(zeros, re.MULTILINE), contents):
         first_line = z.group(0).strip().splitlines()[0]
         if not re.search(hsl, first_line):
           errors.append('    ' + first_line)
       return errors
 
+    # NOTE: Currently multi-line checks don't support 'after'. Instead, add
+    # suggestions while parsing the file so another pass isn't necessary.
     added_or_modified_files_checks = [
         { 'desc': 'Alphabetize properties and list vendor specific (i.e. '
                   '-webkit) above standard.',
           'test': alphabetize_props,
           'multiline': True,
         },
         { 'desc': 'Start braces ({) end a selector, have a space before them '
                   'and no rules after.',
           'test': braces_have_space_before_and_nothing_after,
         },
@@ skipping 11 matching lines @@
           'test': favor_single_quotes,
         },
         { 'desc': 'Use abbreviated hex (#rgb) when in form #rrggbb.',
           'test': hex_could_be_shorter,
           'after': suggest_short_hex,
         },
         { 'desc': 'Use milliseconds for time measurements under 1 second.',
           'test': milliseconds_for_small_times,
           'after': suggest_ms_from_s,
         },
-        { 'desc': 'Don\'t use data URIs in source files. Use grit instead.',
+        { 'desc': "Don't use data URIs in source files. Use grit instead.",
           'test': no_data_uris_in_source_files,
         },
         { 'desc': 'One rule per line (what not to do: color: red; margin: 0;).',
           'test': one_rule_per_line,
         },
         { 'desc': 'One selector per line (what not to do: a, b {}).',
           'test': one_selector_per_line,
           'multiline': True,
         },
+        { 'desc': 'Pseudo-elements should use double colon (i.e. ::after).',
+          'test': pseudo_elements_double_colon,
+          'multiline': True,
+        },
         { 'desc': 'Use rgb() over #hex when not a shade of gray (like #333).',
           'test': rgb_if_not_gray,
           'after': suggest_rgb_from_hex,
         },
         { 'desc': 'Make all zero length terms (i.e. 0px) 0 unless inside of '
                   'hsl() or part of @keyframe.',
           'test': zero_length_values,
           'multiline': True,
         },
     ]
 
     results = []
     affected_files = self.input_api.AffectedFiles(include_deletes=False,
                                                   file_filter=self.file_filter)
     files = []
     for f in affected_files:
       # Remove all /*comments*/, @at-keywords, and grit <if|include> tags; we're
       # not using a real parser. TODO(dbeam): Check alpha in <if> blocks.
       file_contents = _remove_all('\n'.join(f.NewContents()))
       files.append((f.LocalPath(), file_contents))
 
     # Only look at CSS files for now.
     for f in filter(lambda f: f[0].endswith('.css'), files):
       file_errors = []
       for check in added_or_modified_files_checks:
         # If the check is multiline, it receieves the whole file and gives us
         # back a list of things wrong. If the check isn't multiline, we pass it
         # each line and the check returns something truthy if there's an issue.
         if ('multiline' in check and check['multiline']):
+          assert not 'after' in check
           check_errors = check['test'](f[1])
           if len(check_errors) > 0:
-            # There are currently no multiline checks with ['after'].
             file_errors.append('- %s\n%s' %
                 (check['desc'], '\n'.join(check_errors).rstrip()))
         else:
           check_errors = []
           lines = f[1].splitlines()
           for lnum in range(0, len(lines)):
             line = lines[lnum]
             if check['test'](line):
               error = '    ' + line.strip()
               if 'after' in check:
                 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))))
 
     if results:
       # Add your name if you're here often mucking around in the code.
       authors = ['dbeam@chromium.org']
       results.append(self.output_api.PresubmitNotifyResult(
           'Was the CSS checker useful? Send feedback or hate mail to %s.' %
           ', '.join(authors)))
 
     return results