pre-commit-bigfix 2.0.1__py3-none-any.whl

pre_commit_bigfix/run_all.py

@@ -0,0 +1,305 @@
+#!/usr/bin/env python3
+"""Run every pre-commit-bigfix hook over a folder, without pre-commit.
+
+    uvx pre-commit-bigfix [PATH ...]
+
+This is the `pre-commit-bigfix` command. It finds the files under each PATH
+(default: the current folder), gives each hook the ones its `files` pattern in
+.pre-commit-hooks.yaml matches, with that hook's default `args`, and prints a
+pass/fail line per hook. The exit code is 1 when any hook fails, and 2 for
+a PATH that does not exist or a bad option.
+
+It is read-only. Run by pre-commit, several hooks fix files in place by
+default; here each one is told not to (--auto-fix=no, or --check for the
+hooks that convert or rename), so fixable problems are reported instead.
+To apply the fixes, run the hook itself, or use pre-commit.
+
+Hidden folders (a name starting with `.`, or the hidden flag on macOS and
+Windows) are not searched unless --include-hidden is given, and __pycache__
+and node_modules never are; a PATH that names a folder is searched anyway.
+Symlinked files found while searching are skipped, as pre-commit skips them.
+A named file that no hook checks is reported on stderr.
+
+bes-siterepo-validate-layout checks a whole repo from `git ls-files`, so it
+runs once in each git repo that holds a PATH, and is skipped when none does.
+
+A hook with no matching files is skipped rather than run with no file names:
+run that way, most hooks would search the current folder themselves.
+"""
+
+from __future__ import annotations
+
+import argparse
+import importlib
+import os
+import re
+import stat
+import subprocess
+import sys
+import traceback
+from typing import NamedTuple
+
+from . import bes_common
+
+
+class Hook(NamedTuple):
+    """One hook from .pre-commit-hooks.yaml, as the runner calls it."""
+
+    id: str
+    module: str  # in this package; its main(argv) is the console script
+    files: str | None  # the hook's `files` regex; None: it lists its own
+    args: tuple[str, ...] = ()  # the hook's default `args`
+    read_only: tuple[str, ...] = ()  # what keeps it from writing
+
+    def load(self):
+        """Import the hook's module (only when it runs, as some are heavy)."""
+        return importlib.import_module(f"{__package__}.{self.module}")
+
+
+# Same order, ids, `files` and `args` as .pre-commit-hooks.yaml (minus aliases);
+# tests/test_run_all.py keeps the two in step.
+HOOKS = (
+    Hook(
+        "bes-schema-validate",
+        "bes_schema_validate",
+        r"\.(bes|ojo)$|(^|/)(siteConfig|site|digest)\.xml$"
+        r"|(^|/)Signatures/[^/]+\.xml$",
+    ),
+    Hook(
+        "bes-conventions-check",
+        "bes_conventions_check",
+        r"\.bes$",
+        read_only=("--auto-fix=no",),
+    ),
+    Hook(
+        "bes-actionscript-lint-schclass",
+        "bes_actionscript_lint_schclass",
+        r"\.bes$",
+        read_only=("--auto-fix=no",),
+    ),
+    Hook(
+        "bes-actionscript-validate-prefetch",
+        "bes_actionscript_validate_prefetch",
+        r"\.bes$",
+        # --auto-fix-network is already off by default; say so anyway
+        read_only=("--auto-fix=no", "--auto-fix-network=no"),
+    ),
+    Hook(
+        "bes-actionscript-validate-script",
+        "bes_actionscript_validate_script",
+        r"\.bes$",
+        read_only=("--auto-fix=no",),
+    ),
+    Hook(
+        "bes-relevance-lint",
+        "bes_relevance_lint",
+        r"\.(bes|bes\.xml|ojo|besrpt|beswrpt|webreport|bsr|rel)$",
+        args=("--disable", "W601"),
+    ),
+    Hook(
+        "bes-relevance-convert-group",
+        "bes_relevance_convert_group",
+        r"\.bes$",
+        read_only=("--check",),
+    ),
+    Hook(
+        "bes-siterepo-validate-layout",
+        "bes_siterepo_validate_layout",
+        None,
+        read_only=("--check",),
+    ),
+)
+
+# any file some hook checks; anything else is not worth listing
+ANY_HOOK_RE = re.compile("|".join(f"(?:{h.files})" for h in HOOKS if h.files))
+
+
+def _is_hidden(path, name):
+    """True for a dot folder, or one with the macOS or Windows hidden flag."""
+    if name.startswith("."):
+        return True
+    try:
+        st = os.lstat(path)
+    except OSError:
+        return False
+    # st_flags exists on BSD/macOS and st_file_attributes on Windows; each
+    # constant is missing (so 0) on the other platforms
+    if getattr(st, "st_flags", 0) & getattr(stat, "UF_HIDDEN", 0):
+        return True
+    return bool(
+        getattr(st, "st_file_attributes", 0) & getattr(stat, "FILE_ATTRIBUTE_HIDDEN", 0)
+    )
+
+
+def _match_path(path):
+    """The string a hook's `files` regex is searched in.
+
+    pre-commit searches the repo-relative path, so `(^|/)Signatures/x.xml`
+    sees the folder. The path as given may not hold it (`x.xml`, run from
+    inside Signatures/), so the absolute path is used instead.
+    """
+    return os.path.abspath(path).replace(os.sep, "/")
+
+
+def discover(paths, include_hidden=False):
+    """Return the files under `paths` that some hook checks, sorted, each once.
+
+    A file named in `paths` is kept even if no hook checks it. Folders are
+    walked, skipping symlinked files (pre-commit does not pass them to these
+    hooks), bes_common.DISCOVERY_SKIP_DIRS and, unless `include_hidden`, hidden
+    folders; a folder named in `paths` is walked even if it is hidden.
+    """
+    found = set()
+    for top in paths:
+        if not os.path.isdir(top):
+            found.add(os.path.normpath(top))
+            continue
+        for dirpath, dirnames, filenames in os.walk(top):
+            dirnames[:] = [
+                d
+                for d in dirnames
+                if d not in bes_common.DISCOVERY_SKIP_DIRS
+                and (include_hidden or not _is_hidden(os.path.join(dirpath, d), d))
+            ]
+            for name in filenames:
+                path = os.path.normpath(os.path.join(dirpath, name))
+                if not os.path.islink(path) and ANY_HOOK_RE.search(_match_path(path)):
+                    found.add(path)
+    return sorted(found)
+
+
+def repo_roots(paths):
+    """Return the top folders of the git repos holding `paths`, each once."""
+    roots = []
+    for path in paths:
+        folder = path if os.path.isdir(path) else os.path.dirname(path) or "."
+        try:
+            result = subprocess.run(
+                ["git", "rev-parse", "--show-toplevel"],
+                cwd=folder,
+                capture_output=True,
+                check=False,
+            )
+        except OSError:  # git not installed
+            return []
+        root = os.fsdecode(result.stdout).strip()
+        if result.returncode == 0 and root and root not in roots:
+            roots.append(root)
+    return roots
+
+
+def _call(hook, argv):
+    """Run `hook`'s main(argv); return its exit code, a crash counting as 1."""
+    try:
+        code = hook.load().main(argv)
+    except SystemExit as exc:  # argparse errors, or a hook that exits
+        code = exc.code
+    except Exception:  # noqa: BLE001 - one broken hook must not hide the rest
+        traceback.print_exc()
+        print(f"{hook.id}: crashed")
+        return 1
+    if code is None:
+        return 0
+    return code if isinstance(code, int) else 1
+
+
+def _run_in_repos(hook, roots):
+    """Run a whole-repo hook once in each of `roots`; return its worst exit code."""
+    worst = 0
+    here = os.getcwd()
+    for root in roots:
+        print(f"=== {hook.id} ({root})", flush=True)
+        # the hook finds its repo from the current folder
+        os.chdir(root)
+        try:
+            worst = max(worst, _call(hook, [*hook.args, *hook.read_only]))
+        finally:
+            os.chdir(here)
+    return worst
+
+
+def run_hook(hook, files, roots):
+    """Run one hook read-only; return (status, code).
+
+    A file hook gets the `files` its pattern matches; a whole-repo hook runs in
+    each of the git repos `roots`. status is "passed", "failed" or
+    "skipped: <why>".
+    """
+    if hook.files is None:
+        if not roots:
+            return "skipped: not a git repo", 0
+        code = _run_in_repos(hook, roots)
+    else:
+        pattern = re.compile(hook.files)
+        matched = [path for path in files if pattern.search(_match_path(path))]
+        if not matched:
+            return "skipped: no files", 0
+        print(f"=== {hook.id}", flush=True)
+        # `--` so a file named like an option (-h.bes) is still a file name
+        code = _call(hook, [*hook.args, *hook.read_only, "--", *matched])
+    sys.stdout.flush()
+    return ("failed" if code else "passed"), code
+
+
+def build_parser():
+    parser = argparse.ArgumentParser(
+        prog="pre-commit-bigfix",
+        description=__doc__,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument(
+        "paths",
+        nargs="*",
+        default=["."],
+        metavar="PATH",
+        help="files or folders to check (default: the current folder)",
+    )
+    parser.add_argument(
+        "--skip",
+        action="append",
+        default=[],
+        choices=[hook.id for hook in HOOKS],
+        metavar="HOOK",
+        help="a hook id not to run; repeatable",
+    )
+    parser.add_argument(
+        "--include-hidden",
+        action="store_true",
+        help="also search hidden folders (see above)",
+    )
+    return parser
+
+
+def main(argv=None):
+    """Execution starts here; returns 1 if any hook failed, 2 for a bad PATH."""
+    args = build_parser().parse_args(argv)
+
+    missing = [path for path in args.paths if not os.path.exists(path)]
+    if missing:
+        for path in missing:
+            print(f"pre-commit-bigfix: no such file or folder: {path}", file=sys.stderr)
+        return 2
+
+    files = discover(args.paths, include_hidden=args.include_hidden)
+    for path in args.paths:
+        if os.path.isfile(path) and not ANY_HOOK_RE.search(_match_path(path)):
+            print(f"{path}: not checked by any hook", file=sys.stderr)
+    roots = repo_roots(args.paths)
+
+    results = []
+    for hook in HOOKS:
+        if hook.id in args.skip:
+            results.append((hook.id, "skipped: --skip", 0))
+            continue
+        status, code = run_hook(hook, files, roots)
+        results.append((hook.id, status, code))
+
+    width = max(len(hook.id) for hook in HOOKS) + 3
+    print()
+    for hook_id, status, _code in results:
+        print(f"{hook_id} {'.' * (width - len(hook_id))} {status}")
+    return 1 if any(code for _id, _status, code in results) else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

pre_commit_bigfix/schclass.py

@@ -0,0 +1,284 @@
+#!/usr/bin/env python3
+"""Generic loader for .schclass lexer-schema files.
+
+The .schclass format is the lex-schema format of the Codejock Xtreme
+ToolkitPro SyntaxEdit control, which the BigFix console embeds for its
+ActionScript editor. A schema is a series of `lexClass:` blocks, each an
+indented list of `key = value` lines describing one lexical class: how the
+class is entered (`start:Tag` literals or `token:tag` keyword lists), how it
+ends (`end:Tag` literals / `end:separators`), escape sequences consumed
+without ending it (`skip:Tag`), context constraints on where it may begin
+(`previous:tag`), token boundary separators, and parent/child containment.
+
+This module only LOADS schemas; pre_commit_bigfix/schclass_tokenizer.py walks
+them. Nothing here is ActionScript-specific except the convenience default
+loader at the bottom.
+
+Loading supports merging several files so a small override schema can
+supplement a vendored base grammar (same-named classes union their token
+lists; explicitly-set fields replace; new classes append). This matters
+because .schclass files are display grammars, not validation grammars, and
+need small corrections for lint use (see schclass_data/bigfix_overrides.schclass).
+
+Format notes pinned by tests (and by the real console-generated file):
+    - keys are case-insensitive (`start:tag` and `start:Tag` both occur)
+    - values are comma-separated items: quoted strings (with backslash
+      escapes: \\ \' \" \n \r \t), @specials (@eol, @specs), or bare tokens
+    - repeated `token:tag` lines accumulate, even across blank lines and
+      interleaved with other keys
+    - `children = 0` means "no children"
+    - // comment lines are ignored
+    - files may be CRLF or LF
+"""
+
+import dataclasses
+import os
+
+# @-special sentinels used in previous:tag lists (plain strings; a literal
+# "@eol" token text cannot occur, so identity-by-value is safe)
+AT_EOL = "@eol"
+AT_SPECS = "@specs"
+
+_ESCAPES = {"\\": "\\", "'": "'", '"': '"', "n": "\n", "r": "\r", "t": "\t"}
+
+_DATA_DIR = os.path.join(os.path.dirname(__file__), "schclass_data")
+# resolved relative to __file__ (not importlib.resources): fine for pip /
+# pre-commit installs; would not survive zip-import, which none of our
+# consumers use.
+DEFAULT_SCHCLASS_FILES = (
+    os.path.join(_DATA_DIR, "ExpandedActionScript.schclass"),
+    os.path.join(_DATA_DIR, "bigfix_overrides.schclass"),
+)
+
+
+@dataclasses.dataclass
+class LexClass:
+    """One `lexClass:` block: a single lexical class of the grammar."""
+
+    name: str = ""
+    parents: tuple = ()  # from `parent` / `parent:dyn`
+    parent_dyn: bool = False
+    parent_file: str = None  # e.g. `<*.ActionScript>` on the root class
+    children: tuple = ()  # `children = 0` -> ()
+    start_tags: tuple = ()  # literals that enter this class as a state
+    end_tags: tuple = ()  # literals that exit the state (consumed)
+    end_at_eol: bool = False  # @eol appeared in end:Tag
+    skip_tags: tuple = ()  # escape sequences consumed without ending
+    end_separators: tuple = ()  # exit the state WITHOUT consuming
+    end_separators_eol: bool = False
+    previous_tags: tuple = ()  # context constraint; may hold AT_EOL/AT_SPECS
+    token_tags: tuple = ()  # keyword literals (accumulated)
+    token_start_separators: tuple = ()
+    token_start_eol: bool = False
+    token_end_separators: tuple = ()
+    token_end_eol: bool = False
+    attrs: dict = dataclasses.field(default_factory=dict)  # DisplayName, txt:*
+
+
+@dataclasses.dataclass
+class Schema:
+    """An ordered collection of LexClasses parsed from .schclass text."""
+
+    classes: dict = dataclasses.field(default_factory=dict)
+
+    def root(self):
+        """Return the file-level root class (`parent:file`), or best guess."""
+        for cls in self.classes.values():
+            if cls.parent_file is not None:
+                return cls
+        for cls in self.classes.values():
+            if not cls.parents:
+                return cls
+        return next(iter(self.classes.values()), None)
+
+    def all_token_tags(self):
+        """Return {token literal: class name} across every class.
+
+        The first class declaring a literal wins (schema order).
+        """
+        tags = {}
+        for cls in self.classes.values():
+            for token in cls.token_tags:
+                tags.setdefault(token, cls.name)
+        return tags
+
+
+def _split_items(value):
+    """Split a raw value into (kind, text) items; kind is 'str' or 'bare'.
+
+    Items are comma-separated at the top level; commas INSIDE quotes (the
+    separator lists include a literal ',') must not split. Quoted items decode
+    backslash escapes; bare items are kept verbatim (`@eol`, `global`,
+    `0x0000FF`, `<*.ActionScript>`).
+    """
+    items = []
+    i, n = 0, len(value)
+    while i < n:
+        ch = value[i]
+        if ch in " \t,":
+            i += 1
+            continue
+        if ch in "'\"":
+            quote = ch
+            i += 1
+            buf = []
+            while i < n:
+                char = value[i]
+                if char == "\\" and i + 1 < n:
+                    buf.append(_ESCAPES.get(value[i + 1], value[i + 1]))
+                    i += 2
+                    continue
+                if char == quote:
+                    i += 1
+                    break
+                buf.append(char)
+                i += 1
+            items.append(("str", "".join(buf)))
+        else:
+            j = i
+            while j < n and value[j] != ",":
+                j += 1
+            items.append(("bare", value[i:j].strip()))
+            i = j
+    return items
+
+
+def _literals(items):
+    """Return the quoted-string literals from a parsed item list."""
+    return tuple(text for kind, text in items if kind == "str")
+
+
+def _has_bare(items, token):
+    """True if `items` holds the bare token `token` (case-insensitive)."""
+    return any(kind == "bare" and text.lower() == token for kind, text in items)
+
+
+def _apply_key(cls, key, items, raw_value):
+    """Fold one `key = value` line into the LexClass being built."""
+    if key == "name":
+        cls.name = raw_value
+    elif key == "parent":
+        cls.parents += tuple(text for _kind, text in items)
+    elif key == "parent:dyn":
+        cls.parents += tuple(text for _kind, text in items)
+        cls.parent_dyn = True
+    elif key == "parent:file":
+        cls.parent_file = raw_value
+    elif key == "children":
+        if not _has_bare(items, "0"):
+            cls.children += tuple(text for _kind, text in items)
+    elif key == "start:tag":
+        cls.start_tags += _literals(items)
+    elif key == "end:tag":
+        cls.end_tags += _literals(items)
+        cls.end_at_eol = cls.end_at_eol or _has_bare(items, AT_EOL)
+    elif key == "skip:tag":
+        cls.skip_tags += _literals(items)
+    elif key == "end:separators":
+        cls.end_separators += _literals(items)
+        cls.end_separators_eol = cls.end_separators_eol or _has_bare(items, AT_EOL)
+    elif key == "previous:tag":
+        for kind, text in items:
+            if kind == "bare" and text.lower() in (AT_EOL, AT_SPECS):
+                cls.previous_tags += (text.lower(),)
+            elif kind == "str":
+                cls.previous_tags += (text,)
+    elif key == "token:tag":
+        cls.token_tags += _literals(items)
+    elif key == "token:start:separators":
+        cls.token_start_separators += _literals(items)
+        cls.token_start_eol = cls.token_start_eol or _has_bare(items, AT_EOL)
+    elif key == "token:end:separators":
+        cls.token_end_separators += _literals(items)
+        cls.token_end_eol = cls.token_end_eol or _has_bare(items, AT_EOL)
+    else:
+        # presentation / unknown keys (DisplayName, txt:*, ParseOnScreen...)
+        decoded = [text for _kind, text in items]
+        cls.attrs[key] = ", ".join(decoded) if decoded else raw_value
+
+
+def parse_schclass_text(text):
+    """Parse .schclass text into a Schema."""
+    text = text.replace("\r\n", "\n").replace("\r", "\n")
+    schema = Schema()
+    current = None
+    for raw_line in text.split("\n"):
+        stripped = raw_line.strip()
+        if not stripped or stripped.startswith("//"):
+            continue
+        if stripped.lower().startswith("lexclass:"):
+            if current is not None and current.name:
+                schema.classes[current.name] = current
+            current = LexClass()
+            continue
+        if current is None or "=" not in stripped:
+            continue
+        key, _, value = stripped.partition("=")
+        key = key.strip().lower()
+        value = value.strip()
+        _apply_key(current, key, _split_items(value), value)
+    if current is not None and current.name:
+        schema.classes[current.name] = current
+    return schema
+
+
+# (list field, paired eol/dyn flag) -- a merge replaces the pair together when
+# the override sets either half, so `end:Tag = '"'` (no @eol) clears the flag.
+_PAIRED_FIELDS = (
+    ("parents", "parent_dyn"),
+    ("start_tags", None),
+    ("end_tags", "end_at_eol"),
+    ("skip_tags", None),
+    ("end_separators", "end_separators_eol"),
+    ("previous_tags", None),
+    ("token_start_separators", "token_start_eol"),
+    ("token_end_separators", "token_end_eol"),
+    ("children", None),
+)
+
+
+def merge_schemas(base, override):
+    """Merge `override` onto `base`; return a new Schema.
+
+    Same-named classes: token_tags are unioned (base order, then new ones);
+    any field group the override explicitly sets replaces the base's; fields
+    the override leaves unset are preserved. New classes append after the
+    base's, keeping schema order deterministic.
+    """
+    merged = Schema()
+    for name, cls in base.classes.items():
+        merged.classes[name] = dataclasses.replace(cls, attrs=dict(cls.attrs))
+    for name, ocls in override.classes.items():
+        if name not in merged.classes:
+            merged.classes[name] = dataclasses.replace(ocls, attrs=dict(ocls.attrs))
+            continue
+        bcls = merged.classes[name]
+        bcls.token_tags += tuple(
+            token for token in ocls.token_tags if token not in bcls.token_tags
+        )
+        for list_field, flag_field in _PAIRED_FIELDS:
+            flag_set = flag_field is not None and getattr(ocls, flag_field)
+            if getattr(ocls, list_field) or flag_set:
+                setattr(bcls, list_field, getattr(ocls, list_field))
+                if flag_field is not None:
+                    setattr(bcls, flag_field, getattr(ocls, flag_field))
+        if ocls.parent_file is not None:
+            bcls.parent_file = ocls.parent_file
+        bcls.attrs.update(ocls.attrs)
+    return merged
+
+
+def load_schclass_files(paths):
+    """Parse each .schclass file and merge them left to right into one Schema."""
+    schema = None
+    for path in paths:
+        with open(path, "rb") as handle:
+            text = handle.read().decode("utf-8", errors="replace")
+        parsed = parse_schclass_text(text)
+        schema = parsed if schema is None else merge_schemas(schema, parsed)
+    return schema if schema is not None else Schema()
+
+
+def load_default_actionscript_schema():
+    """Load the vendored BigFix ActionScript grammar plus its overrides."""
+    return load_schclass_files(DEFAULT_SCHCLASS_FILES)