mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-23 18:26:15 +00:00
2d61b7becb
Soon, warnings will be suppressed by default and won't causes a failure. Therefore to prevent loss of coverage, we need to make sure that any lint warning that causes a failure today, needs to be converted to an error so it keeps failing tomorrow. Depends on D3819 Differential Revision: https://phabricator.services.mozilla.com/D3820 --HG-- extra : moz-landing-system : lando
167 lines
4.4 KiB
Python
167 lines
4.4 KiB
Python
# 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/.
|
|
|
|
from __future__ import absolute_import, print_function
|
|
|
|
import os
|
|
import json
|
|
import signal
|
|
import which
|
|
|
|
# Py3/Py2 compatibility.
|
|
try:
|
|
from json.decoder import JSONDecodeError
|
|
except ImportError:
|
|
JSONDecodeError = ValueError
|
|
|
|
import mozpack.path as mozpath
|
|
from mozpack.files import FileFinder
|
|
from mozlint import result
|
|
from mozprocess import ProcessHandlerMixin
|
|
|
|
|
|
SHELLCHECK_NOT_FOUND = """
|
|
Unable to locate shellcheck, please ensure it is installed and in
|
|
your PATH or set the SHELLCHECK environment variable.
|
|
|
|
https://shellcheck.net or your system's package manager.
|
|
""".strip()
|
|
|
|
results = []
|
|
|
|
|
|
class ShellcheckProcess(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):
|
|
try:
|
|
data = json.loads(line)
|
|
except JSONDecodeError as e:
|
|
print('Unable to load shellcheck output ({}): {}'.format(e, line))
|
|
return
|
|
|
|
for entry in data:
|
|
res = {
|
|
'path': entry['file'],
|
|
'message': entry['message'],
|
|
'level': 'error',
|
|
'lineno': entry['line'],
|
|
'column': entry['column'],
|
|
'rule': entry['code'],
|
|
}
|
|
results.append(result.from_config(self.config, **res))
|
|
|
|
def run(self, *args, **kwargs):
|
|
orig = signal.signal(signal.SIGINT, signal.SIG_IGN)
|
|
ProcessHandlerMixin.run(self, *args, **kwargs)
|
|
signal.signal(signal.SIGINT, orig)
|
|
|
|
|
|
def determine_shell_from_script(path):
|
|
"""Returns a string identifying the shell used.
|
|
|
|
Returns None if not identifiable.
|
|
|
|
Copes with the following styles:
|
|
#!bash
|
|
#!/bin/bash
|
|
#!/usr/bin/env bash
|
|
"""
|
|
with open(path, 'r') as f:
|
|
head = f.readline()
|
|
|
|
if not head.startswith('#!'):
|
|
return
|
|
|
|
# allow for parameters to the shell
|
|
shebang = head.split()[0]
|
|
|
|
# if the first entry is a variant of /usr/bin/env
|
|
if 'env' in shebang:
|
|
shebang = head.split()[1]
|
|
|
|
if shebang.endswith('sh'):
|
|
# Strip first to avoid issues with #!bash
|
|
return shebang.strip('#!').split('/')[-1]
|
|
# make it clear we return None, rather than fall through.
|
|
return
|
|
|
|
|
|
def find_shell_scripts(config, paths):
|
|
found = dict()
|
|
|
|
root = config['root']
|
|
exclude = [mozpath.join(root, e) for e in config.get('exclude', [])]
|
|
|
|
if config.get('extensions'):
|
|
pattern = '**/*.{}'.format(config.get('extensions')[0])
|
|
else:
|
|
pattern = '**/*.sh'
|
|
|
|
files = []
|
|
for path in paths:
|
|
path = mozpath.normsep(path)
|
|
ignore = [e[len(path):].lstrip('/') for e in exclude
|
|
if mozpath.commonprefix((path, e)) == path]
|
|
finder = FileFinder(path, ignore=ignore)
|
|
files.extend([os.path.join(path, p) for p, f in finder.find(pattern)])
|
|
|
|
for filename in files:
|
|
shell = determine_shell_from_script(filename)
|
|
if shell:
|
|
found[filename] = shell
|
|
return found
|
|
|
|
|
|
def run_process(config, cmd):
|
|
proc = ShellcheckProcess(config, cmd)
|
|
proc.run()
|
|
try:
|
|
proc.wait()
|
|
except KeyboardInterrupt:
|
|
proc.kill()
|
|
|
|
|
|
def get_shellcheck_binary():
|
|
"""
|
|
Returns the path of the first shellcheck binary available
|
|
if not found returns None
|
|
"""
|
|
binary = os.environ.get('SHELLCHECK')
|
|
if binary:
|
|
return binary
|
|
|
|
try:
|
|
return which.which('shellcheck')
|
|
except which.WhichError:
|
|
return None
|
|
|
|
|
|
def lint(paths, config, **lintargs):
|
|
|
|
binary = get_shellcheck_binary()
|
|
|
|
if not binary:
|
|
print(SHELLCHECK_NOT_FOUND)
|
|
if 'MOZ_AUTOMATION' in os.environ:
|
|
return 1
|
|
return []
|
|
|
|
config['root'] = lintargs['root']
|
|
|
|
files = find_shell_scripts(config, paths)
|
|
|
|
base_command = [binary, '-f', 'json']
|
|
if config.get('excludecodes'):
|
|
base_command.extend(['-e', ','.join(config.get('excludecodes'))])
|
|
|
|
for f in files:
|
|
cmd = list(base_command)
|
|
cmd.extend(['-s', files[f], f])
|
|
run_process(config, cmd)
|
|
return results
|