Rule disabler

README.md

@@ -44,8 +44,8 @@ Check that code parses correctly. If so, check that the formatting meets a speci
 * 182 Whitespace characters after comparison operator
 * 183 Tabs after comparison operator
 ### 200 Parameter errors
-* 110 Missing Let
-* 111 Optional Let
+* 201 Missing Let
+* 202 Optional Let
 * 210 parameter naming
 * 220 Keyword not capitalized
 * function / sub naming
@@ -74,7 +74,7 @@ Check that code parses correctly. If so, check that the formatting meets a speci
 ### 700 Module Errors
 * Blank line begining file
 * blank line end of file
-* missing final eol
+* 701 missing final eol
 * 601 missing module attributes
 * 602 Missing module declarations
 ### 800 Documentation

src/vba_linter/linter.py

@@ -41,6 +41,8 @@ def lint(self: T, dir: RuleDirectory, code: str) -> list:
             token = ts.LT(1)
             assert token is not None
             while not token.type == Token.EOF:
+                # Walk the stream and test the token against
+                # each rule.
                 for key in rules:
                     rule = rules[key]
                     output.extend(rule.test(ts))
@@ -52,9 +54,25 @@ def lint(self: T, dir: RuleDirectory, code: str) -> list:
             listener.listeners = dir.get_parser_rules()
             ParseTreeWalker.DEFAULT.walk(listener, program)
             output.extend(listener.get_output())
-            output.sort()
+            # Get the ignore list and remove violations
+            # that should be removed.
+            rule_disabler = dir.get_rule_disabler()
+            ignored = rule_disabler.ignored
+            filtered_output = []
+            if len(ignored) > 0:
+                for violation in output:
+                    violated_rule = violation[2]
+                    if violated_rule in ignored:
+                        violation_line = violation[0]
+                        if violation_line not in ignored[violated_rule]:
+                            filtered_output.append(violation)
+                    else:
+                        filtered_output.append(violation)
+            else:
+                filtered_output = output
+            filtered_output.sort()
         self.pretty = ts
-        return output
+        return filtered_output
 
     def get_pretty_code(self: T) -> str:
         code = ""

src/vba_linter/rule_directory.py

@@ -21,6 +21,7 @@
 from vba_linter.rules.listeners.missing_visibility import MissingVisibility
 from vba_linter.rules.listeners.missing_let import MissingLet
 from vba_linter.rules.listeners.optional_let import OptionalLet
+from vba_linter.rule_disabler import RuleDisabler
 
 
 T = TypeVar('T', bound='RuleDirectory')
@@ -35,13 +36,19 @@ def __init__(self: T) -> None:
         # load config file.
         self._rules: Dict[str, RuleBase] = {}
         self._parser_rules: Dict[str, ParseTreeListener] = {}
+        self.add_rule(RuleDisabler())
 
     def add_rule(self: T, rule: RuleBase) -> None:
         if isinstance(rule, ParseTreeListener):
             self._parser_rules[rule.get_rule_name()] = rule
         else:
             self._rules[rule.get_rule_name()] = rule
 
+    def get_rule_disabler(self: T) -> RuleDisabler:
+        rule = self.get_rule("000")
+        assert isinstance(rule, RuleDisabler)
+        return rule
+
     def remove_rule(self: T, name: str) -> None:
         if name in self._rules:
             del self._rules[name]
@@ -64,7 +71,7 @@ def load_standard_rules(self: T) -> None:
         rule910.set_rule_name("910")
         rule910.severity = 'F'
         self._rules.update({
-            "201": NewlineEof(),
+            "701": NewlineEof(),
             "220": KeywordCaps(),
             "400": LineEnding(),
             "305": TrailingWhitespace(),
@@ -82,7 +89,7 @@ def load_all_rules(self: T) -> None:
         self._parser_rules.update({
             '505': OptionalPublic(),
             '510': MissingVisibility(),
-            '110': MissingLet(), '111': OptionalLet()
+            '201': MissingLet(), '202': OptionalLet()
         })
 
     def get_rule(self: T, rule_name: str) -> RuleBase:

src/vba_linter/rule_disabler.py

@@ -0,0 +1,78 @@
+from antlr4.tree.Tree import TerminalNode, TerminalNodeImpl
+from antlr4_vba.vbaParser import vbaParser as Parser
+from typing import Dict, TypeVar
+from vba_linter.antlr.vbaListener import VbaListener
+
+
+T = TypeVar('T', bound='RuleDisabler')
+
+
+class RuleDisabler(VbaListener):
+    def __init__(self: T) -> None:
+        super().__init__()
+        self._rule_name = "000"
+        self.open_blocks: Dict[str, int] = {}
+
+        # Key: rule name
+        # value: list of line numbers in which the rule is ignored.
+        self.ignored: Dict[str, set] = {}
+
+    def enterStartRule(  # noqa: N802
+            self: T,
+            ctx: Parser.StartRuleContext) -> None:
+        self.ignored = {}
+
+    def enterClassBeginBlock(  # noqa: N802
+            self: T,
+            ctx: Parser.ClassBeginBlockContext) -> None:
+        start = ctx.start.line
+        stop = ctx.stop.line
+        # ignore excess whitespace after and before equals sign.
+        self.add_ignored_lines('151', start, stop)
+        self.add_ignored_lines('154', start, stop)
+
+    def enterCommentBody(self: T,  # noqa: N802
+                         ctx: Parser.CommentBodyContext) -> None:
+        tok = ctx.start
+        if tok.text[:8] == "' noqa: ":
+            rule = ctx.start.text[8:]
+            if tok.column == 0:
+                # ignore multiple lines
+                self.open_blocks[rule] = tok.line
+            else:
+                # ignore one line
+                self.add_ignored_line(rule, tok.line)
+        elif tok.text[:6] == "' qa: ":
+            rule = tok.text[6:]
+            if rule in self.open_blocks:
+                start_line = self.open_blocks[rule]
+                self.add_ignored_lines(rule, start_line, tok.line)
+                del self.open_blocks[rule]
+
+    def visitTerminal(self: T,  # noqa: N802
+                      node: TerminalNode) -> None:
+        assert isinstance(node, TerminalNodeImpl)
+        end_line = node.symbol.line
+        for rule in self.open_blocks:
+            start_line = self.open_blocks[rule]
+            self.add_ignored_lines(rule, start_line, end_line)
+
+    def add_ignored_line(self: T, rule: str, line: int) -> None:
+        if rule in self.ignored:
+            lines = self.ignored[rule]
+        else:
+            lines = set()
+        lines.add(line)
+        new = {rule: lines}
+        self.ignored.update(new)
+
+    def add_ignored_lines(
+            self: T, rule: str, start_line: int, end_line: int
+    ) -> None:
+        if rule in self.ignored:
+            lines = self.ignored[rule]
+        else:
+            lines = set()
+        lines.update(range(start_line, end_line))
+        new = {rule: lines}
+        self.ignored.update(new)

src/vba_linter/rules/listeners/missing_let.py

@@ -11,7 +11,7 @@ def __init__(self: T) -> None:
         super().__init__()
         self.output: list = []
         self._severity = 'W'
-        self._rule_name = "110"
+        self._rule_name = "201"
         self._message = "Missing let"
 
     def enterLetStatement(self: T,  # noqa: N802

src/vba_linter/rules/listeners/optional_let.py

@@ -11,7 +11,7 @@ def __init__(self: T) -> None:
         super().__init__()
         self.output: list = []
         self._severity = 'W'
-        self._rule_name = "111"
+        self._rule_name = "202"
         self._message = "Optional let"
 
     def enterLetStatement(  # noqa: N802

src/vba_linter/rules/newline_eof.py

@@ -9,7 +9,7 @@
 
 class NewlineEof(RuleBase):
     def __init__(self: T) -> None:
-        self._rule_name = "201"
+        self._rule_name = "701"
         self._message = "no newline at end of file"
         self._severity = 'W'
 
@@ -21,5 +21,5 @@ def test(self: T, ts: CommonTokenStream) -> list:
                 token.type != vbaLexer.NEWLINE):
             line = token.line
             column = token.column + len(token.text) + 1
-            output = [(line, column, "201")]
+            output = [(line, column, self._rule_name)]
         return output

tests/Functional/test_ignore.py

@@ -0,0 +1,166 @@
+import pytest
+import random
+import string
+from pathlib import Path
+from pytest_mock import MockerFixture
+from _pytest.capture import CaptureFixture
+from vba_linter.__main__ import main
+
+
+@pytest.fixture(autouse=True)
+def run_around_tests() -> None:
+    global files
+    files = []
+    # Code that will run before your test, for example:
+    # A test function will be run at this point
+    yield
+    # Code that will run after your test, for example:
+    for file in files:
+        delete_code(file)
+    files = []
+
+
+def save_code(code: str) -> str:
+    file_name = create_filename(ext='.bas')
+    p = Path(file_name)
+    with p.open(mode='a') as fi:
+        fi.write(code)
+    return file_name
+
+
+def create_filename(num: int = 16, ext: str = ".txt") -> str:
+    chars = ""
+    for i in range(num):
+        chars += random.choice(string.ascii_lowercase)
+    file_name = chars + ext
+    return "tests/Functional/" + file_name
+
+
+def delete_code(file_name: str) -> None:
+    p = Path(file_name)
+    p.unlink()
+
+
+function = 'Supercalifragilisticexpialidocious'
+
+
+worst_practice1 = (
+    'Attribute VB_Name = "Foo"\r\n' +
+    '\' noqa: 400\n'
+    'Public Function ' + function +
+    ' ( atrocious ,  precocious, indubitably ) \r\n' +
+    ' \r\n' +
+    '\' qa: 400\r\n' +
+    '\n' +
+    '\r\n' +
+    'I = (2 + 1)\r\n' +
+    '    foo_val=6\r\n'
+    '    Let BarVal  =  (7 + 2) / 3\r\n'
+    'End Function \' noqa: 400\n' +
+    '\r\n' +
+    'sub O()\r\n' +
+    'End Sub \' noqa: 400\n' +
+    '\r\n'
+)
+
+
+def test_ignore(mocker: MockerFixture, capsys: CaptureFixture) -> None:
+    file_name = save_code(worst_practice1)
+    files.append(file_name)
+    full_path = ("/home/runner/work/VBA-Linter/VBA-Linter/" + file_name)
+    mocker.patch(
+        "sys.argv",
+        [
+            "vba_linter.py",
+            "tests/Functional",
+        ],
+    )
+    with pytest.raises(SystemExit):
+        main()
+    captured = capsys.readouterr()
+    expected = """\
+%s:3:51: E121 Excess whitespace before '('
+%s:3:53: E124 Excess whitespace after '('
+%s:3:63: E141 Excess whitespace before ','
+%s:3:66: E144 Excess whitespace after ','
+%s:3:90: E131 Excess whitespace before ')'
+%s:3:92: E305 Trailing whitespace
+%s:6:0: E400 incorrect line ending
+%s:9:12: E150 Missing whitespace before '='
+%s:9:13: E153 Missing whitespace after '='
+%s:10:16: E151 Excess whitespace before '='
+%s:10:19: E154 Excess whitespace after '='
+%s:13:1: E220 Keyword not capitalized
+12 Errors in 1 File
+""".replace("%s", full_path)  # noqa
+    mocker.patch(
+        "sys.argv",
+        [
+            "vba_linter.py",
+            "tests/Functional",
+        ],
+    )
+    with pytest.raises(SystemExit):
+        main()
+    captured = capsys.readouterr()
+    assert captured.err == expected
+
+
+worst_practice2 = (
+    'Attribute VB_Name = "Foo"\r\n' +
+    '\r\n'
+    'Public Function ' + function +
+    ' ( atrocious ,  precocious, indubitably ) \' noqa: 121\r\n' +
+    ' \r\n' +
+    '\' qa: 400\r\n' +
+    '\n' +
+    '\r\n' +
+    'I = (2 + 1)\r\n' +
+    '    foo_val=6\r\n'
+    '    Let BarVal  =  (7 + 2) / 3\r\n'
+    'End Function \' noqa: 400\n' +
+    '\r\n' +
+    'sub O()\r\n' +
+    'End Sub \' noqa: 400\n' +
+    '\r\n'
+)
+
+
+def test_ignore_single(mocker: MockerFixture, capsys: CaptureFixture) -> None:
+    file_name = save_code(worst_practice2)
+    files.append(file_name)
+    full_path = ("/home/runner/work/VBA-Linter/VBA-Linter/" + file_name)
+    mocker.patch(
+        "sys.argv",
+        [
+            "vba_linter.py",
+            "tests/Functional",
+        ],
+    )
+    with pytest.raises(SystemExit):
+        main()
+    captured = capsys.readouterr()
+    expected = """\
+%s:3:53: E124 Excess whitespace after '('
+%s:3:63: E141 Excess whitespace before ','
+%s:3:66: E144 Excess whitespace after ','
+%s:3:90: E131 Excess whitespace before ')'
+%s:6:0: E400 incorrect line ending
+%s:9:12: E150 Missing whitespace before '='
+%s:9:13: E153 Missing whitespace after '='
+%s:10:16: E151 Excess whitespace before '='
+%s:10:19: E154 Excess whitespace after '='
+%s:13:1: E220 Keyword not capitalized
+10 Errors in 1 File
+""".replace("%s", full_path)  # noqa
+    mocker.patch(
+        "sys.argv",
+        [
+            "vba_linter.py",
+            "tests/Functional",
+        ],
+    )
+    with pytest.raises(SystemExit):
+        main()
+    captured = capsys.readouterr()
+    assert captured.err == expected