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

tests/test_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/>.
 
 from __future__ import unicode_literals
 
 import pytest
 
 from abp.filters import (
-    parse_line, parse_filterlist, ParseError,
-    SelectorType as St, FilterAction as Fa, FilterOption as Opt,

[rhowell, 2019/01/12 01:25:31]

I wasn't sure what best practices were for this naming scheme. St, Fa, and Opt
seem a little odd to me. Any suggestions?

[Vasily Kuznetsov, 2019/01/12 19:23:38]

Yeah, I agree about the oddness. Maybe just the first letters of the words in
CAPS: ST, FA and FO. How does this feel?

[rhowell, 2019/01/12 21:18:34]

That produces another flake8 error: `N814 camelcase 'FA' imported as constant`.
I tried a couple different options. SelectorType is the only one that causes the
lines to be too long, so I shortened it to SelType. But the rest of them could
just be imported as-is?

[Vasily Kuznetsov, 2019/01/14 14:14:35]

I see. Pep8-naming is stricter than I expected. This is a bit verbose but I
don't really have better ideas :/

+    parse_line, parse_filterlist, ParseError, SelectorType as SelType,
+    FilterAction, FilterOption,
 )
 from abp.filters.parser import Comment, Metadata, Header
 
 
 def test_parse_empty():
     line = parse_line('    ')
     assert line.type == 'emptyline'
 
 
 @pytest.mark.parametrize('filter_text, expected', {
     # Blocking filters with patterns and regexps and blocking exceptions.
     '*asdf*d**dd*': {
-        'selector': {'type': St.URL_PATTERN, 'value': '*asdf*d**dd*'},
-        'action': Fa.BLOCK,
+        'selector': {'type': SelType.URL_PATTERN, 'value': '*asdf*d**dd*'},
+        'action': FilterAction.BLOCK,
     },
     '@@|*asd|f*d**dd*|': {
-        'selector': {'type': St.URL_PATTERN, 'value': '|*asd|f*d**dd*|'},
-        'action': Fa.ALLOW,
+        'selector': {'type': SelType.URL_PATTERN, 'value': '|*asd|f*d**dd*|'},
+        'action': FilterAction.ALLOW,
     },
     '/ddd|f?a[s]d/': {
-        'selector': {'type': St.URL_REGEXP, 'value': 'ddd|f?a[s]d'},
-        'action': Fa.BLOCK,
+        'selector': {'type': SelType.URL_REGEXP, 'value': 'ddd|f?a[s]d'},
+        'action': FilterAction.BLOCK,
     },
     '@@/ddd|f?a[s]d/': {
-        'selector': {'type': St.URL_REGEXP, 'value': 'ddd|f?a[s]d'},
-        'action': Fa.ALLOW,
+        'selector': {'type': SelType.URL_REGEXP, 'value': 'ddd|f?a[s]d'},
+        'action': FilterAction.ALLOW,
     },
     # Blocking filters with some options.
     'bla$match-case,~script,domain=foo.com|~bar.com,sitekey=foo': {
-        'selector': {'type': St.URL_PATTERN, 'value': 'bla'},
-        'action': Fa.BLOCK,
-        'options': [
-            (Opt.MATCH_CASE, True),
-            (Opt.SCRIPT, False),
-            (Opt.DOMAIN, [('foo.com', True), ('bar.com', False)]),
-            (Opt.SITEKEY, ['foo']),
+        'selector': {'type': SelType.URL_PATTERN, 'value': 'bla'},
+        'action': FilterAction.BLOCK,
+        'options': [
+            (FilterOption.MATCH_CASE, True),
+            (FilterOption.SCRIPT, False),
+            (FilterOption.DOMAIN, [('foo.com', True), ('bar.com', False)]),
+            (FilterOption.SITEKEY, ['foo']),
         ],
     },
     '@@http://bla$~script,~other,sitekey=foo|bar': {
-        'selector': {'type': St.URL_PATTERN, 'value': 'http://bla'},
-        'action': Fa.ALLOW,
-        'options': [
-            (Opt.SCRIPT, False),
-            (Opt.OTHER, False),
-            (Opt.SITEKEY, ['foo', 'bar']),
+        'selector': {'type': SelType.URL_PATTERN, 'value': 'http://bla'},
+        'action': FilterAction.ALLOW,
+        'options': [
+            (FilterOption.SCRIPT, False),
+            (FilterOption.OTHER, False),
+            (FilterOption.SITEKEY, ['foo', 'bar']),
         ],
     },
     "||foo.com^$csp=script-src 'self' * 'unsafe-inline',script,sitekey=foo,"
     + 'other,match-case,domain=foo.com': {
-        'selector': {'type': St.URL_PATTERN, 'value': '||foo.com^'},
-        'action': Fa.BLOCK,
-        'options': [
-            (Opt.CSP, "script-src 'self' * 'unsafe-inline'"),
+        'selector': {'type': SelType.URL_PATTERN, 'value': '||foo.com^'},
+        'action': FilterAction.BLOCK,
+        'options': [
+            (FilterOption.CSP, "script-src 'self' * 'unsafe-inline'"),
             ('script', True),
             ('sitekey', ['foo']),
             ('other', True),
             ('match-case', True),
             ('domain', [('foo.com', True)]),
         ],
     },
     '@@bla$script,other,domain=foo.com|~bar.foo.com,csp=c s p': {
-        'selector': {'type': St.URL_PATTERN, 'value': 'bla'},
-        'action': Fa.ALLOW,
+        'selector': {'type': SelType.URL_PATTERN, 'value': 'bla'},
+        'action': FilterAction.ALLOW,
         'options': [
             ('script', True),
             ('other', True),
             ('domain', [('foo.com', True), ('bar.foo.com', False)]),
             ('csp', 'c s p'),
         ],
     },
     '||content.server.com/files/*.php$rewrite=$1': {
-        'selector': {'type': St.URL_PATTERN,
+        'selector': {'type': SelType.URL_PATTERN,
                      'value': '||content.server.com/files/*.php'},
-        'action': Fa.BLOCK,
+        'action': FilterAction.BLOCK,
         'options': [
             ('rewrite', '$1'),
         ],
     },
     # Element hiding filters and exceptions.
     '##ddd': {
-        'selector': {'type': St.CSS, 'value': 'ddd'},
-        'action': Fa.HIDE,
+        'selector': {'type': SelType.CSS, 'value': 'ddd'},
+        'action': FilterAction.HIDE,
         'options': [],
     },
     '#@#body > div:first-child': {
-        'selector': {'type': St.CSS, 'value': 'body > div:first-child'},
-        'action': Fa.SHOW,
+        'selector': {'type': SelType.CSS, 'value': 'body > div:first-child'},
+        'action': FilterAction.SHOW,
         'options': [],
     },
     'foo,~bar##ddd': {
-        'options': [(Opt.DOMAIN, [('foo', True), ('bar', False)])],
+        'options': [(FilterOption.DOMAIN, [('foo', True), ('bar', False)])],
     },
     # Element hiding emulation filters (extended CSS).
     'foo,~bar#?#:-abp-properties(abc)': {
-        'selector': {'type': St.XCSS, 'value': ':-abp-properties(abc)'},
-        'action': Fa.HIDE,
-        'options': [(Opt.DOMAIN, [('foo', True), ('bar', False)])],
+        'selector': {'type': SelType.XCSS, 'value': ':-abp-properties(abc)'},
+        'action': FilterAction.HIDE,
+        'options': [(FilterOption.DOMAIN, [('foo', True), ('bar', False)])],
     },
     'foo.com#?#aaa :-abp-properties(abc) bbb': {
         'selector': {
-            'type': St.XCSS,
+            'type': SelType.XCSS,
             'value': 'aaa :-abp-properties(abc) bbb',
         },
     },
     '#?#:-abp-properties(|background-image: url(data:*))': {
         'selector': {
-            'type': St.XCSS,
+            'type': SelType.XCSS,
             'value': ':-abp-properties(|background-image: url(data:*))',
         },
         'options': [],
     },
 }.items())
 def test_parse_filters(filter_text, expected):
     """Parametric test for filter parsing."""
     parsed = parse_line(filter_text)
     assert parsed.type == 'filter'
     assert parsed.text == filter_text
@@ skipping 78 matching lines @@
 def test_exception_timing():
     result = parse_filterlist(['! good line', '%bad line%'])
     assert next(result) == Comment('good line')
     with pytest.raises(ParseError):
         next(result)
 
 
 def test_parse_line_bytes():
     line = parse_line(b'! \xc3\xbc')
     assert line.text == '\xfc'