gitmole 0.6.3__tar.gz → 0.6.5__tar.gz

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

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

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

gitmole-0.6.5/gitmole/coupling.py

@@ -0,0 +1,57 @@
+"""Change-coupling pairs grouped into clusters: a directory whose files all change together (generated
+tables, one-per-version data files) is one fact, not a page of pairs."""
+from __future__ import annotations
+
+import os
+from collections import defaultdict
+
+ROOT = "(root files)"
+
+
+def _dir(path: str) -> str:
+    head = os.path.dirname(path)
+    return head + "/" if head else ROOT
+
+
+def _components(pairs: list) -> list:
+    """Connected groups of files among `pairs` (union-find), each as the list of its pairs."""
+    parent = {}
+
+    def find(x):
+        parent.setdefault(x, x)
+        while parent[x] != x:
+            parent[x] = parent[parent[x]]
+            x = parent[x]
+        return x
+
+    for p in pairs:
+        parent[find(p["entity"])] = find(p["coupled"])
+    groups = defaultdict(list)
+    for p in pairs:
+        groups[find(p["entity"])].append(p)
+    return list(groups.values())
+
+
+def clusters(pairs: list, min_files: int = 4, min_density: float = 0.8) -> tuple:
+    """Split `pairs` into (groups, rest). Pairs whose two files share a directory are gathered per
+    directory and then into connected groups; a group of at least `min_files` distinct files with at
+    least `min_density` of the possible pairs present becomes one cluster with the file and pair
+    counts, the weakest degree and the mean of the pairs' average revisions. Every other pair comes
+    back unchanged, in its original order. Two unrelated pairs in one directory, or a chain of pairs,
+    are not a cluster: "each other" has to be true. Clusters are largest first."""
+    by_dir = defaultdict(list)
+    for p in pairs:
+        if _dir(p["entity"]) == _dir(p["coupled"]):
+            by_dir[_dir(p["entity"])].append(p)
+    groups, taken = [], set()
+    for directory, ps in by_dir.items():
+        for component in _components(ps):
+            files = {p["entity"] for p in component} | {p["coupled"] for p in component}
+            possible = len(files) * (len(files) - 1) / 2
+            if len(files) < min_files or len(component) < min_density * possible:
+                continue
+            groups.append({"dir": directory, "files": len(files), "pairs": len(component), "degree": min(p["degree"] for p in component),
+                           "average-revs": round(sum(p["average-revs"] for p in component) / len(component))})
+            taken.update(id(p) for p in component)
+    groups.sort(key=lambda g: (-g["files"], -g["degree"], g["dir"]))
+    return groups, [p for p in pairs if id(p) not in taken]

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

@@ -65,6 +65,24 @@ def is_doc_path(path: str) -> bool:
     return bool(_DOC_PATH.search(path))
 
 
+_SAMPLE_PATH = re.compile(r"(^|/)(examples?|samples?|fixtures?|testdata|demos?|rules)(/|$)", re.I)
+
+
+def is_sample_path(path: str) -> bool:
+    """Example, sample, fixture, demo and rule directories: a value there is a specimen (a language
+    sample, a scanner's own rule definitions), not a credential in use."""
+    return bool(_SAMPLE_PATH.search(path))
+
+
+_VENDOR_PATH = re.compile(r"(^|/)(_?vendor|node_modules|third_?party|external)(/|$)", 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."""
+    return bool(_VENDOR_PATH.search(path))
+
+
 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.3 → gitmole-0.6.5}/gitmole/findings.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 
 import re
 
-from . import filetypes, hotspots, knowledge, leaks, loss, textfmt, trend
+from . import coupling, filetypes, hotspots, knowledge, leaks, loss, textfmt, trend
 
 SEVERITIES = ["critical", "warning", "info"]
 
@@ -40,13 +40,14 @@ def _secret_statement(groups: list) -> str:
 
 def secrets_found(report: dict) -> list:
     """Secrets grouped by value. A value anywhere in source is critical; one that only ever appears in
-    test files (fixtures, saved pages) or documentation (templates, samples) is a warning, so a
-    critical gate does not trip on test data or a planning document. Version strings, template markers
-    and key blocks without key material were flagged as placeholders and are not a finding."""
+    test files (fixtures, saved pages), example or rule directories (language samples, a scanner's own
+    rules) or documentation (templates) is a warning, so a critical gate does not trip on test data or a
+    planning document. Version strings, template markers and key blocks without key material were
+    flagged as placeholders and are not a finding."""
     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)) 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)) 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."
@@ -55,7 +56,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 or documentation files", _secret_statement(aside),
+        out.append(_f("warning", f"{len(aside)} secret(s) only in test, example or documentation files", _secret_statement(aside),
                       f"Confirm they are fixtures or templates, not live keys. {ignore}"))
     return out
 
@@ -93,9 +94,18 @@ def placeholder_identity(report: dict, min_share: float = 0.01) -> list:
 
 
 def _source_ownership(report: dict) -> list:
-    """Ownership rows for source files. Test files are left out of every rule that names a next
-    step: owning the tests is not the knowledge risk. The default tables leave them out too."""
-    return [r for r in report.get("ownership") or [] if not filetypes.is_test_path(r["entity"])]
+    """Ownership rows for source files. Test files and vendored trees are left out of every rule that
+    names a next step: owning the tests is not the knowledge risk, and whoever imported vendor/ did
+    not write it. The default tables leave test files out too."""
+    return [r for r in report.get("ownership") or [] if not (filetypes.is_test_path(r["entity"]) or filetypes.is_vendor_path(r["entity"]))]
+
+
+def _present_areas(report: dict, rows: list, build=knowledge.areas) -> list:
+    """Areas built from the ownership rows of directories that still exist, then only those areas that
+    exist themselves: a directory the history knows but HEAD does not (the layout before a move to
+    src/ or crates/) is nowhere to pair anyone on. `build` is knowledge.areas or a wrapper of it."""
+    tree = _tree(report)
+    return [a for a in build(knowledge.present_rows(rows, tree)) if knowledge.in_tree(a["area"], tree)]
 
 
 def bus_factor(report: dict, threshold: float = 0.7, min_lines: int = 200) -> list:
@@ -109,7 +119,7 @@ def bus_factor(report: dict, threshold: float = 0.7, min_lines: int = 200) -> li
     if lines / total <= threshold:
         return []
     theirs = []
-    for a in knowledge.areas(_source_ownership(report)):
+    for a in _present_areas(report, _source_ownership(report)):
         owned = dict(a["owners"]).get(name, 0)
         if a["lines"] >= min_lines and owned / a["lines"] >= 0.8:
             theirs.append((a["area"], round(100 * owned / a["lines"])))
@@ -183,11 +193,21 @@ def tight_coupling(report: dict, min_degree: int = 80, min_revs: int = 5) -> lis
     if not pairs:
         return []
     pairs.sort(key=lambda p: (-p["degree"], -p["average-revs"]))
+    groups, pairs = coupling.clusters(pairs)
+    when = f"together at least {min_degree}% of the time"
     top = "; ".join(f"{p['entity']} + {p['coupled']} ({p['degree']}%)" for p in pairs[:3])
+    if groups:
+        # a directory of files that change as one is a generator or a shared layout, said once
+        named = ", ".join(f"{g['files']} files in {g['dir']}" for g in groups[:2]) + (f" and {len(groups) - 2} more directories" if len(groups) > 2 else "")
+        rest = (f", and {_plural(len(pairs), 'more pair')} {'does' if len(pairs) == 1 else 'do'}: {top}." if pairs
+                else f", {_plural(sum(g['pairs'] for g in groups), 'pair')} in all.")
+        first = groups[0]
+        return [_f("info", "Files that always change together", f"{named} change {when}{rest}",
+                   f"Review {first['dir']} first: {first['files']} files change as one; a generator or a shared layout links them.")]
     count = f"{len(pairs)} pair changes" if len(pairs) == 1 else f"{len(pairs)} pairs change"
     first = pairs[0]
     return [_f("info", "Files that always change together",
-               f"{count} together at least {min_degree}% of the time, e.g. {top}.",
+               f"{count} {when}, e.g. {top}.",
                f"Review {first['entity']} and {first['coupled']} first: a shared layout or a hidden dependency links them.")]
 
 
@@ -251,7 +271,9 @@ def reverts(report: dict, min_share: float = 0.05, min_count: int = 5, warn_shar
 
 
 def knowledge_islands(report: dict, min_lines: int = 200, min_share: float = 0.9) -> list:
-    areas = knowledge.areas(_source_ownership(report))
+    """Areas of the tree written almost entirely by one person. Areas that no longer exist are left
+    out, of the islands and of the total they are measured against."""
+    areas = _present_areas(report, _source_ownership(report))
     islands = knowledge.islands(areas, min_lines=min_lines, min_share=min_share)
     if not islands:
         return []
@@ -317,9 +339,10 @@ def _loss_people(by_person: dict, total: int) -> str:
 
 
 def _loss_areas(report: dict, names: set, source_rows: list) -> list:
-    """Areas at 200+ lines where 80%+ of the surviving code is theirs, tagged live or not and
-    sorted live-first: that is where the gap bites soonest."""
-    theirs = [a for a in loss.areas(source_rows, names) if a["lines"] >= 200 and a["lost_share"] >= 0.8]
+    """Areas at 200+ lines where 80%+ of the surviving code is theirs, still in the tree, tagged live
+    or not and sorted live-first: that is where the gap bites soonest."""
+    theirs = [a for a in _present_areas(report, source_rows, build=lambda rows: loss.areas(rows, names))
+              if a["lines"] >= 200 and a["lost_share"] >= 0.8]
     for a in theirs:
         a["live"] = _is_live(a["area"], report.get("age") or [])
     theirs.sort(key=lambda a: (not a["live"], -a["lines"], a["area"]))   # a live area first: that is where the gap bites
@@ -363,8 +386,10 @@ 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 source files. A warning when one sits in a hotspot."""
-    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"])]
+    """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."""
+    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"]))]
     if not big:
         return []
     big.sort(key=lambda f: (-f["ccn"], -f["nloc"], f["file"], f["function"], f["start"]))

{gitmole-0.6.3 → gitmole-0.6.5}/gitmole/knowledge.py

@@ -7,6 +7,16 @@ from collections import Counter, defaultdict
 ROOT = "(root files)"
 
 
+def in_tree(area: str, tree: dict) -> bool:
+    """Whether any tracked file sits under `area` (a directory prefix ending in "/", or ROOT). With
+    no tree listing every area counts: there is nothing to judge by."""
+    if not tree:
+        return True
+    if area == ROOT:
+        return any("/" not in path for path in tree)
+    return any(path.startswith(area) for path in tree)
+
+
 def _area(entity: str, depth: int) -> str:
     dirs = entity.split("/")[:-1]
     if not dirs:
@@ -14,6 +24,20 @@ def _area(entity: str, depth: int) -> str:
     return "/".join(dirs[:depth]) + "/"
 
 
+def top_area(entity: str) -> str:
+    """The top-level directory of a path, or ROOT."""
+    return _area(entity, 1)
+
+
+def present_rows(rows: list, tree: dict) -> list:
+    """Ownership rows for files whose top-level directory still exists in the tree. Filtering the rows
+    before areas are built keeps a vanished layout (the src/ before a move to crates/) from inflating
+    the total and hiding that one directory now holds almost everything."""
+    if not tree:
+        return rows
+    return [r for r in rows if in_tree(top_area(r["entity"]), tree)]
+
+
 def _aggregate(rows: list, depth: int) -> list:
     lines, per_author = Counter(), defaultdict(Counter)
     for r in rows:

{gitmole-0.6.3 → gitmole-0.6.5}/gitmole/leaks.py

@@ -33,10 +33,13 @@ RAW_FIELDS = ("Secret", "Match", "Line", "Message", "Attributes")
 
 # Shapes that cannot be a live secret: a version string (5.0.0-1667386184.dfbbb54), a token shortened
 # with an ellipsis, a whole-value template marker (your-project-id, <your-token>, XXXX-XXXX, changeme),
+# a whole value that is one of the words every example uses (`password: 'hello'` in a doc comment),
 # and a key block whose body holds no key material. Every rule is about the whole value; nothing is
 # skipped by prefix, since a public and a private key of the same service often share one.
 _VERSION = re.compile(r"^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$")
 _MARKER = re.compile(r"^(<[^<>]+>|x+|(?:x{2,}[-_ ]?)+|your[-_][\w-]+|change[-_]?me|replace[-_]?me)$", re.I)
+_EXAMPLE_WORDS = {"password", "passwd", "pass", "secret", "hello", "hey", "test", "example", "sample", "dummy", "foo", "bar",
+                  "baz", "admin", "root", "user", "123456", "12345678", "123456789", "abc123", "qwerty", "letmein", "welcome"}
 _KEY_BLOCK = re.compile(r"-----BEGIN [A-Z ]*KEY-----(.*?)-----END [A-Z ]*KEY-----", re.S)
 _KEY_MATERIAL = 64   # a real body is hundreds of base64 characters; a template has dots or a few x's
 
@@ -54,7 +57,7 @@ def digest(value: str, key: bytes) -> str:
 
 def is_placeholder(value: str) -> bool:
     value = (value or "").strip()
-    if _VERSION.match(value) or value.endswith("...") or value.endswith("…") or _MARKER.match(value):
+    if _VERSION.match(value) or value.endswith("...") or value.endswith("…") or _MARKER.match(value) or value.lower() in _EXAMPLE_WORDS:
         return True
     m = _KEY_BLOCK.search(value)
     if m:

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

@@ -13,7 +13,7 @@ from rich.panel import Panel
 from rich.table import Table
 from rich.text import Text
 
-from . import filetypes, hotspots, identity, knowledge, leaks, loss, textfmt, trend, watch
+from . import coupling, filetypes, hotspots, identity, knowledge, leaks, loss, textfmt, trend, watch
 
 SEVERITY_STYLE = {"critical": "bold red", "warning": "yellow", "info": "cyan"}
 
@@ -78,8 +78,11 @@ def _more(total: int, limit) -> str:
     return f"and {total - limit} more" if limit is not None and total > limit else None
 
 
-def _hide_tests(rows: list, path_of, full, noun="test file", plural=None) -> tuple:
-    """Drop rows whose path (or any of whose paths) is a test path, unless `full` is True.
+HIDDEN_SUFFIX = "; --full shows them"
+
+
+def _hide_rows(rows: list, path_of, full, pred, noun: str, plural=None) -> tuple:
+    """Drop rows whose path (or any of whose paths) satisfies `pred`, unless `full` is True.
     `path_of(row)` returns a single path or a tuple of paths to check. `noun` names one hidden row
     and `plural` names several, `noun + "s"` by default (a multi-word noun gives its own plural:
     "function in a test file" -> "functions in test files"). Returns (rows, note), `note` being
@@ -90,14 +93,41 @@ def _hide_tests(rows: list, path_of, full, noun="test file", plural=None) -> tup
     for row in rows:
         paths = path_of(row)
         paths = (paths,) if isinstance(paths, str) else paths
-        if any(filetypes.is_test_path(p) for p in paths):
+        if any(pred(p) for p in paths):
             hidden += 1
         else:
             kept.append(row)
-    note = f"{hidden} {noun if hidden == 1 else plural or noun + 's'} hidden; --full shows them" if hidden else None
+    note = f"{hidden} {noun if hidden == 1 else plural or noun + 's'} hidden{HIDDEN_SUFFIX}" if hidden else None
     return kept, note
 
 
+def _hide_tests(rows: list, path_of, full, noun="test file", plural=None) -> tuple:
+    """Test files: they change with every fix, so they are not a signal on their own."""
+    return _hide_rows(rows, path_of, full, filetypes.is_test_path, noun, plural)
+
+
+def _hide_vendor(rows: list, path_of, full, noun="file in vendored code", plural="files in vendored code") -> tuple:
+    """Vendored trees: somebody else's code, not this repository's risk."""
+    return _hide_rows(rows, path_of, full, filetypes.is_vendor_path, noun, plural)
+
+
+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]
+    return "; ".join(parts) + HIDDEN_SUFFIX if parts else None
+
+
+def _hide_deleted(rows: list, report: dict, full) -> tuple:
+    """Drop hotspot rows for files no longer in the tree, unless `full` is True or there is no tree
+    listing to judge by: a deleted file's churn is history. Returns (rows, note) like _hide_tests."""
+    tree = (report.get("size") or {}).get("files") or {}
+    if full is True or not tree:
+        return rows, None
+    kept = [h for h in rows if h["code"] is not None]
+    hidden = len(rows) - len(kept)
+    return kept, (f"{hidden} deleted file{'s' if hidden != 1 else ''} hidden{HIDDEN_SUFFIX}" if hidden else None)
+
+
 def _hide_gone(pairs: list, report: dict, full) -> tuple:
     """Drop coupled pairs where either file is no longer in the tree, unless `full` is True: they
     describe a layout that no longer exists. Returns (pairs, note) like _hide_tests."""
@@ -345,6 +375,8 @@ def hotspots_section(report: dict, full: bool = True, width=None) -> dict:
     fixes = {f["entity"]: f["n-fixes"] for f in report.get("fixes") or []}
     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)
     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 {}
@@ -376,9 +408,18 @@ 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)
-    hidden_note = "; ".join(n for n in (hidden_note, gone_note) if n) or None
+    groups, cluster_note = [], None
+    if full is not True:
+        # a directory whose files all change together is one row; --full lists every pair
+        groups, pairs = coupling.clusters(pairs)
+        if groups:
+            n_pairs, n_dirs = sum(g["pairs"] for g in groups), len(groups)
+            cluster_note = (f"{n_pairs} pairs in {n_dirs} director{'y' if n_dirs == 1 else 'ies'} shown as "
+                            f"{'one row' if n_dirs == 1 else 'one row each'}{HIDDEN_SUFFIX}")
+    hidden_note = _join_hidden(hidden_note, gone_note, cluster_note)
     limit = _limit("Change coupling", full)
-    rows = [(p["entity"], p["coupled"], f"{p['degree']}%", p["average-revs"]) for p in pairs[:limit]]
+    rows = [(f"{g['dir']} ({g['files']} files)", "each other", f"≥{g['degree']}%", g["average-revs"]) for g in groups]
+    rows += [(p["entity"], p["coupled"], f"{p['degree']}%", p["average-revs"]) for p in pairs[:max(limit - len(groups), 0) if limit else None]]
     columns = [("file", PATH), ("changes with", PATH), ("degree", RIGHT), ("avg revs", RIGHT)]
     if full is not True:
         columns, rows = _keep(columns, rows, ["file", "changes with", "degree"])
@@ -432,6 +473,8 @@ def functions_section(report: dict, full: bool = True, width=None) -> dict:
     measured = report.get("functions") or []
     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)
     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)]
@@ -459,7 +502,16 @@ def knowledge_section(report: dict, full: bool = True, width=None) -> dict:
     """Ownership by area of the tree: who wrote most of each directory, gone owners marked."""
     months = report["meta"].get("gone_months", loss.DEFAULT_MONTHS)
     gone = {g["name"] for g in loss.gone(report, months)}
-    areas = loss.areas(report.get("ownership") or [], gone)   # every area the map showed before, tests included
+    rows_all = report.get("ownership") or []   # every area the map showed before, tests included
+    areas = loss.areas(rows_all, gone)
+    hidden_note = None
+    tree = (report.get("size") or {}).get("files") or {}
+    if full is not True and tree:
+        # a directory the history knows but HEAD does not is a layout that no longer exists; the rows are
+        # filtered before the areas are built so a vanished layout cannot hide that one directory now dominates
+        areas = [a for a in loss.areas(knowledge.present_rows(rows_all, tree), gone) if knowledge.in_tree(a["area"], tree)]
+        hidden = len({knowledge.top_area(r["entity"]) for r in rows_all if not knowledge.in_tree(knowledge.top_area(r["entity"]), tree)})
+        hidden_note = f"{hidden} historical area{'s' if hidden != 1 else ''} hidden{HIDDEN_SUFFIX}" if hidden else None
     limit = _limit("Knowledge map", full)
     rows = []
     for a in areas[:limit]:
@@ -469,7 +521,7 @@ def knowledge_section(report: dict, full: bool = True, width=None) -> dict:
     columns = [("area", PATH), ("lines added", RIGHT), ("authors", RIGHT), ("lost", RIGHT), ("main owner", {}), ("second", {})]
     if full is not True:
         columns, rows = _keep(columns, rows, ["area", "lines added", "main owner", "second"])
-    notes = [c for c in (_more(len(areas), limit),) if c]
+    notes = [c for c in (_more(len(areas), limit), hidden_note) if c]
     if gone:
         notes.append(f"gone = no commits in the {months} months before {report['meta'].get('last_date')}"
                      + ("; gone and lost are measured over the whole history" if report["meta"].get("since") else ""))

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitmole
-Version: 0.6.3
+Version: 0.6.5
 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.3 → gitmole-0.6.5}/gitmole.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ gitmole/banner.py
 gitmole/blame.py
 gitmole/clean.py
 gitmole/cli.py
+gitmole/coupling.py
 gitmole/filetypes.py
 gitmole/findings.py
 gitmole/functions.py
@@ -34,6 +35,7 @@ tests/test_banner.py
 tests/test_blame.py
 tests/test_clean.py
 tests/test_cli.py
+tests/test_coupling.py
 tests/test_filetypes.py
 tests/test_findings.py
 tests/test_functions.py

gitmole-0.6.5/tests/test_coupling.py

@@ -0,0 +1,68 @@
+import unittest
+
+from gitmole import coupling
+
+
+def pair(a, b, degree=100, revs=10):
+    return {"entity": a, "coupled": b, "degree": degree, "average-revs": revs}
+
+
+def clique(directory, names, degree=100, revs=10):
+    files = [f"{directory}/{n}" if directory else n for n in names]
+    return [pair(a, b, degree, revs) for i, a in enumerate(files) for b in files[i + 1:]]
+
+
+class Clusters(unittest.TestCase):
+    def test_a_directory_of_four_or_more_files_becomes_one_cluster(self):
+        pairs = clique("rich/_unicode_data", ["u10.py", "u11.py", "u12.py", "u13.py"]) + [pair("a.py", "b.py", 90)]
+        groups, rest = coupling.clusters(pairs)
+        self.assertEqual(groups, [{"dir": "rich/_unicode_data/", "files": 4, "pairs": 6, "degree": 100, "average-revs": 10}])
+        self.assertEqual(rest, [pair("a.py", "b.py", 90)])
+
+    def test_the_cluster_degree_is_the_weakest_pair(self):
+        pairs = clique("d", ["a", "b", "c", "e"], degree=100)
+        pairs[2]["degree"] = 83
+        pairs[4]["average-revs"] = 40
+        [g], _ = coupling.clusters(pairs)
+        self.assertEqual(g["degree"], 83)
+        self.assertEqual(g["average-revs"], 15)   # the mean of the pairs' averages, rounded
+
+    def test_three_files_stay_as_pairs(self):
+        pairs = clique("d", ["a", "b", "c"])
+        groups, rest = coupling.clusters(pairs)
+        self.assertEqual(groups, [])
+        self.assertEqual(rest, pairs)
+
+    def test_pairs_across_directories_never_cluster(self):
+        pairs = [pair("x/a", "y/b"), pair("x/c", "y/d"), pair("x/e", "y/f"), pair("x/g", "y/h")]
+        groups, rest = coupling.clusters(pairs)
+        self.assertEqual(groups, [])
+        self.assertEqual(len(rest), 4)
+
+    def test_root_files_cluster_under_their_own_label_and_largest_cluster_first(self):
+        pairs = clique("", ["a", "b", "c", "d"]) + clique("lib", ["p", "q", "r", "s", "t"], degree=90)
+        groups, rest = coupling.clusters(pairs)
+        self.assertEqual([g["dir"] for g in groups], ["lib/", "(root files)"])
+        self.assertEqual(rest, [])
+
+    def test_a_chain_is_not_a_cluster(self):
+        pairs = [pair("d/a", "d/b"), pair("d/b", "d/c"), pair("d/c", "d/e")]   # 4 files, 3 of 6 possible pairs: connected, not a clique
+        groups, rest = coupling.clusters(pairs)
+        self.assertEqual(groups, [])
+        self.assertEqual(rest, pairs)
+
+    def test_a_near_complete_clique_is_a_cluster(self):
+        pairs = clique("d", ["a", "b", "c", "e", "f"])   # 5 files, 10 pairs
+        eight = pairs[:8]
+        [g], rest = coupling.clusters(eight)
+        self.assertEqual((g["files"], g["pairs"]), (5, 8))
+        self.assertEqual(rest, [])
+        groups, rest = coupling.clusters(pairs[:7])   # 7 of 10 is under the 80% floor
+        self.assertEqual(groups, [])
+        self.assertEqual(len(rest), 7)
+
+    def test_two_unrelated_pairs_in_one_directory_are_not_a_cluster(self):
+        pairs = [pair("a", "b"), pair("c", "d")]
+        groups, rest = coupling.clusters(pairs)
+        self.assertEqual(groups, [])
+        self.assertEqual(rest, pairs)

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

@@ -97,6 +97,20 @@ class TestPaths(unittest.TestCase):
         for path in ("app/settings.py", "static/index.html", "docsite/app.js", "mdx/a.py", "config.yaml"):
             self.assertFalse(filetypes.is_doc_path(path), path)
 
+    def test_example_fixture_and_rule_directories(self):
+        for path in ("examples/language/bru.bru", "example/app.py", "samples/x.json", "sample/x.json", "fixtures/keys.pem",
+                     "src/fixture/a.txt", "pkg/testdata/creds.yaml", "demo/x.py", "demos/x.py", "config/generate/rules/slack.go"):
+            self.assertTrue(filetypes.is_sample_path(path), path)
+        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_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"):
+            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"):
+            self.assertFalse(filetypes.is_vendor_path(path), path)
+
 
 if __name__ == "__main__":
     unittest.main()

{gitmole-0.6.3 → gitmole-0.6.5}/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 or documentation files")
+        self.assertEqual(warn["title"], "2 secret(s) only in test, example 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"])
@@ -56,11 +56,21 @@ class SecretsFound(unittest.TestCase):
         r = report(secrets=[self.row("h3", "tests/t.py")])
         self.assertEqual([f["severity"] for f in findings.secrets_found(r)], ["warning"])
 
+    def test_a_value_only_in_an_example_fixture_or_rules_directory_is_a_warning(self):
+        r = report(secrets=[self.row("h1", "examples/language/bru.bru", "57d82e9", rule="generic-password"),
+                            self.row("h2", "config/generate/rules/slack.go", "04bdee4", rule="slack-bot-token"),
+                            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")
+        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_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 or documentation files")
+        self.assertEqual(f[0]["title"], "1 secret(s) only in test, example 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")
@@ -135,6 +145,21 @@ class BusFactor(unittest.TestCase):
         self.assertEqual(findings.bus_factor(r)[0]["advice"], "Pair someone with Ann on core/ first; it is 95% theirs since 2025-01-01.",
                          "ownership is windowed while the headline share is not")
 
+    def test_areas_no_longer_in_the_tree_are_not_named_in_the_advice(self):
+        own = [{"entity": "flask/a.py", "author": "Ann", "added": 5000, "deleted": 0},   # the pre-src/ layout
+               {"entity": "src/a.py", "author": "Ann", "added": 900, "deleted": 0},
+               {"entity": "src/b.py", "author": "Bob", "added": 50, "deleted": 0}]
+        tree = {"files": {"src/a.py": {"code": 1, "complexity": 0}, "src/b.py": {"code": 1, "complexity": 0}}}
+        f = findings.bus_factor(report(theseus_authors={"Ann": 79, "Bob": 21}, ownership=own, size=tree))
+        self.assertEqual(f[0]["advice"], "Pair someone with Ann on src/ first; it is 95% theirs.")
+
+    def test_vendored_trees_are_not_named_in_the_advice(self):
+        own = [{"entity": "vendor/github.com/x/a.go", "author": "Ann", "added": 500000, "deleted": 0},
+               {"entity": "core/a.py", "author": "Ann", "added": 900, "deleted": 0},
+               {"entity": "core/b.py", "author": "Bob", "added": 50, "deleted": 0}]
+        f = findings.bus_factor(report(theseus_authors={"Ann": 79, "Bob": 21}, ownership=own))
+        self.assertEqual(f[0]["advice"], "Pair someone with Ann on core/ first; it is 95% theirs.")
+
     def test_nothing_when_spread(self):
         self.assertEqual(findings.bus_factor(report()), [])
 
@@ -234,6 +259,17 @@ class TightCoupling(unittest.TestCase):
         f = findings.tight_coupling(report(coupling=pairs))
         self.assertIn("1 pair changes together", f[0]["detail"])
 
+    def test_a_directory_of_files_that_change_as_one_is_one_cluster(self):
+        files = [f"rich/_unicode_data/unicode{n}.py" for n in ("10", "11", "12", "13")]
+        pairs = [{"entity": a, "coupled": b, "degree": 100, "average-revs": 5} for i, a in enumerate(files) for b in files[i + 1:]]
+        pairs.append({"entity": "rich/a.py", "coupled": "rich/b.py", "degree": 90, "average-revs": 8})
+        f = findings.tight_coupling(report(coupling=pairs))
+        self.assertIn("4 files in rich/_unicode_data/ change together at least 80% of the time, and 1 more pair does: rich/a.py + rich/b.py (90%).", f[0]["detail"])
+        self.assertNotIn("unicode10", f[0]["detail"])
+        self.assertTrue(f[0]["detail"].endswith("Review rich/_unicode_data/ first: 4 files change as one; a generator or a shared layout links them."), f[0]["detail"])
+        f = findings.tight_coupling(report(coupling=pairs[:-1]))
+        self.assertIn("4 files in rich/_unicode_data/ change together at least 80% of the time, 6 pairs in all.", f[0]["detail"])
+
     def test_nothing_when_no_tight_pairs(self):
         self.assertEqual(findings.tight_coupling(report()), [])
 
@@ -338,6 +374,14 @@ class BrainMethods(unittest.TestCase):
         self.assertNotIn("test_all", f[0]["detail"])
         self.assertEqual(findings.brain_methods(report(functions=fns[:1])), [])
 
+    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}]
+        f = findings.brain_methods(report(functions=fns))
+        self.assertEqual(f[0]["advice"], "Split countLoopGeneric in processor/workers.go first, before the next change lands there.")
+        self.assertNotIn("vendor/", f[0]["detail"])
+        self.assertEqual(findings.brain_methods(report(functions=fns[:1])), [])
+
     def test_a_partial_run_says_there_may_be_more(self):
         r = report(functions=self.FUNCS)
         self.assertNotIn("part way", findings.brain_methods(r)[0]["detail"])
@@ -402,6 +446,29 @@ class KnowledgeIslands(unittest.TestCase):
         self.assertEqual(f[0]["advice"], "Pair someone with Bob on core/ first; it is the largest at 300 lines.")
         self.assertNotIn("tests/", f[0]["detail"])
 
+    def test_areas_no_longer_in_the_tree_are_not_islands(self):
+        own = [{"entity": "src/a.rs", "author": "Ann", "added": 30000, "deleted": 0},   # moved to crates/ years ago
+               {"entity": "grep-printer/a.rs", "author": "Ann", "added": 20000, "deleted": 0},
+               {"entity": "crates/core/a.rs", "author": "Bob", "added": 300, "deleted": 0}]
+        tree = {"files": {"crates/core/a.rs": {"code": 300, "complexity": 1}}}
+        f = findings.knowledge_islands(report(ownership=own, size=tree))
+        self.assertEqual(f[0]["advice"], "Pair someone with Bob on crates/core/ first; it is the largest at 300 lines.",
+                         "with the vanished directories gone, crates/ holds everything and the map descends into it")
+        self.assertNotIn("src/", f[0]["detail"])
+        self.assertIn("100% of all lines added", f[0]["detail"], "lines in vanished directories are not in the denominator")
+        f = findings.knowledge_islands(report(ownership=own))
+        self.assertIn("src/", f[0]["detail"], "without a tree listing every area counts")
+
+    def test_vendored_trees_are_not_islands(self):
+        own = [{"entity": "vendor/github.com/x/a.go", "author": "Ann", "added": 500000, "deleted": 0},
+               {"entity": "web/node_modules/y/b.js", "author": "Ann", "added": 90000, "deleted": 0},
+               {"entity": "core/a.py", "author": "Bob", "added": 300, "deleted": 0}]
+        f = findings.knowledge_islands(report(ownership=own))
+        self.assertEqual(f[0]["advice"], "Pair someone with Bob on core/ first; it is the largest at 300 lines.")
+        self.assertNotIn("vendor/", f[0]["detail"])
+        self.assertNotIn("web/", f[0]["detail"])
+        self.assertIn("100% of all lines added", f[0]["detail"], "vendored lines are not in the denominator either")
+
     def test_nothing_when_shared(self):
         self.assertEqual(findings.knowledge_islands(report(ownership=self.OWN[2:])), [])
         self.assertEqual(findings.knowledge_islands(report()), [])
@@ -465,6 +532,18 @@ class KnowledgeLoss(unittest.TestCase):
         self.assertIn("Areas mostly theirs: old/ (100%), docs/ (100%)", f[0]["detail"])
         self.assertEqual(f[0]["advice"], "Pair someone on old/ first; nobody who wrote it is around to ask.")
 
+    def test_areas_no_longer_in_the_tree_are_not_named(self):
+        r = self._report(theseus_authors={"Ann": 60, "Bob": 40},
+                         age=[{"entity": "flask/a.py", "age-months": 2}, {"entity": "src/x.py", "age-months": 2}],
+                         ownership=[{"entity": "flask/a.py", "author": "Bob", "added": 8000, "deleted": 0},   # the old layout, all Bob's
+                                    {"entity": "src/x.py", "author": "Bob", "added": 300, "deleted": 0},
+                                    {"entity": "app/b.py", "author": "Ann", "added": 900, "deleted": 0}],
+                         size={"files": {"src/x.py": {"code": 1, "complexity": 0}, "app/b.py": {"code": 1, "complexity": 0}}})
+        f = findings.knowledge_loss(r)
+        self.assertIn("Areas mostly theirs: src/ (100%).", f[0]["detail"])
+        self.assertNotIn("flask/", f[0]["detail"])
+        self.assertEqual(f[0]["advice"], "Pair someone on src/ first; nobody who wrote it is around to ask.")
+
     def test_a_live_area_is_preferred_over_a_bigger_idle_one(self):
         r = self._report(theseus_authors={"Ann": 60, "Bob": 40},
                          age=[{"entity": "old/a.py", "age-months": 30}, {"entity": "live/b.py", "age-months": 3}],

{gitmole-0.6.3 → gitmole-0.6.5}/tests/test_knowledge.py

@@ -48,6 +48,36 @@ class OddNames(unittest.TestCase):
         self.assertEqual(areas[0]["lines"], 1000)
 
 
+class InTree(unittest.TestCase):
+    TREE = {"crates/core/a.rs": {}, "crates/ignore/src/b.rs": {}, "build.rs": {}}
+
+    def test_an_area_is_in_the_tree_when_any_tracked_file_sits_under_it(self):
+        self.assertTrue(knowledge.in_tree("crates/", self.TREE))
+        self.assertTrue(knowledge.in_tree("crates/ignore/", self.TREE))
+        self.assertFalse(knowledge.in_tree("src/", self.TREE))
+        self.assertFalse(knowledge.in_tree("crate/", self.TREE), "a prefix of a directory name is not that directory")
+
+    def test_root_files_are_in_the_tree_when_any_file_has_no_directory(self):
+        self.assertTrue(knowledge.in_tree(knowledge.ROOT, self.TREE))
+        self.assertFalse(knowledge.in_tree(knowledge.ROOT, {"crates/core/a.rs": {}}))
+
+    def test_no_tree_listing_means_every_area_counts(self):
+        self.assertTrue(knowledge.in_tree("src/", {}))
+
+    def test_present_rows_drop_vanished_top_level_directories_so_the_survivor_can_dominate(self):
+        rows = [{"entity": "src/a.rs", "author": "Ann", "added": 30000, "deleted": 0},          # the layout before crates/
+                {"entity": "crates/core/a.rs", "author": "Ann", "added": 9000, "deleted": 0},
+                {"entity": "crates/ignore/b.rs", "author": "Bob", "added": 900, "deleted": 0},
+                {"entity": "ci/x.sh", "author": "Ann", "added": 500, "deleted": 0}]
+        tree = {"crates/core/a.rs": {}, "crates/ignore/b.rs": {}, "ci/x.sh": {}}
+        kept = knowledge.present_rows(rows, tree)
+        self.assertEqual([r["entity"] for r in kept], ["crates/core/a.rs", "crates/ignore/b.rs", "ci/x.sh"])
+        self.assertEqual([a["area"] for a in knowledge.areas(kept)], ["crates/core/", "crates/ignore/", "ci/"],
+                         "with src/ gone, crates/ holds over 80% and the map descends into it")
+        self.assertEqual([a["area"] for a in knowledge.areas(rows)], ["src/", "crates/", "ci/"], "the vanished src/ used to hide that")
+        self.assertEqual(knowledge.present_rows(rows, {}), rows)
+
+
 class Islands(unittest.TestCase):
     def test_areas_dominated_by_one_author(self):
         areas = knowledge.areas(OWNERSHIP)

{gitmole-0.6.3 → gitmole-0.6.5}/tests/test_leaks.py

@@ -59,6 +59,13 @@ class Placeholder(unittest.TestCase):
         for value in ["AKIA" + "X" * 16, "6L" + "x" * 38, "ghp_" + "a1" * 18, "yourkey" + "9" * 20]:
             self.assertFalse(leaks.is_placeholder(value), "a marker inside real-looking material is not enough: " + value)
 
+    def test_common_example_words_are_placeholders(self):
+        # `password: 'hello'` in a doc comment, `secret` in a sample config: the words every example uses
+        for value in ["hello", "Hello", "secret", "password", "PASSWORD", "example", "123456", "qwerty", "letmein", "foo", "dummy"]:
+            self.assertTrue(leaks.is_placeholder(value), value)
+        for value in ["hello123", "secret-9f8a7b6c5d4e", "s3cr3t!Passw0rd", "foobarbaz2024"]:
+            self.assertFalse(leaks.is_placeholder(value), "a word inside other material is not a placeholder: " + 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

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

@@ -212,6 +212,7 @@ class Report(unittest.TestCase):
     def test_knowledge_map_caption_says_gone_is_measured_over_the_whole_history(self):
         r = sample_report()
         r["meta"].update({"last_date": "2026-09-10", "bots": []})
+        r["size"]["files"]["tests/t.py"] = {"code": 1, "complexity": 0}   # every area in the tree, so nothing is hidden
         r["activity"]["authors"] = {"Ann": {"commits": 1, "added": 0, "deleted": 0, "first": "2025-01-01", "last": "2026-09-01"},
                                     "Bob": {"commits": 1, "added": 0, "deleted": 0, "first": "2025-01-01", "last": "2025-01-01"}}
         def caption(rep):
@@ -244,6 +245,7 @@ class Report(unittest.TestCase):
         self.assertEqual(caption(r, True), "trend sampled for the top 10 hotspots")
         self.assertIsNone(caption(r, False), "the tight report keeps its captions short")
         r["revisions"] = [{"entity": f"f{i}.py", "n-revs": 100 - i} for i in range(60)]
+        r["size"]["files"].update({f"f{i}.py": {"code": 10, "complexity": 0} for i in range(60)})   # in the tree, so not hidden as deleted
         self.assertEqual(caption(r, "markdown"), "and 10 more; trend sampled for the top 10 hotspots")
 
     def test_watch_list_caption_reports_the_backtest_or_why_not(self):
@@ -289,10 +291,10 @@ class Report(unittest.TestCase):
     def test_default_coupling_hides_test_pairs_and_says_so(self):
         r = sample_report()
         r["coupling"].append({"entity": "static/tax.html", "coupled": "tests/test_tax.py", "degree": 100, "average-revs": 11})
-        text = rendered(r, [])
+        text = rendered(r, [], width=200)
         coupling = text[text.index("Change coupling"):]
         self.assertNotIn("tests/test_tax.py", coupling)
-        self.assertIn("1 test pair hidden; --full shows them", coupling)
+        self.assertIn("1 test pair hidden; 1 historical pair hidden; --full shows them", coupling, "one suffix for every hidden count")
         full_text = rendered(r, [], full=True)
         self.assertIn("tests/test_tax.py", full_text[full_text.index("Change coupling"):])
 
@@ -306,6 +308,16 @@ class Report(unittest.TestCase):
         full_text = rendered(r, [], full=True)
         self.assertIn("tests/test_a.py", full_text[full_text.index("Complex functions"):])
 
+    def test_default_complex_functions_hide_vendored_code_and_say_so(self):
+        r = sample_report()
+        r["functions"].append({"file": "vendor/github.com/x/y.go", "function": "validate", "ccn": 179, "nloc": 424, "params": 3, "start": 1, "end": 424})
+        r["functions"].append({"file": "tests/test_a.py", "function": "test_thing", "ccn": 40, "nloc": 50, "params": 0, "start": 1, "end": 50})
+        fn = _section_text(rendered(r, [], width=200), "Complex functions")
+        self.assertNotIn("vendor/", fn)
+        self.assertIn("1 function in a test file hidden; 1 function in vendored code hidden; --full shows them", fn)
+        full = _section_text(rendered(r, [], width=200, full=True), "Complex functions")
+        self.assertIn("vendor/github.com/x/y.go", 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}]
@@ -325,6 +337,41 @@ class Report(unittest.TestCase):
         self.assertIn("static/tax.html", full)
         self.assertNotIn("hidden", full)
 
+    def test_default_hotspots_hide_deleted_files_and_say_so(self):
+        r = sample_report()   # the tree holds static/index.html and static/apps-metadata.json only
+        r["revisions"].append({"entity": "src/sizes/old.go", "n-revs": 40})
+        hot = _section_text(rendered(r, [], width=200), "◆ Hotspots")
+        self.assertNotIn("src/sizes/old.go", hot)
+        self.assertIn("1 deleted file hidden; --full shows them", hot)
+        full = _section_text(rendered(r, [], width=200, full=True), "◆ Hotspots")
+        self.assertIn("src/sizes/old.go", full)
+        self.assertNotIn("hidden", full)
+
+    def test_hotspots_without_a_tree_listing_hide_nothing(self):
+        r = sample_report()
+        r["size"]["files"] = {}
+        hot = _section_text(rendered(r, [], width=200), "◆ Hotspots")
+        self.assertIn("static/index.html", hot)
+        self.assertNotIn("deleted", hot)
+
+    def test_default_coupling_collapses_a_directory_that_changes_as_one(self):
+        r = sample_report()
+        files = [f"rich/_unicode_data/unicode{n}.py" for n in ("10", "11", "12", "13")]
+        for f in files:
+            r["size"]["files"][f] = {"code": 600, "complexity": 0}
+        r["coupling"] = [{"entity": a, "coupled": b, "degree": 100, "average-revs": 5} for i, a in enumerate(files) for b in files[i + 1:]]
+        r["coupling"].append({"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("rich/_unicode_data/ (4 files)", coupling)
+        self.assertIn("each other", coupling)
+        self.assertIn("≥100%", coupling)
+        self.assertNotIn("unicode10", coupling)
+        self.assertIn("static/index.html", coupling)
+        self.assertIn("6 pairs in 1 directory shown as one row; --full shows them", coupling)
+        full = _section_text(rendered(r, [], width=200, full=True), "Change coupling")
+        self.assertIn("unicode10", full)
+        self.assertNotIn("each other", full)
+
     def test_coupling_with_only_test_pairs_says_what_was_hidden(self):
         r = sample_report()
         r["coupling"] = [{"entity": "static/tax.html", "coupled": "tests/test_tax.py", "degree": 100, "average-revs": 11}]
@@ -590,6 +637,25 @@ class KnowledgeMap(unittest.TestCase):
         r["ownership"] = []
         self.assertIn("no ownership data", rendered(r, []))
 
+    def test_default_map_hides_areas_no_longer_in_the_tree_and_says_so(self):
+        r = sample_report()   # the tree holds static/ files only; tests/t.py in the ownership rows is history
+        r["ownership"].append({"entity": "flask/app.py", "author": "Ann", "added": 4000, "deleted": 0})
+        km = _section_text(rendered(r, [], width=200), "Knowledge map")
+        self.assertIn("static/", km)
+        self.assertNotIn("flask/", km)
+        self.assertNotIn("tests/", km)
+        self.assertIn("2 historical areas hidden; --full shows them", km)
+        full = _section_text(rendered(r, [], width=200, full=True), "Knowledge map")
+        self.assertIn("flask/", full)
+        self.assertNotIn("hidden", full)
+
+    def test_map_without_a_tree_listing_hides_nothing(self):
+        r = sample_report()
+        r["size"]["files"] = {}
+        km = _section_text(rendered(r, [], width=200), "Knowledge map")
+        self.assertIn("tests/", km)
+        self.assertNotIn("historical", km)
+
 
 class Timeline(unittest.TestCase):
     def test_last_twelve_months_per_author_with_dots_for_zero(self):
@@ -866,6 +932,7 @@ class Markdown(unittest.TestCase):
         r = sample_report()
         r["coupling"] = []
         r["revisions"] = [{"entity": "weird|name.py", "n-revs": 3}]
+        r["size"]["files"]["weird|name.py"] = {"code": 5, "complexity": 0}   # in the tree, so not hidden as deleted
         md = render.markdown(r, [])
         self.assertIn("weird\\|name.py", md)
         self.assertIn("_no pairs with 5+ shared revisions_", md)