rulebook_pylint.checkers

16class AbbreviationAsWordChecker(RulebookChecker):
17    """See detail: https://hanggrian.github.io/rulebook/rules/#abbreviation-as-word"""
18    _MSG: str = 'abbreviation.as.word'
19
20    _ABBREVIATION_REGEX: Pattern = re(r'[A-Z]{3,}(?=[A-Z][a-z]|$)')
21
22    name: str = 'abbreviation-as-word'
23    msgs: dict[str, tuple[str, str, str]] = Messages.of(_MSG)
24
25    def visit_classdef(self, node: ClassDef) -> None:
26        # checks for violation
27        if not self._ABBREVIATION_REGEX.findall(node.name):
28            return
29        self.add_message(
30            self._MSG,
31            node=node,
32            args= \
33                self._ABBREVIATION_REGEX.sub(
34                    lambda m: m.group(0)[0] + m.group(0)[1:].lower(),
35                    node.name,
36                ),
37            col_offset= \
38                node.col_offset + 6 \
39                    if node.col_offset is not None \
40                    else None,
41        )

15class BlockCommentClipChecker(RulebookChecker):
16    """See detail: https://hanggrian.github.io/rulebook/rules/#block-comment-clip"""
17    _MSG: str = 'block.comment.clip'
18
19    _SINGLELINE_TEMPLATE = 6  # """"""
20
21    name: str = 'block-comment-clip'
22    msgs: dict[str, tuple[str, str, str]] = Messages.of(_MSG)
23    options: Options = (
24        MAX_LINE_LENGTH_OPTION,
25    )
26
27    _max_line_length: int = 100
28
29    def open(self) -> None:
30        self._max_line_length = self.linter.config.rulebook_max_line_length
31
32    def visit_module(self, node: Module) -> None:
33        self._process(node.doc_node)
34
35    def visit_classdef(self, node: ClassDef) -> None:
36        self._process(node.doc_node)
37
38    def visit_functiondef(self, node: FunctionDef) -> None:
39        self._process(node.doc_node)
40
41    def _process(self, docstring: Const | None) -> None:
42        # checks for violation
43        if docstring is None:
44            return
45        if '\n' not in docstring.value:
46            return
47        line: str = docstring.value.strip()
48        if '\n' in line:
49            return
50        if docstring.col_offset is None:
51            return
52        text_length: int = docstring.col_offset + len(line)
53        if text_length + self._SINGLELINE_TEMPLATE <= self._max_line_length:
54            self.add_message(self._MSG, node=docstring)

16class BlockCommentTrimChecker(RulebookChecker):
17    """See detail: https://hanggrian.github.io/rulebook/rules/#block-comment-trim"""
18    _MSG_FIRST: str = 'block.comment.trim.first'
19    _MSG_LAST: str = 'block.comment.trim.last'
20
21    _MULTIPLE_EMPTY_LINES: Pattern = re(r'\n\n\s*$')
22
23    name: str = 'block-comment-trim'
24    msgs: dict[str, tuple[str, str, str]] = Messages.of(_MSG_FIRST, _MSG_LAST)
25
26    def visit_module(self, node: Module) -> None:
27        self._process(node.doc_node)
28
29    def visit_classdef(self, node: ClassDef) -> None:
30        self._process(node.doc_node)
31
32    def visit_functiondef(self, node: FunctionDef) -> None:
33        self._process(node.doc_node)
34
35    def _process(self, docstring: Const | None) -> None:
36        # checks for violation
37        if docstring is None:
38            return
39        if docstring.value.startswith('\n\n'):
40            self.add_message(self._MSG_FIRST, node=docstring, line=docstring.lineno)
41        if self._MULTIPLE_EMPTY_LINES.search(docstring.value):
42            self.add_message(self._MSG_LAST, node=docstring, line=docstring.end_lineno)

16class CaseSeparatorChecker(RulebookFileChecker):
17    """See detail: https://hanggrian.github.io/rulebook/rules/#case-separator"""
18    _MSG_MISSING: str = 'case.separator.missing'
19    _MSG_UNEXPECTED: str = 'case.separator.unexpected'
20
21    name: str = 'case-separator'
22    msgs: dict[str, tuple[str, str, str]] = Messages.of(_MSG_MISSING, _MSG_UNEXPECTED)
23
24    def visit_match(self, node: Match) -> None:
25        # collect cases
26        if not node.cases:
27            return
28
29        # checks for violation
30        has_multiline = \
31            any(
32                is_multiline(match_case) or
33                has_comment_above(self.lines, match_case) for
34                match_case in node.cases
35            )
36        for (i, match_case) in enumerate(node.cases):
37            if i == 0:
38                continue
39            last_match_case: MatchCase = node.cases[i - 1]
40            match_case_fromlineno: int = \
41                get_fromlineno_before(self.lines, match_case, last_match_case)
42            last_body: NodeNG = last_match_case.body[-1]
43            if has_multiline:
44                if last_body.tolineno - 1 != match_case_fromlineno - 2:
45                    self.add_message(
46                        self._MSG_MISSING,
47                        line=last_body.lineno,
48                        end_lineno=last_body.end_lineno,
49                        col_offset=last_body.col_offset,
50                        end_col_offset=last_body.end_col_offset,
51                    )
52            elif last_body.tolineno - 1 != match_case_fromlineno - 1:
53                self.add_message(
54                    self._MSG_UNEXPECTED,
55                    line=last_body.lineno,
56                    end_lineno=last_body.end_lineno,
57                    col_offset=last_body.col_offset,
58                    end_col_offset=last_body.end_col_offset,
59                )

15class CommentSpacesChecker(RulebookTokenChecker):
16    """See detail: https://hanggrian.github.io/rulebook/rules/#comment-spaces"""
17    _MSG: str = 'comment.spaces'
18
19    name: str = 'comment-spaces'
20    msgs: dict[str, tuple[str, str, str]] = Messages.of(_MSG)
21
22    def process_tokens(self, tokens: list[TokenInfo]) -> None:
23        # checks for violation
24        for token in [t for t in tokens if t.type == COMMENT]:
25            if token.string.startswith('# ') or \
26                token.string.startswith('#!') or \
27                all(c == '#' for c in token.string):
28                continue
29            self.add_message(self._MSG, line=token.start[0], col_offset=token.start[1])

16class CommentTrimChecker(RulebookTokenChecker):
17    """See detail: https://hanggrian.github.io/rulebook/rules/#comment-trim"""
18    _MSG: str = 'comment.trim'
19
20    name: str = 'comment-trim'
21    msgs: dict[str, tuple[str, str, str]] = Messages.of(_MSG)
22
23    def process_tokens(self, tokens: list[TokenInfo]) -> None:
24        for i, token in enumerate(tokens):
25            # target comment
26            if token.type != COMMENT:
27                continue
28
29            # continue if this comment is first line
30            if i - 2 >= 0 and \
31                tokens[i - 1].type == NL and \
32                tokens[i - 2].type == COMMENT:
33                return
34
35            # iterate to find last
36            j: int = i
37            while j + 2 < len(tokens) and \
38                tokens[j + 1].type == NL and \
39                tokens[j + 2].type == COMMENT:
40                j += 2
41            curr_token: TokenInfo = tokens[j]
42
43            # skip blank comment
44            if curr_token is token:
45                return
46
47            # checks for violation
48            if is_comment_empty(token):
49                self.add_message(
50                    self._MSG,
51                    line=token.start[0],
52                    col_offset=token.start[1],
53                )
54            if is_comment_empty(curr_token):
55                self.add_message(
56                    self._MSG,
57                    line=curr_token.start[0],
58                    col_offset=curr_token.start[1],
59                )
60            return

15class CommonFunctionPositionChecker(RulebookChecker):
16    """See detail: https://hanggrian.github.io/rulebook/rules/#common-function-position"""
17    _MSG: str = 'common.function.position'
18
19    _COMMON_FUNCTIONS: frozenset[str] = \
20        frozenset([
21            '__str__',
22            '__hash__',
23            '__eq__',
24            '__new__',
25            '__del__',
26            '__repr__',
27            '__bytes__',
28            '__format__',
29            '__lt__',
30            '__le__',
31            '__ne__',
32            '__gt__',
33            '__ge__',
34            '__bool__',
35        ])
36
37    name: str = 'common-function-position'
38    msgs: dict[str, tuple[str, str, str]] = Messages.of(_MSG)
39
40    def visit_functiondef(self, node: FunctionDef) -> None:
41        # target special function
42        if node.name not in self._COMMON_FUNCTIONS:
43            return
44
45        current: NodeNG | None = node
46        while current is not None:
47            # checks for violation
48            if isinstance(current, FunctionDef) and \
49                not has_decorator(current, 'staticmethod') and \
50                current.name not in self._COMMON_FUNCTIONS:
51                self.add_message(self._MSG, node=node, args=node.name)
52                return
53
54            current = current.next_sibling()

14class ComplicatedAssertionChecker(RulebookChecker):
15    """See detail: https://hanggrian.github.io/rulebook/rules/#complicated-assertion"""
16    _MSG: str = 'complicated.assertion'
17
18    name: str = 'complicated-assertion'
19    msgs: dict[str, tuple[str, str, str]] = Messages.of(_MSG)
20
21    _BOOLEAN_ASSERTIONS: frozenset[str] = frozenset(['assertTrue', 'assertFalse'])
22    _EQUALITY_ASSERTIONS: frozenset[str] = frozenset(['assertEqual', 'assertNotEqual'])
23
24    def visit_classdef(self, node: ClassDef) -> None:
25        # find built-in tests
26        if not any(isinstance(b, Name) and b.name == 'TestCase' for b in node.bases):
27            return
28
29        for method in [m for m in node.methods() if isinstance(m, FunctionDef)]:
30            for expr in [b for b in method.body if isinstance(b, Expr)]:
31                # checks for violation
32                call: NodeNG = expr.value
33                if not isinstance(call, Call) or \
34                    not isinstance(call.func, Attribute):
35                    continue
36                name: str = call.func.attrname
37                if not call.args:
38                    continue
39                call_replacement: str
40                if name in self._BOOLEAN_ASSERTIONS:
41                    arg: NodeNG = call.args[0]
42                    if not isinstance(arg, Compare):
43                        continue
44                    op: str = arg.ops[0][0]
45                    if op == '==':
46                        call_replacement = 'assertEqual'
47                    elif op == '!=':
48                        call_replacement = 'assertNotEqual'
49                    elif op == 'is':
50                        call_replacement = 'assertIs'
51                    elif op == 'is not':
52                        call_replacement = 'assertIsNot'
53                    else:
54                        continue
55                elif name in self._EQUALITY_ASSERTIONS:
56                    args: list[NodeNG] = call.args
57                    if any(self._is_const(arg, True) for arg in args):
58                        call_replacement = 'assertTrue'
59                    elif any(self._is_const(arg, False) for arg in args):
60                        call_replacement = 'assertFalse'
61                    elif any(self._is_const(arg, None) for arg in args):
62                        call_replacement = 'assertIsNone'
63                    else:
64                        continue
65                else:
66                    continue
67                self.add_message(self._MSG, node=call.func, args=call_replacement)
68
69    @staticmethod
70    def _is_const(node: NodeNG, value: object) -> bool:
71        return isinstance(node, Const) and \
72            node.value is value

14class ComplicatedAssignmentChecker(RulebookChecker):
15    """See detail: https://hanggrian.github.io/rulebook/rules/#complicated-assignment"""
16    _MSG: str = 'complicated.assignment'
17
18    _SHORTHAND_OPERATIONS: frozenset[str] = frozenset(['+', '-', '*', '/', '%'])
19
20    name: str = 'complicated-assignment'
21    msgs: dict[str, tuple[str, str, str]] = Messages.of(_MSG)
22
23    def visit_assign(self, node: Assign) -> None:
24        # skip destructuring
25        if len(node.targets) != 1:
26            return
27
28        # checks for violation
29        identifier: NodeNG = node.targets[0]
30        if not isinstance(identifier, AssignName):
31            return
32        if not isinstance(node.value, BinOp):
33            return
34        bin_op: BinOp = self._deepest_bin_op(node.value)
35        if bin_op.op not in self._SHORTHAND_OPERATIONS:
36            return
37        if not isinstance(bin_op.left, Name) or \
38            bin_op.left.name != identifier.name:
39            return
40        self.add_message(self._MSG, node=node, args=bin_op.op + '=')
41
42    @staticmethod
43    def _deepest_bin_op(node: BinOp) -> BinOp:
44        current: BinOp = node
45        while isinstance(current.left, BinOp):
46            current = current.left
47        return current

15class ConfusingAssertionChecker(RulebookChecker):
16    """See detail: https://hanggrian.github.io/rulebook/rules/#confusing-assertion"""
17    _MSG: str = 'confusing.assertion'
18
19    _ASSERT_CALLS: dict[str, str] = \
20        two_way_dict(('assertTrue', 'assertFalse'))
21
22    name: str = 'confusing-assertion'
23    msgs: dict[str, tuple[str, str, str]] = Messages.of(_MSG)
24
25    def visit_classdef(self, node: ClassDef) -> None:
26        # find built-in tests
27        if not any(isinstance(b, Name) and b.name == 'TestCase' for b in node.bases):
28            return
29
30        for method in [m for m in node.methods() if isinstance(m, FunctionDef)]:
31            for expr in [b for b in method.body if isinstance(b, Expr)]:
32                # find inverted assert function
33                call: NodeNG = expr.value
34                if not isinstance(call, Call) or \
35                    not isinstance(call.func, Attribute):
36                    continue
37                call_replacement: str | None = self._ASSERT_CALLS.get(call.func.attrname, None)
38                if call_replacement is None:
39                    continue
40
41                # checks for violation
42                if not call.args:
43                    continue
44                arg: NodeNG = call.args[0]
45                if not isinstance(arg, UnaryOp) or \
46                    arg.op != 'not':
47                    continue
48                self.add_message(self._MSG, node=call.func, args=call_replacement)

14class DuplicateBlankLineChecker(RulebookFileChecker):
15    """See detail: https://hanggrian.github.io/rulebook/rules/#duplicate-blank-line"""
16    _MSG: str = 'duplicate.blank.line'
17
18    name: str = 'duplicate-blank-line'
19    msgs: dict[str, tuple[str, str, str]] = Messages.of(_MSG)
20
21    def process_module(self, node: Module) -> None:
22        # checks for violation
23        counter: int = 0
24        with node.stream() as stream:
25            for (i, line) in enumerate(stream.readlines()):
26                counter = counter + 1 if not line.strip() else 0
27                if counter < 3:
28                    continue
29                self.add_message(self._MSG, line=i + 1)

14class DuplicateBlankLineInBlockCommentChecker(RulebookChecker):
15    """See detail: https://hanggrian.github.io/rulebook/rules/#duplicate-blank-line-in-block-comment"""
16    _MSG: str = 'duplicate.blank.line.in.block.comment'
17
18    name: str = 'duplicate-blank-line-in-block-comment'
19    msgs: dict[str, tuple[str, str, str]] = Messages.of(_MSG)
20
21    def visit_module(self, node: Module) -> None:
22        self._process(node.doc_node)
23
24    def visit_classdef(self, node: ClassDef) -> None:
25        self._process(node.doc_node)
26
27    def visit_functiondef(self, node: FunctionDef) -> None:
28        self._process(node.doc_node)
29
30    def _process(self, docstring: Const | None) -> None:
31        # checks for violation
32        if docstring is None or \
33            '\n\n\n' not in docstring.value:
34            return
35        self.add_message(self._MSG, node=docstring)

16class DuplicateBlankLineInCommentChecker(RulebookTokenChecker):
17    """See detail: https://hanggrian.github.io/rulebook/rules/#duplicate-blank-line-in-comment"""
18    _MSG: str = 'duplicate.blank.line.in.comment'
19
20    name: str = 'duplicate-blank-line-in-comment'
21    msgs: dict[str, tuple[str, str, str]] = Messages.of(_MSG)
22
23    def process_tokens(self, tokens: list[TokenInfo]) -> None:
24        last_empty_token: TokenInfo | None = None
25        # checks for violation
26        for token in [t for t in tokens if t.type == COMMENT and is_comment_empty(t)]:
27            if last_empty_token is None:
28                last_empty_token = token
29                continue
30            if last_empty_token.start[0] + 1 == token.start[0]:
31                self.add_message(self._MSG, line=token.start[0], col_offset=token.start[1])
32
33            # keep previous token for comparison
34            last_empty_token = token

15class DuplicateSpaceChecker(RulebookTokenChecker):
16    """See detail: https://hanggrian.github.io/rulebook/rules/#duplicate-space"""
17    _MSG: str = 'duplicate.space'
18
19    name: str = 'duplicate-space'
20    msgs: dict[str, tuple[str, str, str]] = Messages.of(_MSG)
21
22    def process_tokens(self, tokens: list[TokenInfo]) -> None:
23        # fstring_flag: bool = False
24        for i, token in enumerate(tokens):
25            # get last token to compare
26            last_token: TokenInfo = tokens[i - 1]
27
28            # FSTRING_END unavailable on 3.11
29            # if last_token.type == FSTRING_END:
30            #     fstring_flag = False
31
32            # checks for violation
33            # if fstring_flag or not self._is_duplicate_space(token, last_token):
34            if not self._is_duplicate_space(token, last_token):
35                continue
36            self.add_message(
37                self._MSG,
38                line=last_token.start[0],
39                col_offset=last_token.start[1],
40            )
41
42            # if token.type == FSTRING_START:
43            #     fstring_flag = True
44
45    @staticmethod
46    def _is_duplicate_space(token: TokenInfo, last_token: TokenInfo) -> bool:
47        if any(
48            t in (NEWLINE, NL, INDENT, DEDENT, ENDMARKER)
49            for t in (token.type, last_token.type)
50        ):
51            return False
52        return token.start[1] - last_token.end[1] > 2 \
53            if token.type == COMMENT \
54            else token.start[1] - last_token.end[1] > 1