gitmole 0.6.8__tar.gz → 0.6.10__tar.gz

{gitmole-0.6.8 → gitmole-0.6.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitmole
-Version: 0.6.8
+Version: 0.6.10
 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
@@ -55,7 +55,7 @@ Linux package names, the release binaries, `--plots` and the pip caveats:
 ```bash
 gitmole .                              # the clone you are in
 gitmole /path/to/clone                 # any local clone
-gitmole owner/repo                     # clones with gh into a temp dir first
+gitmole owner/repo                     # clones into a temp dir first, with gh or plain git
 gitmole 'owner/*'                      # every non-archived repo of a user or org, one summary table
 
 gitmole . --markdown report.md         # the same report as a Markdown document

{gitmole-0.6.8 → gitmole-0.6.10}/README.md

@@ -35,7 +35,7 @@ Linux package names, the release binaries, `--plots` and the pip caveats:
 ```bash
 gitmole .                              # the clone you are in
 gitmole /path/to/clone                 # any local clone
-gitmole owner/repo                     # clones with gh into a temp dir first
+gitmole owner/repo                     # clones into a temp dir first, with gh or plain git
 gitmole 'owner/*'                      # every non-archived repo of a user or org, one summary table
 
 gitmole . --markdown report.md         # the same report as a Markdown document

{gitmole-0.6.8 → gitmole-0.6.10}/gitmole/__init__.py

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

{gitmole-0.6.8 → gitmole-0.6.10}/gitmole/filetypes.py

@@ -50,20 +50,22 @@ def parse(spec):
     return {t.strip().lstrip(".").lower() for t in spec.split(",") if t.strip()}
 
 
-_TEST_PATH = re.compile(r"(^|/)(tests?|spec|specs|__tests__|testing)(/|$)|(^|/)(test_[^/]*|[^/]*_test\.[^/]+|[^/]*\.spec\.[^/]+|[^/]*\.test\.[^/]+)$", re.I)
+_TEST_PATH = re.compile(r"(^|/)(tests?|spec|specs|__tests__|testing|snapshots?|__snapshots__|[\w-]+[_-]tests?|tests?[_-][\w-]+)(/|$)"
+                        r"|(^|/)(test_[^/]*|[^/]*_test\.[^/]+|[^/]*\.spec\.[^/]+|[^/]*\.test\.[^/]+|[^/]*\.snap)$", re.I)
 
 
 def is_test_path(path: str) -> bool:
-    """A test file or anything under a tests directory: changes with every fix, so not a signal on its own."""
+    """A test file or anything under a tests directory (tests/, pending_tests/, e2e-tests/, test_utils/,
+    snapshots/ and .snap files): changes with every fix, so not a signal on its own."""
     return bool(_TEST_PATH.search(path))
 
 
-_DOC_PATH = re.compile(r"(^|/)docs?(/|$)|\.(md|markdown|rst|txt|adoc)$", re.I)
+_DOC_PATH = re.compile(r"(^|/)docs?([-_][\w-]+)?(/|$)|\.(md|markdown|rst|txt|adoc)$", re.I)
 
 
 def is_doc_path(path: str) -> bool:
-    """Documentation: prose formats anywhere, or anything under docs/. A key in a planning document
-    is far more often a template than a leak."""
+    """Documentation: prose formats anywhere, or anything under docs/, doc/, docs_src/, docs-site/. A
+    key in a planning document or a tutorial is far more often a template than a leak."""
     return bool(_DOC_PATH.search(path))
 
 
@@ -98,6 +100,17 @@ def is_release_path(path: str) -> bool:
     return name in _RELEASE_NAMES or name.endswith(".gemspec") or name.startswith(("changelog", "changes.", "history.", "news."))
 
 
+def plumbing_paths(report: dict) -> set:
+    """Files the change log showed to be release plumbing by behaviour rather than by name: nearly
+    every commit touching them changed a line or two (a version constant in __init__.py)."""
+    return {r["entity"] for r in report.get("plumbing") or []}
+
+
+def is_release(path: str, plumbing=frozenset()) -> bool:
+    """is_release_path, or a path the change log showed to be plumbing (see plumbing_paths)."""
+    return is_release_path(path) or path in plumbing
+
+
 # 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

{gitmole-0.6.8 → gitmole-0.6.10}/gitmole/findings.py

@@ -176,7 +176,8 @@ 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.
     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"]))),
+    plumb = filetypes.plumbing_paths(report)
+    revs = sorted((r for r in report.get("revisions") or [] if not (filetypes.is_test_path(r["entity"]) or filetypes.is_release(r["entity"], plumb))),
                   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 []
@@ -266,8 +267,9 @@ 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.
     So is release plumbing: a manifest touched by every fix release is not where the bug was."""
+    plumb = filetypes.plumbing_paths(report)
     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"]))]
+           and not (filetypes.is_test_path(f["entity"]) or filetypes.is_release(f["entity"], plumb))]
     if not hot:
         return []
     hot.sort(key=lambda f: (-f["recent-fixes"], -f["n-fixes"], f["entity"]))

{gitmole-0.6.8 → gitmole-0.6.10}/gitmole/functions.py

@@ -30,10 +30,20 @@ def select_files(repo: str, ignore=(), types_spec: str = None) -> list:
     return [f for f in files if lizard.get_reader_for(f) is not None]
 
 
+NAME_CAP = 200        # a deeply nested fixture gives lizard a dotted name of megabytes; nobody reads past this
+LONG_NAME_CAP = 500
+
+
+def _cut(text: str, cap: int) -> str:
+    return text if len(text) <= cap else text[:cap - 1] + "…"
+
+
 def csv_row(info, fn) -> list:
-    """The columns `lizard --csv` prints, so the loader does not care which produced the file."""
+    """The columns `lizard --csv` prints, so the loader does not care which produced the file. Names
+    are cut to what a table can show, so one pathological fixture cannot make the file unreadable."""
+    name = _cut(fn.name, NAME_CAP)
     return [fn.nloc, fn.cyclomatic_complexity, fn.token_count, fn.parameter_count, fn.length,
-            f"{fn.name}@{fn.start_line}-{fn.end_line}@{info.filename}", info.filename, fn.name, fn.long_name, fn.start_line, fn.end_line]
+            f"{name}@{fn.start_line}-{fn.end_line}@{info.filename}", info.filename, name, _cut(fn.long_name, LONG_NAME_CAP), fn.start_line, fn.end_line]
 
 
 def write_duplicates(dup: Duplicates, fh) -> None:

{gitmole-0.6.8 → gitmole-0.6.10}/gitmole/identity.py

@@ -53,7 +53,13 @@ def same_person(a: dict, b: dict) -> bool:
     for handle, full in ((na, tb), (nb, ta)):
         if " " not in handle and handle in full and len(full) >= 2 and _distinctive(handle):
             return True
-    return False
+    # RobinMalfait and Robin Malfait: the full name run together, six letters or more so it is not anyone
+    sa, sb = _squash(a["name"]), _squash(b["name"])
+    return bool(sa) and sa == sb and len(sa) >= 6 and (len(ta) >= 2 or len(tb) >= 2)
+
+
+def _squash(name: str) -> str:
+    return re.sub(r"[^a-z0-9]", "", name.lower())
 
 
 def merge(identities: list) -> list:

{gitmole-0.6.8 → gitmole-0.6.10}/gitmole/load.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 
 import csv
 import io
+import sys
 import json
 import os
 import re
@@ -64,7 +65,7 @@ def parse_scc(text: str, types=None) -> dict:
     }
 
 
-NUMERIC_COLUMNS = {"n-revs", "degree", "average-revs", "n-authors", "age-months", "added", "deleted", "n-fixes", "recent-fixes"}
+NUMERIC_COLUMNS = {"n-revs", "degree", "average-revs", "n-authors", "age-months", "added", "deleted", "n-fixes", "recent-fixes", "tiny-revs"}
 
 
 def parse_maat_csv(text: str) -> list:
@@ -145,13 +146,21 @@ def parse_authors_log(text: str) -> list:
     ]
 
 
+NAME_CAP = 200   # a function name a table can show; deeply nested fixtures give lizard dotted names of megabytes
+csv.field_size_limit(min(sys.maxsize, 2**31 - 1))   # an older functions.csv may still carry such a name
+
+
+def _cut(name: str, cap: int = NAME_CAP) -> str:
+    return name if len(name) <= cap else name[:cap - 1] + "…"
+
+
 def parse_functions(text: str) -> list:
     """lizard --csv rows: nloc, ccn, tokens, params, length, location, file, function, long name, start, end."""
     rows = []
     for r in csv.reader(io.StringIO(text)):
         if len(r) < 11:
             continue
-        rows.append({"file": _rel(r[6]), "function": r[7] or "(anonymous)", "ccn": _num(r[1]), "nloc": _num(r[0]), "params": _num(r[3]),
+        rows.append({"file": _rel(r[6]), "function": _cut(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
 
@@ -235,6 +244,7 @@ def load_report(out_dir: str, nested: bool = True) -> dict:
         # was measured unfiltered, so it is re-rendered unfiltered rather than with a guessed list
         "size": parse_scc(_read(out_dir, "size.json"), filetypes.parse(meta["file_types"]) if "file_types" in meta else None),
         "revisions": parse_maat_csv(_read(out_dir, "maat-revisions.csv")),
+        "plumbing": parse_maat_csv(_read(out_dir, "maat-plumbing.csv")),
         "coupling": parse_maat_csv(_read(out_dir, "maat-coupling.csv")),
         "authors": parse_maat_csv(_read(out_dir, "maat-authors.csv")),
         "age": parse_maat_csv(_read(out_dir, "maat-age.csv")),

{gitmole-0.6.8 → gitmole-0.6.10}/gitmole/maat.py

@@ -221,8 +221,22 @@ def activity(commits: list) -> dict:
             "reverted": dict(sorted(reverted.items(), key=lambda kv: (-kv[1], kv[0])))}
 
 
+def plumbing(commits: list, min_revs: int = 20, share: float = 0.8, max_lines: int = 2) -> list:
+    """Files whose commits nearly always change a line or two: a version constant in __init__.py, a
+    date in a header. Their churn is the release cadence, not where the next bug lands. Needs enough
+    commits to judge by."""
+    revs, tiny = Counter(), Counter()
+    for c in commits:
+        for path, added, deleted in c["files"]:
+            revs[path] += 1
+            if added + deleted <= max_lines:
+                tiny[path] += 1
+    return [{"entity": e, "n-revs": n, "tiny-revs": tiny[e]} for e, n in sorted(revs.items()) if n >= min_revs and tiny[e] / n >= share]
+
+
 ANALYSES = {
     "revisions": (revisions, ["entity", "n-revs"]),
+    "plumbing": (plumbing, ["entity", "n-revs", "tiny-revs"]),
     "coupling": (coupling, ["entity", "coupled", "degree", "average-revs"]),
     "authors": (authors, ["entity", "n-authors", "n-revs"]),
     "age": (age, ["entity", "age-months"]),

{gitmole-0.6.8 → gitmole-0.6.10}/gitmole/render.py

@@ -395,7 +395,8 @@ def hotspots_section(report: dict, full: bool = True, width=None) -> dict:
     scored, hidden_note = _hide_tests(scored, lambda h: h["entity"], full)
     scored, deleted_note = _hide_deleted(scored, report, full)
     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")
+    plumb = filetypes.plumbing_paths(report)
+    scored, release_note = _hide_rows(scored, lambda h: h["entity"], full, lambda p: filetypes.is_release(p, plumb), "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)

{gitmole-0.6.8 → gitmole-0.6.10}/gitmole/run.py

@@ -96,10 +96,22 @@ def list_repos(owner: str, lister=_gh) -> list:
     return sorted(set(out.split()))
 
 
-def clone(target: str, dest_parent: str, runner=_gh) -> str:
-    """Clone a remote target with gh (so private repos use the existing auth). Raises GhError."""
+def clone_url(target: str) -> str:
+    """The URL plain git can clone: a URL as given, owner/repo on github.com."""
+    return target if _URL.match(target) else f"https://github.com/{target}.git"
+
+
+def clone(target: str, dest_parent: str, runner=_gh, git_runner=_gh) -> str:
+    """Clone a remote target with gh (so private repos use the existing auth), or with plain git when
+    gh is missing or fails: a public repository needs no token. Raises GhError naming both failures."""
     dest = os.path.join(dest_parent, repo_name(target))
-    _wrap(runner, ["gh", "repo", "clone", target, dest, "--", "--quiet"])
+    try:
+        _wrap(runner, ["gh", "repo", "clone", target, dest, "--", "--quiet"])
+    except GhError as gh_error:
+        try:
+            _wrap(git_runner, [*filetypes.GIT, "clone", "--quiet", clone_url(target), dest])
+        except GhError as git_error:
+            raise GhError(f"{gh_error}; git clone also failed: {git_error}") from None
     return dest
 
 

{gitmole-0.6.8 → gitmole-0.6.10}/gitmole/watch.py

@@ -64,9 +64,10 @@ def risks(report: dict, min_revs: int = 2) -> list:
     fixes = {f["entity"]: f for f in report.get("fixes") or []}
     n_authors = {a["entity"]: a["n-authors"] for a in report.get("authors") or []}
 
+    plumb = filetypes.plumbing_paths(report)
     rows = []
     for h in hotspots.ranked(report):
-        if h["code"] is None or h["revs"] < min_revs or filetypes.is_test_path(h["entity"]) or filetypes.is_release_path(h["entity"]):
+        if h["code"] is None or h["revs"] < min_revs or filetypes.is_test_path(h["entity"]) or filetypes.is_release(h["entity"], plumb):
             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()

{gitmole-0.6.8 → gitmole-0.6.10}/gitmole.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitmole
-Version: 0.6.8
+Version: 0.6.10
 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
@@ -55,7 +55,7 @@ Linux package names, the release binaries, `--plots` and the pip caveats:
 ```bash
 gitmole .                              # the clone you are in
 gitmole /path/to/clone                 # any local clone
-gitmole owner/repo                     # clones with gh into a temp dir first
+gitmole owner/repo                     # clones into a temp dir first, with gh or plain git
 gitmole 'owner/*'                      # every non-archived repo of a user or org, one summary table
 
 gitmole . --markdown report.md         # the same report as a Markdown document

{gitmole-0.6.8 → gitmole-0.6.10}/tests/test_filetypes.py

@@ -86,15 +86,18 @@ class Discover(unittest.TestCase):
 
 class TestPaths(unittest.TestCase):
     def test_test_files_and_directories(self):
-        for path in ("tests/test_a.py", "a/spec/b.rb", "src/__tests__/x.js", "x/y_test.go", "app.spec.ts", "app.test.tsx", "test_x.py"):
+        for path in ("tests/test_a.py", "a/spec/b.rb", "src/__tests__/x.js", "x/y_test.go", "app.spec.ts", "app.test.tsx", "test_x.py",
+                     "pending_tests/main.py", "e2e-tests/login.ts", "src/test_utils/helpers.py", "crates/x/snapshots/rule__S105.py.snap",
+                     "src/__snapshots__/a.js.snap", "lib/render.snap"):
             self.assertTrue(filetypes.is_test_path(path), path)
-        for path in ("src/contest.py", "gitmole/render.py", "attest/x.py", "latest.md"):
+        for path in ("src/contest.py", "gitmole/render.py", "attest/x.py", "latest.md", "src/testimony.py", "snapshot.py"):
             self.assertFalse(filetypes.is_test_path(path), path)
 
     def test_documentation_files_and_directories(self):
-        for path in ("README.md", "docs/GA4-API-INTEGRATION.md", "doc/guide.rst", "NOTES.txt", "a/b/CHANGELOG.markdown", "docs/conf.py", "x.adoc"):
+        for path in ("README.md", "docs/GA4-API-INTEGRATION.md", "doc/guide.rst", "NOTES.txt", "a/b/CHANGELOG.markdown", "docs/conf.py", "x.adoc",
+                     "docs_src/security/tutorial004.py", "docs-site/app.js", "doc_examples/x.py"):
             self.assertTrue(filetypes.is_doc_path(path), path)
-        for path in ("app/settings.py", "static/index.html", "docsite/app.js", "mdx/a.py", "config.yaml"):
+        for path in ("app/settings.py", "static/index.html", "docsite/app.js", "mdx/a.py", "config.yaml", "doctor/a.py"):
             self.assertFalse(filetypes.is_doc_path(path), path)
 
     def test_example_fixture_and_rule_directories(self):

{gitmole-0.6.8 → gitmole-0.6.10}/tests/test_findings.py

@@ -297,6 +297,12 @@ class ReleasePlumbing(unittest.TestCase):
         self.assertIn("requests/models.py changed 60 times", f[0]["detail"])
         self.assertNotIn("setup.py", f[0]["detail"])
 
+    def test_a_file_the_change_log_shows_as_plumbing_does_not_dominate_the_churn(self):
+        revs = [{"entity": "fastapi/__init__.py", "n-revs": 331}, {"entity": "fastapi/routing.py", "n-revs": 187}, {"entity": "fastapi/utils.py", "n-revs": 70}]
+        r = report(revisions=revs, plumbing=[{"entity": "fastapi/__init__.py", "n-revs": 331, "tiny-revs": 300}])
+        f = findings.hotspot_dominance(r)
+        self.assertIn("fastapi/routing.py changed 187 times", 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}]

{gitmole-0.6.8 → gitmole-0.6.10}/tests/test_functions.py

@@ -67,6 +67,17 @@ class FunctionsScript(unittest.TestCase):
         self.assertIn('"tracked"', csv, "functions are still measured")
         self.assertIsNone(dup, "no duplicates.txt: the finder did not run, so nothing pretends it did")
 
+    def test_a_huge_nested_name_is_cut_before_it_is_written(self):
+        from types import SimpleNamespace
+        name = ".".join("a" for _ in range(100_000))
+        fn = SimpleNamespace(nloc=5, cyclomatic_complexity=3, token_count=40, parameter_count=1, length=5, name=name,
+                             long_name=name + "( )", start_line=1, end_line=5)
+        row = functions.csv_row(SimpleNamespace(filename="a.py"), fn)
+        self.assertEqual(len(row[7]), functions.NAME_CAP)
+        self.assertTrue(row[7].endswith("…"))
+        self.assertLessEqual(len(row[8]), functions.LONG_NAME_CAP)
+        self.assertLessEqual(len(row[5]), functions.NAME_CAP + len("@1-5@a.py"))
+
     def test_csv_matches_lizards_own_layout(self):
         with tempfile.TemporaryDirectory() as d:
             make_repo(d)

{gitmole-0.6.8 → gitmole-0.6.10}/tests/test_identity.py

@@ -34,6 +34,12 @@ class Merge(unittest.TestCase):
         self.assertEqual(merged, {"Junegunn Choi": 3047, "Sam Altman": 5, "sam": 2, "Kevin Brown": 76, "Kevin": 21},
                          "a short or common first name is not distinctive enough")
 
+    def test_a_handle_that_is_the_full_name_run_together_is_the_same_person(self):
+        ids = [{"name": "Robin Malfait", "email": "malfait.robin@a.com", "commits": 1271}, {"name": "RobinMalfait", "email": "1834413+RobinMalfait@users.noreply.github.com", "commits": 4},
+               {"name": "Jo Li", "email": "jo@a.com", "commits": 3}, {"name": "joli", "email": "x@b.com", "commits": 1}]
+        merged = {m["name"]: m["commits"] for m in identity.merge(ids)}
+        self.assertEqual(merged, {"Robin Malfait": 1275, "Jo Li": 3, "joli": 1}, "a run-together name shorter than six letters could be anyone")
+
     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}]

{gitmole-0.6.8 → gitmole-0.6.10}/tests/test_load.py

@@ -138,6 +138,19 @@ class ParseFunctions(unittest.TestCase):
     def test_empty(self):
         self.assertEqual(load.parse_functions(""), [])
 
+    def test_a_row_with_a_huge_long_name_does_not_abort_the_report(self):
+        # ruff: lizard wrote a long name of several hundred kilobytes for one function, over csv's default field limit
+        huge = "f( " + "a, " * 100_000 + ")"
+        rows = load.parse_functions(f'5,3,40,1,5,"f@1-5@a.rs","a.rs","f","{huge}",1,5\n')
+        self.assertEqual((rows[0]["function"], rows[0]["file"], rows[0]["ccn"]), ("f", "a.rs", 3))
+
+    def test_a_huge_function_name_is_cut_to_something_a_table_can_show(self):
+        # a test fixture of deeply nested functions gives lizard a dotted name of megabytes
+        name = ".".join("a" for _ in range(100_000))
+        rows = load.parse_functions(f'5,3,40,1,5,"{name}@1-5@a.py","a.py","{name}","{name}( )",1,5\n')
+        self.assertEqual(len(rows[0]["function"]), load.NAME_CAP)
+        self.assertTrue(rows[0]["function"].endswith("…"))
+
     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')
@@ -224,6 +237,7 @@ class LoadReport(unittest.TestCase):
                 "meta.json": json.dumps({"name": "demo", "commits": 3, "identities": []}),
                 "size.json": json.dumps([{"Name": "Python", "Count": 1, "Code": 10, "Comment": 0, "Blank": 0, "Complexity": 1}]),
                 "maat-revisions.csv": "entity,n-revs\na.py,3\n",
+                "maat-plumbing.csv": "entity,n-revs,tiny-revs\npkg/__init__.py,25,24\n",
                 "maat-coupling.csv": "entity,coupled,degree,average-revs\n",
                 "maat-age.csv": "entity,age-months\na.py,0\n",
                 "maat-authors.csv": "entity,n-authors,n-revs\na.py,1,3\n",
@@ -243,6 +257,7 @@ class LoadReport(unittest.TestCase):
         self.assertEqual(r["meta"]["name"], "demo")
         self.assertEqual(r["size"]["total_code"], 10)
         self.assertEqual(r["revisions"][0]["entity"], "a.py")
+        self.assertEqual(r["plumbing"], [{"entity": "pkg/__init__.py", "n-revs": 25, "tiny-revs": 24}])
         self.assertEqual(r["coupling"], [])
         self.assertEqual(r["fixes"][0]["recent-fixes"], 1)
         self.assertEqual(r["cohorts"], {"Code added in 2026": 10})

{gitmole-0.6.8 → gitmole-0.6.10}/tests/test_maat.py

@@ -99,6 +99,29 @@ class Revisions(unittest.TestCase):
         self.assertEqual(dict((r["entity"], r["n-revs"]) for r in rows)["src/c.py"], 1)
 
 
+class Plumbing(unittest.TestCase):
+    def _commits(self, path, tiny, big):
+        out = [{"hash": f"t{i}", "date": "2026-01-01", "time": "", "author": "A", "subject": "bump", "files": [(path, 1, 1)]} for i in range(tiny)]
+        out += [{"hash": f"b{i}", "date": "2026-01-01", "time": "", "author": "A", "subject": "work", "files": [(path, 40, 12)]} for i in range(big)]
+        return out
+
+    def test_a_file_whose_commits_nearly_always_change_a_line_or_two_is_plumbing(self):
+        commits = self._commits("fastapi/__init__.py", tiny=300, big=31) + self._commits("fastapi/routing.py", tiny=10, big=90) + self._commits("VERSION", tiny=5, big=0)
+        rows = maat.plumbing(commits)
+        self.assertEqual(rows, [{"entity": "fastapi/__init__.py", "n-revs": 331, "tiny-revs": 300}],
+                         "routing.py has real edits; VERSION has too few commits to judge")
+
+    def test_written_alongside_the_other_analyses(self):
+        with tempfile.TemporaryDirectory() as d:
+            log = os.path.join(d, "log.txt")
+            with open(log, "w", encoding="utf-8") as fh:
+                fh.write("".join(f"--h{i}--2026-01-{1 + i % 28:02d}T10:00:00+00:00--Ann--bump\n1\t1\tpkg/__init__.py\n" for i in range(25)))
+            maat.write_all(log, d, types=None)
+            with open(os.path.join(d, "maat-plumbing.csv"), encoding="utf-8") as fh:
+                text = fh.read()
+        self.assertEqual(text.splitlines(), ["entity,n-revs,tiny-revs", "pkg/__init__.py,25,25"])
+
+
 class Coupling(unittest.TestCase):
     def test_degree_is_shared_over_average_revisions(self):
         rows = maat.coupling(maat.parse_log(LOG))
@@ -311,14 +334,15 @@ class SinceWindow(unittest.TestCase):
 
 
 class WriteAll(unittest.TestCase):
-    def test_writes_the_five_csv_files_in_code_maat_layout(self):
+    def test_writes_the_csv_files_in_code_maat_layout_plus_plumbing(self):
         with tempfile.TemporaryDirectory() as d:
             log = os.path.join(d, "log.txt")
             with open(log, "w") as fh:
                 fh.write(LOG)
             maat.write_all(log, d)
             names = sorted(n for n in os.listdir(d) if n.startswith("maat-"))
-            self.assertEqual(names, ["maat-age.csv", "maat-authors.csv", "maat-coupling.csv", "maat-entity-ownership.csv", "maat-fixes.csv", "maat-revisions.csv"])
+            self.assertEqual(names, ["maat-age.csv", "maat-authors.csv", "maat-coupling.csv", "maat-entity-ownership.csv", "maat-fixes.csv",
+                                     "maat-plumbing.csv", "maat-revisions.csv"])
             self.assertTrue(os.path.isfile(os.path.join(d, "activity.json")))
             with open(os.path.join(d, "maat-revisions.csv")) as fh:
                 self.assertEqual(fh.readline().strip(), "entity,n-revs")

{gitmole-0.6.8 → gitmole-0.6.10}/tests/test_render.py

@@ -345,6 +345,16 @@ class Report(unittest.TestCase):
         full = rendered(r, [], width=200, full=True)
         self.assertIn("setup.py", full[full.index("◆ Hotspots"):])
 
+    def test_default_hotspots_hide_files_the_change_log_shows_as_plumbing(self):
+        r = sample_report()
+        r["size"]["files"]["pkg/__init__.py"] = {"code": 40, "complexity": 0}
+        r["revisions"].append({"entity": "pkg/__init__.py", "n-revs": 331})
+        r["plumbing"] = [{"entity": "pkg/__init__.py", "n-revs": 331, "tiny-revs": 300}]
+        hot = rendered(r, [], width=200)
+        hot = hot[hot.index("◆ Hotspots"):hot.index("Change coupling")]
+        self.assertNotIn("pkg/__init__.py", hot)
+        self.assertIn("1 release file hidden; --full shows them", hot)
+
     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"):

{gitmole-0.6.8 → gitmole-0.6.10}/tests/test_run.py

@@ -77,11 +77,36 @@ class GhErrors(unittest.TestCase):
             run.list_repos("acme", lister=lister)
         self.assertIn("failed to verify certificate", str(ctx.exception))
 
-    def test_clone_wraps_gh_failure_with_its_stderr(self):
+    def test_clone_falls_back_to_plain_git_when_gh_is_missing_or_fails(self):
+        # a public repository needs no gh and no token: git alone can clone it
+        calls = []
+        def no_gh(argv):
+            raise FileNotFoundError("gh")
+        def git(argv):
+            calls.append(argv)
+            return ""
+        with tempfile.TemporaryDirectory() as d:
+            dest = run.clone("acme/widgets", d, runner=no_gh, git_runner=git)
+            self.assertEqual(dest, os.path.join(d, "widgets"))
+            self.assertEqual(calls, [["git", "-c", "core.quotePath=false", "clone", "--quiet", "https://github.com/acme/widgets.git", dest]])
+            calls.clear()
+            run.clone("https://github.com/acme/widgets.git", d, runner=lambda argv: (_ for _ in ()).throw(subprocess.CalledProcessError(1, argv, stderr="tls")), git_runner=git)
+            self.assertEqual(calls[0][5], "https://github.com/acme/widgets.git", "a URL is cloned as given")
+
+    def test_clone_reports_both_failures_when_git_fails_too(self):
         with tempfile.TemporaryDirectory() as d:
             with self.assertRaises(run.GhError) as ctx:
-                run.clone("acme/definitely-missing-repo-xyz", d, runner=lambda argv: (_ for _ in ()).throw(subprocess.CalledProcessError(1, argv, stderr="repository not found")))
+                run.clone("acme/definitely-missing-repo-xyz", d,
+                          runner=lambda argv: (_ for _ in ()).throw(subprocess.CalledProcessError(1, argv, stderr="repository not found")),
+                          git_runner=lambda argv: (_ for _ in ()).throw(subprocess.CalledProcessError(128, argv, stderr="fatal: not found")))
         self.assertIn("repository not found", str(ctx.exception))
+        self.assertIn("git clone also failed: fatal: not found", str(ctx.exception))
+
+    def test_clone_does_not_touch_git_when_gh_succeeds(self):
+        calls = []
+        with tempfile.TemporaryDirectory() as d:
+            run.clone("acme/widgets", d, runner=lambda argv: "", git_runner=lambda argv: calls.append(argv))
+        self.assertEqual(calls, [])
 
 
 class ParseSince(unittest.TestCase):

{gitmole-0.6.8 → gitmole-0.6.10}/tests/test_watch.py

@@ -61,6 +61,13 @@ class Risks(unittest.TestCase):
         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_a_file_the_change_log_shows_as_plumbing_is_not_on_the_list(self):
+        r = report()
+        r["size"]["files"]["pkg/__init__.py"] = {"code": 40, "complexity": 0}
+        r["revisions"] = [{"entity": "pkg/__init__.py", "n-revs": 331}, {"entity": "core/parser.py", "n-revs": 40}]
+        r["plumbing"] = [{"entity": "pkg/__init__.py", "n-revs": 331, "tiny-revs": 300}]
+        self.assertEqual([x["file"] for x in watch.risks(r)], ["core/parser.py"])
+
     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]