mirror of
https://github.com/astral-sh/ruff.git
synced 2026-11-21 12:16:15 +08:00
## Summary Use a shared ty override for Ruff’s standalone scripts now that PEP 723 scripts can inherit project settings. Fix the diagnostics in the two PR automation scripts so they can use the same checks. ## Notes to reviewers All 28 standalone scripts passed ty with locked dependencies, and the changed-file hooks and mocked workflow checks passed. --------- Co-authored-by: Alex Waygood <alex.waygood@gmail.com>
257 lines
6.7 KiB
Python
Executable File
257 lines
6.7 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
#
|
|
# /// script
|
|
# requires-python = ">=3.12"
|
|
# dependencies = []
|
|
#
|
|
# [tool.uv]
|
|
# no-build = true
|
|
# exclude-newer = "P7D"
|
|
# require-build-hashes = true
|
|
# preview-features = ["build-dependency-hashes", "missing-exclude-newer-package-lock"]
|
|
# ///
|
|
|
|
"""Generate boilerplate for a new rule.
|
|
|
|
Example usage:
|
|
|
|
python scripts/add_rule.py \
|
|
--name PreferListBuiltin \
|
|
--prefix PIE \
|
|
--code 807 \
|
|
--linter flake8-pie \
|
|
--category pedantic
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import argparse
|
|
import re
|
|
import subprocess
|
|
from pathlib import Path
|
|
|
|
ROOT_DIR = Path(__file__).resolve().parent.parent
|
|
|
|
|
|
def dir_name(linter_name: str) -> str:
|
|
return linter_name.replace("-", "_")
|
|
|
|
|
|
def pascal_case(linter_name: str) -> str:
|
|
"""Convert from snake-case to PascalCase."""
|
|
return "".join(word.title() for word in linter_name.split("-"))
|
|
|
|
|
|
def snake_case(name: str) -> str:
|
|
"""Convert from PascalCase to snake_case."""
|
|
return "".join(
|
|
f"_{word.lower()}" if word.isupper() else word for word in name
|
|
).lstrip("_")
|
|
|
|
|
|
def get_indent(line: str) -> str:
|
|
return re.match(r"^\s*", line).group() # type: ignore[union-attr, ty:missing-union-attribute]
|
|
|
|
|
|
def main(*, name: str, prefix: str, code: str, linter: str, category: str) -> None:
|
|
"""Generate boilerplate for a new rule."""
|
|
# Create a test fixture.
|
|
filestem = f"{prefix}{code}" if linter != "pylint" else snake_case(name)
|
|
with (
|
|
ROOT_DIR
|
|
/ "crates/ruff_linter/resources/test/fixtures"
|
|
/ dir_name(linter)
|
|
/ f"{filestem}.py"
|
|
).open("a"):
|
|
pass
|
|
|
|
plugin_module = ROOT_DIR / "crates/ruff_linter/src/rules" / dir_name(linter)
|
|
rule_name_snake = snake_case(name)
|
|
|
|
# Add the relevant `#testcase` macro.
|
|
mod_rs = plugin_module / "mod.rs"
|
|
content = mod_rs.read_text()
|
|
|
|
with mod_rs.open("w") as fp:
|
|
has_added_testcase = False
|
|
lines = []
|
|
for line in content.splitlines():
|
|
if not has_added_testcase and (
|
|
line.strip() == "fn rules(rule_code: Rule, path: &Path) -> Result<()> {"
|
|
):
|
|
indent = get_indent(line)
|
|
lines.append(
|
|
f'{indent}#[test_case(Rule::{name}, Path::new("{filestem}.py"))]',
|
|
)
|
|
fp.write("\n".join(lines))
|
|
fp.write("\n")
|
|
lines.clear()
|
|
has_added_testcase = True
|
|
|
|
if has_added_testcase:
|
|
fp.write(line)
|
|
fp.write("\n")
|
|
elif line.strip() == "":
|
|
fp.write("\n".join(lines))
|
|
fp.write("\n\n")
|
|
lines.clear()
|
|
else:
|
|
lines.append(line)
|
|
|
|
# Add the exports
|
|
rules_dir = plugin_module / "rules"
|
|
rules_mod = rules_dir / "mod.rs"
|
|
|
|
contents = rules_mod.read_text()
|
|
parts = contents.split("\n\n")
|
|
|
|
new_pub_use = f"pub(crate) use {rule_name_snake}::*"
|
|
new_mod = f"mod {rule_name_snake};"
|
|
|
|
if len(parts) == 2:
|
|
new_contents = parts[0]
|
|
new_contents += "\n" + new_pub_use + ";"
|
|
new_contents += "\n\n"
|
|
new_contents += parts[1] + new_mod
|
|
new_contents += "\n"
|
|
|
|
rules_mod.write_text(new_contents)
|
|
else:
|
|
with rules_mod.open("a") as fp:
|
|
fp.write(f"{new_pub_use};")
|
|
fp.write("\n\n")
|
|
fp.write(f"{new_mod}")
|
|
fp.write("\n")
|
|
|
|
# Add the relevant rule function.
|
|
with (rules_dir / f"{rule_name_snake}.rs").open("w") as fp:
|
|
fp.write(
|
|
f"""\
|
|
use ruff_macros::{{ViolationMetadata, derive_message_formats}};
|
|
|
|
use crate::Violation;
|
|
use crate::checkers::ast::Checker;
|
|
use crate::codes::Category;
|
|
|
|
/// ## What it does
|
|
///
|
|
/// ## Why is this bad?
|
|
///
|
|
/// ## Example
|
|
/// ```python
|
|
/// ```
|
|
///
|
|
/// Use instead:
|
|
/// ```python
|
|
/// ```
|
|
#[derive(ViolationMetadata)]
|
|
#[violation_metadata(preview_since = "NEXT_RUFF_VERSION", category = Category::{pascal_case(category)})]
|
|
pub(crate) struct {name};
|
|
|
|
impl Violation for {name} {{
|
|
#[derive_message_formats]
|
|
fn message(&self) -> String {{
|
|
format!("TODO: write message: {{}}", todo!("implement message"))
|
|
}}
|
|
}}
|
|
""",
|
|
)
|
|
fp.write(
|
|
f"""
|
|
/// {prefix}{code}
|
|
pub(crate) fn {rule_name_snake}(checker: &mut Checker) {{}}
|
|
""",
|
|
)
|
|
|
|
text = ""
|
|
with (ROOT_DIR / "crates/ruff_linter/src/codes.rs").open("r") as fp:
|
|
while (line := next(fp)).strip() != f"// {linter}":
|
|
text += line
|
|
text += line
|
|
|
|
lines = []
|
|
while (line := next(fp)).strip() != "":
|
|
lines.append(line)
|
|
|
|
variant = pascal_case(linter)
|
|
linter_name = linter.split(" ", maxsplit=1)[0].replace("-", "_")
|
|
rule = f"""rules::{linter_name}::rules::{name}"""
|
|
lines.append(
|
|
" " * 8 + f"""({variant}, "{code}") => {rule},\n""",
|
|
)
|
|
lines.sort()
|
|
text += "".join(lines)
|
|
text += "\n"
|
|
text += fp.read()
|
|
with (ROOT_DIR / "crates/ruff_linter/src/codes.rs").open("w") as fp:
|
|
fp.write(text)
|
|
|
|
_rustfmt(rules_mod)
|
|
|
|
|
|
def _rustfmt(path: str | Path) -> None:
|
|
subprocess.run(["rustfmt", path], check=True)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
parser = argparse.ArgumentParser(
|
|
description="Generate boilerplate for a new rule.",
|
|
epilog=(
|
|
"python scripts/add_rule.py "
|
|
"--name PreferListBuiltin --code PIE807 --linter flake8-pie "
|
|
"--category pedantic"
|
|
),
|
|
)
|
|
parser.add_argument(
|
|
"--name",
|
|
type=str,
|
|
required=True,
|
|
help=(
|
|
"The name of the check to generate, in PascalCase "
|
|
"(e.g., 'PreferListBuiltin')."
|
|
),
|
|
)
|
|
parser.add_argument(
|
|
"--prefix",
|
|
type=str,
|
|
required=True,
|
|
help="Prefix code for the plugin (e.g. 'PIE').",
|
|
)
|
|
parser.add_argument(
|
|
"--code",
|
|
type=str,
|
|
required=True,
|
|
help="The code of the check to generate (e.g., '807').",
|
|
)
|
|
parser.add_argument(
|
|
"--linter",
|
|
type=str,
|
|
required=True,
|
|
help="The source with which the check originated (e.g., 'flake8-pie').",
|
|
)
|
|
parser.add_argument(
|
|
"--category",
|
|
choices=(
|
|
"correctness",
|
|
"suspicious",
|
|
"complexity",
|
|
"performance",
|
|
"style",
|
|
"security",
|
|
"formatting",
|
|
"pedantic",
|
|
"restriction",
|
|
),
|
|
required=True,
|
|
help="The semantic category for the rule.",
|
|
)
|
|
args = parser.parse_args()
|
|
|
|
main(
|
|
name=args.name,
|
|
prefix=args.prefix,
|
|
code=args.code,
|
|
linter=args.linter,
|
|
category=args.category,
|
|
)
|