rulebook_cppcheck.checkers

14class AbbreviationAsWordChecker(RulebookChecker):
15    """See detail: https://hanggrian.github.io/rulebook/rules/#abbreviation-as-word"""
16    ID: str = 'abbreviation-as-word'
17    _MSG: str = 'abbreviation.as.word'
18
19    _ABBREVIATION_REGEX: Pattern = re(r'[A-Z]{3,}(?=[A-Z][a-z]|$)')
20
21    def get_scopeset(self) -> set[str]:
22        return {'Class', 'Struct', 'Union', 'Enum'}
23
24    def visit_scope(self, scope: Scope) -> None:
25        # checks for violation
26        if scope.className is None or \
27            not self._ABBREVIATION_REGEX.findall(scope.className):
28            return
29        name_token: Token | None = \
30            prev_sibling(scope.bodyStart, lambda t: t.str == scope.className)
31        self.report_error(
32            name_token if name_token is not None else scope.bodyStart,
33            Messages.get(
34                self._MSG,
35                self._ABBREVIATION_REGEX.sub(
36                    lambda m: m.group(0)[0] + m.group(0)[1:].lower(),
37                    scope.className,
38                ),
39            ),
40        )

11class AssignmentWrapChecker(RulebookTokenChecker):
12    """See detail: https://hanggrian.github.io/rulebook/rules/#assignment-wrap"""
13    ID: str = 'assignment-wrap'
14    _MSG: str = 'assignment.wrap'
15
16    _START_TOKENS: frozenset[str] = frozenset(['{', '[', '(', 'lambda'])
17
18    def process_tokens(self, tokens: list[Token]) -> None:
19        for token in [t for t in tokens if t.str == '=' and t.isAssignmentOp]:
20            rhs_start: Token | None = token.next
21            if rhs_start is None or \
22                rhs_start.str in self._START_TOKENS:
23                continue
24            rhs_end: Token | None = token.astOperand2
25            if rhs_end is None:
26                continue
27            last_rhs_token: Token = rhs_end
28            while last_rhs_token.astOperand2 is not None:
29                last_rhs_token = last_rhs_token.astOperand2
30            if last_rhs_token.str == ';':
31                last_rhs_token = last_rhs_token.previous
32
33            # checks for violation
34            if rhs_start.linenr != token.linenr or \
35                last_rhs_token.linenr <= token.linenr:
36                continue
37            self.report_error(token, Messages.get(self._MSG))

13class BlockCommentSpacesChecker(RulebookFileChecker):
14    """See detail: https://hanggrian.github.io/rulebook/rules/#block-comment-spaces"""
15    ID: str = 'block-comment-spaces'
16    _MSG_SINGLE_START: str = 'block.comment.spaces.single.start'
17    _MSG_SINGLE_END: str = 'block.comment.spaces.single.end'
18    _MSG_MULTI: str = 'block.comment.spaces.multi'
19
20    _BLOCK_COMMENT_START_REGEX: Pattern = re(r'^/\*+[^/*\s]')
21    _BLOCK_COMMENT_CENTER_REGEX: Pattern = re(r'^\s*\*[^\s/]')
22    _BLOCK_COMMENT_END_REGEX: Pattern = re(r'[^\s\*]\*/$')
23
24    def check_file(self, token: Token, content: str) -> None:
25        for match in finditer(r'/\*.*?\*/', content, DOTALL):
26            comment_text: str = match.group()
27            start_line: int = content.count('\n', 0, match.start()) + 1
28            lines: list[str] = comment_text.splitlines()
29
30            # checks for violation
31            if self._BLOCK_COMMENT_START_REGEX.search(lines[0]):
32                self.report_error(
33                    token,
34                    Messages.get(self._MSG_SINGLE_START),
35                    start_line,
36                )
37            if self._BLOCK_COMMENT_END_REGEX.search(lines[-1]):
38                self.report_error(
39                    token,
40                    Messages.get(self._MSG_SINGLE_END),
41                    start_line + len(lines) - 1,
42                )
43            for i in range(1, len(lines)):
44                if not self._BLOCK_COMMENT_CENTER_REGEX.search(lines[i]):
45                    continue
46                self.report_error(
47                    token,
48                    Messages.get(self._MSG_MULTI),
49                    start_line + i,
50                )

13class BlockCommentTrimChecker(RulebookFileChecker):
14    """See detail: https://hanggrian.github.io/rulebook/rules/#block-comment-trim"""
15    ID: str = 'block-comment-trim'
16    _MSG_FIRST: str = 'block.comment.trim.first'
17    _MSG_LAST: str = 'block.comment.trim.last'
18
19    _EMPTY_LINES: frozenset[str] = frozenset(['*', ''])
20
21    def check_file(self, token: Token, content: str) -> None:
22        for match in finditer(r'/\*(.*?)\*/', content, DOTALL):
23            comment_body: str = match.group(1)
24            start_line: int = content.count('\n', 0, match.start()) + 1
25            lines: list[str] = comment_body.splitlines()
26
27            # filter out block comments that couldn't be trimmed
28            if len(lines) < 3:
29                continue
30
31            # collect content
32            content_indices = [
33                i for i, line in enumerate(lines) if line.strip() not in self._EMPTY_LINES
34            ]
35            if not content_indices:
36                continue
37
38            # check first line
39            first_line: str = lines[0].strip()
40            second_line: str = lines[1].strip()
41            if (first_line in self._EMPTY_LINES) and \
42                second_line == '*':
43                if content_indices[0] > 1:
44                    self.report_error(
45                        token,
46                        Messages.get(self._MSG_FIRST),
47                        start_line + 1,
48                    )
49
50            # check last line
51            last_line: str = lines[-1].strip()
52            penultimate_line: str = lines[-2].strip()
53            if last_line != '' or \
54                penultimate_line != '*':
55                continue
56            if content_indices[-1] >= len(lines) - 2:
57                continue
58            self.report_error(
59                token,
60                Messages.get(self._MSG_LAST),
61                start_line + len(lines) - 1,
62            )

13class BlockTagIndentationChecker(RulebookFileChecker):
14    """See detail: https://hanggrian.github.io/rulebook/rules/#block-tag-indentation"""
15    ID: str = 'block-tag-indentation'
16    _MSG: str = 'block.tag.indentation'
17
18    _BLOCK_TAG_REGEX: Pattern = re_compile(r'^\s*\*\s+@\w+')
19    _CONTINUATION_LINE_REGEX: Pattern = re_compile(r'^\s*\*(\s+)')
20
21    def check_file(self, token: Token, content: str) -> None:
22        for match in finditer(r'/\*\*.*?\*/', content, DOTALL):
23            comment_text: str = match.group()
24            start_line: int = content.count('\n', 0, match.start()) + 1
25            lines: list[str] = comment_text.splitlines()
26            in_block_tag: bool = False
27            for i, line in enumerate(lines):
28                # target block tag
29                if self._BLOCK_TAG_REGEX.search(line):
30                    in_block_tag = True
31                    continue
32                if not in_block_tag:
33                    continue
34                stripped: str = line.strip()
35                if not stripped or \
36                    stripped == '*' or \
37                    stripped == '*/':
38                    in_block_tag = False
39                    continue
40                if stripped.startswith('* @'):
41                    in_block_tag = True
42                    continue
43
44                # checks for violation
45                match_indent: Match | None = self._CONTINUATION_LINE_REGEX.match(line)
46                if match_indent is None:
47                    continue
48                indent_size: int = len(match_indent.group(1))
49                if indent_size == 5:
50                    continue
51                self.report_error(token, Messages.get(self._MSG), start_line + i)

14class BlockTagPunctuationChecker(RulebookFileChecker):
15    """See detail: https://hanggrian.github.io/rulebook/rules/#block-tag-punctuation"""
16    ID: str = 'block-tag-punctuation'
17    _MSG: str = 'block.tag.punctuation'
18    ARGS: list[str] = [PUNCTUATE_BLOCK_TAGS_OPTION]
19
20    _PUNCTUATIONS: frozenset[str] = frozenset(['.', '!', '?', ')'])
21
22    def __init__(self) -> None:
23        super().__init__()
24        self._block_tags: set[str] = {
25            '@param',
26            '@return',
27            '@returns',
28        }
29
30    def before_run(self, args: dict[str, str]) -> None:
31        self._block_tags = set(args[PUNCTUATE_BLOCK_TAGS_OPTION].split(','))
32
33    def check_file(self, token: Token, content: str) -> None:
34        for match in finditer(r'/\*(.*?)\*/', content, DOTALL):
35            comment_body: str = match.group(1)
36            start_line: int = content.count('\n', 0, match.start())
37            lines: list[str] = comment_body.splitlines()
38
39            # strategy to capture continuation indent
40            current_tag: str | None = None
41            last_text: str = ''
42            last_text_line_idx: int = -1
43
44            for i, line in enumerate(lines):
45                stripped: str = line.strip().lstrip('*').strip()
46                if not stripped:
47                    continue
48
49                # only enforce certain tags
50                found_tag: str | None = \
51                    next((t for t in self._block_tags if stripped.startswith(t)), None)
52
53                # long descriptions have multiple lines, take only the last one
54                if found_tag:
55                    if current_tag is not None and \
56                        last_text and \
57                        last_text[-1] not in self._PUNCTUATIONS:
58                        self.report_error(
59                            token,
60                            Messages.get(self._MSG, current_tag),
61                            start_line + last_text_line_idx,
62                        )
63
64                    current_tag = found_tag
65                    remainder: str = stripped[len(found_tag):].strip()
66                    if current_tag == '@param':
67                        parts: list[str] = remainder.split(maxsplit=1)
68                        last_text = parts[1] if len(parts) > 1 else ''
69                    else:
70                        last_text = remainder
71                    last_text_line_idx = i if last_text else -1
72                elif current_tag:
73                    last_text = stripped
74                    last_text_line_idx = i
75
76            # checks for violation
77            if current_tag is None or \
78                not last_text or \
79                last_text[-1] in self._PUNCTUATIONS:
80                continue
81            self.report_error(
82                token,
83                Messages.get(self._MSG, current_tag),
84                start_line + last_text_line_idx,
85            )

 12class CaseSeparatorChecker(RulebookChecker):
 13    """See detail: https://hanggrian.github.io/rulebook/rules/#case-separator"""
 14    ID: str = 'case-separator'
 15    _MSG_MISSING: str = 'case.separator.missing'
 16    _MSG_UNEXPECTED: str = 'case.separator.unexpected'
 17
 18    _BRANCH_TOKENS: frozenset[str] = frozenset(['case', 'default'])
 19
 20    def __init__(self) -> None:
 21        super().__init__()
 22        self._reported_errors: set[tuple[str, int, int, str]] = set()
 23
 24    def get_scopeset(self) -> set[str]:
 25        return {'Switch'}
 26
 27    def visit_scope(self, scope: Scope) -> None:
 28        # collect cases
 29        body_start: Token | None = scope.bodyStart
 30        body_end: Token | None = scope.bodyEnd
 31        if body_start is None or \
 32            body_end is None:
 33            return
 34
 35        groups: list[list[Token]] = []
 36        curr_token: Token | None = body_start.next
 37
 38        while curr_token is not None and \
 39            curr_token is not body_end:
 40            if not isinstance(curr_token, Token):
 41                continue
 42            if curr_token.str in self._BRANCH_TOKENS:
 43                case_keyword: Token = curr_token
 44                case_label: Token = curr_token.next if curr_token.str == 'case' else curr_token
 45
 46                end_token: Token = case_keyword
 47                scan: Token | None = curr_token.next
 48                colon_found: bool = False
 49                has_body: bool = False
 50
 51                while scan is not None and \
 52                    scan is not body_end:
 53                    if not isinstance(scan, Token):
 54                        continue
 55                    if scan.str in self._BRANCH_TOKENS and \
 56                        scan.scope is scope:
 57                        break
 58                    if scan.str == ':':
 59                        colon_found = True
 60                    elif colon_found:
 61                        has_body = True
 62                    end_token = scan
 63                    scan = scan.next
 64
 65                if not has_body and \
 66                    scan is not None and \
 67                    scan is not body_end and \
 68                    isinstance(scan, Token) and \
 69                    scan.str in self._BRANCH_TOKENS:
 70                    end_token = scan
 71
 72                groups.append([case_label, case_keyword, end_token])
 73                curr_token = scan
 74                continue
 75            curr_token = curr_token.next
 76
 77        # checks for violation
 78        if not groups:
 79            return
 80
 81        for i in range(1, len(groups)):
 82            prev_group: list[Token] = groups[i - 1]
 83            curr_group: list[Token] = groups[i]
 84
 85            prev_is_multiline: bool = prev_group[2].linenr - prev_group[1].linenr > 0
 86            prev_has_body: bool = prev_group[2].str not in self._BRANCH_TOKENS
 87
 88            if not prev_has_body:
 89                curr_is_single_line: bool = curr_group[2].linenr == curr_group[1].linenr
 90                if not curr_is_single_line:
 91                    continue
 92
 93            prev_end_line: int = prev_group[2].linenr
 94            curr_start_line: int = curr_group[1].linenr
 95            line_diff: int = curr_start_line - prev_end_line
 96
 97            if prev_is_multiline:
 98                if line_diff != 2:
 99                    self._report_error_once(prev_group[0], Messages.get(self._MSG_MISSING))
100            elif line_diff != 1:
101                self._report_error_once(prev_group[0], Messages.get(self._MSG_UNEXPECTED))
102
103    def _report_error_once(self, token: Token, message: str) -> None:
104        error_key: tuple[str, int, int, str] = (token.file, token.linenr, token.column, message)
105        if error_key in self._reported_errors:
106            return
107        self._reported_errors.add(error_key)
108        self.report_error(token, message)

 11class ChainCallWrapChecker(RulebookTokenChecker):
 12    """See detail: https://hanggrian.github.io/rulebook/rules/#chain-call-wrap"""
 13    ID: str = 'chain-call-wrap'
 14    _MSG_MISSING: str = 'chain.call.wrap.missing'
 15    _MSG_UNEXPECTED: str = 'chain.call.wrap.unexpected'
 16
 17    _SHOULD_BREAK: frozenset[str] = frozenset(['+', ';', '{', '}', '=', '?', ':'])
 18    _CLOSING_PARENTHESES: frozenset[str] = frozenset([')', '}'])
 19
 20    def __init__(self) -> None:
 21        super().__init__()
 22        self._reported_errors: set[tuple[str, int, int, str]] = set()
 23
 24    def process_tokens(self, tokens: list[Token]) -> None:
 25        for token in [
 26            t for t in tokens if t.str == '.' and (not t.previous or t.previous.str != '.')
 27        ]:
 28            # check if this dot is inside function call parameters
 29            check_token: Token | None = token.previous
 30            paren_depth: int = 0
 31            while check_token is not None:
 32                if check_token.str == ')':
 33                    paren_depth += 1
 34                elif check_token.str == '(':
 35                    if paren_depth == 0:
 36                        break
 37                    paren_depth -= 1
 38                elif check_token.str in self._SHOULD_BREAK:
 39                    check_token = None
 40                    break
 41                check_token = check_token.previous
 42            if check_token is not None and \
 43                check_token.str == '(':
 44                continue
 45
 46            # look backwards to detect ternary
 47            check_token = token.previous
 48            paren_depth = 0
 49            found_ternary = False
 50            while check_token is not None:
 51                if check_token.str == ')':
 52                    paren_depth += 1
 53                elif check_token.str == '(':
 54                    paren_depth -= 1
 55                elif paren_depth == 0:
 56                    if check_token.str == '?':
 57                        found_ternary = True
 58                        break
 59                    if check_token.str in self._SHOULD_BREAK:
 60                        break
 61                check_token = check_token.previous
 62
 63            if found_ternary:
 64                continue
 65
 66            # collect dots
 67            dots: list[Token] = []
 68            curr: Token | None = token
 69            depth: int = 0
 70            while curr is not None:
 71                if curr.str == '(':
 72                    depth += 1
 73                elif curr.str == ')':
 74                    depth -= 1
 75                if depth < 0:
 76                    break
 77                if depth == 0:
 78                    if curr.str == '.':
 79                        dots.append(curr)
 80                    elif curr.str in self._SHOULD_BREAK:
 81                        break
 82                curr = curr.next
 83
 84            # skip dots in single-line
 85            if len(dots) < 2:
 86                continue
 87            first_dot: Token = dots[0]
 88            if all(d.linenr == first_dot.linenr for d in dots):
 89                continue
 90
 91            # checks for violation
 92            for dot in dots:
 93                prev_token: Token | None = dot.previous
 94                if prev_token is None:
 95                    continue
 96                if prev_token.str in self._CLOSING_PARENTHESES and \
 97                    prev_token.previous and \
 98                    prev_token.linenr > prev_token.previous.linenr:
 99                    if dot.linenr > prev_token.linenr:
100                        self._report_error_once(dot, Messages.get(self._MSG_UNEXPECTED))
101                    continue
102                if dot.linenr == prev_token.linenr:
103                    self._report_error_once(dot, Messages.get(self._MSG_MISSING))
104
105    def _report_error_once(self, token: Token, message: str) -> None:
106        error_key: tuple[str, int, int, str] = (token.file, token.linenr, token.column, message)
107        if error_key in self._reported_errors:
108            return
109        self._reported_errors.add(error_key)
110        self.report_error(token, message)