gitmole 0.6.5__tar.gz → 0.6.7__tar.gz

{gitmole-0.6.5 → gitmole-0.6.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitmole
-Version: 0.6.5
+Version: 0.6.7
 Summary: Offline git repository analysis with a terminal report: hotspots, coupling, ownership, code age, secrets, repo health.
 License: MIT
 Project-URL: Homepage, https://github.com/antvinni/gitmole

{gitmole-0.6.5 → gitmole-0.6.7}/gitmole/__init__.py

@@ -1,3 +1,3 @@
 """gitmole: offline git repository analysis with a terminal report."""
 
-__version__ = "0.6.5"
+__version__ = "0.6.7"

{gitmole-0.6.5 → gitmole-0.6.7}/gitmole/cli.py

@@ -15,7 +15,7 @@ from rich.live import Live
 from rich.spinner import Spinner
 from rich.text import Text
 
-from . import __version__, banner, filetypes, findings, load, loss, run
+from . import __version__, banner, blame, filetypes, findings, load, loss, run
 
 
 def parse_args(argv):
@@ -294,6 +294,8 @@ def _meta_for_run(repo_dir: str, args, estimate, age_ok: bool, plots_ok: bool, p
     meta = run.collect_meta(repo_dir, since=args.since_date)
     meta["file_types"] = types_spec   # the loader filters scc's size data the way every other step was filtered
     meta["gone_months"] = args.gone
+    ignore = list(run.DATA_IGNORES if args.ignore_data else []) + list(args.ignore)
+    meta["generated"] = filetypes.generated_files(repo_dir, blame.text_files(repo_dir, ignore))   # hidden from the tables, out of the findings
     if args.since_date and meta["commits"] == 0:
         raise NoCommits(f"no commits since {args.since_date}; widen --since")
     if args.now:

{gitmole-0.6.5 → gitmole-0.6.7}/gitmole/filetypes.py

@@ -2,6 +2,8 @@
 Standalone so blame.py and maat.py can import it as scripts."""
 from __future__ import annotations
 
+import fnmatch
+import os
 import re
 import subprocess
 from collections import Counter
@@ -74,15 +76,73 @@ def is_sample_path(path: str) -> bool:
     return bool(_SAMPLE_PATH.search(path))
 
 
-_VENDOR_PATH = re.compile(r"(^|/)(_?vendor|node_modules|third_?party|external)(/|$)", re.I)
+_VENDOR_PATH = re.compile(r"(^|/)(_?vendor|vendored|node_modules|third_?party|external)(/|$)|^[^/]+/packages/", re.I)
 
 
 def is_vendor_path(path: str) -> bool:
     """Vendored and third-party trees: somebody else's code, so its complexity and its single
-    importer are not this repository's risk."""
+    importer are not this repository's risk. A `packages/` inside a package (requests/packages/,
+    the Python vendoring convention) counts; a monorepo's own `packages/` at the root does not."""
     return bool(_VENDOR_PATH.search(path))
 
 
+_RELEASE_NAMES = {"version", "version.rb", "version.py", "version.go", "version.rs", "version.txt", "__version__.py", "package.json",
+                  "package-lock.json", "yarn.lock", "pnpm-lock.yaml", "gemfile", "gemfile.lock", "cargo.toml", "cargo.lock",
+                  "pyproject.toml", "setup.py", "setup.cfg", "poetry.lock", "uv.lock", "go.mod", "go.sum", "composer.json", "composer.lock"}
+
+
+def is_release_path(path: str) -> bool:
+    """Release plumbing: version files, manifests, lock files and changelogs. Two of them changing
+    together is a release commit, not a dependency between them."""
+    name = path.rsplit("/", 1)[-1].lower()
+    return name in _RELEASE_NAMES or name.endswith(".gemspec") or name.startswith(("changelog", "changes.", "history.", "news."))
+
+
+# What a generated file says about itself in its first lines: protoc, ajv, code generators of every kind.
+_GENERATED = re.compile(r"auto[- ]?generated|generated (by|from|file|code|automatically|with)|do not (edit|modify)|@generated|code generated", re.I)
+GENERATED_HEAD_LINES = 5
+
+
+def _generated_patterns(repo: str) -> list:
+    """The .gitattributes patterns marked linguist-generated at the repository root."""
+    try:
+        with open(os.path.join(repo, ".gitattributes"), encoding="utf-8", errors="replace") as fh:
+            lines = fh.read().splitlines()
+    except OSError:
+        return []
+    out = []
+    for line in lines:
+        parts = line.split()
+        if len(parts) >= 2 and any(p in ("linguist-generated", "linguist-generated=true") for p in parts[1:]):
+            out.append(parts[0].lstrip("/"))
+    return out
+
+
+def _attribute_match(path: str, pattern: str) -> bool:
+    if "/" in pattern:
+        return fnmatch.fnmatchcase(path, pattern) or fnmatch.fnmatchcase(path, pattern.rstrip("/") + "/*")
+    return fnmatch.fnmatchcase(path.rsplit("/", 1)[-1], pattern)
+
+
+def generated_files(repo: str, paths: list) -> list:
+    """The tracked files that are generated: marked linguist-generated in .gitattributes, or saying so
+    in their first lines. Their complexity and churn are the generator's, not the repository's."""
+    patterns = _generated_patterns(repo)
+    out = []
+    for path in paths:
+        if any(_attribute_match(path, p) for p in patterns):
+            out.append(path)
+            continue
+        try:
+            with open(os.path.join(repo, path), "rb") as fh:
+                head = fh.read(2048)
+        except OSError:
+            continue
+        if any(_GENERATED.search(line) for line in head.decode("utf-8", "replace").splitlines()[:GENERATED_HEAD_LINES]):
+            out.append(path)
+    return sorted(out)
+
+
 def key(path: str) -> str:
     """The lowercased extension, or the whole lowercased name when there is none."""
     name = path.rsplit("/", 1)[-1].lower()

{gitmole-0.6.5 → gitmole-0.6.7}/gitmole/findings.py

@@ -47,7 +47,8 @@ def secrets_found(report: dict) -> list:
     groups = leaks.group(report.get("secrets") or [])
 
     def in_source(g):
-        return any(not (filetypes.is_test_path(f) or filetypes.is_doc_path(f) or filetypes.is_sample_path(f)) for f in g["files"])
+        return any(not (filetypes.is_test_path(f) or filetypes.is_doc_path(f) or filetypes.is_sample_path(f) or filetypes.is_vendor_path(f))
+                   for f in g["files"])
     source = [g for g in groups if in_source(g)]
     aside = [g for g in groups if not in_source(g)]
     ignore = "Add the fingerprint of any false positive from secrets.json to .betterleaksignore in the repository."
@@ -56,7 +57,7 @@ def secrets_found(report: dict) -> list:
         out.append(_f("critical", f"{len(source)} secret(s) in history", _secret_statement(source),
                       f"Rotate them; deleting the file does not remove them from git. {ignore}"))
     if aside:
-        out.append(_f("warning", f"{len(aside)} secret(s) only in test, example or documentation files", _secret_statement(aside),
+        out.append(_f("warning", f"{len(aside)} secret(s) only in test, example, vendored or documentation files", _secret_statement(aside),
                       f"Confirm they are fixtures or templates, not live keys. {ignore}"))
     return out
 
@@ -173,8 +174,10 @@ def sizer_concerns(report: dict) -> list:
 
 
 def hotspot_dominance(report: dict, ratio: float = 2.0, minimum: int = 20) -> list:
-    """One source file takes most of the churn. Test files are left out: they change with everything."""
-    revs = sorted((r for r in report.get("revisions") or [] if not filetypes.is_test_path(r["entity"])), key=lambda r: -r["n-revs"])
+    """One source file takes most of the churn. Test files are left out: they change with everything.
+    So is release plumbing: a version file or a manifest changes on every release by design."""
+    revs = sorted((r for r in report.get("revisions") or [] if not (filetypes.is_test_path(r["entity"]) or filetypes.is_release_path(r["entity"]))),
+                  key=lambda r: -r["n-revs"])
     if len(revs) < 2 or revs[0]["n-revs"] < minimum or revs[0]["n-revs"] < ratio * revs[1]["n-revs"]:
         return []
     top, nxt = revs[0], revs[1]
@@ -185,10 +188,12 @@ def hotspot_dominance(report: dict, ratio: float = 2.0, minimum: int = 20) -> li
 
 def tight_coupling(report: dict, min_degree: int = 80, min_revs: int = 5) -> list:
     """A file and its test are expected to change together, so pairs with a test file on either side are
-    left out; so are pairs where either file is no longer in the tree, which are history, not a dependency."""
+    left out; so are pairs where either file is no longer in the tree, which are history, not a dependency,
+    and pairs of release plumbing (two version files, a manifest and its lock file), which are a release."""
     tree = _tree(report)
     pairs = [p for p in report.get("coupling") or [] if p["degree"] >= min_degree and p["average-revs"] >= min_revs
              and not (filetypes.is_test_path(p["entity"]) or filetypes.is_test_path(p["coupled"]))
+             and not (filetypes.is_release_path(p["entity"]) and filetypes.is_release_path(p["coupled"]))
              and not (tree and (p["entity"] not in tree or p["coupled"] not in tree))]
     if not pairs:
         return []
@@ -229,8 +234,10 @@ def stale_files(report: dict, months: int = 12, share: float = 0.3) -> list:
 
 
 def bug_magnets(report: dict, min_recent: int = 3, warn_at: int = 5) -> list:
-    """Source files with a run of recent fix commits. Test files are left out: they change with every fix."""
-    hot = [f for f in report.get("fixes") or [] if f["recent-fixes"] >= min_recent and not filetypes.is_test_path(f["entity"])]
+    """Source files with a run of recent fix commits. Test files are left out: they change with every fix.
+    So is release plumbing: a manifest touched by every fix release is not where the bug was."""
+    hot = [f for f in report.get("fixes") or [] if f["recent-fixes"] >= min_recent
+           and not (filetypes.is_test_path(f["entity"]) or filetypes.is_release_path(f["entity"]))]
     if not hot:
         return []
     hot.sort(key=lambda f: (-f["recent-fixes"], -f["n-fixes"], f["entity"]))
@@ -386,20 +393,36 @@ def _partial_functions(report: dict) -> str:
 
 
 def brain_methods(report: dict, min_ccn: int = 15, min_lines: int = 100) -> list:
-    """Functions that are both long and complex, in this repository's own source files: test files and
-    vendored code are left out. A warning when one sits in a hotspot."""
+    """Functions that are both long and complex, in this repository's own source files: test files,
+    vendored code and generated files are left out. A warning when one sits in a hotspot."""
+    generated = _generated(report)
     big = [f for f in report.get("functions") or [] if f["ccn"] >= min_ccn and f["nloc"] >= min_lines
-           and not (filetypes.is_test_path(f["file"]) or filetypes.is_vendor_path(f["file"]))]
+           and not (filetypes.is_test_path(f["file"]) or filetypes.is_vendor_path(f["file"]) or f["file"] in generated)]
     if not big:
         return []
     big.sort(key=lambda f: (-f["ccn"], -f["nloc"], f["file"], f["function"], f["start"]))
     hot = hotspots.top(report)
     sev = "warning" if any(f["file"] in hot for f in big) else "info"
-    listed = "; ".join(f"{f['function']} ({f['file']}) complexity {f['ccn']}, {f['nloc']} lines, {f['params']} params" for f in big[:5])
+    listed = "; ".join(f"{f['function']} ({_place(f)}) complexity {f['ccn']}, {f['nloc']} lines, {f['params']} params" for f in big[:5])
     more = f" and {len(big) - 5} more" if len(big) > 5 else ""
+    first = big[0]
+    which = f"the anonymous function at {_place(first)}" if first["function"] == ANONYMOUS else f"{first['function']} in {first['file']}"
     return [_f(sev, "Brain methods",
                f"{len(big)} function(s) are both long and complex: {listed}{more}.{_partial_functions(report)}",
-               f"Split {big[0]['function']} in {big[0]['file']} first, before the next change lands there.")]
+               f"Split {which} first, before the next change lands there.")]
+
+
+ANONYMOUS = "(anonymous)"
+
+
+def _place(f: dict) -> str:
+    """Where a function is: its file, or file:line when it has no name to find it by."""
+    return f"{f['file']}:{f['start']}" if f["function"] == ANONYMOUS else f["file"]
+
+
+def _generated(report: dict) -> set:
+    """Files the run found to be generated (a header marker or a linguist-generated attribute)."""
+    return set((report.get("meta") or {}).get("generated") or [])
 
 
 def complexity_growth(report: dict, min_growers: int = 3, min_pct: int = 25, top_n: int = 10) -> list:

{gitmole-0.6.5 → gitmole-0.6.7}/gitmole/identity.py

@@ -20,8 +20,26 @@ def _tokens(name: str) -> set:
     return {t for t in re.split(r"[^a-z0-9]+", name.lower()) if len(t) >= 3}
 
 
+# A bare first name under two emails may be two people; anything else spelled identically is one.
+_COMMON_FIRST_NAMES = {
+    "adam", "alex", "alexander", "andrew", "andy", "ann", "anna", "ben", "bob", "chris", "dan", "daniel", "dave", "david", "ed",
+    "eric", "frank", "george", "jack", "james", "jan", "jean", "jim", "joe", "john", "jon", "josh", "kevin", "lee", "li", "luke",
+    "mark", "martin", "matt", "max", "michael", "mike", "nick", "paul", "pete", "peter", "phil", "rob", "robert", "ryan", "sam",
+    "scott", "steve", "tim", "tom", "tony", "will",
+}
+
+
+def _plain(name: str) -> str:
+    return " ".join(name.lower().split())
+
+
 def same_person(a: dict, b: dict) -> bool:
-    return a["email"].lower() == b["email"].lower() or len(_tokens(a["name"]) & _tokens(b["name"])) >= 2
+    """Same email, two shared name tokens, or the same name spelled identically (a handle such as
+    KaKa under three emails), unless that name is a bare common first name."""
+    if a["email"].lower() == b["email"].lower() or len(_tokens(a["name"]) & _tokens(b["name"])) >= 2:
+        return True
+    name = _plain(a["name"])
+    return bool(name) and name == _plain(b["name"]) and name not in _COMMON_FIRST_NAMES
 
 
 def merge(identities: list) -> list:

{gitmole-0.6.5 → gitmole-0.6.7}/gitmole/load.py

@@ -151,7 +151,7 @@ def parse_functions(text: str) -> list:
     for r in csv.reader(io.StringIO(text)):
         if len(r) < 11:
             continue
-        rows.append({"file": _rel(r[6]), "function": r[7], "ccn": _num(r[1]), "nloc": _num(r[0]), "params": _num(r[3]),
+        rows.append({"file": _rel(r[6]), "function": r[7] or "(anonymous)", "ccn": _num(r[1]), "nloc": _num(r[0]), "params": _num(r[3]),
                      "start": _num(r[9]), "end": _num(r[10])})
     return rows
 

{gitmole-0.6.5 → gitmole-0.6.7}/gitmole/maat.py

@@ -4,7 +4,9 @@
 Standalone on purpose: gitmole runs it as a pipeline step with
 `python3 maat.py LOG OUT_DIR [--aliases META_JSON]` and it must not need the
 package on sys.path. Input is `git log --all --numstat --date=short
---pretty=format:--%h--%ad--%aN --no-renames`.
+--pretty=format:--%h--%ad--%aN -M`: renames are followed, so a moved file
+is one entity under its new path and a pure move adds and deletes nothing.
+Whoever moved a directory to src/ did not write it.
 """
 from __future__ import annotations
 
@@ -40,13 +42,26 @@ def parse_log(text: str, aliases: dict = None, types=None) -> list:
             commits.append(current)
         elif line.strip() and current is not None:
             added, deleted, path = line.split("\t", 2)
-            path = filetypes.unquote(path)
+            path = _renamed_to(filetypes.unquote(path))
             if not filetypes.matches(path, types):
                 continue
             current["files"].append((path, int(added) if added.isdigit() else 0, int(deleted) if deleted.isdigit() else 0))
     return commits
 
 
+_BRACED_RENAME = re.compile(r"\{([^{}]*) => ([^{}]*)\}")
+
+
+def _renamed_to(path: str) -> str:
+    """The new path of a rename as `git log -M --numstat` spells it: `{old => new}/rest`,
+    `dir/{a => b}` or `old => new` for a whole path. A path without ' => ' is itself."""
+    if " => " not in path:
+        return path
+    if "{" in path:
+        return _BRACED_RENAME.sub(lambda m: m.group(2), path).replace("//", "/")
+    return path.split(" => ", 1)[1]
+
+
 _FIX_CONVENTIONAL = re.compile(r"^(fix|hotfix|bugfix)(\([^)]*\))?!?:", re.I)
 _FIX_WORDS = re.compile(r"\b(fix|fixes|fixed|fixing|bugfix|hotfix|bug|bugs|regression|crash|crashes)\b", re.I)
 

{gitmole-0.6.5 → gitmole-0.6.7}/gitmole/render.py

@@ -111,6 +111,24 @@ def _hide_vendor(rows: list, path_of, full, noun="file in vendored code", plural
     return _hide_rows(rows, path_of, full, filetypes.is_vendor_path, noun, plural)
 
 
+def _hide_generated(rows: list, path_of, report: dict, full, noun="generated file", plural=None) -> tuple:
+    """Generated files (a header marker or a linguist-generated attribute, found at run time): the
+    generator's churn and complexity, not the repository's."""
+    generated = set((report.get("meta") or {}).get("generated") or [])
+    return _hide_rows(rows, path_of, full, lambda p: p in generated, noun, plural)
+
+
+def _hide_release(pairs: list, full) -> tuple:
+    """Coupled pairs where both files are release plumbing (version files, manifests, lock files,
+    changelogs): they change together because a release touches them all, not because one depends on
+    the other. A version file paired with real code stays."""
+    if full is True:
+        return pairs, None
+    kept = [p for p in pairs if not (filetypes.is_release_path(p["entity"]) and filetypes.is_release_path(p["coupled"]))]
+    hidden = len(pairs) - len(kept)
+    return kept, (f"{hidden} release pair{'s' if hidden != 1 else ''} hidden{HIDDEN_SUFFIX}" if hidden else None)
+
+
 def _join_hidden(*notes) -> str:
     """Several hidden-row notes as one caption phrase: 'A hidden; B hidden; --full shows them'."""
     parts = [n[:-len(HIDDEN_SUFFIX)] if n.endswith(HIDDEN_SUFFIX) else n for n in notes if n]
@@ -376,7 +394,9 @@ def hotspots_section(report: dict, full: bool = True, width=None) -> dict:
     scored = hotspots.ranked(report)
     scored, hidden_note = _hide_tests(scored, lambda h: h["entity"], full)
     scored, deleted_note = _hide_deleted(scored, report, full)
-    hidden_note = _join_hidden(hidden_note, deleted_note)
+    scored, generated_note = _hide_generated(scored, lambda h: h["entity"], report, full)
+    scored, release_note = _hide_rows(scored, lambda h: h["entity"], full, filetypes.is_release_path, "release file")
+    hidden_note = _join_hidden(hidden_note, deleted_note, generated_note, release_note)
     title = "Hotspots (score = revisions × lines of code)" if full is True else "Hotspots"
     limit = _limit("Hotspots", full)
     series = (report.get("trend") or {}).get("files") or {}
@@ -408,6 +428,8 @@ def coupling_section(report: dict, full: bool = True, width=None) -> dict:
     pairs = sorted((p for p in report.get("coupling") or [] if p["average-revs"] >= 5), key=lambda p: (-p["degree"], -p["average-revs"]))
     pairs, hidden_note = _hide_tests(pairs, lambda p: (p["entity"], p["coupled"]), full, noun="test pair")
     pairs, gone_note = _hide_gone(pairs, report, full)
+    pairs, release_note = _hide_release(pairs, full)
+    gone_note = _join_hidden(gone_note, release_note)
     groups, cluster_note = [], None
     if full is not True:
         # a directory whose files all change together is one row; --full lists every pair
@@ -474,7 +496,8 @@ def functions_section(report: dict, full: bool = True, width=None) -> dict:
     funcs = sorted((f for f in measured if f["ccn"] >= CCN_FLOOR), key=lambda f: (-f["ccn"], -f["nloc"], f["file"], f["function"], f["start"]))
     funcs, hidden_note = _hide_tests(funcs, lambda f: f["file"], full, noun="function in a test file", plural="functions in test files")
     funcs, vendor_note = _hide_vendor(funcs, lambda f: f["file"], full, noun="function in vendored code", plural="functions in vendored code")
-    hidden_note = _join_hidden(hidden_note, vendor_note)
+    funcs, generated_note = _hide_generated(funcs, lambda f: f["file"], report, full, noun="function in a generated file", plural="functions in generated files")
+    hidden_note = _join_hidden(hidden_note, vendor_note, generated_note)
     limit = _limit("Complex functions", full)
     rows = [(f["function"], f["file"], f["ccn"], f["nloc"], f["params"]) for f in funcs[:limit]]
     columns = [("function", {"overflow": "fold"}), ("file", PATH), ("ccn", RIGHT), ("lines", RIGHT), ("params", RIGHT)]

{gitmole-0.6.5 → gitmole-0.6.7}/gitmole/run.py

@@ -172,7 +172,7 @@ def plan(repo_dir: str, out_dir: str, branch: str = "HEAD", age: bool = True, pl
         {"name": "scc", "argv": ["scc", "--by-file", "--format", "json"], "stdout": o("size.json"), "deps": []},
         {"name": "git-sizer", "argv": ["git-sizer", "--verbose"], "stdout": o("repo-health.txt"), "deps": []},
         {"name": "betterleaks", "argv": [sys.executable, LEAKS_SCRIPT, o("secrets.json")], "stdout": None, "deps": []},   # hashes the values before anything is written
-        {"name": "git-log", "argv": [*filetypes.GIT, "log", "--all", "--use-mailmap", "--numstat", "--date=iso-strict", "--pretty=format:--%h--%ad--%aN--%s", "--no-renames"], "stdout": log, "deps": []},
+        {"name": "git-log", "argv": [*filetypes.GIT, "log", "--all", "--use-mailmap", "--numstat", "--date=iso-strict", "--pretty=format:--%h--%ad--%aN--%s", "-M"], "stdout": log, "deps": []},   # -M: a move is not an edit
         {"name": "change analysis", "argv": [sys.executable, MAAT_SCRIPT, log, out_dir, *type_args, *(["--now", now] if now else []), *(["--since", since] if since else []), "--aliases", o("meta.json")], "stdout": None, "deps": ["git-log"]},
     ]
     if lizard:

{gitmole-0.6.5 → gitmole-0.6.7}/gitmole/watch.py

@@ -66,8 +66,8 @@ def risks(report: dict, min_revs: int = 2) -> list:
 
     rows = []
     for h in hotspots.ranked(report):
-        if h["code"] is None or h["revs"] < min_revs or filetypes.is_test_path(h["entity"]):
-            continue
+        if h["code"] is None or h["revs"] < min_revs or filetypes.is_test_path(h["entity"]) or filetypes.is_release_path(h["entity"]):
+            continue   # a version file or a manifest changes on every release, not where the next bug lands
         fx = fixes.get(h["entity"], {})
         own = owners.get(h["entity"]) or Counter()
         owner, owner_lines = (own.most_common(1)[0] if own else (None, 0))

{gitmole-0.6.5 → gitmole-0.6.7}/gitmole.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitmole
-Version: 0.6.5
+Version: 0.6.7
 Summary: Offline git repository analysis with a terminal report: hotspots, coupling, ownership, code age, secrets, repo health.
 License: MIT
 Project-URL: Homepage, https://github.com/antvinni/gitmole

{gitmole-0.6.5 → gitmole-0.6.7}/tests/test_cli.py

@@ -592,6 +592,28 @@ class Arguments(unittest.TestCase):
         self.assertNotIn("jar", text)
 
 
+class GeneratedFiles(unittest.TestCase):
+    def test_a_run_records_the_generated_files_in_meta(self):
+        with tempfile.TemporaryDirectory() as d:
+            _tiny_repo(d)
+            os.makedirs(os.path.join(d, "lib"))
+            with open(os.path.join(d, "lib", "validator.js"), "w") as fh:
+                fh.write("// This file is autogenerated by build/build.js, do not edit\nmodule.exports = 1\n")
+            with open(os.path.join(d, "lib", "app.js"), "w") as fh:
+                fh.write("module.exports = 2\n")
+            import subprocess
+            subprocess.run(["git", "-C", d, "add", "-A"], check=True)
+            subprocess.run(["git", "-C", d, "-c", "user.name=T", "-c", "user.email=t@x.com", "commit", "-q", "-m", "files"], check=True)
+            out = os.path.join(d, "out")
+            planner = lambda repo, o, branch="HEAD", **kw: [{"name": "q", "argv": ["true"], "stdout": None, "deps": []}]
+            rc = cli.main([d, "--out", out], console=console(), tool_check=lambda **kw: [], planner=planner,
+                          estimator=lambda repo, interval, **kw: {"files": 2, "samples": 1, "blames": 2})
+            with open(os.path.join(out, "meta.json")) as fh:
+                meta = json.load(fh)
+        self.assertEqual(rc, 0)
+        self.assertEqual(meta["generated"], ["lib/validator.js"])
+
+
 class Clean(unittest.TestCase):
     """--clean lists what gitmole left behind and deletes on a yes. TMPDIR is pointed at a scratch dir so the
     real temp folder is never listed or touched."""

{gitmole-0.6.5 → gitmole-0.6.7}/tests/test_filetypes.py

@@ -104,11 +104,39 @@ class TestPaths(unittest.TestCase):
         for path in ("app/settings.py", "examplesite/app.py", "src/rulesets/a.go", "sampler/x.py", "config/betterleaks.toml"):
             self.assertFalse(filetypes.is_sample_path(path), path)
 
+    def test_release_plumbing_files(self):
+        for path in ("lib/sinatra/version.rb", "VERSION", "src/pkg/__version__.py", "package.json", "package-lock.json", "Gemfile.lock",
+                     "Cargo.toml", "pyproject.toml", "go.sum", "CHANGELOG.md", "CHANGES.rst", "sinatra.gemspec", "uv.lock"):
+            self.assertTrue(filetypes.is_release_path(path), path)
+        for path in ("lib/version_check.py", "src/app.py", "docs/versions.md", "Makefile", "lib/sinatra/base.rb"):
+            self.assertFalse(filetypes.is_release_path(path), path)
+
+    def test_generated_files_by_header_marker_or_attribute(self):
+        with tempfile.TemporaryDirectory() as d:
+            files = {
+                "lib/config-validator.js": "// This file is autogenerated by build/build-validation.js, do not edit\n'use strict'\n",
+                "pb/api.pb.go": "// Code generated by protoc-gen-go. DO NOT EDIT.\npackage pb\n",
+                "gen/schema.py": "# @generated\nx = 1\n",
+                "src/app.py": "# the app; it generated reports once\ndef main():\n    pass\n",
+                "docs/notes.md": "generated notes are the best notes\n",
+                "dist/bundle.js": "var a = 1;\n",
+                "src/late.py": "\n" * 10 + "# generated by hand, do not edit\n",   # a marker past the first lines does not count
+            }
+            for path, text in files.items():
+                os.makedirs(os.path.join(d, os.path.dirname(path)), exist_ok=True)
+                with open(os.path.join(d, path), "w") as fh:
+                    fh.write(text)
+            with open(os.path.join(d, ".gitattributes"), "w") as fh:
+                fh.write("* text=auto\ndist/* linguist-generated=true\n*.min.js linguist-generated\n")
+            found = filetypes.generated_files(d, sorted(files))
+        self.assertEqual(found, ["dist/bundle.js", "gen/schema.py", "lib/config-validator.js", "pb/api.pb.go"])
+
     def test_vendored_trees(self):
         for path in ("vendor/github.com/x/y.go", "web/node_modules/a/index.js", "third_party/z/a.c", "thirdparty/a.c", "_vendor/a.py",
-                     "external/lib/a.cpp"):
+                     "external/lib/a.cpp", "requests/packages/urllib3/a.py", "pip/_vendor/six.py", "botocore/vendored/requests/a.py"):
             self.assertTrue(filetypes.is_vendor_path(path), path)
-        for path in ("vendors.py", "src/vendoring/a.py", "node/a.js", "externals.txt", "app/main.go"):
+        for path in ("vendors.py", "src/vendoring/a.py", "node/a.js", "externals.txt", "app/main.go",
+                     "packages/runtime-core/src/renderer.ts", "packages-private/x.ts"):   # a monorepo's own packages/ at the root
             self.assertFalse(filetypes.is_vendor_path(path), path)
 
 

{gitmole-0.6.5 → gitmole-0.6.7}/tests/test_findings.py

@@ -47,7 +47,7 @@ class SecretsFound(unittest.TestCase):
         self.assertIn("1 distinct value in 2 places: generic-api-key in app/settings.py (c1, c2)", crit["detail"])
         self.assertIn("Rotate", crit["advice"])
         self.assertIn(".betterleaksignore", crit["advice"])
-        self.assertEqual(warn["title"], "2 secret(s) only in test, example or documentation files")
+        self.assertEqual(warn["title"], "2 secret(s) only in test, example, vendored or documentation files")
         self.assertIn("2 distinct values in 3 places", warn["detail"])
         self.assertIn("tests/data/a.html and 1 other file", warn["detail"])
         self.assertIn(".betterleaksignore", warn["advice"])
@@ -62,15 +62,22 @@ class SecretsFound(unittest.TestCase):
                             self.row("h3", "pkg/testdata/creds.yaml", "c3")])
         f = findings.secrets_found(r)
         self.assertEqual([x["severity"] for x in f], ["warning"])
-        self.assertEqual(f[0]["title"], "3 secret(s) only in test, example or documentation files")
+        self.assertEqual(f[0]["title"], "3 secret(s) only in test, example, vendored or documentation files")
         r = report(secrets=[self.row("h1", "examples/app.py", "c1"), self.row("h1", "app/config.py", "c2")])
         self.assertEqual([x["severity"] for x in findings.secrets_found(r)], ["critical"], "the same value in source is a leak")
 
+    def test_a_value_only_in_vendored_code_is_a_warning(self):
+        # oauthlib's RFC test vectors inside requests/packages/: upstream's specimen, not this repository's credential
+        r = report(secrets=[self.row("h1", "requests/packages/oauthlib/oauth1/rfc5849/parameters.py", "9576518")])
+        f = findings.secrets_found(r)
+        self.assertEqual([x["severity"] for x in f], ["warning"])
+        self.assertIn("vendored", f[0]["title"])
+
     def test_a_value_only_in_documentation_is_a_warning_that_says_template(self):
         r = report(secrets=[self.row("h1", "docs/GA4-API-INTEGRATION.md", "e8c0508")])
         f = findings.secrets_found(r)
         self.assertEqual([x["severity"] for x in f], ["warning"])
-        self.assertEqual(f[0]["title"], "1 secret(s) only in test, example or documentation files")
+        self.assertEqual(f[0]["title"], "1 secret(s) only in test, example, vendored or documentation files")
         self.assertIn("fixtures or templates", f[0]["advice"])
         r = report(secrets=[self.row("h1", "docs/GA4-API-INTEGRATION.md", "e8c0508"), self.row("h1", "app/config.py", "c2")])
         self.assertEqual([x["severity"] for x in findings.secrets_found(r)], ["critical"], "the same value in source is a leak")
@@ -254,6 +261,15 @@ class TightCoupling(unittest.TestCase):
         f = findings.tight_coupling(report(coupling=pairs))
         self.assertIn("2 pairs", f[0]["detail"], "without a tree listing every pair counts")
 
+    def test_release_plumbing_pairs_are_not_a_dependency(self):
+        pairs = [{"entity": "lib/sinatra/version.rb", "coupled": "rack-protection/lib/rack/protection/version.rb", "degree": 100, "average-revs": 60},
+                 {"entity": "package.json", "coupled": "package-lock.json", "degree": 95, "average-revs": 40},
+                 {"entity": "lib/sinatra/version.rb", "coupled": "lib/sinatra/base.rb", "degree": 85, "average-revs": 10}]
+        f = findings.tight_coupling(report(coupling=pairs))
+        self.assertIn("1 pair changes together", f[0]["detail"], "a version file paired with real code still counts")
+        self.assertNotIn("package.json", f[0]["detail"])
+        self.assertEqual(findings.tight_coupling(report(coupling=pairs[:2])), [])
+
     def test_single_pair_reads_grammatically(self):
         pairs = [{"entity": "a", "coupled": "b", "degree": 100, "average-revs": 10}]
         f = findings.tight_coupling(report(coupling=pairs))
@@ -274,6 +290,21 @@ class TightCoupling(unittest.TestCase):
         self.assertEqual(findings.tight_coupling(report()), [])
 
 
+class ReleasePlumbing(unittest.TestCase):
+    def test_a_version_file_or_manifest_does_not_dominate_the_churn(self):
+        revs = [{"entity": "setup.py", "n-revs": 184}, {"entity": "requests/models.py", "n-revs": 60}, {"entity": "requests/api.py", "n-revs": 20}]
+        f = findings.hotspot_dominance(report(revisions=revs))
+        self.assertIn("requests/models.py changed 60 times", f[0]["detail"])
+        self.assertNotIn("setup.py", f[0]["detail"])
+
+    def test_a_manifest_is_not_a_bug_magnet(self):
+        fixes = [{"entity": "package.json", "n-fixes": 20, "last-fix": "2026-09-01", "recent-fixes": 6},
+                 {"entity": "lib/reply.js", "n-fixes": 10, "last-fix": "2026-09-01", "recent-fixes": 4}]
+        f = findings.bug_magnets(report(fixes=fixes))
+        self.assertIn("lib/reply.js", f[0]["detail"])
+        self.assertNotIn("package.json", f[0]["detail"])
+
+
 class StaleFiles(unittest.TestCase):
     def test_info_when_a_third_untouched_for_a_year(self):
         age = [{"entity": f"f{i}", "age-months": 12} for i in range(4)] + [{"entity": "g", "age-months": 0} for _ in range(6)]
@@ -374,6 +405,21 @@ class BrainMethods(unittest.TestCase):
         self.assertNotIn("test_all", f[0]["detail"])
         self.assertEqual(findings.brain_methods(report(functions=fns[:1])), [])
 
+    def test_an_anonymous_function_is_named_by_its_place(self):
+        fns = [{"file": "completions.go", "function": "(anonymous)", "ccn": 47, "nloc": 136, "params": 1, "start": 316, "end": 585}]
+        f = findings.brain_methods(report(functions=fns))
+        self.assertIn("(anonymous) (completions.go:316) complexity 47, 136 lines, 1 params", f[0]["detail"])
+        self.assertEqual(f[0]["advice"], "Split the anonymous function at completions.go:316 first, before the next change lands there.")
+
+    def test_generated_files_are_not_brain_methods(self):
+        fns = [{"file": "lib/config-validator.js", "function": "validate10", "ccn": 373, "nloc": 1150, "params": 5, "start": 1, "end": 1150},
+               {"file": "lib/reply.js", "function": "onSendEnd", "ccn": 34, "nloc": 180, "params": 2, "start": 1, "end": 180}]
+        r = report(functions=fns)
+        r["meta"]["generated"] = ["lib/config-validator.js"]
+        f = findings.brain_methods(r)
+        self.assertEqual(f[0]["advice"], "Split onSendEnd in lib/reply.js first, before the next change lands there.")
+        self.assertNotIn("validate10", f[0]["detail"])
+
     def test_vendored_functions_are_not_brain_methods(self):
         fns = [{"file": "vendor/github.com/google/jsonschema-go/jsonschema/validate.go", "function": "validate", "ccn": 179, "nloc": 424, "params": 3, "start": 1, "end": 424},
                {"file": "processor/workers.go", "function": "countLoopGeneric", "ccn": 56, "nloc": 164, "params": 8, "start": 1, "end": 164}]

{gitmole-0.6.5 → gitmole-0.6.7}/tests/test_identity.py

@@ -18,6 +18,19 @@ class Merge(unittest.TestCase):
         names = [m["name"] for m in merged]
         self.assertEqual(names, ["Bob", "Grzegorz Bankosz", "Ann"])
 
+    def test_an_identical_handle_under_several_emails_is_one_person(self):
+        ids = [{"name": "KaKa", "email": "kaka@a.com", "commits": 57}, {"name": "KaKa", "email": "23028015+climba@users.noreply.github.com", "commits": 56},
+               {"name": "kaka", "email": "climba@b.com", "commits": 10}, {"name": "namusyaka", "email": "n@a.com", "commits": 180},
+               {"name": "namusyaka", "email": "n@b.com", "commits": 8}, {"name": "Li Yu", "email": "li@a.com", "commits": 5},
+               {"name": "Li Yu", "email": "li@b.com", "commits": 3}]
+        merged = {m["name"]: m["commits"] for m in identity.merge(ids)}
+        self.assertEqual(merged, {"KaKa": 123, "namusyaka": 188, "Li Yu": 8})
+
+    def test_a_bare_common_first_name_is_not_enough(self):
+        ids = [{"name": "Jean", "email": "jean@a.com", "commits": 24}, {"name": "Jean", "email": "jean@b.com", "commits": 18},
+               {"name": "Alex", "email": "alex@a.com", "commits": 3}, {"name": "alex", "email": "alex@b.com", "commits": 2}]
+        self.assertEqual(len(identity.merge(ids)), 4, "two Jeans and two Alexes may be four people")
+
     def test_merged_row_sums_commits_and_lists_aliases(self):
         merged = {m["name"]: m for m in identity.merge(IDS)}
         self.assertEqual(merged["Grzegorz Bankosz"]["commits"], 41)

{gitmole-0.6.5 → gitmole-0.6.7}/tests/test_load.py

@@ -138,6 +138,11 @@ class ParseFunctions(unittest.TestCase):
     def test_empty(self):
         self.assertEqual(load.parse_functions(""), [])
 
+    def test_a_nameless_function_is_called_anonymous(self):
+        # lizard names Go function literals with an empty string where it names JavaScript's "(anonymous)"
+        rows = load.parse_functions('136,47,926,1,270,"@316-585@completions.go","completions.go",""," c * Command",316,585\n')
+        self.assertEqual((rows[0]["function"], rows[0]["start"]), ("(anonymous)", 316))
+
     def test_a_row_cut_short_by_a_killed_step_does_not_abort_the_report(self):
         rows = load.parse_functions(self.CSV + '5,3,40,1,5,"g@1-5@a.py","a.py","g","g( )",1,\n')
         self.assertEqual(len(rows), 3)

{gitmole-0.6.5 → gitmole-0.6.7}/tests/test_maat.py

@@ -48,6 +48,18 @@ class ParseLog(unittest.TestCase):
         self.assertEqual(commits[0]["files"], [("src/a.py", 3, 1), ("src/b.py", 2, 0)])
         self.assertEqual(commits[1]["files"][2], ("img/logo.png", 0, 0))
 
+    def test_renames_are_followed_to_the_new_path_and_a_pure_move_adds_no_lines(self):
+        # `git log -M --numstat` spells a rename three ways; the mover is not the owner of what moved
+        log = ("--d63e94f5--2023-08-13T10:00:00+00:00--Nate--Move to src layout\n"
+               "0\t0\t{requests => src/requests}/__init__.py\n"
+               "4\t7\tSECURITY.md => .github/SECURITY.md\n"
+               "0\t0\tCODE_OF_CONDUCT.md => .github/CODE_OF_CONDUCT.md\n"
+               "2\t0\tsrc/requests/{models.py => models_v2.py}\n"
+               "1\t1\tMakefile\n")
+        commits = maat.parse_log(log, types=None)
+        self.assertEqual(commits[0]["files"], [("src/requests/__init__.py", 0, 0), (".github/SECURITY.md", 4, 7),
+                                                (".github/CODE_OF_CONDUCT.md", 0, 0), ("src/requests/models_v2.py", 2, 0), ("Makefile", 1, 1)])
+
     def test_subjects_with_exotic_line_break_characters_do_not_split_the_log(self):
         # U+2028 and form feed are line breaks to str.splitlines but not to git
         text = "--x--2026-05-04T10:00:00+00:00--Ann--Fix\u2028broken\x0cthing\n1\t0\tf.py\n"

{gitmole-0.6.5 → gitmole-0.6.7}/tests/test_render.py

@@ -318,6 +318,47 @@ class Report(unittest.TestCase):
         full = _section_text(rendered(r, [], width=200, full=True), "Complex functions")
         self.assertIn("vendor/github.com/x/y.go", full)
 
+    def test_default_tables_hide_generated_files_and_say_so(self):
+        r = sample_report()
+        r["meta"]["generated"] = ["lib/config-validator.js"]
+        r["size"]["files"]["lib/config-validator.js"] = {"code": 1153, "complexity": 373}
+        r["revisions"].append({"entity": "lib/config-validator.js", "n-revs": 8})
+        r["functions"].append({"file": "lib/config-validator.js", "function": "validate10", "ccn": 373, "nloc": 1150, "params": 5, "start": 1, "end": 1150})
+        text = rendered(r, [], width=200)
+        hot = text[text.index("◆ Hotspots"):text.index("Change coupling")]
+        self.assertNotIn("config-validator", hot)
+        self.assertIn("1 generated file hidden; --full shows them", hot)
+        fn = _section_text(text, "Complex functions")
+        self.assertNotIn("validate10", fn)
+        self.assertIn("1 function in a generated file hidden; --full shows them", fn)
+        full = rendered(r, [], width=200, full=True)
+        self.assertIn("validate10", full)
+
+    def test_default_hotspots_hide_release_plumbing_and_say_so(self):
+        r = sample_report()
+        r["size"]["files"].update({"setup.py": {"code": 6, "complexity": 0}, "version.go": {"code": 2, "complexity": 0}})
+        r["revisions"] += [{"entity": "setup.py", "n-revs": 184}, {"entity": "version.go", "n-revs": 29}]
+        hot = rendered(r, [], width=200)
+        hot = hot[hot.index("◆ Hotspots"):hot.index("Change coupling")]
+        self.assertNotIn("setup.py", hot)
+        self.assertIn("2 release files hidden; --full shows them", hot)
+        full = rendered(r, [], width=200, full=True)
+        self.assertIn("setup.py", full[full.index("◆ Hotspots"):])
+
+    def test_default_coupling_hides_release_plumbing_pairs_and_says_so(self):
+        r = sample_report()
+        for f in ("lib/version.rb", "contrib/version.rb", "Gemfile", "Gemfile.lock"):
+            r["size"]["files"][f] = {"code": 3, "complexity": 0}
+        r["coupling"] = [{"entity": "lib/version.rb", "coupled": "contrib/version.rb", "degree": 64, "average-revs": 60},
+                         {"entity": "Gemfile", "coupled": "Gemfile.lock", "degree": 90, "average-revs": 20},
+                         {"entity": "static/index.html", "coupled": "static/apps-metadata.json", "degree": 90, "average-revs": 11}]
+        coupling = _section_text(rendered(r, [], width=200), "Change coupling")
+        self.assertIn("static/index.html", coupling)
+        self.assertNotIn("version.rb", coupling)
+        self.assertIn("2 release pairs hidden; --full shows them", coupling)
+        full = _section_text(rendered(r, [], width=200, full=True), "Change coupling")
+        self.assertIn("version.rb", full)
+
     def test_hotspots_with_only_test_files_say_what_was_hidden(self):
         r = sample_report()
         r["revisions"] = [{"entity": "tests/test_a.py", "n-revs": 200}]

{gitmole-0.6.5 → gitmole-0.6.7}/tests/test_run.py

@@ -192,6 +192,8 @@ class Plan(unittest.TestCase):
         self.assertEqual(by["scc"]["stdout"], "/o/size.json")
         self.assertIn("--by-file", by["scc"]["argv"])
         self.assertIn("--use-mailmap", by["git-log"]["argv"])
+        self.assertIn("-M", by["git-log"]["argv"], "renames are followed so a move to src/ credits nobody with the moved lines")
+        self.assertNotIn("--no-renames", by["git-log"]["argv"])
         self.assertEqual(by["git-log"]["argv"][:4], ["git", "-c", "core.quotePath=false", "log"], "non-ASCII paths must not be octal-escaped and quoted")
 
     def test_function_metrics_step_is_optional_and_runs_the_bundled_script(self):

{gitmole-0.6.5 → gitmole-0.6.7}/tests/test_watch.py

@@ -53,6 +53,14 @@ class Risks(unittest.TestCase):
         self.assertNotIn("core/gone.py", files, "no longer in the tree")
         self.assertNotIn("core/once.py", files, "changed once")
 
+    def test_release_plumbing_is_not_on_the_list(self):
+        r = report()
+        r["size"]["files"].update({"setup.py": {"code": 6, "complexity": 0}, "version.go": {"code": 2, "complexity": 0}, "Makefile": {"code": 21, "complexity": 0}})
+        r["revisions"] = [{"entity": "setup.py", "n-revs": 184}, {"entity": "version.go", "n-revs": 29}, {"entity": "Makefile", "n-revs": 131},
+                          {"entity": "core/parser.py", "n-revs": 40}]
+        files = sorted(x["file"] for x in watch.risks(r))
+        self.assertEqual(files, ["Makefile", "core/parser.py"], "a version file or a manifest changes on every release, not where the next bug lands")
+
     def test_test_companions_and_weak_pairs_are_not_reasons(self):
         top = watch.risks(report())[0]
         coupling = [r for r in top["reasons"] if r.startswith("changes with")][0]