Noissue - Added flake8 extension accounting for our coding style and some other stuff

flake8-abp/setup.py

+# This file is part of Adblock Plus <https://adblockplus.org/>,
+# Copyright (C) 2006-2016 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 print_function
+
+import os
+import glob
+import tokenize
+import sys
+import re
+
+try:
+    from StringIO import StringIO
+except ImportError:
+    from io import StringIO
+
+from setuptools import setup, Command
+
+
+class TestCommand(Command):

[Vasily Kuznetsov, 2016/05/09 13:39:51]

Hm, a custom test runner. I would have probably just used pytest with parametric
fixtures but your approach also works and there are fewer external dependencies.

In any case I really like how the tests themselves look. Just some Python code
with mark up for expected errors in the comments -- that's concise and easy to
understand and author.

[Sebastian Noack, 2016/05/09 16:49:12]

I'm not sure how that code would look like if using pytest, but I feel the way
these tests work (which we seem to agree on), we wouldn't reuse much of any test
framework's infrastructure, in particular if we want to avoid additional
boilerplate.

[Vasily Kuznetsov, 2016/05/09 17:37:32]

Yeah, you could plug it into py.test and make it run the same test (compare
flake8 output with the comments) for a bunch of instances of a parametric
fixture (the test input file). I think the amount of code would be about the
same. So it could make more sense if you wanted to also have other kinds of
tests that would benefit from a testing framework and you'd want to run it all
together. But here it's not the case so I think your implementation is as good.

+    user_options = []
+
+    def _get_expected_errors(self, filename):
+        errors = set()
+
+        def tokeneater(kind, token, start, end, line):
+            if kind == tokenize.COMMENT:
+                match = re.search(r'^#+[*\s]*(A\d+)', token)
+                if match:
+                    try:
+                        offset = token.index('*')
+                    except ValueError:
+                        offset = 0
+                    errors.add((start[0] + 1,
+                                start[1] + 1 + offset,
+                                match.group(1)))
+
+        with open(filename, 'rb') as file:
+            if sys.version_info[0] >= 3:
+                for token in tokenize.tokenize(file.readline):
+                    tokeneater(*token)
+            else:
+                tokenize.tokenize(file.readline, tokeneater)
+
+        return errors
+
+    def _get_reported_errors(self, filename, style_guide):
+        orig_stdout = sys.stdout
+        sys.stdout = stdout = StringIO()
+
+        try:
+            style_guide.check_files([filename])
+        finally:
+            sys.stdout = orig_stdout
+
+        stdout.seek(0)
+        errors = set()
+
+        for line in stdout:
+            _, lineno, colno, error = line.split(':', 3)
+            errors.add((int(lineno), int(colno), error.split()[0]))
+
+        return errors
+
+    def initialize_options(self):
+        pass
+
+    def finalize_options(self):
+        pass
+
+    def run(self):
+        import flake8.engine
+
+        directory = os.path.dirname(__file__)
+        filenames = glob.glob(os.path.join(directory, 'tests', '*.py'))
+        style_guide = flake8.engine.get_style_guide()
+        failed = False
+
+        for filename in sorted(filenames):
+            expected = self._get_expected_errors(filename)
+            reported = self._get_reported_errors(filename, style_guide)
+            failures = expected ^ reported
+
+            if not failures:
+                print(filename + ': OK')
+                continue
+
+            for record in sorted(failures):
+                lineno, colno, error = record
+
+                print('{}:{}:{}: '.format(filename, lineno, colno), end='')
+                if record in expected:
+                    print(error + ' expected')
+                else:
+                    print('unexpected ' + error)
+
+            failed = True
+
+        if failed:
+            sys.exit(1)
+
+
+setup(
+    name='flake8-abp',
+    version='0.1',
+    py_modules=['flake8_abp'],
+    entry_points={
+        'flake8.extension': [
+            'AXXX      = flake8_abp:ASTChecker',
+            'A109-A110 = flake8_abp:check_quotes',
+            'A111      = flake8_abp:check_redundant_parenthesis',
+            'A303      = flake8_abp:check_non_default_encoding',
+        ],
+    },
+    cmdclass={'test': TestCommand}
+)