Adrien Ufferte
619 lines
26 KiB
Python
619 lines
26 KiB
Python
import os
|
|
import re
|
|
import sys
|
|
from collections import defaultdict, Counter
|
|
|
|
|
|
def split_params(param_string: str):
|
|
"""Split parameters on commas while ignoring nested structures."""
|
|
params = []
|
|
current: list[str] = []
|
|
stack: list[str] = []
|
|
pairs = {')': '(', ']': '[', '}': '{'}
|
|
in_quote = None
|
|
escape = False
|
|
for char in param_string:
|
|
if escape:
|
|
current.append(char)
|
|
escape = False
|
|
continue
|
|
|
|
if char == "\\":
|
|
current.append(char)
|
|
escape = True
|
|
continue
|
|
|
|
if in_quote:
|
|
current.append(char)
|
|
if char == in_quote:
|
|
in_quote = None
|
|
continue
|
|
|
|
if char in "'\"":
|
|
current.append(char)
|
|
in_quote = char
|
|
continue
|
|
|
|
if char in '([{':
|
|
stack.append(char)
|
|
elif char in ')]}':
|
|
if stack and stack[-1] == pairs.get(char):
|
|
stack.pop()
|
|
else:
|
|
raise ValueError("unbalance in delimiter")
|
|
|
|
if char == ',' and not stack:
|
|
params.append(''.join(current).strip())
|
|
current = []
|
|
else:
|
|
current.append(char)
|
|
|
|
if stack:
|
|
raise ValueError("unbalance in delimiter")
|
|
if in_quote:
|
|
raise ValueError(f"Unclosed quote: {in_quote}")
|
|
|
|
params.append(''.join(current).strip())
|
|
params = [p for p in params if p]
|
|
return params
|
|
|
|
|
|
EXCLUDED_DIRS = {"addons", ".git", ".github"}
|
|
EXCLUDED_FILES = {os.path.normpath("script_templates/Node/default.gd")}
|
|
|
|
issues: list = []
|
|
|
|
# ─── Messages ────────────────────────────────────────────────────────────────
|
|
# Structural issue messages. Use {key} for context-specific values.
|
|
# Naming issues are rendered dynamically (see format_message / SUGGESTION_FN).
|
|
|
|
MESSAGES = {
|
|
# File/header structure
|
|
'annotation_order': "annotation not allowed here: '{found}' — only @tool, @icon or @static_unload are allowed at the top of the file",
|
|
'class_position': "class_name must appear right after annotations (if any)",
|
|
'extends_position': "extends must appear after annotations and class_name",
|
|
'extends_missing': "extends is missing — add 'extends BaseClass' (or 'extends RefCounted' for base classes)",
|
|
|
|
# Function spacing
|
|
'func_blank': "expected 2 blank lines before function (found {found})",
|
|
|
|
# Signals
|
|
'signal_position': "signal found after {after} — expected order: signal > enum > const > static var > @export > var > @onready",
|
|
'signal_format': "signal must declare parameters with () — found: '{found}'",
|
|
'signal_blank_extra': "remove blank line between signal declarations — signals must be grouped together",
|
|
|
|
# Enums
|
|
'enum_position': "enum found after {after} — expected order: signal > enum > const > static var > @export > var > @onready",
|
|
'enum_format': "enum declaration should be 'enum Name {{' — found: '{found}'",
|
|
'enum_member_blank': "remove blank line between enum members",
|
|
'enum_member_indent': "enum member must be indented with a single tab — found: '{found}'",
|
|
'enum_no_close': "enum declaration is missing a closing '}'",
|
|
'enum_blank_missing': "missing blank line before the enum section",
|
|
'enum_blank_extra': "remove blank line between enum declarations — enums must be grouped together",
|
|
|
|
# Constants
|
|
'const_position': "const found after {after} — expected order: signal > enum > const > static var > @export > var > @onready",
|
|
'const_blank_missing': "missing blank line before the const section",
|
|
'const_blank_extra': "remove blank line between const declarations — constants must be grouped together",
|
|
|
|
# Static variables
|
|
'static_position': "static var found after {after} — expected order: signal > enum > const > static var > @export > var > @onready",
|
|
'static_blank_missing': "missing blank line before the static var section",
|
|
'static_blank_extra': "remove blank line between static var declarations — static variables must be grouped together",
|
|
|
|
# Export variables
|
|
'export_position': "@export found after {after} — expected order: signal > enum > const > static var > @export > var > @onready",
|
|
'export_blank_missing': "missing blank line before the @export section",
|
|
'export_blank_extra': "remove blank line between @export declarations — export variables must be grouped together",
|
|
|
|
# Regular variables
|
|
'var_position': "var found after {after} — expected order: signal > enum > const > static var > @export > var > @onready",
|
|
'var_blank_missing': "missing blank line before the var section",
|
|
'var_blank_extra': "remove blank line between var declarations — variables must be grouped together",
|
|
|
|
# @onready variables
|
|
'onready_position': "@onready var found after {after} — expected order: signal > enum > const > static var > @export > var > @onready",
|
|
'onready_blank_missing': "missing blank line before the @onready section",
|
|
'onready_blank_extra': "remove blank line between @onready declarations — @onready variables must be grouped together",
|
|
}
|
|
|
|
# ─── Naming conventions ───────────────────────────────────────────────────────
|
|
|
|
PASCAL_CASE = re.compile(r"^[A-Z][A-Za-z0-9]*$")
|
|
SNAKE_CASE = re.compile(r"^_?[a-z][a-z0-9_]*$")
|
|
UPPER_SNAKE_CASE = re.compile(r"^_?[A-Z][A-Z0-9_]*$")
|
|
REGION_RE = re.compile(r"#\s*(region|endregion)\b", re.IGNORECASE)
|
|
|
|
|
|
def _to_snake_case(name: str) -> str:
|
|
prefix = '_' if name.startswith('_') else ''
|
|
core = name.lstrip('_')
|
|
s = re.sub(r'([a-z0-9])([A-Z])', r'\1_\2', core)
|
|
s = re.sub(r'([A-Z]+)([A-Z][a-z])', r'\1_\2', s)
|
|
return prefix + s.lower()
|
|
|
|
|
|
def _to_pascal_case(name: str) -> str:
|
|
prefix = '_' if name.startswith('_') else ''
|
|
core = name.lstrip('_')
|
|
# Split on camelCase boundaries first, then on underscores/spaces
|
|
# e.g. 'myBadEnum' → 'my_Bad_Enum' → 'MyBadEnum'
|
|
snake = re.sub(r'([a-z0-9])([A-Z])', r'\1_\2', core)
|
|
snake = re.sub(r'([A-Z]+)([A-Z][a-z])', r'\1_\2', snake)
|
|
return prefix + ''.join(w.capitalize() for w in re.split(r'[_\s]+', snake) if w)
|
|
|
|
|
|
def _to_upper_snake_case(name: str) -> str:
|
|
prefix = '_' if name.startswith('_') else ''
|
|
core = name.lstrip('_')
|
|
s = re.sub(r'([a-z0-9])([A-Z])', r'\1_\2', core)
|
|
s = re.sub(r'([A-Z]+)([A-Z][a-z])', r'\1_\2', s)
|
|
return prefix + s.upper()
|
|
|
|
|
|
CONVENTION_NAMES: dict[str, str] = {
|
|
'class': 'PascalCase',
|
|
'enum_name': 'PascalCase',
|
|
'enum_member': 'UPPER_SNAKE_CASE',
|
|
'function': 'snake_case',
|
|
'variable': 'snake_case',
|
|
'constant': 'UPPER_SNAKE_CASE',
|
|
'signal': 'snake_case',
|
|
}
|
|
|
|
SUGGESTION_FN: dict = {
|
|
'class': _to_pascal_case,
|
|
'enum_name': _to_pascal_case,
|
|
'enum_member': _to_upper_snake_case,
|
|
'function': _to_snake_case,
|
|
'variable': _to_snake_case,
|
|
'constant': _to_upper_snake_case,
|
|
'signal': _to_snake_case,
|
|
}
|
|
|
|
NAMING_KINDS = frozenset({'class', 'enum_name', 'enum_member', 'function', 'variable', 'constant', 'signal'})
|
|
|
|
# ─── Naming check ─────────────────────────────────────────────────────────────
|
|
|
|
def _check_enum_member(path: str, idx: int, name: str) -> None:
|
|
"""Flag a single enum member name if it is not UPPER_SNAKE_CASE."""
|
|
if name and not UPPER_SNAKE_CASE.match(name):
|
|
issues.append((path, idx, 'enum_member', name))
|
|
|
|
|
|
def check_naming(path: str, lines: list[str]):
|
|
in_enum = False # True while scanning the body of a multi-line enum
|
|
|
|
for idx, line in enumerate(lines, 1):
|
|
stripped = line.strip()
|
|
if stripped.startswith('#') or stripped.startswith('@warning_ignore(') or not stripped:
|
|
continue
|
|
|
|
# ── Enum-body lines ────────────────────────────────────────────────────
|
|
if in_enum:
|
|
close = stripped.find('}')
|
|
if close != -1:
|
|
in_enum = False
|
|
# Any identifiers before the closing brace on this line
|
|
before = stripped[:close]
|
|
for part in before.split(','):
|
|
m = re.match(r"\s*([A-Za-z0-9_]+)", part)
|
|
if m:
|
|
_check_enum_member(path, idx, m.group(1))
|
|
else:
|
|
# One (or more) members on this line: "NAME," or "NAME = val,"
|
|
for part in stripped.split(','):
|
|
m = re.match(r"\s*([A-Za-z0-9_]+)", part)
|
|
if m:
|
|
_check_enum_member(path, idx, m.group(1))
|
|
continue
|
|
# ── End enum-body ──────────────────────────────────────────────────────
|
|
|
|
match_class = re.match(r"class_name\s+([A-Za-z0-9_]+)", stripped)
|
|
if match_class:
|
|
name = match_class.group(1)
|
|
if not PASCAL_CASE.match(name):
|
|
issues.append((path, idx, 'class', name))
|
|
|
|
match_func = re.match(r"(?:static\s+)?func\s+([A-Za-z0-9_]+)\s*(\([^)]*\))?", stripped)
|
|
if match_func:
|
|
name = match_func.group(1)
|
|
if not SNAKE_CASE.match(name):
|
|
issues.append((path, idx, 'function', name))
|
|
params = match_func.group(2)
|
|
if params:
|
|
params = params.strip('()')
|
|
for param in split_params(params):
|
|
param_name = param.split(':')[0].split('=')[0].strip()
|
|
if param_name and not SNAKE_CASE.match(param_name):
|
|
issues.append((path, idx, 'variable', param_name))
|
|
|
|
# Match variable declarations with any annotation/modifier prefix.
|
|
# Handles: var, static var, @export var, @export_range(...) var,
|
|
# @export_multiline var, @onready var, etc.
|
|
# Does NOT match annotation-only lines like @export_category("Difficulty").
|
|
match_var = re.match(r"(?:(?:static|@\w+(?:\([^)]*\))?)\s+)*var\s+([A-Za-z0-9_]+)", stripped)
|
|
if match_var:
|
|
name = match_var.group(1)
|
|
if not SNAKE_CASE.match(name):
|
|
issues.append((path, idx, 'variable', name))
|
|
|
|
match_const = re.match(r"const\s+([A-Za-z0-9_]+)", stripped)
|
|
if match_const:
|
|
name = match_const.group(1)
|
|
if not UPPER_SNAKE_CASE.match(name):
|
|
issues.append((path, idx, 'constant', name))
|
|
|
|
match_enum = re.match(r"enum\s+([A-Za-z0-9_]+)", stripped)
|
|
if match_enum:
|
|
name = match_enum.group(1)
|
|
if not PASCAL_CASE.match(name):
|
|
issues.append((path, idx, 'enum_name', name))
|
|
# Determine whether the enum body is inline or multi-line
|
|
brace = stripped.find('{')
|
|
if brace != -1:
|
|
rest = stripped[brace + 1:]
|
|
close = rest.find('}')
|
|
if close != -1:
|
|
# Inline enum — check members immediately
|
|
for part in rest[:close].split(','):
|
|
m = re.match(r"\s*([A-Za-z0-9_]+)", part)
|
|
if m:
|
|
_check_enum_member(path, idx, m.group(1))
|
|
else:
|
|
# Body continues on following lines
|
|
in_enum = True
|
|
|
|
match_signal = re.match(r"signal\s+([A-Za-z0-9_]+)", stripped)
|
|
if match_signal:
|
|
name = match_signal.group(1)
|
|
if not SNAKE_CASE.match(name):
|
|
issues.append((path, idx, 'signal', name))
|
|
|
|
match_for = re.match(r"for\s+([A-Za-z0-9_]+)(?:\s*:\s*[^\s]+)?\s+in\b", stripped)
|
|
if match_for:
|
|
name = match_for.group(1)
|
|
if not SNAKE_CASE.match(name):
|
|
issues.append((path, idx, 'variable', name))
|
|
|
|
|
|
# ─── Content order check ──────────────────────────────────────────────────────
|
|
|
|
ANNOTATION_LINE_RE = re.compile(
|
|
r"^(?:@(tool|icon|static_unload)(?:\([^\n]*\))?)(?:,\s*@(tool|icon|static_unload)(?:\([^\n]*\))?)*$"
|
|
)
|
|
ALLOWED_ANNOTATION_RE = re.compile(r"@(tool|icon|static_unload)\b")
|
|
|
|
|
|
def check_content_order(path: str, lines: list[str]):
|
|
content = [
|
|
(line.rstrip('\n'), idx)
|
|
for idx, line in enumerate(lines, 1)
|
|
if not line.startswith(' ') # Line is not indented (tab character)
|
|
and not line.lstrip().startswith('#')
|
|
and not line.lstrip().startswith('@warning_ignore(')
|
|
]
|
|
idx = 0
|
|
n = len(content)
|
|
|
|
# 1) Annotations (@tool / @icon / @static_unload must be first)
|
|
if idx < n and ANNOTATION_LINE_RE.fullmatch(content[idx][0].strip()):
|
|
idx += 1
|
|
else:
|
|
for j in range(idx, n):
|
|
if ALLOWED_ANNOTATION_RE.search(content[j][0]):
|
|
issues.append((path, content[j][1], 'annotation_order', {'found': content[j][0].strip()}))
|
|
break
|
|
|
|
# 2) class_name (optional)
|
|
for j in range(idx, n):
|
|
if content[j][0].strip().startswith('class_name'):
|
|
if j != idx:
|
|
issues.append((path, content[j][1], 'class_position', 'class_name'))
|
|
else:
|
|
idx += 1
|
|
break
|
|
|
|
# 3) extends (recommended; missing is flagged but does not block ordering checks)
|
|
extends_pos = None
|
|
for j in range(idx, n):
|
|
if content[j][0].strip().startswith('extends'):
|
|
extends_pos = j
|
|
break
|
|
|
|
if extends_pos is None:
|
|
issues.append((path, 0, 'extends_missing', 'extends'))
|
|
# Don't return — continue ordering checks from current position
|
|
prev_token: str = content[idx - 1][0].strip() if idx > 0 else ''
|
|
else:
|
|
if extends_pos != idx:
|
|
issues.append((path, content[extends_pos][1], 'extends_position', 'extends'))
|
|
idx = extends_pos + 1
|
|
prev_token = content[extends_pos][0].strip()
|
|
|
|
order = ['signal', 'enum', 'const', 'static var', '@export', 'var', '@onready var']
|
|
order_index = {name: i for i, name in enumerate(order)}
|
|
seen: set[str] = set()
|
|
current_order = -1
|
|
j = idx
|
|
while j < n:
|
|
line, line_no = content[j]
|
|
stripped = line.strip()
|
|
if stripped == '':
|
|
prev_token = ''
|
|
j += 1
|
|
continue
|
|
if re.match(r'(?:static\s+)?func\b', stripped):
|
|
break
|
|
token = None
|
|
if stripped.startswith('signal'):
|
|
token = 'signal'
|
|
if not re.fullmatch(r"signal\s+\w+\([^)]*\)", stripped):
|
|
issues.append((path, line_no, 'signal_format', {'found': stripped}))
|
|
if 'signal' in seen and prev_token == '':
|
|
issues.append((path, content[j - 1][1], 'signal_blank_extra', 'signal'))
|
|
seen.add('signal')
|
|
elif stripped.startswith('enum'):
|
|
token = 'enum'
|
|
if not re.fullmatch(r"enum\s+\w+\s*{", stripped):
|
|
issues.append((path, line_no, 'enum_format', {'found': stripped}))
|
|
if 'enum' not in seen:
|
|
if prev_token != '':
|
|
issues.append((path, line_no, 'enum_blank_missing', 'enum'))
|
|
else:
|
|
if prev_token != '}' and prev_token != ']':
|
|
issues.append((path, line_no, 'enum_blank_extra', 'enum'))
|
|
k = j + 1
|
|
while k < n and content[k][0].strip() != '}':
|
|
member, m_line_no = content[k]
|
|
if member.strip() == '':
|
|
issues.append((path, m_line_no, 'enum_member_blank', 'enum'))
|
|
if not member.startswith('\t') or member.startswith('\t\t'):
|
|
issues.append((path, m_line_no, 'enum_member_indent', {'found': member.strip()}))
|
|
k += 1
|
|
if k >= n:
|
|
issues.append((path, line_no, 'enum_no_close', 'enum'))
|
|
return
|
|
j = k
|
|
prev_token = '}'
|
|
seen.add('enum')
|
|
curr_order = order_index['enum']
|
|
if curr_order < current_order:
|
|
after_token = order[current_order]
|
|
issues.append((path, line_no, 'enum_position', {'after': after_token}))
|
|
else:
|
|
current_order = max(current_order, curr_order)
|
|
j += 1
|
|
continue
|
|
elif stripped.startswith('const '):
|
|
token = 'const'
|
|
if 'const' not in seen:
|
|
if prev_token != '':
|
|
issues.append((path, line_no, 'const_blank_missing', 'const'))
|
|
else:
|
|
if prev_token != 'const' and prev_token != '}' and prev_token != ']':
|
|
issues.append((path, line_no, 'const_blank_extra', 'const'))
|
|
seen.add('const')
|
|
elif stripped.startswith('static var '):
|
|
token = 'static var'
|
|
if 'static var' not in seen:
|
|
if prev_token != '':
|
|
issues.append((path, line_no, 'static_blank_missing', 'static var'))
|
|
else:
|
|
if prev_token != 'static var' and prev_token != '}' and prev_token != ']':
|
|
issues.append((path, line_no, 'static_blank_extra', 'static var'))
|
|
seen.add('static var')
|
|
elif stripped.startswith('@export'):
|
|
token = '@export'
|
|
if '@export' not in seen:
|
|
if prev_token != '':
|
|
issues.append((path, line_no, 'export_blank_missing', '@export'))
|
|
else:
|
|
if prev_token != '@export' and prev_token != '}' and prev_token != ']':
|
|
issues.append((path, line_no, 'export_blank_extra', '@export'))
|
|
seen.add('@export')
|
|
elif stripped.startswith('var '):
|
|
token = 'var'
|
|
if 'var' not in seen:
|
|
if prev_token != '':
|
|
issues.append((path, line_no, 'var_blank_missing', 'var'))
|
|
else:
|
|
if prev_token != 'var' and prev_token != '}' and prev_token != ']':
|
|
issues.append((path, line_no, 'var_blank_extra', 'var'))
|
|
seen.add('var')
|
|
elif stripped.startswith('@onready var '):
|
|
token = '@onready var'
|
|
if '@onready var' not in seen:
|
|
if prev_token != '':
|
|
issues.append((path, line_no, 'onready_blank_missing', '@onready var'))
|
|
else:
|
|
if prev_token != '@onready var' and prev_token != '}' and prev_token != ']':
|
|
issues.append((path, line_no, 'onready_blank_extra', '@onready var'))
|
|
seen.add('@onready var')
|
|
else:
|
|
prev_token = stripped
|
|
j += 1
|
|
continue
|
|
|
|
curr_order = order_index[token]
|
|
key_map = {
|
|
'signal': 'signal_position',
|
|
'enum': 'enum_position',
|
|
'const': 'const_position',
|
|
'static var': 'static_position',
|
|
'@export': 'export_position',
|
|
'var': 'var_position',
|
|
'@onready var': 'onready_position',
|
|
}
|
|
if curr_order < current_order:
|
|
after_token = order[current_order]
|
|
issues.append((path, line_no, key_map[token], {'after': after_token}))
|
|
else:
|
|
current_order = max(current_order, curr_order)
|
|
|
|
prev_token = token
|
|
j += 1
|
|
|
|
|
|
# ─── Function spacing check ───────────────────────────────────────────────────
|
|
|
|
def check_func_spacing(path: str):
|
|
with open(path, 'r', encoding='utf-8') as file:
|
|
lines = file.readlines()
|
|
for idx, line in enumerate(lines):
|
|
stripped_line = line.lstrip()
|
|
if re.match(r'(?:static\s+)?func\b', stripped_line):
|
|
if re.match(r'(?:static\s+)?func\s*\(', stripped_line):
|
|
continue
|
|
start_idx = idx
|
|
# Skip annotations and regular comments above the function
|
|
while start_idx > 0:
|
|
prev_line = lines[start_idx - 1].lstrip()
|
|
if prev_line.startswith('@warning_ignore('):
|
|
start_idx -= 1
|
|
elif prev_line.startswith('#') and not REGION_RE.match(prev_line):
|
|
start_idx -= 1
|
|
else:
|
|
break
|
|
test_index = start_idx - 1
|
|
blank_count = 0
|
|
while test_index >= 0:
|
|
stripped = lines[test_index].lstrip()
|
|
if stripped == '':
|
|
blank_count += 1
|
|
test_index -= 1
|
|
continue
|
|
if stripped.startswith('@warning_ignore('):
|
|
test_index -= 1
|
|
continue
|
|
if stripped.startswith('#') and not REGION_RE.match(stripped):
|
|
test_index -= 1
|
|
continue
|
|
break
|
|
region_above = test_index >= 0 and REGION_RE.match(lines[test_index].lstrip())
|
|
if region_above:
|
|
if blank_count > 1:
|
|
issues.append((path, idx + 1, 'func_blank', {'found': blank_count}))
|
|
continue
|
|
elif blank_count != 2:
|
|
if not (blank_count == 1 and test_index >= 0 and lines[test_index].lstrip().startswith('#region')):
|
|
issues.append((path, idx + 1, 'func_blank', {'found': blank_count}))
|
|
|
|
|
|
# ─── Main ─────────────────────────────────────────────────────────────────────
|
|
|
|
for root, dirs, files in os.walk('.', topdown=True):
|
|
rel_root = os.path.relpath(root, '.')
|
|
if any(rel_root == excluded or rel_root.startswith(f"{excluded}{os.sep}") for excluded in EXCLUDED_DIRS):
|
|
dirs[:] = []
|
|
continue
|
|
for fname in files:
|
|
if not fname.endswith('.gd'):
|
|
continue
|
|
path = os.path.join(root, fname)
|
|
rel_path = os.path.normpath(os.path.relpath(path, '.'))
|
|
if rel_path in EXCLUDED_FILES:
|
|
continue
|
|
try:
|
|
with open(path, 'r', encoding='utf-8') as file:
|
|
lines = file.readlines()
|
|
except Exception as e:
|
|
issues.append((path, 0, 'error', f'Could not read file: {e}'))
|
|
continue
|
|
check_naming(path, lines)
|
|
check_content_order(path, lines)
|
|
check_func_spacing(path)
|
|
|
|
|
|
# ─── Output ───────────────────────────────────────────────────────────────────
|
|
|
|
ORDERING_KINDS = frozenset({
|
|
'annotation_order', 'class_position', 'extends_position', 'extends_missing',
|
|
'signal_position', 'enum_position', 'const_position', 'static_position',
|
|
'export_position', 'var_position', 'onready_position',
|
|
})
|
|
FORMATTING_KINDS = frozenset({
|
|
'func_blank',
|
|
'signal_format', 'signal_blank_extra',
|
|
'enum_format', 'enum_blank_missing', 'enum_blank_extra',
|
|
'enum_member_blank', 'enum_member_indent', 'enum_no_close',
|
|
'const_blank_missing', 'const_blank_extra',
|
|
'static_blank_missing', 'static_blank_extra',
|
|
'export_blank_missing', 'export_blank_extra',
|
|
'var_blank_missing', 'var_blank_extra',
|
|
'onready_blank_missing', 'onready_blank_extra',
|
|
})
|
|
|
|
|
|
def categorize(kind: str) -> str:
|
|
if kind in NAMING_KINDS:
|
|
return 'naming'
|
|
if kind in ORDERING_KINDS:
|
|
return 'ordering'
|
|
if kind in FORMATTING_KINDS:
|
|
return 'formatting'
|
|
return 'other'
|
|
|
|
|
|
_KIND_LABEL: dict[str, str] = {
|
|
'class': 'class names',
|
|
'enum_name': 'enum names',
|
|
'enum_member': 'enum member names',
|
|
'function': 'function names',
|
|
'variable': 'variable names',
|
|
'constant': 'constant names',
|
|
'signal': 'signal names',
|
|
}
|
|
|
|
|
|
def format_message(kind: str, data) -> str:
|
|
if kind in NAMING_KINDS:
|
|
suggestion = SUGGESTION_FN[kind](data)
|
|
conv = CONVENTION_NAMES[kind]
|
|
label = _KIND_LABEL.get(kind, f"{kind}s")
|
|
return f"'{data}' should be '{suggestion}' ({label} must be {conv})"
|
|
if kind == 'error':
|
|
return str(data)
|
|
template = MESSAGES.get(kind, kind)
|
|
if isinstance(data, dict):
|
|
return template.format(**data)
|
|
return template
|
|
|
|
|
|
if not issues:
|
|
print("✅ All GDScript files follow the naming conventions.")
|
|
sys.exit(0)
|
|
|
|
# Group issues by file, sort by line number within each file
|
|
by_file: dict = defaultdict(list)
|
|
counts: Counter = Counter()
|
|
for path, line_no, kind, data in issues:
|
|
by_file[path].append((line_no, kind, data))
|
|
counts[categorize(kind)] += 1
|
|
|
|
total = len(issues)
|
|
file_count = len(by_file)
|
|
|
|
summary_parts = []
|
|
for cat in ('naming', 'ordering', 'formatting', 'other'):
|
|
if counts[cat]:
|
|
summary_parts.append(f"{counts[cat]} {cat}")
|
|
summary = ', '.join(summary_parts)
|
|
|
|
print(f"### ❌ GDScript Naming Convention Check Failed\n")
|
|
print(f"**{total} issue{'s' if total != 1 else ''}** in {file_count} file{'s' if file_count != 1 else ''} ({summary})\n")
|
|
|
|
for fpath in sorted(by_file):
|
|
file_issues = sorted(by_file[fpath], key=lambda x: x[0])
|
|
count = len(file_issues)
|
|
print("<details>")
|
|
print(f"<summary><code>{fpath}</code> — {count} issue{'s' if count != 1 else ''}</summary>\n")
|
|
print("| Line | Issue |")
|
|
print("|------|-------|")
|
|
for line_no, kind, data in file_issues:
|
|
msg = format_message(kind, data)
|
|
print(f"| {line_no} | {msg} |")
|
|
print("\n</details>\n")
|
|
|
|
sys.exit(1)
|