Issue 7205 - Change classes that use ALL_CAPS naming to be CamelCase

abp/filters/parser.py

 # This file is part of Adblock Plus <https://adblockplus.org/>,
 # Copyright (C) 2006-present eyeo GmbH
 #
 # Adblock Plus is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License version 3 as
 # published by the Free Software Foundation.
 #
 # Adblock Plus is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with Adblock Plus.  If not, see <http://www.gnu.org/licenses/>.
 
 """Parser for ABP filterlist format."""
 
 from __future__ import unicode_literals
 
 import re
 from collections import namedtuple
 
 __all__ = [
-    'FILTER_ACTION',
-    'FILTER_OPTION',
-    'SELECTOR_TYPE',
+    'FilterAction',
+    'FilterOption',
+    'SelectorType',
     'ParseError',
     'parse_filterlist',
     'parse_line',
 ]
 
 
 class ParseError(Exception):
     """Exception thrown by the parser when it encounters invalid input.
 
     Parameters
     ----------
     error : str
         Description of the error.
     text : str
         The source text that caused an error.
 
     """
 
     def __init__(self, error, text):
         Exception.__init__(self, '{} in "{}"'.format(error, text))
         self.text = text
         self.error = error
 
 
 # Constants related to filters (see https://adblockplus.org/filters).
-class SELECTOR_TYPE:  # flake8: noqa (this is a namespace of constants).
+class SelectorType:
     """Selector type constants."""
 
     URL_PATTERN = 'url-pattern'  # Normal URL patterns.
     URL_REGEXP = 'url-regexp'    # Regular expressions for URLs.
     CSS = 'css'                  # CSS selectors for hiding filters.
     XCSS = 'extended-css'        # Extended CSS selectors (to emulate CSS4).
     ABP_SIMPLE = 'abp-simple'    # Simplified element hiding syntax.
 
 
-class FILTER_ACTION:  # flake8: noqa (this is a namespace of constants).
+class FilterAction:
     """Filter action constants."""
 
     BLOCK = 'block'              # Block the request.
     ALLOW = 'allow'              # Allow the request (whitelist).
     HIDE = 'hide'                # Hide selected element(s).
     SHOW = 'show'                # Show selected element(s) (whitelist).
 
 
-class FILTER_OPTION:  # flake8: noqa (this is a namespace of constants).
+class FilterOption:
     """Filter option constants."""
 
     # Resource types.
     OTHER = 'other'
     SCRIPT = 'script'
     IMAGE = 'image'
     STYLESHEET = 'stylesheet'
     OBJECT = 'object'
     SUBDOCUMENT = 'subdocument'
     DOCUMENT = 'document'
@@ skipping 82 matching lines @@
         return option.split('=', 1)
     if option.startswith('~'):
         return option[1:], False
     return option, True
 
 
 def _parse_filter_option(option):
     name, value = _parse_option(option)
 
     # Handle special cases of multivalued options.
-    if name == FILTER_OPTION.DOMAIN:
+    if name == FilterOption.DOMAIN:
         value = [_parse_option(o) for o in value.split('|')]
-    elif name == FILTER_OPTION.SITEKEY:
+    elif name == FilterOption.SITEKEY:
         value = value.split('|')
 
     return name, value
 
 
 def _parse_filter_options(options):
     return [_parse_filter_option(o) for o in options.split(',')]
 
 
 def _parse_blocking_filter(text):
     # Based on RegExpFilter.fromText in lib/filterClasses.js
     # in https://hg.adblockplus.org/adblockpluscore.
-    action = FILTER_ACTION.BLOCK
+    action = FilterAction.BLOCK
     options = []
     selector = text
 
     if selector.startswith('@@'):
-        action = FILTER_ACTION.ALLOW
+        action = FilterAction.ALLOW
         selector = selector[2:]
 
     if '$' in selector:
         opt_match = FILTER_OPTIONS_REGEXP.search(selector)
         if opt_match:
             selector = selector[:opt_match.start(0)]
             options = _parse_filter_options(opt_match.group(1))
 
     if (len(selector) > 1
             and selector.startswith('/') and selector.endswith('/')):
-        selector = {'type': SELECTOR_TYPE.URL_REGEXP, 'value': selector[1:-1]}
+        selector = {'type': SelectorType.URL_REGEXP, 'value': selector[1:-1]}
     else:
-        selector = {'type': SELECTOR_TYPE.URL_PATTERN, 'value': selector}
+        selector = {'type': SelectorType.URL_PATTERN, 'value': selector}
 
     return Filter(text, selector, action, options)
 
 
 def _parse_hiding_filter(text, domain, type_flag, selector_value):
-    selector = {'type': SELECTOR_TYPE.CSS, 'value': selector_value}
-    action = FILTER_ACTION.HIDE
+    selector = {'type': SelectorType.CSS, 'value': selector_value}
+    action = FilterAction.HIDE
     options = []
 
     if type_flag == '@':
-        action = FILTER_ACTION.SHOW
+        action = FilterAction.SHOW
     elif type_flag == '?':
-        selector['type'] = SELECTOR_TYPE.XCSS
+        selector['type'] = SelectorType.XCSS
 
     if domain:
         domains = [_parse_option(d) for d in domain.split(',')]
-        options.append((FILTER_OPTION.DOMAIN, domains))
+        options.append((FilterOption.DOMAIN, domains))
 
     return Filter(text, selector, action, options)
 
 
 def parse_filter(text):
     """Parse one filter.
 
     Parameters
     ----------
     text : str
@@ skipping 103 matching lines @@
     for line in lines:
         parsed_line = parse_line(line, position)
         yield parsed_line
 
         if position != 'body' and parsed_line.type in {'header', 'metadata'}:
             # Continue parsing metadata until it's over...
             position = 'metadata'
         else:
             # ...then switch to parsing the body.
             position = 'body'