[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',
+                       '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-]+)(?=[^{}]+?{)'
+    def pseudo_elements_double_colon(contents):
+      errors = []
+      for p in re.finditer(re.compile(pseudo_reg, re.MULTILINE), contents):
+        pseudo = p.group(1).strip().splitlines()[0]
+        # print 'pseudo: %s, stripped: %s' % (pseudo, _strip_prefix(pseudo))
+        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'].
+            # Multiline checks do not support ['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