dotless 1.0.0__py3-none-any.whl

dotless/__init__.py

@@ -0,0 +1,3 @@
+"""dotless: find dotted/dotless I bugs caused by locale-dependent case mapping."""
+
+__version__ = "1.0.0"

dotless/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

dotless/analysis.py

@@ -0,0 +1,350 @@
+"""Decide how serious a locale-dependent case conversion is.
+
+Only one character pair behaves differently in Turkic locales: I/i.
+That makes equality checks against ASCII constants decidable:
+
+* lowering, then comparing with a constant that contains 'i'  -> broken
+* lowering, then comparing with a constant without any 'i'    -> unaffected
+* upper-casing works the same way with 'I'
+
+A site is reported as ``high`` when its result is compared with an
+affected ASCII constant or is used as a lookup key (hash table, key file,
+dictionary, MIME type, file extension ...). A site whose only uses are
+comparisons with unaffected constants is not reported at all. Everything
+else is ``low``.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+from .lexer import Source, literal_value
+
+LOWER, UPPER, BOTH = "lower", "upper", "both"
+
+_CMP_OP = re.compile(r"\s*(===|!==|==|!=)\s*(?:(?:Ok|Some)\s*\(\s*)?")
+_CMP_OP_BEFORE = re.compile(r"(===|!==|==|!=)\s*$")
+_PY_IN = re.compile(r"\s*(?:not\s+)?in\s*([(\[{])")
+_METHOD_AFTER = re.compile(r"\s*\.\s*(\w+)\s*\(")
+_IDENT_BEFORE = re.compile(r"([A-Za-z_$][\w$]*(?:\s*(?:\.|->|::)\s*[A-Za-z_$][\w$]*)*)\s*$")
+_ASSIGN_BEFORE = re.compile(
+    r"([A-Za-z_$][\w$]*)\s*(?:\[[^\]]*\]\s*)?=\s*(?:\(\s*(?:const\s+)?\w+\s*\**\s*\)\s*)?$"
+)
+_CASE_LABEL = re.compile(r"\bcase\s+")
+
+COMPARE_FUNCS = {
+    "strcmp", "strncmp", "g_strcmp0", "g_str_equal", "g_str_has_prefix",
+    "g_str_has_suffix", "strstr", "g_strrstr", "strcasecmp", "strncasecmp",
+    "g_ascii_strcasecmp", "g_ascii_strncasecmp", "g_strv_contains", "memcmp",
+    "streq", "g_strcasecmp", "g_strncasecmp", "strcasestr", "g_regex_match_simple",
+    "g_pattern_match_simple",
+}
+COMPARE_METHODS = {
+    "has_prefix", "has_suffix", "contains", "startsWith", "endsWith",
+    "includes", "indexOf", "startswith", "endswith", "find", "index",
+    "equals", "equal", "match", "test", "search", "replace", "split",
+}
+KEY_FUNC_PREFIXES = (
+    "g_hash_table_", "g_tree_", "g_key_file_", "g_settings_", "g_quark_",
+    "g_intern_", "g_datalist_", "g_dataset_", "g_content_type_", "g_mime_",
+    "g_variant_lookup", "g_variant_dict_", "g_object_get_data", "g_object_set_data",
+    "g_file_info_get_attribute", "g_file_info_set_attribute", "bsearch",
+    "g_app_info_get_default_for_type", "g_application_get_", "g_type_from_name",
+    "g_enum_get_value_by_", "g_flags_get_value_by_",
+)
+KEY_METHODS = {
+    "lookup", "lookup_extended", "get", "has", "has_key", "contains_key",
+    "get_string", "get_boolean", "get_int", "get_value", "get_data",
+    "setdefault", "pop",
+}
+# Storing a converted key is only a problem if something later looks it up
+# with a differently converted string; that is not visible locally.
+INSERT_FUNCS = {
+    "g_hash_table_add", "g_hash_table_insert", "g_hash_table_replace",
+    "g_tree_insert", "g_tree_replace", "insert", "set", "add", "push", "append",
+}
+# Calls and methods that pass a string through without changing its case.
+TRANSPARENT_FUNCS = {
+    "from_ptr", "from", "String", "str", "CStr", "Some", "Ok", "g_strstrip",
+    "g_strchomp", "g_strchug", "strip", "trim",
+}
+TRANSPARENT_METHODS = {
+    "to_str", "to_bytes", "to_string_lossy", "to_string", "to_owned", "unwrap",
+    "as_str", "as_ref", "strip", "trim", "toString", "get_string",
+}
+IGNORED_USES = {"g_free", "free", "g_clear_pointer", "g_strfreev", "g_steal_pointer", "g_strdup", "strlen"}
+# Variable names that mark machine-readable identifiers. "key" and
+# "keyword" are deliberately absent: in GNOME code they usually hold
+# keyboard keys or user search terms.
+KEYISH_WORDS = {
+    "ext", "exts", "extension", "extensions", "suffix", "mime", "mimetype",
+    "scheme", "protocol", "proto", "charset", "encoding", "codeset", "header",
+}
+_DEFINE = re.compile(r'^[ 	]*#[ 	]*define[ 	]+(\w+)[ 	]+("(?:[^"\
+]|\.)*")[ 	]*$', re.M)
+
+
+@dataclass
+class Verdict:
+    severity: str | None  # "high", "low" or None (provably unaffected)
+    reason: str
+
+
+def _affected(value: str, kind: str) -> bool:
+    if not value.isascii():
+        return False
+    if kind == LOWER:
+        return "i" in value
+    if kind == UPPER:
+        return "I" in value
+    return "i" in value or "I" in value
+
+
+def _ident_words(name: str) -> set[str]:
+    spaced = re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", name).lower()
+    return {w for w in re.split(r"[_\W]+", spaced) if w}
+
+
+def is_keyish(name: str) -> bool:
+    words = _ident_words(name)
+    if words & KEYISH_WORDS:
+        return True
+    return "content_type" in "_".join(words) or "mime_type" in "_".join(words)
+
+
+_BRACKETS = {"(": ")", "[": "]", "{": "}"}
+_match_cache: tuple[str, dict[int, int]] = ("", {})
+
+
+def _bracket_map(bare: str) -> dict[int, int]:
+    """Offset of every opening bracket -> offset just past its closer.
+
+    Computed once per file in a single pass. A mismatched closer (macro
+    tricks, broken code) closes the innermost open bracket; brackets left
+    open at the end map to the end of the text.
+    """
+    global _match_cache
+    if _match_cache[0] is bare:
+        return _match_cache[1]
+    result: dict[int, int] = {}
+    stack: list[int] = []
+    for i, c in enumerate(bare):
+        if c in _BRACKETS:
+            stack.append(i)
+        elif c in ")]}" and stack:
+            result[stack.pop()] = i + 1
+    n = len(bare)
+    for i in stack:
+        result[i] = n
+    _match_cache = (bare, result)
+    return result
+
+
+def matching_close(bare: str, open_idx: int) -> int:
+    """Index just past the bracket matching ``bare[open_idx]``."""
+    return _bracket_map(bare).get(open_idx, len(bare))
+
+
+def enclosing(bare: str, pos: int, limit: int = 2000) -> tuple[int, str, int] | None:
+    """Innermost unclosed ( or [ before ``pos`` and the name in front of it.
+
+    Returns (offset of the bracket, name, offset where the possibly
+    qualified name starts). ``name`` is "[" for subscripts. Stops at
+    statement boundaries.
+    """
+    depth = 0
+    i = pos - 1
+    stop = max(0, pos - limit)
+    while i >= stop:
+        c = bare[i]
+        if c in ")]":
+            depth += 1
+        elif c in "([":
+            if depth == 0:
+                if c == "[":
+                    return i, "[", i
+                m = _IDENT_BEFORE.search(bare, max(0, i - 200), i)
+                if not m:
+                    return i, "", i
+                return i, re.split(r"\s*(?:\.|->|::)\s*", m.group(1))[-1], m.start(1)
+            depth -= 1
+        elif c in ";{}" and depth == 0:
+            return None
+        i -= 1
+    return None
+
+
+def defines(src: Source) -> dict[str, str]:
+    """``#define NAME "literal"`` constants of a file (cached on ``src``)."""
+    cached = getattr(src, "_dotless_defines", None)
+    if cached is None:
+        cached = {m.group(1): literal_value(m.group(2)) for m in _DEFINE.finditer(src.text)} if "#" in src.text else {}
+        src._dotless_defines = cached
+    return cached
+
+
+def literals_in(src: Source, start: int, end: int) -> list[str]:
+    """Literal values in text[start:end], including #define'd constants."""
+    out = []
+    consts = defines(src)
+    if consts:
+        for m in re.finditer(r"[A-Za-z_]\w*", src.bare[start:end]):
+            v = consts.get(m.group(0))
+            if v is not None:
+                out.append(v)
+    for s, e in src.strings:
+        if s >= end:
+            break
+        if s >= start:
+            v = literal_value(src.text[s:e])
+            if v is not None:
+                out.append(v)
+    return out
+
+
+def judge_literals(values: list[str], kind: str, what: str) -> Verdict | None:
+    if not values:
+        return None
+    hit = next((v for v in values if _affected(v, kind)), None)
+    if hit is not None:
+        return Verdict("high", f"{what} {_show(hit)}")
+    return Verdict(None, f"{what} only constants without i/I")
+
+
+def _show(v: str) -> str:
+    v = v if len(v) <= 40 else v[:37] + "..."
+    return '"' + v.replace("\n", "\\n") + '"'
+
+
+def _literal_ending_at(src: Source, end: int) -> str | None:
+    for s, e in reversed(src.strings):
+        if e == end:
+            return literal_value(src.text[s:e])
+        if e < end:
+            return None
+    return None
+
+
+def judge_expression(src: Source, start: int, end: int, kind: str, lang: str, depth: int = 0) -> Verdict | None:
+    """Look at how the value of ``text[start:end]`` is used.
+
+    Returns a Verdict when the use is decidable, None otherwise.
+    """
+    bare = src.bare
+
+    # Skip case-preserving method chains: expr.to_str().unwrap() == "lit"
+    while True:
+        m = _METHOD_AFTER.match(bare, end)
+        if not m or m.group(1) not in TRANSPARENT_METHODS:
+            break
+        end = matching_close(bare, m.end() - 1)
+
+    # expr == "lit"
+    m = _CMP_OP.match(bare, end)
+    if m:
+        span = src.string_at(m.end())
+        if span:
+            v = literal_value(src.text[span[0] : span[1]])
+            if v is not None:
+                return judge_literals([v], kind, "compared with")
+    # "lit" == expr
+    m = _CMP_OP_BEFORE.search(bare, max(0, start - 50), start)
+    if m:
+        k = m.start()
+        while k > 0 and bare[k - 1].isspace():
+            k -= 1
+        v = _literal_ending_at(src, k)
+        if v is not None:
+            return judge_literals([v], kind, "compared with")
+
+    # expr in ("a", "b")
+    if lang == "python":
+        m = _PY_IN.match(bare, end)
+        if m:
+            close = matching_close(bare, m.end() - 1)
+            return judge_literals(literals_in(src, m.end(), close), kind, "checked for membership in")
+
+    # expr.endsWith(".ini") / expr.has_suffix (".ini")
+    m = _METHOD_AFTER.match(bare, end)
+    if m:
+        close = matching_close(bare, m.end() - 1)
+        if m.group(1) in COMPARE_METHODS:
+            v = judge_literals(literals_in(src, m.end(), close), kind, f"passed to .{m.group(1)}() with")
+            if v:
+                return v
+
+    enc = enclosing(bare, start)
+    if enc is None:
+        return None
+    open_idx, name, name_start = enc
+    if name == "[":
+        return Verdict("high", "used as a subscript key")
+    if name == "switch":
+        close = matching_close(bare, open_idx)
+        brace = bare.find("{", close)
+        if brace >= 0 and not bare[close:brace].strip():
+            body_end = matching_close(bare, brace)
+            labels = []
+            for cm in _CASE_LABEL.finditer(bare, brace, body_end):
+                span = src.string_at(cm.end())
+                if span:
+                    v = literal_value(src.text[span[0] : span[1]])
+                    if v is not None:
+                        labels.append(v)
+            return judge_literals(labels, kind, "switch case")
+        return None
+    close = matching_close(bare, open_idx)
+    if name in TRANSPARENT_FUNCS and depth < 3:
+        return judge_expression(src, name_start, close, kind, lang, depth + 1)
+    if name in COMPARE_FUNCS or name in COMPARE_METHODS:
+        return judge_literals(literals_in(src, open_idx, close), kind, f"passed to {name}() with")
+    if name in INSERT_FUNCS:
+        return Verdict("low", f"stored as a key with {name}()")
+    if name.startswith(KEY_FUNC_PREFIXES) or name in KEY_METHODS:
+        return Verdict("high", f"used as a lookup key in {name}()")
+    if name in IGNORED_USES:
+        return Verdict(None, f"only passed to {name}()")
+    return None
+
+
+def judge_call(src: Source, start: int, end: int, kind: str, lang: str) -> Verdict:
+    """Severity for a locale-dependent call spanning text[start:end]."""
+    direct = judge_expression(src, start, end, kind, lang)
+    if direct is not None:
+        return direct
+
+    # Result stored in a variable: follow it for a while.
+    bare = src.bare
+    # Assignments sit right before the call; a bounded window keeps very
+    # long lines (minified or generated code) linear.
+    line_start = max(bare.rfind("\n", 0, start) + 1, start - 300)
+    m = _ASSIGN_BEFORE.search(bare, line_start, start)
+    if m:
+        var = m.group(1)
+        if is_keyish(var):
+            return Verdict("high", f"stored in `{var}` (looks like a key, extension, MIME type or protocol name)")
+        return _follow_variable(src, var, end, kind, lang)
+    return Verdict("low", "result not compared with a constant nearby")
+
+
+def _follow_variable(src: Source, var: str, from_off: int, kind: str, lang: str) -> Verdict:
+    bare = src.bare
+    end_line = src.line_of(from_off) + 60
+    limit = src.line_offset(end_line)
+    use = re.compile(r"(?<![\w$.>])" + re.escape(var) + r"(?![\w$])")
+    verdicts: list[Verdict] = []
+    undecided = False
+    for m in use.finditer(bare, from_off, limit):
+        if re.match(r"\s*=(?!=)", bare[m.end() : m.end() + 3]):
+            break  # reassigned
+        v = judge_expression(src, m.start(), m.end(), kind, lang)
+        if v is None:
+            undecided = True
+            continue
+        if v.severity == "high":
+            return Verdict("high", f"stored in `{var}`, which is {v.reason} (line {src.line_of(m.start())})")
+        verdicts.append(v)
+    if verdicts and not undecided:
+        return Verdict(None, f"`{var}` is {verdicts[0].reason}")
+    return Verdict("low", f"stored in `{var}`; no comparison with an affected constant found")

dotless/cli.py

@@ -0,0 +1,173 @@
+"""Command line interface.
+
+Exit status: 0 nothing found (or ``--exit-zero``), 1 findings reported,
+2 usage or configuration error. ``dotless run`` uses 0 for identical
+output, 1 for differences and 2 when it cannot run the comparison.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+
+from . import __version__
+from .rules import RULES, SEVERITIES
+
+EXIT_OK, EXIT_FINDINGS, EXIT_ERROR = 0, 1, 2
+
+
+def _err(msg: str) -> None:
+    print(f"dotless: {msg}", file=sys.stderr)
+
+
+def use_color(mode: str, stream) -> bool:
+    """Colour for --color=auto follows NO_COLOR and whether ``stream`` is a terminal."""
+    if mode == "always":
+        return True
+    if mode == "never":
+        return False
+    return "NO_COLOR" not in os.environ and hasattr(stream, "isatty") and stream.isatty()
+
+
+def _write(text: str) -> None:
+    try:
+        sys.stdout.write(text)
+        sys.stdout.flush()
+    except BrokenPipeError:
+        # The reader went away (e.g. `dotless scan . | head`); stop quietly.
+        devnull = os.open(os.devnull, os.O_WRONLY)
+        os.dup2(devnull, sys.stdout.fileno())
+
+
+def _scan(args: argparse.Namespace) -> int:
+    from . import config, formats
+    from .scanner import scan_paths
+
+    for p in args.paths:
+        if not os.path.exists(p):
+            _err(f"{p}: no such file or directory")
+            return EXIT_ERROR
+    bad = [r for r in args.disable if r not in RULES]
+    if bad:
+        _err(f"unknown rule id(s): {', '.join(bad)} (see `dotless rules`)")
+        return EXIT_ERROR
+
+    cfg = config.Config()
+    path = args.config if args.config else (None if args.no_config else config.find_pyproject(os.getcwd()))
+    if args.config and not os.path.isfile(args.config):
+        _err(f"{args.config}: no such file")
+        return EXIT_ERROR
+    if path:
+        try:
+            cfg, warning = config.load(path)
+        except (config.ConfigError, OSError) as e:
+            _err(str(e))
+            return EXIT_ERROR
+        if warning:
+            _err(f"warning: {warning}")
+
+    min_severity = args.min_severity or cfg.min_severity or "low"
+    errors: list[str] = []
+    findings, files = scan_paths(
+        args.paths,
+        min_severity,
+        excludes=cfg.exclude + args.exclude,
+        disable=cfg.disable + args.disable,
+        force_exclude=args.force_exclude,
+        errors=errors,
+    )
+    for e in errors:
+        _err(f"warning: cannot read {e}")
+
+    if args.format == "text":
+        stream = sys.stdout if args.output is None else None
+        out = formats.text(findings, files, color=stream is not None and use_color(args.color, stream))
+    else:
+        out = formats.FORMATS[args.format](findings, files)
+        print(formats.summary(findings, files), file=sys.stderr)
+    if args.output:
+        try:
+            with open(args.output, "w", encoding="utf-8", newline="\n") as fh:
+                fh.write(out)
+        except OSError as e:
+            _err(f"{args.output}: {e.strerror or e}")
+            return EXIT_ERROR
+    else:
+        _write(out)
+    return EXIT_FINDINGS if findings and not args.exit_zero else EXIT_OK
+
+
+def _rules(args: argparse.Namespace) -> int:
+    lines = []
+    for r in RULES.values():
+        lines.append(f"{r.id}  {r.name}  [{', '.join(r.languages)}]")
+        lines.append(f"       {r.summary}")
+        lines.append(f"       fix: {r.fix}")
+    _write("\n".join(lines) + "\n")
+    return EXIT_OK
+
+
+def _run(args: argparse.Namespace) -> int:
+    from .runtime import run_compare
+
+    cmd = args.command
+    if cmd and cmd[0] == "--":
+        cmd = cmd[1:]
+    if not cmd:
+        _err("run: missing command (usage: dotless run -- COMMAND [ARGS...])")
+        return EXIT_ERROR
+    return run_compare(cmd, args.locales.split(","), args.baseline, args.timeout, args.stdin)
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="dotless",
+        description="Find dotted/dotless I bugs caused by locale-dependent case mapping.",
+        epilog="Exit status: 0 nothing found, 1 findings reported, 2 error.",
+    )
+    p.add_argument("--version", action="version", version=f"dotless {__version__}")
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    s = sub.add_parser(
+        "scan",
+        help="scan source files",
+        description="Scan C, Vala, Python, JavaScript and Rust sources. Settings in "
+        "[tool.dotless] of the nearest pyproject.toml are used unless --no-config is given.",
+    )
+    s.add_argument("paths", nargs="+", metavar="PATH")
+    s.add_argument("-f", "--format", choices=["text", "json", "sarif", "gitlab"], default="text")
+    s.add_argument("--min-severity", choices=SEVERITIES, default=None, help="default: low")
+    s.add_argument("-o", "--output", metavar="FILE", help="write the report to FILE")
+    s.add_argument("--exclude", action="append", default=[], metavar="GLOB", help="skip matching paths (repeatable)")
+    s.add_argument("--force-exclude", action="store_true", help="apply excludes to files named on the command line too")
+    s.add_argument("--disable", action="append", default=[], metavar="RULE", help="turn off a rule, e.g. DL005 (repeatable)")
+    s.add_argument("--color", choices=["auto", "always", "never"], default="auto", help="colour text output (default: auto)")
+    s.add_argument("--config", metavar="FILE", help="read [tool.dotless] from FILE")
+    s.add_argument("--no-config", action="store_true", help="ignore pyproject.toml")
+    s.add_argument("--exit-zero", action="store_true", help="exit with 0 even if there are findings")
+    s.set_defaults(func=_scan)
+
+    r = sub.add_parser("rules", help="list rules")
+    r.set_defaults(func=_rules)
+
+    run = sub.add_parser(
+        "run",
+        help="run a command under Turkic locales and compare its output",
+        usage="dotless run [--locales L1,L2] [--baseline LOCALE] -- COMMAND [ARGS...]",
+    )
+    run.add_argument("--locales", default="tr_TR.UTF-8,az_AZ.UTF-8")
+    run.add_argument("--baseline", default="C.UTF-8")
+    run.add_argument("--timeout", type=float, default=60.0)
+    run.add_argument("--stdin", metavar="FILE", help="feed FILE to the command's standard input")
+    run.add_argument("command", nargs=argparse.REMAINDER)
+    run.set_defaults(func=_run)
+    return p
+
+
+def main(argv: list[str] | None = None) -> int:
+    for stream in (sys.stdout, sys.stderr):
+        if hasattr(stream, "reconfigure"):
+            stream.reconfigure(errors="backslashreplace")
+    args = build_parser().parse_args(argv)
+    return args.func(args)

dotless/config.py

@@ -0,0 +1,91 @@
+"""``[tool.dotless]`` settings from pyproject.toml.
+
+Reading TOML needs ``tomllib`` (Python 3.11+). On older Pythons a
+pyproject.toml that has a ``[tool.dotless]`` table is reported and
+ignored; command line options keep working.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+from dataclasses import dataclass, field
+
+from .rules import RULES, SEVERITIES
+
+try:
+    import tomllib
+except ImportError:  # Python < 3.11
+    tomllib = None
+
+KEYS = {"exclude", "min-severity", "disable"}
+
+
+class ConfigError(Exception):
+    pass
+
+
+@dataclass
+class Config:
+    path: str | None = None
+    exclude: list[str] = field(default_factory=list)
+    min_severity: str | None = None
+    disable: list[str] = field(default_factory=list)
+
+
+def find_pyproject(start: str) -> str | None:
+    """The nearest pyproject.toml in ``start`` or one of its parents."""
+    d = os.path.abspath(start)
+    while True:
+        candidate = os.path.join(d, "pyproject.toml")
+        if os.path.isfile(candidate):
+            return candidate
+        parent = os.path.dirname(d)
+        if parent == d:
+            return None
+        d = parent
+
+
+def load(path: str) -> tuple[Config, str | None]:
+    """Read ``[tool.dotless]`` from ``path``.
+
+    Returns (config, warning). Raises ConfigError for invalid settings.
+    """
+    with open(path, "rb") as fh:
+        raw = fh.read()
+    if tomllib is None:
+        if re.search(rb"^\s*\[tool\.dotless\]", raw, re.M):
+            return Config(), (f"{path}: [tool.dotless] ignored, reading it needs Python 3.11 or newer")
+        return Config(), None
+    try:
+        data = tomllib.loads(raw.decode("utf-8"))
+    except (tomllib.TOMLDecodeError, UnicodeDecodeError) as e:
+        raise ConfigError(f"{path}: {e}") from None
+    table = data.get("tool", {}).get("dotless")
+    if table is None:
+        return Config(), None
+    if not isinstance(table, dict):
+        raise ConfigError(f"{path}: [tool.dotless] must be a table")
+    unknown = set(table) - KEYS
+    if unknown:
+        raise ConfigError(f"{path}: unknown key(s) in [tool.dotless]: {', '.join(sorted(unknown))}")
+
+    cfg = Config(path=path)
+    exclude = table.get("exclude", [])
+    if not (isinstance(exclude, list) and all(isinstance(x, str) for x in exclude)):
+        raise ConfigError(f"{path}: 'exclude' must be a list of strings")
+    cfg.exclude = exclude
+
+    sev = table.get("min-severity")
+    if sev is not None and sev not in SEVERITIES:
+        raise ConfigError(f"{path}: 'min-severity' must be one of {', '.join(SEVERITIES)}")
+    cfg.min_severity = sev
+
+    disable = table.get("disable", [])
+    if not (isinstance(disable, list) and all(isinstance(x, str) for x in disable)):
+        raise ConfigError(f"{path}: 'disable' must be a list of rule ids")
+    bad = [r for r in disable if r not in RULES]
+    if bad:
+        raise ConfigError(f"{path}: unknown rule id(s) in 'disable': {', '.join(bad)}")
+    cfg.disable = disable
+    return cfg, None