diff options
Diffstat (limited to 'python/mozlint')
35 files changed, 1553 insertions, 0 deletions
diff --git a/python/mozlint/mozlint/__init__.py b/python/mozlint/mozlint/__init__.py new file mode 100644 index 0000000000..18eaf51125 --- /dev/null +++ b/python/mozlint/mozlint/__init__.py @@ -0,0 +1,7 @@ +# 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/. +# flake8: noqa + +from .roller import LintRoller +from .result import ResultContainer diff --git a/python/mozlint/mozlint/cli.py b/python/mozlint/mozlint/cli.py new file mode 100644 index 0000000000..84c1b6aa4e --- /dev/null +++ b/python/mozlint/mozlint/cli.py @@ -0,0 +1,115 @@ +# 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 print_function, unicode_literals + +import os +import sys +from argparse import ArgumentParser, REMAINDER + + +SEARCH_PATHS = [] + + +class MozlintParser(ArgumentParser): + arguments = [ + [['paths'], + {'nargs': '*', + 'default': None, + 'help': "Paths to file or directories to lint, like " + "'browser/components/loop' or 'mobile/android'. " + "Defaults to the current directory if not given.", + }], + [['-l', '--linter'], + {'dest': 'linters', + 'default': [], + 'action': 'append', + 'help': "Linters to run, e.g 'eslint'. By default all linters " + "are run for all the appropriate files.", + }], + [['-f', '--format'], + {'dest': 'fmt', + 'default': 'stylish', + 'help': "Formatter to use. Defaults to 'stylish'.", + }], + [['-n', '--no-filter'], + {'dest': 'use_filters', + 'default': True, + 'action': 'store_false', + 'help': "Ignore all filtering. This is useful for quickly " + "testing a directory that otherwise wouldn't be run, " + "without needing to modify the config file.", + }], + [['-r', '--rev'], + {'default': None, + 'help': "Lint files touched by the given revision(s). Works with " + "mercurial or git." + }], + [['-w', '--workdir'], + {'default': False, + 'action': 'store_true', + 'help': "Lint files touched by changes in the working directory " + "(i.e haven't been committed yet). Works with mercurial or git.", + }], + [['extra_args'], + {'nargs': REMAINDER, + 'help': "Extra arguments that will be forwarded to the underlying linter.", + }], + ] + + def __init__(self, **kwargs): + ArgumentParser.__init__(self, usage=self.__doc__, **kwargs) + + for cli, args in self.arguments: + self.add_argument(*cli, **args) + + def parse_known_args(self, *args, **kwargs): + # This is here so the eslint mach command doesn't lose 'extra_args' + # when using mach's dispatch functionality. + args, extra = ArgumentParser.parse_known_args(self, *args, **kwargs) + args.extra_args = extra + return args, extra + + +def find_linters(linters=None): + lints = [] + for search_path in SEARCH_PATHS: + if not os.path.isdir(search_path): + continue + + files = os.listdir(search_path) + for f in files: + name, ext = os.path.splitext(f) + if ext != '.lint': + continue + + if linters and name not in linters: + continue + + lints.append(os.path.join(search_path, f)) + return lints + + +def run(paths, linters, fmt, rev, workdir, **lintargs): + from mozlint import LintRoller, formatters + + lint = LintRoller(**lintargs) + lint.read(find_linters(linters)) + + # run all linters + results = lint.roll(paths, rev=rev, workdir=workdir) + + formatter = formatters.get(fmt) + + # Explicitly utf-8 encode the output as some of the formatters make + # use of unicode characters. This will prevent a UnicodeEncodeError + # on environments where utf-8 isn't the default + print(formatter(results).encode('utf-8', 'replace')) + return lint.return_code + + +if __name__ == '__main__': + parser = MozlintParser() + args = vars(parser.parse_args()) + sys.exit(run(**args)) diff --git a/python/mozlint/mozlint/errors.py b/python/mozlint/mozlint/errors.py new file mode 100644 index 0000000000..a899a1974c --- /dev/null +++ b/python/mozlint/mozlint/errors.py @@ -0,0 +1,25 @@ +# 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 os + + +class LintException(Exception): + pass + + +class LinterNotFound(LintException): + def __init__(self, path): + LintException.__init__(self, "Could not find lint file '{}'".format(path)) + + +class LinterParseError(LintException): + def __init__(self, path, message): + LintException.__init__(self, "{}: {}".format(os.path.basename(path), message)) + + +class LintersNotConfigured(LintException): + def __init__(self): + LintException.__init__(self, "No linters registered! Use `LintRoller.read` " + "to register a linter.") diff --git a/python/mozlint/mozlint/formatters/__init__.py b/python/mozlint/mozlint/formatters/__init__.py new file mode 100644 index 0000000000..33aca0446d --- /dev/null +++ b/python/mozlint/mozlint/formatters/__init__.py @@ -0,0 +1,25 @@ +# 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 + +from ..result import ResultEncoder +from .stylish import StylishFormatter +from .treeherder import TreeherderFormatter + + +class JSONFormatter(object): + def __call__(self, results): + return json.dumps(results, cls=ResultEncoder) + + +all_formatters = { + 'json': JSONFormatter, + 'stylish': StylishFormatter, + 'treeherder': TreeherderFormatter, +} + + +def get(name, **fmtargs): + return all_formatters[name](**fmtargs) diff --git a/python/mozlint/mozlint/formatters/stylish.py b/python/mozlint/mozlint/formatters/stylish.py new file mode 100644 index 0000000000..62ddfbeb6a --- /dev/null +++ b/python/mozlint/mozlint/formatters/stylish.py @@ -0,0 +1,122 @@ +# 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 unicode_literals + +from ..result import ResultContainer + +try: + import blessings +except ImportError: + blessings = None + + +class NullTerminal(object): + """Replacement for `blessings.Terminal()` that does no formatting.""" + class NullCallableString(unicode): + """A dummy callable Unicode stolen from blessings""" + def __new__(cls): + new = unicode.__new__(cls, u'') + return new + + def __call__(self, *args): + if len(args) != 1 or isinstance(args[0], int): + return u'' + return args[0] + + def __getattr__(self, attr): + return self.NullCallableString() + + +class StylishFormatter(object): + """Formatter based on the eslint default.""" + + # Colors later on in the list are fallbacks in case the terminal + # doesn't support colors earlier in the list. + # See http://www.calmar.ws/vim/256-xterm-24bit-rgb-color-chart.html + _colors = { + 'grey': [247, 8, 7], + 'red': [1], + 'yellow': [3], + 'brightred': [9, 1], + 'brightyellow': [11, 3], + } + fmt = " {c1}{lineno}{column} {c2}{level}{normal} {message} {c1}{rule}({linter}){normal}" + fmt_summary = "{t.bold}{c}\u2716 {problem} ({error}, {warning}){t.normal}" + + def __init__(self, disable_colors=None): + if disable_colors or not blessings: + self.term = NullTerminal() + else: + self.term = blessings.Terminal() + self.num_colors = self.term.number_of_colors + + def color(self, color): + for num in self._colors[color]: + if num < self.num_colors: + return self.term.color(num) + return '' + + def _reset_max(self): + self.max_lineno = 0 + self.max_column = 0 + self.max_level = 0 + self.max_message = 0 + + def _update_max(self, err): + """Calculates the longest length of each token for spacing.""" + self.max_lineno = max(self.max_lineno, len(str(err.lineno))) + if err.column: + self.max_column = max(self.max_column, len(str(err.column))) + self.max_level = max(self.max_level, len(str(err.level))) + self.max_message = max(self.max_message, len(err.message)) + + def _pluralize(self, s, num): + if num != 1: + s += 's' + return str(num) + ' ' + s + + def __call__(self, result): + message = [] + + num_errors = 0 + num_warnings = 0 + for path, errors in sorted(result.iteritems()): + self._reset_max() + + message.append(self.term.underline(path)) + # Do a first pass to calculate required padding + for err in errors: + assert isinstance(err, ResultContainer) + self._update_max(err) + if err.level == 'error': + num_errors += 1 + else: + num_warnings += 1 + + for err in errors: + message.append(self.fmt.format( + normal=self.term.normal, + c1=self.color('grey'), + c2=self.color('red') if err.level == 'error' else self.color('yellow'), + lineno=str(err.lineno).rjust(self.max_lineno), + column=(":" + str(err.column).ljust(self.max_column)) if err.column else "", + level=err.level.ljust(self.max_level), + message=err.message.ljust(self.max_message), + rule='{} '.format(err.rule) if err.rule else '', + linter=err.linter.lower(), + )) + + message.append('') # newline + + # Print a summary + message.append(self.fmt_summary.format( + t=self.term, + c=self.color('brightred') if num_errors else self.color('brightyellow'), + problem=self._pluralize('problem', num_errors + num_warnings), + error=self._pluralize('error', num_errors), + warning=self._pluralize('warning', num_warnings), + )) + + return '\n'.join(message) diff --git a/python/mozlint/mozlint/formatters/treeherder.py b/python/mozlint/mozlint/formatters/treeherder.py new file mode 100644 index 0000000000..7c27011cf4 --- /dev/null +++ b/python/mozlint/mozlint/formatters/treeherder.py @@ -0,0 +1,31 @@ +# 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 unicode_literals + +from ..result import ResultContainer + + +class TreeherderFormatter(object): + """Formatter for treeherder friendly output. + + This formatter looks ugly, but prints output such that + treeherder is able to highlight the errors and warnings. + This is a stop-gap until bug 1276486 is fixed. + """ + fmt = "TEST-UNEXPECTED-{level} | {path}:{lineno}{column} | {message} ({rule})" + + def __call__(self, result): + message = [] + for path, errors in sorted(result.iteritems()): + for err in errors: + assert isinstance(err, ResultContainer) + + d = {s: getattr(err, s) for s in err.__slots__} + d["column"] = ":%s" % d["column"] if d["column"] else "" + d['level'] = d['level'].upper() + d['rule'] = d['rule'] or d['linter'] + message.append(self.fmt.format(**d)) + + return "\n".join(message) diff --git a/python/mozlint/mozlint/parser.py b/python/mozlint/mozlint/parser.py new file mode 100644 index 0000000000..f350d0de75 --- /dev/null +++ b/python/mozlint/mozlint/parser.py @@ -0,0 +1,85 @@ +# 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 imp +import os +import sys +import uuid + +from .types import supported_types +from .errors import LinterNotFound, LinterParseError + + +class Parser(object): + """Reads and validates `.lint` files.""" + required_attributes = ( + 'name', + 'description', + 'type', + 'payload', + ) + + def __call__(self, path): + return self.parse(path) + + def _load_linter(self, path): + # Ensure parent module is present otherwise we'll (likely) get + # an error due to unknown parent. + parent_module = 'mozlint.linters' + if parent_module not in sys.modules: + mod = imp.new_module(parent_module) + sys.modules[parent_module] = mod + + write_bytecode = sys.dont_write_bytecode + sys.dont_write_bytecode = True + + module_name = '{}.{}'.format(parent_module, uuid.uuid1().get_hex()) + imp.load_source(module_name, path) + + sys.dont_write_bytecode = write_bytecode + + mod = sys.modules[module_name] + + if not hasattr(mod, 'LINTER'): + raise LinterParseError(path, "No LINTER definition found!") + + definition = mod.LINTER + definition['path'] = path + return definition + + def _validate(self, linter): + missing_attrs = [] + for attr in self.required_attributes: + if attr not in linter: + missing_attrs.append(attr) + + if missing_attrs: + raise LinterParseError(linter['path'], "Missing required attribute(s): " + "{}".format(','.join(missing_attrs))) + + if linter['type'] not in supported_types: + raise LinterParseError(linter['path'], "Invalid type '{}'".format(linter['type'])) + + for attr in ('include', 'exclude'): + if attr in linter and (not isinstance(linter[attr], list) or + not all(isinstance(a, basestring) for a in linter[attr])): + raise LinterParseError(linter['path'], "The {} directive must be a " + "list of strings!".format(attr)) + + def parse(self, path): + """Read a linter and return its LINTER definition. + + :param path: Path to the linter. + :returns: Linter definition (dict) + :raises: LinterNotFound, LinterParseError + """ + if not os.path.isfile(path): + raise LinterNotFound(path) + + if not path.endswith('.lint'): + raise LinterParseError(path, "Invalid filename, linters must end with '.lint'!") + + linter = self._load_linter(path) + self._validate(linter) + return linter diff --git a/python/mozlint/mozlint/pathutils.py b/python/mozlint/mozlint/pathutils.py new file mode 100644 index 0000000000..532904dca7 --- /dev/null +++ b/python/mozlint/mozlint/pathutils.py @@ -0,0 +1,156 @@ +# 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 unicode_literals + +import os + +from mozpack import path as mozpath +from mozpack.files import FileFinder + + +class FilterPath(object): + """Helper class to make comparing and matching file paths easier.""" + def __init__(self, path, exclude=None): + self.path = os.path.normpath(path) + self._finder = None + self.exclude = exclude + + @property + def finder(self): + if self._finder: + return self._finder + self._finder = FileFinder( + self.path, find_executables=False, ignore=self.exclude) + return self._finder + + @property + def ext(self): + return os.path.splitext(self.path)[1] + + @property + def exists(self): + return os.path.exists(self.path) + + @property + def isfile(self): + return os.path.isfile(self.path) + + @property + def isdir(self): + return os.path.isdir(self.path) + + def join(self, *args): + return FilterPath(os.path.join(self, *args)) + + def match(self, patterns): + return any(mozpath.match(self.path, pattern.path) for pattern in patterns) + + def contains(self, other): + """Return True if other is a subdirectory of self or equals self.""" + if isinstance(other, FilterPath): + other = other.path + a = os.path.abspath(self.path) + b = os.path.normpath(os.path.abspath(other)) + + if b.startswith(a): + return True + return False + + def __repr__(self): + return repr(self.path) + + +def filterpaths(paths, linter, **lintargs): + """Filters a list of paths. + + Given a list of paths, and a linter definition plus extra + arguments, return the set of paths that should be linted. + + :param paths: A starting list of paths to possibly lint. + :param linter: A linter definition. + :param lintargs: Extra arguments passed to the linter. + :returns: A list of file paths to lint. + """ + include = linter.get('include', []) + exclude = lintargs.get('exclude', []) + exclude.extend(linter.get('exclude', [])) + root = lintargs['root'] + + if not lintargs.get('use_filters', True) or (not include and not exclude): + return paths + + def normalize(path): + if not os.path.isabs(path): + path = os.path.join(root, path) + return FilterPath(path) + + include = map(normalize, include) + exclude = map(normalize, exclude) + + # Paths with and without globs will be handled separately, + # pull them apart now. + includepaths = [p for p in include if p.exists] + excludepaths = [p for p in exclude if p.exists] + + includeglobs = [p for p in include if not p.exists] + excludeglobs = [p for p in exclude if not p.exists] + + extensions = linter.get('extensions') + keep = set() + discard = set() + for path in map(FilterPath, paths): + # Exclude bad file extensions + if extensions and path.isfile and path.ext not in extensions: + continue + + if path.match(excludeglobs): + continue + + # First handle include/exclude directives + # that exist (i.e don't have globs) + for inc in includepaths: + # Only excludes that are subdirectories of the include + # path matter. + excs = [e for e in excludepaths if inc.contains(e)] + + if path.contains(inc): + # If specified path is an ancestor of include path, + # then lint the include path. + keep.add(inc) + + # We can't apply these exclude paths without explicitly + # including every sibling file. Rather than do that, + # just return them and hope the underlying linter will + # deal with them. + discard.update(excs) + + elif inc.contains(path): + # If the include path is an ancestor of the specified + # path, then add the specified path only if there are + # no exclude paths in-between them. + if not any(e.contains(path) for e in excs): + keep.add(path) + + # Next handle include/exclude directives that + # contain globs. + if path.isfile: + # If the specified path is a file it must be both + # matched by an include directive and not matched + # by an exclude directive. + if not path.match(includeglobs): + continue + + keep.add(path) + elif path.isdir: + # If the specified path is a directory, use a + # FileFinder to resolve all relevant globs. + path.exclude = [e.path for e in excludeglobs] + for pattern in includeglobs: + for p, f in path.finder.find(pattern.path): + keep.add(path.join(p)) + + # Only pass paths we couldn't exclude here to the underlying linter + lintargs['exclude'] = [f.path for f in discard] + return [f.path for f in keep] diff --git a/python/mozlint/mozlint/result.py b/python/mozlint/mozlint/result.py new file mode 100644 index 0000000000..0c56f1d761 --- /dev/null +++ b/python/mozlint/mozlint/result.py @@ -0,0 +1,88 @@ +# 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 json import dumps, JSONEncoder + + +class ResultContainer(object): + """Represents a single lint error and its related metadata. + + :param linter: name of the linter that flagged this error + :param path: path to the file containing the error + :param message: text describing the error + :param lineno: line number that contains the error + :param column: column containing the error + :param level: severity of the error, either 'warning' or 'error' (default 'error') + :param hint: suggestion for fixing the error (optional) + :param source: source code context of the error (optional) + :param rule: name of the rule that was violated (optional) + :param lineoffset: denotes an error spans multiple lines, of the form + (<lineno offset>, <num lines>) (optional) + """ + + __slots__ = ( + 'linter', + 'path', + 'message', + 'lineno', + 'column', + 'hint', + 'source', + 'level', + 'rule', + 'lineoffset', + ) + + def __init__(self, linter, path, message, lineno, column=None, hint=None, + source=None, level=None, rule=None, lineoffset=None): + self.path = path + self.message = message + self.lineno = lineno + self.column = column + self.hint = hint + self.source = source + self.level = level or 'error' + self.linter = linter + self.rule = rule + self.lineoffset = lineoffset + + def __repr__(self): + s = dumps(self, cls=ResultEncoder, indent=2) + return "ResultContainer({})".format(s) + + +class ResultEncoder(JSONEncoder): + """Class for encoding :class:`~result.ResultContainer`s to json. + + Usage: + + json.dumps(results, cls=ResultEncoder) + """ + def default(self, o): + if isinstance(o, ResultContainer): + return {a: getattr(o, a) for a in o.__slots__} + return JSONEncoder.default(self, o) + + +def from_linter(lintobj, **kwargs): + """Create a :class:`~result.ResultContainer` from a LINTER definition. + + Convenience method that pulls defaults from a LINTER + definition and forwards them. + + :param lintobj: LINTER obj as defined in a .lint file + :param kwargs: same as :class:`~result.ResultContainer` + :returns: :class:`~result.ResultContainer` object + """ + attrs = {} + for attr in ResultContainer.__slots__: + attrs[attr] = kwargs.get(attr, lintobj.get(attr)) + + if not attrs['linter']: + attrs['linter'] = lintobj.get('name') + + if not attrs['message']: + attrs['message'] = lintobj.get('description') + + return ResultContainer(**attrs) diff --git a/python/mozlint/mozlint/roller.py b/python/mozlint/mozlint/roller.py new file mode 100644 index 0000000000..2d1608dd87 --- /dev/null +++ b/python/mozlint/mozlint/roller.py @@ -0,0 +1,154 @@ +# 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 unicode_literals + +import os +import signal +import sys +import traceback +from collections import defaultdict +from Queue import Empty +from multiprocessing import ( + Manager, + Pool, + cpu_count, +) + +from .errors import LintersNotConfigured +from .types import supported_types +from .parser import Parser +from .vcs import VCSFiles + + +def _run_linters(queue, paths, **lintargs): + parse = Parser() + results = defaultdict(list) + return_code = 0 + + while True: + try: + # The astute reader may wonder what is preventing the worker from + # grabbing the next linter from the queue after a SIGINT. Because + # this is a Manager.Queue(), it is itself in a child process which + # also received SIGINT. By the time the worker gets back here, the + # Queue is dead and IOError is raised. + linter_path = queue.get(False) + except (Empty, IOError): + return results, return_code + + # Ideally we would pass the entire LINTER definition as an argument + # to the worker instead of re-parsing it. But passing a function from + # a dynamically created module (with imp) does not seem to be possible + # with multiprocessing on Windows. + linter = parse(linter_path) + func = supported_types[linter['type']] + res = func(paths, linter, **lintargs) or [] + + if not isinstance(res, (list, tuple)): + if res: + return_code = 1 + continue + + for r in res: + results[r.path].append(r) + + +def _run_worker(*args, **lintargs): + try: + return _run_linters(*args, **lintargs) + except Exception: + # multiprocessing seems to munge worker exceptions, print + # it here so it isn't lost. + traceback.print_exc() + raise + finally: + sys.stdout.flush() + + +class LintRoller(object): + """Registers and runs linters. + + :param root: Path to which relative paths will be joined. If + unspecified, root will either be determined from + version control or cwd. + :param lintargs: Arguments to pass to the underlying linter(s). + """ + + def __init__(self, root=None, **lintargs): + self.parse = Parser() + self.vcs = VCSFiles() + + self.linters = [] + self.lintargs = lintargs + self.lintargs['root'] = root or self.vcs.root or os.getcwd() + + self.return_code = None + + def read(self, paths): + """Parse one or more linters and add them to the registry. + + :param paths: A path or iterable of paths to linter definitions. + """ + if isinstance(paths, basestring): + paths = (paths,) + + for path in paths: + self.linters.append(self.parse(path)) + + def roll(self, paths=None, rev=None, workdir=None, num_procs=None): + """Run all of the registered linters against the specified file paths. + + :param paths: An iterable of files and/or directories to lint. + :param rev: Lint all files touched by the specified revision. + :param workdir: Lint all files touched in the working directory. + :param num_procs: The number of processes to use. Default: cpu count + :return: A dictionary with file names as the key, and a list of + :class:`~result.ResultContainer`s as the value. + """ + paths = paths or [] + if isinstance(paths, basestring): + paths = [paths] + + if not self.linters: + raise LintersNotConfigured + + # Calculate files from VCS + if rev: + paths.extend(self.vcs.by_rev(rev)) + if workdir: + paths.extend(self.vcs.by_workdir()) + paths = paths or ['.'] + paths = map(os.path.abspath, paths) + + # Set up multiprocessing + m = Manager() + queue = m.Queue() + + for linter in self.linters: + queue.put(linter['path']) + + num_procs = num_procs or cpu_count() + num_procs = min(num_procs, len(self.linters)) + pool = Pool(num_procs) + + all_results = defaultdict(list) + workers = [] + for i in range(num_procs): + workers.append( + pool.apply_async(_run_worker, args=(queue, paths), kwds=self.lintargs)) + pool.close() + + # ignore SIGINT in parent so we can still get partial results + # from child processes. These should shutdown quickly anyway. + signal.signal(signal.SIGINT, signal.SIG_IGN) + self.return_code = 0 + for worker in workers: + # parent process blocks on worker.get() + results, return_code = worker.get() + if results or return_code: + self.return_code = 1 + for k, v in results.iteritems(): + all_results[k].extend(v) + return all_results diff --git a/python/mozlint/mozlint/types.py b/python/mozlint/mozlint/types.py new file mode 100644 index 0000000000..2f49ae2bf2 --- /dev/null +++ b/python/mozlint/mozlint/types.py @@ -0,0 +1,142 @@ +# 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 unicode_literals + +import re +import sys +from abc import ABCMeta, abstractmethod + +from mozlog import get_default_logger, commandline, structuredlog +from mozlog.reader import LogHandler + +from . import result +from .pathutils import filterpaths + + +class BaseType(object): + """Abstract base class for all types of linters.""" + __metaclass__ = ABCMeta + batch = False + + def __call__(self, paths, linter, **lintargs): + """Run `linter` against `paths` with `lintargs`. + + :param paths: Paths to lint. Can be a file or directory. + :param linter: Linter definition paths are being linted against. + :param lintargs: External arguments to the linter not defined in + the definition, but passed in by a consumer. + :returns: A list of :class:`~result.ResultContainer` objects. + """ + paths = filterpaths(paths, linter, **lintargs) + if not paths: + print("{}: no files to lint in specified paths".format(linter['name'])) + return + + if self.batch: + return self._lint(paths, linter, **lintargs) + + errors = [] + try: + for p in paths: + result = self._lint(p, linter, **lintargs) + if result: + errors.extend(result) + except KeyboardInterrupt: + pass + return errors + + @abstractmethod + def _lint(self, path): + pass + + +class LineType(BaseType): + """Abstract base class for linter types that check each line individually. + + Subclasses of this linter type will read each file and check the provided + payload against each line one by one. + """ + __metaclass__ = ABCMeta + + @abstractmethod + def condition(payload, line): + pass + + def _lint(self, path, linter, **lintargs): + payload = linter['payload'] + + with open(path, 'r') as fh: + lines = fh.readlines() + + errors = [] + for i, line in enumerate(lines): + if self.condition(payload, line): + errors.append(result.from_linter(linter, path=path, lineno=i+1)) + + return errors + + +class StringType(LineType): + """Linter type that checks whether a substring is found.""" + + def condition(self, payload, line): + return payload in line + + +class RegexType(LineType): + """Linter type that checks whether a regex match is found.""" + + def condition(self, payload, line): + return re.search(payload, line) + + +class ExternalType(BaseType): + """Linter type that runs an external function. + + The function is responsible for properly formatting the results + into a list of :class:`~result.ResultContainer` objects. + """ + batch = True + + def _lint(self, files, linter, **lintargs): + payload = linter['payload'] + return payload(files, **lintargs) + + +class LintHandler(LogHandler): + def __init__(self, linter): + self.linter = linter + self.results = [] + + def lint(self, data): + self.results.append(result.from_linter(self.linter, **data)) + + +class StructuredLogType(BaseType): + batch = True + + def _lint(self, files, linter, **lintargs): + payload = linter["payload"] + handler = LintHandler(linter) + logger = linter.get("logger") + if logger is None: + logger = get_default_logger() + if logger is None: + logger = structuredlog.StructuredLogger(linter["name"]) + commandline.setup_logging(logger, {}, {"mach": sys.stdout}) + logger.add_handler(handler) + try: + payload(files, logger, **lintargs) + except KeyboardInterrupt: + pass + return handler.results + +supported_types = { + 'string': StringType(), + 'regex': RegexType(), + 'external': ExternalType(), + 'structured_log': StructuredLogType() +} +"""Mapping of type string to an associated instance.""" diff --git a/python/mozlint/mozlint/vcs.py b/python/mozlint/mozlint/vcs.py new file mode 100644 index 0000000000..6a118f2e6a --- /dev/null +++ b/python/mozlint/mozlint/vcs.py @@ -0,0 +1,62 @@ +# 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 os +import subprocess + + +class VCSFiles(object): + def __init__(self): + self._root = None + self._vcs = None + + @property + def root(self): + if self._root: + return self._root + + # First check if we're in an hg repo, if not try git + commands = ( + ['hg', 'root'], + ['git', 'rev-parse', '--show-toplevel'], + ) + + for cmd in commands: + proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE) + output = proc.communicate()[0].strip() + + if proc.returncode == 0: + self._vcs = cmd[0] + self._root = output + return self._root + + @property + def vcs(self): + return self._vcs or (self.root and self._vcs) + + @property + def is_hg(self): + return self.vcs == 'hg' + + @property + def is_git(self): + return self.vcs == 'git' + + def _run(self, cmd): + files = subprocess.check_output(cmd).split() + return [os.path.join(self.root, f) for f in files] + + def by_rev(self, rev): + if self.is_hg: + return self._run(['hg', 'log', '--template', '{files % "\\n{file}"}', '-r', rev]) + elif self.is_git: + return self._run(['git', 'diff', '--name-only', rev]) + return [] + + def by_workdir(self): + if self.is_hg: + return self._run(['hg', 'status', '-amn']) + elif self.is_git: + return self._run(['git', 'diff', '--name-only']) + return [] diff --git a/python/mozlint/setup.py b/python/mozlint/setup.py new file mode 100644 index 0000000000..62d25c38b3 --- /dev/null +++ b/python/mozlint/setup.py @@ -0,0 +1,26 @@ +# 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 setuptools import setup + +VERSION = 0.1 +DEPS = ["mozlog>=3.4"] + +setup( + name='mozlint', + description='Framework for registering and running micro lints', + license='MPL 2.0', + author='Andrew Halberstadt', + author_email='ahalberstadt@mozilla.com', + url='', + packages=['mozlint'], + version=VERSION, + classifiers=[ + 'Environment :: Console', + 'Development Status :: 3 - Alpha', + 'License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)', + 'Natural Language :: English', + ], + install_requires=DEPS, +) diff --git a/python/mozlint/test/__init__.py b/python/mozlint/test/__init__.py new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/python/mozlint/test/__init__.py diff --git a/python/mozlint/test/conftest.py b/python/mozlint/test/conftest.py new file mode 100644 index 0000000000..e171798b01 --- /dev/null +++ b/python/mozlint/test/conftest.py @@ -0,0 +1,42 @@ +# 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 os + +import pytest + +from mozlint import LintRoller + + +here = os.path.abspath(os.path.dirname(__file__)) + + +@pytest.fixture +def lint(request): + lintargs = getattr(request.module, 'lintargs', {}) + return LintRoller(root=here, **lintargs) + + +@pytest.fixture(scope='session') +def filedir(): + return os.path.join(here, 'files') + + +@pytest.fixture(scope='module') +def files(filedir, request): + suffix_filter = getattr(request.module, 'files', ['']) + return [os.path.join(filedir, p) for p in os.listdir(filedir) + if any(p.endswith(suffix) for suffix in suffix_filter)] + + +@pytest.fixture(scope='session') +def lintdir(): + return os.path.join(here, 'linters') + + +@pytest.fixture(scope='module') +def linters(lintdir, request): + suffix_filter = getattr(request.module, 'linters', ['.lint']) + return [os.path.join(lintdir, p) for p in os.listdir(lintdir) + if any(p.endswith(suffix) for suffix in suffix_filter)] diff --git a/python/mozlint/test/files/foobar.js b/python/mozlint/test/files/foobar.js new file mode 100644 index 0000000000..d9754d0a2f --- /dev/null +++ b/python/mozlint/test/files/foobar.js @@ -0,0 +1,2 @@ +// Oh no.. we called this variable foobar, bad! +var foobar = "a string"; diff --git a/python/mozlint/test/files/foobar.py b/python/mozlint/test/files/foobar.py new file mode 100644 index 0000000000..e1677b3fd2 --- /dev/null +++ b/python/mozlint/test/files/foobar.py @@ -0,0 +1,2 @@ +# Oh no.. we called this variable foobar, bad! +foobar = "a string" diff --git a/python/mozlint/test/files/no_foobar.js b/python/mozlint/test/files/no_foobar.js new file mode 100644 index 0000000000..6b95d646c0 --- /dev/null +++ b/python/mozlint/test/files/no_foobar.js @@ -0,0 +1,2 @@ +// What a relief +var properlyNamed = "a string"; diff --git a/python/mozlint/test/linters/badreturncode.lint b/python/mozlint/test/linters/badreturncode.lint new file mode 100644 index 0000000000..398d51a553 --- /dev/null +++ b/python/mozlint/test/linters/badreturncode.lint @@ -0,0 +1,21 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=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/. + + +def lint(files, **lintargs): + return 1 + + +LINTER = { + 'name': "BadReturnCodeLinter", + 'description': "Returns an error code no matter what", + 'include': [ + 'files', + ], + 'type': 'external', + 'extensions': ['.js', '.jsm'], + 'payload': lint, +} diff --git a/python/mozlint/test/linters/explicit_path.lint b/python/mozlint/test/linters/explicit_path.lint new file mode 100644 index 0000000000..8c1a88a1fb --- /dev/null +++ b/python/mozlint/test/linters/explicit_path.lint @@ -0,0 +1,13 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: + +LINTER = { + 'name': "ExplicitPathLinter", + 'description': "Only lint a specific file name", + 'rule': 'no-foobar', + 'include': [ + 'no_foobar.js', + ], + 'type': 'string', + 'payload': 'foobar', +} diff --git a/python/mozlint/test/linters/external.lint b/python/mozlint/test/linters/external.lint new file mode 100644 index 0000000000..dcae419dbf --- /dev/null +++ b/python/mozlint/test/linters/external.lint @@ -0,0 +1,30 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=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 mozlint import result + + +def lint(files, **lintargs): + results = [] + for path in files: + with open(path, 'r') as fh: + for i, line in enumerate(fh.readlines()): + if 'foobar' in line: + results.append(result.from_linter( + LINTER, path=path, lineno=i+1, column=1, rule="no-foobar")) + return results + + +LINTER = { + 'name': "ExternalLinter", + 'description': "It's bad to have the string foobar in js files.", + 'include': [ + 'files', + ], + 'type': 'external', + 'extensions': ['.js', '.jsm'], + 'payload': lint, +} diff --git a/python/mozlint/test/linters/invalid_exclude.lint b/python/mozlint/test/linters/invalid_exclude.lint new file mode 100644 index 0000000000..be6d0045cf --- /dev/null +++ b/python/mozlint/test/linters/invalid_exclude.lint @@ -0,0 +1,10 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: + +LINTER = { + 'name': "BadExcludeLinter", + 'description': "Has an invalid exclude directive.", + 'exclude': [0, 1], # should be a list of strings + 'type': 'string', + 'payload': 'foobar', +} diff --git a/python/mozlint/test/linters/invalid_extension.lnt b/python/mozlint/test/linters/invalid_extension.lnt new file mode 100644 index 0000000000..3cb8153a00 --- /dev/null +++ b/python/mozlint/test/linters/invalid_extension.lnt @@ -0,0 +1,9 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: + +LINTER = { + 'name': "BadExtensionLinter", + 'description': "Has an invalid file extension.", + 'type': 'string', + 'payload': 'foobar', +} diff --git a/python/mozlint/test/linters/invalid_include.lint b/python/mozlint/test/linters/invalid_include.lint new file mode 100644 index 0000000000..343d5e1950 --- /dev/null +++ b/python/mozlint/test/linters/invalid_include.lint @@ -0,0 +1,10 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: + +LINTER = { + 'name': "BadIncludeLinter", + 'description': "Has an invalid include directive.", + 'include': 'should be a list', + 'type': 'string', + 'payload': 'foobar', +} diff --git a/python/mozlint/test/linters/invalid_type.lint b/python/mozlint/test/linters/invalid_type.lint new file mode 100644 index 0000000000..9e5926c5a5 --- /dev/null +++ b/python/mozlint/test/linters/invalid_type.lint @@ -0,0 +1,9 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: + +LINTER = { + 'name': "BadTypeLinter", + 'description': "Has an invalid type.", + 'type': 'invalid', + 'payload': 'foobar', +} diff --git a/python/mozlint/test/linters/missing_attrs.lint b/python/mozlint/test/linters/missing_attrs.lint new file mode 100644 index 0000000000..380512b640 --- /dev/null +++ b/python/mozlint/test/linters/missing_attrs.lint @@ -0,0 +1,7 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: + +LINTER = { + 'name': "MissingAttrsLinter", + 'description': "Missing type and payload", +} diff --git a/python/mozlint/test/linters/missing_definition.lint b/python/mozlint/test/linters/missing_definition.lint new file mode 100644 index 0000000000..a84b305d2a --- /dev/null +++ b/python/mozlint/test/linters/missing_definition.lint @@ -0,0 +1,4 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: + +# No LINTER variable diff --git a/python/mozlint/test/linters/raises.lint b/python/mozlint/test/linters/raises.lint new file mode 100644 index 0000000000..f17e187337 --- /dev/null +++ b/python/mozlint/test/linters/raises.lint @@ -0,0 +1,19 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=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 mozlint.errors import LintException + + +def lint(files, **lintargs): + raise LintException("Oh no something bad happened!") + + +LINTER = { + 'name': "RaisesLinter", + 'description': "Raises an exception", + 'type': 'external', + 'payload': lint, +} diff --git a/python/mozlint/test/linters/regex.lint b/python/mozlint/test/linters/regex.lint new file mode 100644 index 0000000000..439cadf366 --- /dev/null +++ b/python/mozlint/test/linters/regex.lint @@ -0,0 +1,15 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: + +LINTER = { + 'name': "RegexLinter", + 'description': "Make sure the string 'foobar' never appears " + "in a js variable file because it is bad.", + 'rule': 'no-foobar', + 'include': [ + '**/*.js', + '**/*.jsm', + ], + 'type': 'regex', + 'payload': 'foobar', +} diff --git a/python/mozlint/test/linters/string.lint b/python/mozlint/test/linters/string.lint new file mode 100644 index 0000000000..46bf0e8b86 --- /dev/null +++ b/python/mozlint/test/linters/string.lint @@ -0,0 +1,15 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: + +LINTER = { + 'name': "StringLinter", + 'description': "Make sure the string 'foobar' never appears " + "in browser js files because it is bad.", + 'rule': 'no-foobar', + 'include': [ + '**/*.js', + '**/*.jsm', + ], + 'type': 'string', + 'payload': 'foobar', +} diff --git a/python/mozlint/test/linters/structured.lint b/python/mozlint/test/linters/structured.lint new file mode 100644 index 0000000000..e8be8d7b3a --- /dev/null +++ b/python/mozlint/test/linters/structured.lint @@ -0,0 +1,28 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=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/. + + +def lint(files, logger, **kwargs): + for path in files: + with open(path, 'r') as fh: + for i, line in enumerate(fh.readlines()): + if 'foobar' in line: + logger.lint_error(path=path, + lineno=i+1, + column=1, + rule="no-foobar") + + +LINTER = { + 'name': "StructuredLinter", + 'description': "It's bad to have the string foobar in js files.", + 'include': [ + 'files', + ], + 'type': 'structured_log', + 'extensions': ['.js', '.jsm'], + 'payload': lint, +} diff --git a/python/mozlint/test/test_formatters.py b/python/mozlint/test/test_formatters.py new file mode 100644 index 0000000000..b9e6512b24 --- /dev/null +++ b/python/mozlint/test/test_formatters.py @@ -0,0 +1,90 @@ +# 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 unicode_literals + +import json +import sys +from collections import defaultdict + +import pytest + +from mozlint import ResultContainer +from mozlint import formatters + + +@pytest.fixture +def results(scope='module'): + containers = ( + ResultContainer( + linter='foo', + path='a/b/c.txt', + message="oh no foo", + lineno=1, + ), + ResultContainer( + linter='bar', + path='d/e/f.txt', + message="oh no bar", + hint="try baz instead", + level='warning', + lineno=4, + column=2, + rule="bar-not-allowed", + ), + ResultContainer( + linter='baz', + path='a/b/c.txt', + message="oh no baz", + lineno=4, + source="if baz:", + ), + ) + results = defaultdict(list) + for c in containers: + results[c.path].append(c) + return results + + +def test_stylish_formatter(results): + expected = """ +a/b/c.txt + 1 error oh no foo (foo) + 4 error oh no baz (baz) + +d/e/f.txt + 4:2 warning oh no bar bar-not-allowed (bar) + +\u2716 3 problems (2 errors, 1 warning) +""".strip() + + fmt = formatters.get('stylish', disable_colors=True) + assert expected == fmt(results) + + +def test_treeherder_formatter(results): + expected = """ +TEST-UNEXPECTED-ERROR | a/b/c.txt:1 | oh no foo (foo) +TEST-UNEXPECTED-ERROR | a/b/c.txt:4 | oh no baz (baz) +TEST-UNEXPECTED-WARNING | d/e/f.txt:4:2 | oh no bar (bar-not-allowed) +""".strip() + + fmt = formatters.get('treeherder') + assert expected == fmt(results) + + +def test_json_formatter(results): + fmt = formatters.get('json') + formatted = json.loads(fmt(results)) + + assert set(formatted.keys()) == set(results.keys()) + + slots = ResultContainer.__slots__ + for errors in formatted.values(): + for err in errors: + assert all(s in err for s in slots) + + +if __name__ == '__main__': + sys.exit(pytest.main(['--verbose', __file__])) diff --git a/python/mozlint/test/test_parser.py b/python/mozlint/test/test_parser.py new file mode 100644 index 0000000000..e18e7a5a92 --- /dev/null +++ b/python/mozlint/test/test_parser.py @@ -0,0 +1,55 @@ +# 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 os +import sys + +import pytest + +from mozlint.parser import Parser +from mozlint.errors import ( + LinterNotFound, + LinterParseError, +) + + +@pytest.fixture(scope='module') +def parse(lintdir): + parser = Parser() + + def _parse(name): + path = os.path.join(lintdir, name) + return parser(path) + return _parse + + +def test_parse_valid_linter(parse): + lintobj = parse('string.lint') + assert isinstance(lintobj, dict) + assert 'name' in lintobj + assert 'description' in lintobj + assert 'type' in lintobj + assert 'payload' in lintobj + + +@pytest.mark.parametrize('linter', [ + 'invalid_type.lint', + 'invalid_extension.lnt', + 'invalid_include.lint', + 'invalid_exclude.lint', + 'missing_attrs.lint', + 'missing_definition.lint', +]) +def test_parse_invalid_linter(parse, linter): + with pytest.raises(LinterParseError): + parse(linter) + + +def test_parse_non_existent_linter(parse): + with pytest.raises(LinterNotFound): + parse('missing_file.lint') + + +if __name__ == '__main__': + sys.exit(pytest.main(['--verbose', __file__])) diff --git a/python/mozlint/test/test_roller.py b/python/mozlint/test/test_roller.py new file mode 100644 index 0000000000..b4b82c346c --- /dev/null +++ b/python/mozlint/test/test_roller.py @@ -0,0 +1,82 @@ +# 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 os +import sys + +import pytest + +from mozlint import ResultContainer +from mozlint.errors import LintersNotConfigured, LintException + + +here = os.path.abspath(os.path.dirname(__file__)) + + +linters = ('string.lint', 'regex.lint', 'external.lint') + + +def test_roll_no_linters_configured(lint, files): + with pytest.raises(LintersNotConfigured): + lint.roll(files) + + +def test_roll_successful(lint, linters, files): + lint.read(linters) + + result = lint.roll(files) + assert len(result) == 1 + assert lint.return_code == 1 + + path = result.keys()[0] + assert os.path.basename(path) == 'foobar.js' + + errors = result[path] + assert isinstance(errors, list) + assert len(errors) == 6 + + container = errors[0] + assert isinstance(container, ResultContainer) + assert container.rule == 'no-foobar' + + +def test_roll_catch_exception(lint, lintdir, files): + lint.read(os.path.join(lintdir, 'raises.lint')) + + # suppress printed traceback from test output + old_stderr = sys.stderr + sys.stderr = open(os.devnull, 'w') + with pytest.raises(LintException): + lint.roll(files) + sys.stderr = old_stderr + + +def test_roll_with_excluded_path(lint, linters, files): + lint.lintargs.update({'exclude': ['**/foobar.js']}) + + lint.read(linters) + result = lint.roll(files) + + assert len(result) == 0 + assert lint.return_code == 0 + + +def test_roll_with_invalid_extension(lint, lintdir, filedir): + lint.read(os.path.join(lintdir, 'external.lint')) + result = lint.roll(os.path.join(filedir, 'foobar.py')) + assert len(result) == 0 + assert lint.return_code == 0 + + +def test_roll_with_failure_code(lint, lintdir, files): + lint.read(os.path.join(lintdir, 'badreturncode.lint')) + + assert lint.return_code is None + result = lint.roll(files) + assert len(result) == 0 + assert lint.return_code == 1 + + +if __name__ == '__main__': + sys.exit(pytest.main(['--verbose', __file__])) diff --git a/python/mozlint/test/test_types.py b/python/mozlint/test/test_types.py new file mode 100644 index 0000000000..ee0ea9b638 --- /dev/null +++ b/python/mozlint/test/test_types.py @@ -0,0 +1,50 @@ +# 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 os +import sys + +import pytest + +from mozlint.result import ResultContainer + + +@pytest.fixture +def path(filedir): + def _path(name): + return os.path.join(filedir, name) + return _path + + +@pytest.fixture(params=['string.lint', 'regex.lint', 'external.lint', 'structured.lint']) +def linter(lintdir, request): + return os.path.join(lintdir, request.param) + + +def test_linter_types(lint, linter, files, path): + lint.read(linter) + result = lint.roll(files) + assert isinstance(result, dict) + assert path('foobar.js') in result + assert path('no_foobar.js') not in result + + result = result[path('foobar.js')][0] + assert isinstance(result, ResultContainer) + + name = os.path.basename(linter).split('.')[0] + assert result.linter.lower().startswith(name) + + +def test_no_filter(lint, lintdir, files): + lint.read(os.path.join(lintdir, 'explicit_path.lint')) + result = lint.roll(files) + assert len(result) == 0 + + lint.lintargs['use_filters'] = False + result = lint.roll(files) + assert len(result) == 2 + + +if __name__ == '__main__': + sys.exit(pytest.main(['--verbose', __file__])) |