copy from tools/lint/flake8_/__init__.py
copy to tools/lint/yamllint_/__init__.py
--- a/tools/lint/flake8_/__init__.py
+++ b/tools/lint/yamllint_/__init__.py
@@ -1,109 +1,81 @@
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
-import json
+import re
import os
import signal
import subprocess
import which
from mozprocess import ProcessHandlerMixin
from mozlint import result
here = os.path.abspath(os.path.dirname(__file__))
-FLAKE8_REQUIREMENTS_PATH = os.path.join(here, 'flake8_requirements.txt')
-
-FLAKE8_NOT_FOUND = """
-Could not find flake8! Install flake8 and try again.
-
- $ pip install -U --require-hashes -r {}
-""".strip().format(FLAKE8_REQUIREMENTS_PATH)
+YAMLLINT_REQUIREMENTS_PATH = os.path.join(here, 'yamllint_requirements.txt')
-FLAKE8_INSTALL_ERROR = """
-Unable to install correct version of flake8
+YAMLLINT_INSTALL_ERROR = """
+Unable to install correct version of yamllint
Try to install it manually with:
$ pip install -U --require-hashes -r {}
-""".strip().format(FLAKE8_REQUIREMENTS_PATH)
+""".strip().format(YAMLLINT_REQUIREMENTS_PATH)
-LINE_OFFSETS = {
- # continuation line under-indented for hanging indent
- 'E121': (-1, 2),
- # continuation line missing indentation or outdented
- 'E122': (-1, 2),
- # continuation line over-indented for hanging indent
- 'E126': (-1, 2),
- # continuation line over-indented for visual indent
- 'E127': (-1, 2),
- # continuation line under-indented for visual indent
- 'E128': (-1, 2),
- # continuation line unaligned for hanging indend
- 'E131': (-1, 2),
- # expected 1 blank line, found 0
- 'E301': (-1, 2),
- # expected 2 blank lines, found 1
- 'E302': (-2, 3),
-}
-"""Maps a flake8 error to a lineoffset tuple.
-
-The offset is of the form (lineno_offset, num_lines) and is passed
-to the lineoffset property of `ResultContainer`.
-"""
+YAMLLINT_FORMAT_REGEX = re.compile(r'(.*):(.*):(.*): \[(error|warning)\] (.*) \((.*)\)$')
results = []
-class Flake8Process(ProcessHandlerMixin):
+class YAMLLintProcess(ProcessHandlerMixin):
def __init__(self, config, *args, **kwargs):
self.config = config
kwargs['processOutputLine'] = [self.process_line]
ProcessHandlerMixin.__init__(self, *args, **kwargs)
def process_line(self, line):
- # Escape slashes otherwise JSON conversion will not work
- line = line.replace('\\', '\\\\')
try:
- res = json.loads(line)
- except ValueError:
- print('Non JSON output from linter, will not be processed: {}'.format(line))
+ match = YAMLLINT_FORMAT_REGEX.match(line)
+ abspath, line, col, level, message, code = match.groups()
+ except AttributeError:
+ print('Unable to match yaml regex against output: {}'.format(line))
return
- if 'code' in res:
- if res['code'].startswith('W'):
- res['level'] = 'warning'
-
- if res['code'] in LINE_OFFSETS:
- res['lineoffset'] = LINE_OFFSETS[res['code']]
+ res = {'path': os.path.relpath(abspath, self.config['root']),
+ 'message': message,
+ 'level': level,
+ 'lineno': line,
+ 'column': col,
+ 'rule': code,
+ }
results.append(result.from_config(self.config, **res))
def run(self, *args, **kwargs):
- # flake8 seems to handle SIGINT poorly. Handle it here instead
+ # protect against poor SIGINT handling. Handle it here instead
# so we can kill the process without a cryptic traceback.
orig = signal.signal(signal.SIGINT, signal.SIG_IGN)
ProcessHandlerMixin.run(self, *args, **kwargs)
signal.signal(signal.SIGINT, orig)
-def get_flake8_binary():
+def get_yamllint_binary():
"""
- Returns the path of the first flake8 binary available
+ Returns the path of the first yamllint binary available
if not found returns None
"""
- binary = os.environ.get('FLAKE8')
+ binary = os.environ.get('YAMLLINT')
if binary:
return binary
try:
- return which.which('flake8')
+ return which.which('yamllint')
except which.WhichError:
return None
def _run_pip(*args):
"""
Helper function that runs pip with subprocess
"""
@@ -111,66 +83,72 @@ def _run_pip(*args):
subprocess.check_output(['pip'] + list(args),
stderr=subprocess.STDOUT)
return True
except subprocess.CalledProcessError as e:
print(e.output)
return False
-def reinstall_flake8():
+def reinstall_yamllint():
"""
- Try to install flake8 at the target version, returns True on success
+ Try to install yamllint at the target version, returns True on success
otherwise prints the otuput of the pip command and returns False
"""
if _run_pip('install', '-U',
'--require-hashes', '-r',
- FLAKE8_REQUIREMENTS_PATH):
+ YAMLLINT_REQUIREMENTS_PATH):
return True
return False
def run_process(config, cmd):
- proc = Flake8Process(config, cmd)
+ proc = YAMLLintProcess(config, cmd)
proc.run()
try:
proc.wait()
except KeyboardInterrupt:
proc.kill()
+def gen_yamllint_args(cmdargs, paths=None, conf_file=None):
+ args = cmdargs[:]
+ if isinstance(paths, basestring):
+ paths = [paths]
+ if conf_file:
+ return args + ['-c', conf_file] + paths
+ return args + paths
+
+
def lint(files, config, **lintargs):
- if not reinstall_flake8():
- print(FLAKE8_INSTALL_ERROR)
+ if not reinstall_yamllint():
+ print(YAMLLINT_INSTALL_ERROR)
return 1
- binary = get_flake8_binary()
+ binary = get_yamllint_binary()
cmdargs = [
binary,
- '--format', '{"path":"%(path)s","lineno":%(row)s,'
- '"column":%(col)s,"rule":"%(code)s","message":"%(text)s"}',
+ '-f', 'parsable'
]
- # Run any paths with a .flake8 file in the directory separately so
- # it gets picked up. This means only .flake8 files that live in
+ config = config.copy()
+ config['root'] = lintargs['root']
+
+ # Run any paths with a .yamllint file in the directory separately so
+ # it gets picked up. This means only .yamllint files that live in
# directories that are explicitly included will be considered.
- # See bug 1277851
no_config = []
for f in files:
- if not os.path.isfile(os.path.join(f, '.flake8')):
+ yamllint_config = os.path.join(f, '.yamllint')
+ if not os.path.isfile(yamllint_config):
no_config.append(f)
continue
- run_process(config, cmdargs+[f])
-
- # XXX For some reason passing in --exclude results in flake8 not using
- # the local .flake8 file. So for now only pass in --exclude if there
- # is no local config.
- exclude = lintargs.get('exclude')
- if exclude:
- cmdargs += ['--exclude', ','.join(lintargs['exclude'])]
+ run_process(config,
+ gen_yamllint_args(cmdargs, conf_file=yamllint_config, paths=f))
if no_config:
- run_process(config, cmdargs+no_config)
+ run_process(config,
+ gen_yamllint_args(cmdargs, paths=no_config))
return results