Initial commit

Author: arxanas

lint381/__init__.py

@@ -0,0 +1,8 @@
+"""Lint source code for EECS 381.
+
+See http://umich.edu/~eecs381/ for the course homepage. The coding standards
+can be found here:
+
+  * C: http://umich.edu/~eecs381/handouts/C_Coding_Standards.pdf
+  * C++: http://umich.edu/~eecs381/handouts/C++_Coding_Standards.pdf
+"""

lint381/__main__.py

@@ -0,0 +1,36 @@
+"""Run the linter on the specified source code files."""
+import click
+
+from .c import linter as c_linter
+
+
+@click.command()
+@click.argument("files", nargs=-1, type=click.File())
+def main(files):
+    """Lint the files specified on the command-line."""
+    for file in files:
+        lines = file.read().splitlines()
+
+        if file.name.endswith(".c"):
+            errors = c_linter.lint(lines)
+        elif file.name.endswith(".cpp"):
+            raise NotImplementedError()
+        else:
+            click.secho("Unknown file type: {}"
+                        .format(file.name),
+                        fg="red")
+
+        for line_num, errors in sorted(errors.items()):
+            # 1-index the line number.
+            line_num = line_num + 1
+
+            for error_message in errors:
+                message = ""
+                message += click.style("{}:{}: "
+                                       .format(file.name, line_num),
+                                       bold=True)
+                message += click.style("error: ",
+                                       fg="red",
+                                       bold=True)
+                message += error_message
+                click.echo(message)

lint381/c.py

@@ -0,0 +1,18 @@
+"""C linters."""
+from .code import match_tokens
+from .linter import Linter
+
+linter = Linter()
+
+
+@linter.register
+def underscore_define(window):
+    """Find #defines that start with underscores."""
+    match = match_tokens(window, "#define <macro>")
+    if not match:
+        return
+
+    macro = match["macro"]
+    if macro.startswith("_"):
+        return ("Macro `{}` should not start with an underscore"
+                .format(macro))

lint381/code.py

@@ -0,0 +1,51 @@
+"""Tools for matching code patterns."""
+
+
+def tokenize(string):
+    """Split a string into tokens.
+
+    Note that tokenizing C++ is really hard. This doesn't even try to be good
+    at it.
+
+    TODO: Tokenize strings and comments correctly.
+
+    :param str string: The string to tokenize. This could be a line or a file.
+    :returns list: A list of tokens, each of which is a string.
+    """
+    return string.strip().split()
+
+
+def match_tokens(window, pattern):
+    """Match a pattern of tokens on the current window.
+
+    :param lint381.linter.Window window: The window onto the source code.
+    :param str pattern: The pattern to match. TODO: Provide example.
+    :returns dict: A dictionary of the matched pattern values, or `None` if
+        there was no match.
+    """
+    search_tokens = pattern.split()
+
+    def ngrams(seq, n):
+        parts = []
+        for i in range(n):
+            parts.append(seq[i:])
+        return zip(*parts)
+
+    def match_local(sequence):
+        variables = {}
+        for variable, token in zip(search_tokens, candidate):
+            # TODO: Might not be able to use < and > because of template
+            # parameters.
+            if variable.startswith("<") and variable.endswith(">"):
+                variable = variable[1:-1]
+                variables[variable] = token
+            else:
+                if variable != token:
+                    return None
+        return variables
+
+    for candidate in ngrams(window.tokens, n=len(search_tokens)):
+        match = match_local(candidate)
+        if match:
+            return match
+    return None

lint381/linter.py

@@ -0,0 +1,61 @@
+"""Linter tools."""
+import collections
+
+from .code import tokenize
+
+
+class Window(collections.namedtuple("Window", ["lines", "line_num"])):
+    """A window onto a segment of the source code.
+
+    :ivar list lines: The list of lines in the file.
+    :ivar int line_num: The line number we're currently looking at.
+    """
+
+    @property
+    def line(self):
+        """The line we're currently looking at."""
+        return self.lines[self.line_num]
+
+    @property
+    def tokens(self):
+        """The tokens in the current line."""
+        return tokenize(self.line)
+
+
+class Linter:
+    """A registry of linters for a specific language."""
+
+    def __init__(self):
+        """Initialize the linter registry to be empty."""
+        self._linters = []
+
+    def register(self, func):
+        """Register the provided function as a linter.
+
+        This should be used as a decorator:
+
+        ```
+        linters = Linter()
+
+        @linters.register
+        def linter():
+            ...
+        ```
+
+        :param function func: The linting function.
+        """
+        self._linters.append(func)
+        return func
+
+    def lint(self, lines):
+        """Find linting errors on the specified lines of source code."""
+        errors = collections.defaultdict(list)
+
+        for line_num, _ in enumerate(lines):
+            window = Window(lines=lines, line_num=line_num)
+            for func in self._linters:
+                error_message = func(window)
+                if error_message:
+                    errors[line_num].append(error_message)
+
+        return errors

requirements-dev.txt

@@ -0,0 +1,7 @@
+flake8==2.5.1
+flake8-import-order==0.6.1
+flake8-pep257==1.0.5
+
+pytest==2.8.5
+pytest-cov==2.2.0
+pytest-pythonpath==0.7

requirements.txt

@@ -0,0 +1 @@
+click==6.2

setup.cfg

@@ -0,0 +1,17 @@
+[coverage:report]
+show_missing = True
+
+[coverage:run]
+branch = True
+source = lint381
+
+[flake8]
+application-import-names = lint381
+import-order-style = google
+
+[pep257]
+ignore = D203
+
+[pytest]
+addopts = --cov
+python_paths = .

setup.py

@@ -0,0 +1,36 @@
+"""Install the `lint381` script."""
+import os
+
+from setuptools import setup
+
+
+def get_requirements(requirements_filename):
+    """Get the list of requirements from a requirements file.
+
+    :param str requirements_filename: The name of the requirements file, such
+        as `requirements.txt`.
+    :returns list: A list of dependencies in the requirements file.
+    """
+    setup_dir = os.path.dirname(os.path.abspath(__file__))
+    requirements_path = os.path.join(setup_dir, requirements_filename)
+    with open(requirements_path) as f:
+        return [i
+                for i in f.read().splitlines()
+                if i
+                if not i.startswith("#")]
+
+setup(
+    name="lint381",
+    version="0.1.0",
+    author="Waleed Khan",
+    author_email="[email protected]",
+    description="C and C++ linter for EECS 381.",
+    url="https://github.com/arxanas/lint381",
+
+    packages=["lint381"],
+    entry_points="""
+    [console_scripts]
+    lint381=lint381.__main__:main
+    """,
+    install_requires=get_requirements("requirements.txt"),
+)

test/test_c.py

@@ -0,0 +1,39 @@
+"""Test the C linters."""
+from lint381.c import linter
+
+
+def assert_has_error(line, error_message):
+    """Assert that the given line of source code has an error.
+
+    :param str line: The line of source code.
+    :param str error_message: The expected error message.
+    """
+    lines = [line]
+    assert linter.lint(lines) == {0: [error_message]}
+
+
+def assert_no_error(line):
+    """Assert that the given line of source code doesn't have an error.
+
+    :param str line: The line of source code.
+    """
+    lines = [line]
+    assert not linter.lint(lines)
+
+
+def test_correct_source_code():
+    """Ensure that correct source code doesn't raise errors."""
+    code = """
+    int main() {
+        return 0
+    }
+    """
+    lines = code.strip().splitlines()
+    assert not linter.lint(lines)
+
+
+def test_macro_underscore():
+    """Ensure that macros don't start with underscores."""
+    assert_has_error("#define __FOO__",
+                     "Macro `__FOO__` should not start with an underscore")
+    assert_no_error("#define BAR")

test/test_linter.py

@@ -0,0 +1,21 @@
+"""Test the linter tools."""
+from lint381.linter import Linter
+
+
+def test_linter():
+    """Ensure that the linter registers and applies all linting functions."""
+    linter = Linter()
+
+    @linter.register
+    def foo(window):
+        if window.line_num == 0:
+            return "foo"
+
+    @linter.register
+    def bar(window):
+        return "bar"
+
+    assert linter.lint(["foo", "bar"]) == {
+        0: ["foo", "bar"],
+        1: ["bar"],
+    }