gitmole 0.6.9__tar.gz → 0.6.11__tar.gz

{gitmole-0.6.9 → gitmole-0.6.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitmole
-Version: 0.6.9
+Version: 0.6.11
 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.9 → gitmole-0.6.11}/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.9 → gitmole-0.6.11}/gitmole/__init__.py

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

{gitmole-0.6.9 → gitmole-0.6.11}/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))
 
 
@@ -76,7 +78,7 @@ def is_sample_path(path: str) -> bool:
     return bool(_SAMPLE_PATH.search(path))
 
 
-_VENDOR_PATH = re.compile(r"(^|/)(_?vendor|vendored|node_modules|third_?party|external)(/|$)|^[^/]+/packages/", re.I)
+_VENDOR_PATH = re.compile(r"(^|/)(_?vendor|vendored|node_modules|third_?party|external|deps)(/|$)|^[^/]+/packages/", re.I)
 
 
 def is_vendor_path(path: str) -> bool:
@@ -98,6 +100,36 @@ def is_release_path(path: str) -> bool:
     return name in _RELEASE_NAMES or name.endswith(".gemspec") or name.startswith(("changelog", "changes.", "history.", "news."))
 
 
+_SOURCE_EXT = {"c", "cc", "cpp", "cxx", "m", "mm"}
+_HEADER_EXT = {"h", "hh", "hpp", "hxx"}
+
+
+def is_header_pair(a: str, b: str) -> bool:
+    """A C-family source file and its own header, same directory and stem: they change together by
+    construction, so the pair says nothing about a hidden dependency."""
+    if a == b:
+        return False
+    (da, sa, ea), (db, sb, eb) = _split(a), _split(b)
+    return da == db and sa == sb and ({ea, eb} & _SOURCE_EXT) and ({ea, eb} & _HEADER_EXT) and ea != eb
+
+
+def _split(path: str) -> tuple:
+    head, _, name = path.rpartition("/")
+    stem, _, ext = name.rpartition(".")
+    return head, stem, ext.lower()
+
+
+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.9 → gitmole-0.6.11}/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 []
@@ -194,6 +195,8 @@ def tight_coupling(report: dict, min_degree: int = 80, min_revs: int = 5) -> lis
     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 filetypes.is_header_pair(p["entity"], p["coupled"])
+             and not (filetypes.is_vendor_path(p["entity"]) or filetypes.is_vendor_path(p["coupled"]))
              and not (tree and (p["entity"] not in tree or p["coupled"] not in tree))]
     if not pairs:
         return []
@@ -266,8 +269,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.9 → gitmole-0.6.11}/gitmole/identity.py

@@ -5,15 +5,17 @@ import re
 
 
 _BOT_WORDS = ("dependabot", "renovate", "github-actions", "github actions", "copilot", "cursor agent", "cursor-agent", "cursoragent")
+_BOT_NAME = re.compile(r"\bbot\b|\bci\b|deploy|automation", re.I)   # "Deploy from CI", "Release Bot", "Homebrew Automation"
 
 
 def is_bot(name: str, email: str = "") -> bool:
-    """A commit author that is a service, not a person: GitHub's *[bot] suffix, or one of the
-    common automation names in the name or the mailbox."""
+    """A commit author that is a service, not a person: GitHub's *[bot] suffix, one of the common
+    automation names in the name or the mailbox, or a name that says bot, CI, deploy or automation."""
     n, local = name.strip().lower(), email.strip().lower().split("@")[0]
     if n.endswith("[bot]") or local.endswith("[bot]"):
         return True
-    return any(w in n for w in _BOT_WORDS) or any(w in local for w in _BOT_WORDS) or email.strip().lower() == "actions@github.com"
+    return (any(w in n for w in _BOT_WORDS) or any(w in local for w in _BOT_WORDS) or email.strip().lower() == "actions@github.com"
+            or bool(_BOT_NAME.search(name)))
 
 
 def _tokens(name: str) -> set:
@@ -53,7 +55,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.9 → gitmole-0.6.11}/gitmole/leaks.py

@@ -59,18 +59,59 @@ def digest(value: str, key: bytes) -> str:
     return hmac.new(key, value.encode("utf-8", "surrogateescape"), hashlib.sha256).hexdigest()[:12]
 
 
-def is_placeholder(value: str) -> bool:
+# A header followed by no key material is a pattern a script greps for, not a key (ohmyzsh's ssh-agent
+# plugin: the scanner captures the header and the shell code after it).
+_HEADER = re.compile(r"^\^?-----BEGIN[ \\A-Z]*KEY-----")
+_BASE64_RUN = re.compile(r"[A-Za-z0-9+/=]{40,}")
+# A line that calls its own value an example is documentation, wherever it sits: "# Example password: ...".
+_EXAMPLE_LINE = re.compile(r"\b(example|sample|dummy|fake|placeholder)|\be\.g\.", re.I)
+
+
+def _made_up(value: str) -> bool:
+    """A run up the alphabet and the digits (qr6stu789vwxyz, abcd1234): typed, not generated. Eight
+    characters or more, letters non-decreasing, digits non-decreasing, both present or one long."""
+    alnum = re.sub(r"[^A-Za-z0-9]", "", value).lower()
+    letters = [c for c in alnum if c.isalpha()]
+    digits = [c for c in alnum if c.isdigit()]
+    if len(alnum) < 8 or len(alnum) != len(letters) + len(digits):
+        return False
+    return letters == sorted(letters) and digits == sorted(digits) and len(set(letters)) >= 4 or (not letters and digits == sorted(digits))
+
+
+def is_placeholder(value: str, line: str = "") -> bool:
+    """Whether `value` has a shape that cannot be a live secret. `line` is the source line the value
+    sat on, read from the clone at scan time and never written."""
     value = (value or "").strip()
     if (_VERSION.match(value) or value.endswith("...") or value.endswith("…") or _MARKER.match(value) or value.lower() in _EXAMPLE_WORDS
-            or _ENV_REF.match(value)):
+            or _ENV_REF.match(value) or _made_up(value)):
+        return True
+    if line and _EXAMPLE_LINE.search(line):
         return True
     m = _KEY_BLOCK.search(value)
     if m:
         body = re.sub(r"\s|\.|…|\\n", "", m.group(1))   # literal \n sequences appear in JSON samples
         return len(body) < _KEY_MATERIAL
+    h = _HEADER.match(value)
+    if h and not _BASE64_RUN.search(value[h.end():]):
+        return True
     return False
 
 
+def line_of(repo: str, commit: str, path: str, number: int) -> str:
+    """Line `number` of `path` as it was at `commit`, from the clone; "" when it cannot be read. Read
+    for the placeholder rule and dropped, like every other raw field."""
+    if not (commit and path and number):
+        return ""
+    proc = subprocess.run(["git", "-C", repo, "show", f"{commit}:{path}"], capture_output=True)
+    if proc.returncode != 0:
+        return ""
+    lines = proc.stdout.decode("utf-8", "replace").split("\n")
+    return lines[number - 1] if 0 < number <= len(lines) else ""
+
+
+LINE_LOOKUPS = 400   # one git call per finding; past this many the rest go without their line
+
+
 def sanitise(rows: list) -> list:
     key = new_key()   # one key for the whole report, so repeats of a value still group
     out = []
@@ -78,7 +119,7 @@ def sanitise(rows: list) -> list:
         value = r.get("Secret") or ""
         clean = {k: v for k, v in r.items() if k not in RAW_FIELDS}
         clean["SecretHash"] = digest(value, key)
-        clean["Placeholder"] = is_placeholder(value)
+        clean["Placeholder"] = is_placeholder(value, r.get("Line") or "")   # the line is read here and dropped with the other raw fields
         out.append(clean)
     return out
 
@@ -130,7 +171,10 @@ def main(argv=None) -> int:
         print(f"leaks.py: betterleaks exited {proc.returncode}; no report written", file=sys.stderr)
         return proc.returncode
     text = proc.stdout.decode("utf-8", "surrogateescape").strip()
-    rows = sanitise((json.loads(text) if text else None) or [])   # a clean repository is reported as null
+    raw = (json.loads(text) if text else None) or []   # a clean repository is reported as null
+    for r in raw[:LINE_LOOKUPS]:   # betterleaks does not report the line; the clone in the current directory has it
+        r["Line"] = line_of(os.getcwd(), r.get("Commit") or "", r.get("File") or "", int(r.get("StartLine") or 0))
+    rows = sanitise(raw)
     fd, tmp = tempfile.mkstemp(dir=os.path.dirname(os.path.abspath(target)), prefix=".secrets-", suffix=".json")
     try:
         with os.fdopen(fd, "w", encoding="utf-8") as fh:

{gitmole-0.6.9 → gitmole-0.6.11}/gitmole/load.py

@@ -65,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:
@@ -236,7 +236,10 @@ def load_report(out_dir: str, nested: bool = True) -> dict:
     surviving = OrderedDict()
     for name, lines in (parse_theseus(authors) if authors else {}).items():
         key = canonical.get(name, name)
+        if identity.is_bot(key):   # a deploy job that committed a built site owns nothing anyone needs to know
+            continue
         surviving[key] = surviving.get(key, 0) + lines
+    ownership = [r for r in parse_maat_csv(_read(out_dir, "maat-entity-ownership.csv")) if not identity.is_bot(r.get("author") or "")]
     return {
         "out_dir": out_dir,
         "meta": meta,
@@ -244,10 +247,11 @@ 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")),
-        "ownership": parse_maat_csv(_read(out_dir, "maat-entity-ownership.csv")),
+        "ownership": ownership,
         "fixes": parse_maat_csv(_read(out_dir, "maat-fixes.csv")),
         "sizer": parse_git_sizer(_read(out_dir, "repo-health.txt")),
         "cohorts": parse_theseus(cohorts) if cohorts else {},

{gitmole-0.6.9 → gitmole-0.6.11}/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.9 → gitmole-0.6.11}/gitmole/render.py

@@ -129,6 +129,15 @@ def _hide_release(pairs: list, full) -> tuple:
     return kept, (f"{hidden} release pair{'s' if hidden != 1 else ''} hidden{HIDDEN_SUFFIX}" if hidden else None)
 
 
+def _hide_header_pairs(pairs: list, full) -> tuple:
+    """A C-family source file and its own header change together by construction."""
+    if full is True:
+        return pairs, None
+    kept = [p for p in pairs if not filetypes.is_header_pair(p["entity"], p["coupled"])]
+    hidden = len(pairs) - len(kept)
+    return kept, (f"{hidden} header 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]
@@ -395,7 +404,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)
@@ -429,7 +439,9 @@ def coupling_section(report: dict, full: bool = True, width=None) -> dict:
     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)
+    pairs, header_note = _hide_header_pairs(pairs, full)
+    pairs, vendor_note = _hide_vendor(pairs, lambda p: (p["entity"], p["coupled"]), full, noun="vendored pair", plural="vendored pairs")
+    gone_note = _join_hidden(gone_note, release_note, header_note, vendor_note)
     groups, cluster_note = [], None
     if full is not True:
         # a directory whose files all change together is one row; --full lists every pair

{gitmole-0.6.9 → gitmole-0.6.11}/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.9 → gitmole-0.6.11}/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.9 → gitmole-0.6.11}/gitmole.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitmole
-Version: 0.6.9
+Version: 0.6.11
 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.9 → gitmole-0.6.11}/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):
@@ -104,6 +107,13 @@ 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_a_source_file_and_its_own_header_are_a_header_pair(self):
+        for a, b in (("src/vector.c", "src/vector.h"), ("src/vector.h", "src/vector.c"), ("lib/x.cpp", "lib/x.hpp"), ("lib/x.cc", "lib/x.hh"),
+                     ("ui/view.m", "ui/view.h"), ("ui/view.mm", "ui/view.h")):
+            self.assertTrue(filetypes.is_header_pair(a, b), (a, b))
+        for a, b in (("src/vector.c", "src/list.h"), ("src/vector.c", "include/vector.h"), ("src/a.py", "src/a.pyi"), ("src/vector.c", "src/vector.c")):
+            self.assertFalse(filetypes.is_header_pair(a, b), (a, b))
+
     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"):
@@ -133,7 +143,8 @@ class TestPaths(unittest.TestCase):
 
     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", "requests/packages/urllib3/a.py", "pip/_vendor/six.py", "botocore/vendored/requests/a.py"):
+                     "external/lib/a.cpp", "requests/packages/urllib3/a.py", "pip/_vendor/six.py", "botocore/vendored/requests/a.py",
+                     "deps/lua/src/strbuf.c", "deps/jemalloc/Makefile"):
             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",
                      "packages/runtime-core/src/renderer.ts", "packages-private/x.ts"):   # a monorepo's own packages/ at the root

{gitmole-0.6.9 → gitmole-0.6.11}/tests/test_findings.py

@@ -261,6 +261,21 @@ 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_vendored_pairs_are_somebody_elses_coupling(self):
+        pairs = [{"entity": "deps/hiredis/adapters/ae.h", "coupled": "deps/hiredis/adapters/libev.h", "degree": 84, "average-revs": 10},
+                 {"entity": "src/ae.c", "coupled": "deps/hiredis/net.h", "degree": 85, "average-revs": 10},
+                 {"entity": "src/ae.c", "coupled": "src/networking.c", "degree": 85, "average-revs": 10}]
+        f = findings.tight_coupling(report(coupling=pairs))
+        self.assertIn("1 pair changes together", f[0]["detail"], "a pair with a vendored file on either side is not this repository's dependency")
+
+    def test_a_source_file_and_its_header_are_expected_to_change_together(self):
+        pairs = [{"entity": "src/vector.c", "coupled": "src/vector.h", "degree": 100, "average-revs": 20},
+                 {"entity": "deps/lua/src/strbuf.c", "coupled": "deps/lua/src/strbuf.h", "degree": 94, "average-revs": 8},
+                 {"entity": "src/ae.c", "coupled": "src/networking.c", "degree": 85, "average-revs": 10}]
+        f = findings.tight_coupling(report(coupling=pairs))
+        self.assertIn("1 pair changes together", f[0]["detail"])
+        self.assertIn("src/ae.c", f[0]["detail"])
+
     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},
@@ -297,6 +312,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.9 → gitmole-0.6.11}/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}]
@@ -85,7 +91,8 @@ class IsBot(unittest.TestCase):
                             ("github-actions[bot]", "41898282+github-actions[bot]@users.noreply.github.com"),
                             ("dependabot[bot]", "support@github.com"), ("Dependabot", "dependabot@example.com"),
                             ("Renovate Bot", "bot@renovateapp.com"), ("GitHub Actions", "actions@github.com"),
-                            ("Copilot", "198982749+Copilot@users.noreply.github.com"), ("Cursor Agent", "cursoragent@cursor.com")]:
+                            ("Copilot", "198982749+Copilot@users.noreply.github.com"), ("Cursor Agent", "cursoragent@cursor.com"),
+                            ("Deploy from CI", ""), ("Release Bot", "release@x.com"), ("CI", "ci@x.com"), ("Homebrew Automation", "a@x.com")]:
             self.assertTrue(identity.is_bot(name, email), (name, email))
 
     def test_people_are_not_bots(self):

{gitmole-0.6.9 → gitmole-0.6.11}/tests/test_leaks.py

@@ -74,6 +74,42 @@ class Placeholder(unittest.TestCase):
         for value in ["p@ssw0rd!", "AKIA" + "X" * 16, "env-9f8a7b6c5d4e3f2a", "${not closed", "hello$world"]:
             self.assertFalse(leaks.is_placeholder(value), value)
 
+    def test_a_key_header_with_no_key_material_after_it_is_a_marker_not_a_key(self):
+        # ohmyzsh's ssh-agent plugin greps files for the header; the scanner captures the header and the shell code after it
+        for value in ["-----BEGIN OPENSSH PRIVATE KEY-----", "^-----BEGIN\\ OPENSSH\\ PRIVATE\\ KEY-----", "-----BEGIN RSA PRIVATE KEY-----\\n",
+                      '-----BEGIN OPENSSH PRIVATE KEY-----".\n      if [[ -f "$file" && $(command head -n 1 "$file") =~ ^-----BEGIN ]]; then']:
+            self.assertTrue(leaks.is_placeholder(value), value)
+        real = "-----BEGIN OPENSSH PRIVATE KEY-----\n" + "b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAAAMwAAAAtzc2gtZW" * 3
+        self.assertFalse(leaks.is_placeholder(real), "a header followed by base64 is a key, END or no END")
+
+    def test_the_line_is_read_from_the_clone_at_the_commit(self):
+        with tempfile.TemporaryDirectory() as d:
+            subprocess.run(["git", "init", "-q", d], check=True)
+            with open(os.path.join(d, "gen.sh"), "w") as fh:
+                fh.write("#!/bin/sh\n# Example password: nz5ej2kypkvcw0rn5cvhs6qxtm\necho hi\n")
+            subprocess.run(["git", "-C", d, "add", "gen.sh"], check=True)
+            subprocess.run(["git", "-C", d, "-c", "user.name=T", "-c", "user.email=t@x.com", "commit", "-q", "-m", "gen"], check=True)
+            sha = subprocess.run(["git", "-C", d, "rev-parse", "HEAD"], capture_output=True, text=True, check=True).stdout.strip()
+            self.assertEqual(leaks.line_of(d, sha, "gen.sh", 2), "# Example password: nz5ej2kypkvcw0rn5cvhs6qxtm")
+            self.assertEqual(leaks.line_of(d, sha, "gen.sh", 9), "", "past the end is nothing, not an error")
+            self.assertEqual(leaks.line_of(d, sha, "missing.sh", 1), "")
+            self.assertEqual(leaks.line_of(d, "", "gen.sh", 1), "")
+
+    def test_a_line_that_calls_itself_an_example_is_a_placeholder(self):
+        # `# Example password: nz5ej2kypkvcw0rn5cvhs6qxtm` in a password generator's header comment
+        self.assertTrue(leaks.is_placeholder("nz5ej2kypkvcw0rn5cvhs6qxtm", line="# Example password: nz5ej2kypkvcw0rn5cvhs6qxtm"))
+        self.assertTrue(leaks.is_placeholder("nz5ej2kypkvcw0rn5cvhs6qxtm", line="token = 'nz5ej2kypkvcw0rn5cvhs6qxtm'  # e.g. from the dashboard"))
+        self.assertTrue(leaks.is_placeholder("nz5ej2kypkvcw0rn5cvhs6qxtm", line="SAMPLE_KEY = 'nz5ej2kypkvcw0rn5cvhs6qxtm'"))
+        self.assertFalse(leaks.is_placeholder("nz5ej2kypkvcw0rn5cvhs6qxtm", line="api_key = 'nz5ej2kypkvcw0rn5cvhs6qxtm'"))
+        self.assertFalse(leaks.is_placeholder("nz5ej2kypkvcw0rn5cvhs6qxtm"), "without the line there is nothing to go on")
+
+    def test_a_run_up_the_alphabet_or_the_digits_is_made_up(self):
+        # ohmyzsh's spotify plugin: CLIENT_SECRET="qr6stu789vwxyz" in a usage message
+        for value in ["qr6stu789vwxyz", "abcdefghijklmnop", "abcd1234efgh5678", "ABCDEF123456", "0123456789abcdef"]:
+            self.assertTrue(leaks.is_placeholder(value), value)
+        for value in ["nz5ej2kypkvcw0rn5cvhs6qxtm", "abcdefg", "zyxwvutsrq", "ghp_" + "a1" * 18]:
+            self.assertFalse(leaks.is_placeholder(value), value)
+
     def test_anything_else_is_taken_seriously(self):
         # built at runtime: a literal in these shapes would trip secret scanners on this very file
         key_id, long_key = "AKIA" + "X" * 16, "6L" + "x" * 38
@@ -97,6 +133,12 @@ class Sanitise(unittest.TestCase):
         self.assertEqual(rows[0]["Fingerprint"], RAW[0]["Fingerprint"])
         self.assertEqual(rows[0]["Author"], "Ann")
 
+    def test_the_line_is_read_for_the_placeholder_flag_before_it_is_dropped(self):
+        row = dict(RAW[0], Line="# Example token: " + RAW[0]["Secret"])
+        [clean] = leaks.sanitise([row])
+        self.assertTrue(clean["Placeholder"])
+        self.assertNotIn("Line", clean)
+
 
 class Script(unittest.TestCase):
     """Runs the script against a stand-in betterleaks on PATH, so the wiring is tested without real keys."""

{gitmole-0.6.9 → gitmole-0.6.11}/tests/test_load.py

@@ -237,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",
@@ -256,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})
@@ -268,6 +270,24 @@ class LoadReport(unittest.TestCase):
         self.assertEqual(r["duplicates"]["rate"], 5.0)
         self.assertEqual(r["out_dir"], out)
 
+    def test_bot_authors_are_dropped_from_ownership_and_surviving_code(self):
+        # mdBook: a gh-pages deploy job committed the built site under the root, so "Deploy from CI" owned the root files
+        import os, tempfile
+        with tempfile.TemporaryDirectory() as out:
+            os.makedirs(os.path.join(out, "theseus"))
+            files = {
+                "meta.json": json.dumps({"name": "demo", "commits": 3, "identities": [{"name": "Ann", "email": "a@x", "commits": 2}],
+                                         "bots": [{"name": "Deploy from CI", "commits": 40}]}),
+                "maat-entity-ownership.csv": "entity,author,added,deleted\nindex.html,Deploy from CI,6000,0\nsrc/a.rs,Ann,300,0\nsrc/b.rs,dependabot[bot],20,0\n",
+                "theseus/authors.json": json.dumps({"labels": ["Ann", "Deploy from CI"], "ts": ["t"], "y": [[300], [6000]]}),
+            }
+            for name, text in files.items():
+                with open(os.path.join(out, name), "w") as fh:
+                    fh.write(text)
+            r = load.load_report(out)
+        self.assertEqual([o["author"] for o in r["ownership"]], ["Ann"])
+        self.assertEqual(r["theseus_authors"], {"Ann": 300})
+
     def test_size_is_filtered_by_the_file_types_recorded_in_meta(self):
         import os, tempfile
         size = json.dumps([{"Name": "JSON", "Count": 1, "Code": 9000, "Comment": 0, "Blank": 0, "Complexity": 0,

{gitmole-0.6.9 → gitmole-0.6.11}/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.9 → gitmole-0.6.11}/tests/test_render.py

@@ -345,6 +345,41 @@ 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_vendored_pairs_and_says_so(self):
+        r = sample_report()
+        for f in ("deps/lua/a.c", "deps/lua/b.c", "src/x.c", "src/y.c"):
+            r["size"]["files"][f] = {"code": 30, "complexity": 1}
+        r["coupling"] = [{"entity": "deps/lua/a.c", "coupled": "deps/lua/b.c", "degree": 90, "average-revs": 20},
+                         {"entity": "deps/lua/a.c", "coupled": "src/x.c", "degree": 70, "average-revs": 9},
+                         {"entity": "src/x.c", "coupled": "src/y.c", "degree": 60, "average-revs": 9}]
+        coupling = _section_text(rendered(r, [], width=200), "Change coupling")
+        self.assertIn("src/y.c", coupling)
+        self.assertNotIn("deps/", coupling)
+        self.assertIn("2 vendored pairs hidden; --full shows them", coupling)
+
+    def test_default_coupling_hides_header_pairs_and_says_so(self):
+        r = sample_report()
+        for f in ("src/vector.c", "src/vector.h", "src/list.c"):
+            r["size"]["files"][f] = {"code": 30, "complexity": 1}
+        r["coupling"] = [{"entity": "src/vector.c", "coupled": "src/vector.h", "degree": 100, "average-revs": 20},
+                         {"entity": "src/list.c", "coupled": "src/vector.h", "degree": 60, "average-revs": 9}]
+        coupling = _section_text(rendered(r, [], width=200), "Change coupling")
+        self.assertIn("src/list.c", coupling)
+        self.assertNotIn("100%", coupling)
+        self.assertIn("1 header pair hidden; --full shows them", coupling)
+        full = _section_text(rendered(r, [], width=200, full=True), "Change coupling")
+        self.assertIn("100%", full)
+
     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.9 → gitmole-0.6.11}/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.9 → gitmole-0.6.11}/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]