gitmole 0.5.0__tar.gz → 0.6.0__tar.gz

{gitmole-0.5.0 → gitmole-0.6.0}/PKG-INFO

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

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

{gitmole-0.5.0 → gitmole-0.6.0}/gitmole/filetypes.py

@@ -56,6 +56,15 @@ def is_test_path(path: str) -> bool:
     return bool(_TEST_PATH.search(path))
 
 
+_DOC_PATH = re.compile(r"(^|/)docs?(/|$)|\.(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."""
+    return bool(_DOC_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.5.0 → gitmole-0.6.0}/gitmole/findings.py

@@ -40,19 +40,23 @@ 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) is a warning, so a critical gate does not trip on test data.
-    Version strings and shortened tokens were flagged as placeholders and are not a finding."""
+    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."""
     groups = leaks.group(report.get("secrets") or [])
-    source = [g for g in groups if not g["test"]]
-    tests = [g for g in groups if g["test"]]
+
+    def in_source(g):
+        return any(not (filetypes.is_test_path(f) or filetypes.is_doc_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."
     out = []
     if source:
         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 tests:
-        out.append(_f("warning", f"{len(tests)} secret(s) only in test files", _secret_statement(tests),
-                      f"Confirm they are fixtures, not live keys. {ignore}"))
+    if aside:
+        out.append(_f("warning", f"{len(aside)} secret(s) only in test or documentation files", _secret_statement(aside),
+                      f"Confirm they are fixtures or templates, not live keys. {ignore}"))
     return out
 
 
@@ -67,15 +71,24 @@ def _all_identities(report: dict):
 def placeholder_identity(report: dict, min_share: float = 0.01) -> list:
     """A placeholder name or mailbox with a real share of the commits. One stray commit in thousands
     is not worth the panel space."""
-    total = sum(i["commits"] for i in report["meta"].get("identities") or [])
+    identities = report["meta"].get("identities") or []
+    total = sum(i["commits"] for i in identities)
+
+    def is_placeholder(i):
+        return i["name"].strip().lower() in PLACEHOLDER_NAMES or bool(PLACEHOLDER_EMAIL.search(i["email"].lower()))
+    real = max((i for i in identities if not is_placeholder(i)), key=lambda i: i["commits"], default=None)
     out = []
     for i in _all_identities(report):
         if total and i["commits"] / total < min_share:
             continue
-        if i["name"].strip().lower() in PLACEHOLDER_NAMES or PLACEHOLDER_EMAIL.search(i["email"].lower()):
+        if is_placeholder(i):
+            # the busiest real identity is the likely owner; the line is offered, never applied
+            advice = (f"Set user.name and user.email. If those commits are {real['name']}'s, add to .mailmap: "
+                      f"{real['name']} <{real['email']}> {i['name']} <{i['email']}>; the people, bus factor and "
+                      f"knowledge findings then describe one person." if real
+                      else "Set user.name and user.email; consider a .mailmap for history.")
             out.append(_f("warning", "Unconfigured git identity",
-                          f"\"{i['name']} <{i['email']}>\" made {i['commits']} commits ({_pct(i['commits'], total)}).",
-                          "Set user.name and user.email; consider a .mailmap for history."))
+                          f"\"{i['name']} <{i['email']}>\" made {i['commits']} commits ({_pct(i['commits'], total)}).", advice))
     return out
 
 
@@ -130,12 +143,22 @@ def _sizer_advice(row: dict) -> str:
     return "Consider a shallow clone for CI; the history is the cost."
 
 
+def _tree(report: dict) -> dict:
+    """The files at HEAD, from scc, or {} when the run has no size listing to judge by."""
+    return (report.get("size") or {}).get("files") or {}
+
+
 def sizer_concerns(report: dict) -> list:
+    tree = _tree(report)
     out = []
     for row in report.get("sizer") or []:
         sev = "warning" if row["concern"] >= 2 else "info"
         where = f" at {row['ref']}" if row.get("ref") else ""
-        out.append(_f(sev, "Repo health", f"{row['name']} is {row['value']}{where}. git-sizer level of concern {row['concern']}.", _sizer_advice(row)))
+        advice = _sizer_advice(row)
+        if row.get("ref") and tree and row["name"].startswith("Blobs: ") and row["ref"] not in tree:
+            where += ", no longer in the tree"   # deleting it did not shrink the clone
+            advice = "It is already gone from the tree; a history rewrite is only worth it for clone size."
+        out.append(_f(sev, "Repo health", f"{row['name']} is {row['value']}{where}. git-sizer level of concern {row['concern']}.", advice))
     return out
 
 
@@ -151,9 +174,12 @@ def hotspot_dominance(report: dict, ratio: float = 2.0, minimum: int = 20) -> li
 
 
 def tight_coupling(report: dict, min_degree: int = 80, min_revs: int = 5) -> list:
-    """A file and its test are expected to change together, so pairs with a test file on either side are left out."""
+    """A file and its test are expected to change together, so pairs with a test file on either side are
+    left out; so are pairs where either file is no longer in the tree, which are history, not a dependency."""
+    tree = _tree(report)
     pairs = [p for p in report.get("coupling") or [] if p["degree"] >= min_degree and p["average-revs"] >= min_revs
-             and not (filetypes.is_test_path(p["entity"]) or filetypes.is_test_path(p["coupled"]))]
+             and not (filetypes.is_test_path(p["entity"]) or filetypes.is_test_path(p["coupled"]))
+             and not (tree and (p["entity"] not in tree or p["coupled"] not in tree))]
     if not pairs:
         return []
     pairs.sort(key=lambda p: (-p["degree"], -p["average-revs"]))
@@ -169,7 +195,7 @@ def stale_files(report: dict, months: int = 12, share: float = 0.3) -> list:
     """Files still in the tree that nobody has touched. The age table covers every path in the
     history, so paths that were deleted are left out here; they are not dead code, they are gone."""
     age = report.get("age") or []
-    tree = (report.get("size") or {}).get("files") or {}
+    tree = _tree(report)
     if tree:
         age = [a for a in age if a["entity"] in tree]
     if not age:

{gitmole-0.5.0 → gitmole-0.6.0}/gitmole/leaks.py

@@ -31,9 +31,14 @@ ARGV = ["betterleaks", "git", "--no-banner", "--report-format", "json", "--repor
 # the value, the text around it, and the commit message, which can quote it; Attributes repeats the message
 RAW_FIELDS = ("Secret", "Match", "Line", "Message", "Attributes")
 
-# A version string (5.0.0-1667386184.dfbbb54) and a token shortened with an ellipsis are the only shapes
-# skipped. Nothing is skipped by prefix: a public and a private key of the same service often share one.
+# 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),
+# 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)
+_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
 
 
 def new_key() -> bytes:
@@ -48,8 +53,14 @@ def digest(value: str, key: bytes) -> str:
 
 
 def is_placeholder(value: str) -> bool:
-    value = value or ""
-    return bool(_VERSION.match(value)) or value.endswith("...") or value.endswith("…")
+    value = (value or "").strip()
+    if _VERSION.match(value) or value.endswith("...") or value.endswith("…") or _MARKER.match(value):
+        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
+    return False
 
 
 def sanitise(rows: list) -> list:
@@ -66,15 +77,16 @@ def sanitise(rows: list) -> list:
 
 def group(rows: list) -> list:
     """One entry per distinct secret value (placeholders left out): its rule, the files and commits it
-    appears in, the number of distinct places (commit, file, line), and whether every place is a test
-    file. Values that appear in source come first, then the most widespread."""
+    appears in, the number of distinct places (commit, file, line), whether every place is a test
+    file, and whether every place is a documentation file. Values that appear in source come first,
+    then the most widespread."""
     groups, order = {}, []
     for i, r in enumerate(rows):
         if r.get("placeholder"):
             continue
         key = r.get("value") or ("row", i)
         if key not in groups:
-            groups[key] = {"value": r.get("value"), "rule": r["rule"], "files": [], "commits": [], "_places": set(), "test": True}
+            groups[key] = {"value": r.get("value"), "rule": r["rule"], "files": [], "commits": [], "_places": set(), "test": True, "docs": True}
             order.append(key)
         g = groups[key]
         if r["file"] not in g["files"]:
@@ -83,6 +95,7 @@ def group(rows: list) -> list:
             g["commits"].append(r["commit"])
         g["_places"].add((r["commit"], r["file"], r.get("line")))
         g["test"] = g["test"] and filetypes.is_test_path(r["file"])
+        g["docs"] = g["docs"] and filetypes.is_doc_path(r["file"])
     out = []
     for key in order:
         g = groups[key]

{gitmole-0.5.0 → gitmole-0.6.0}/gitmole/render.py

@@ -98,6 +98,17 @@ def _hide_tests(rows: list, path_of, full, noun="test file", plural=None) -> tup
     return kept, note
 
 
+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."""
+    tree = (report.get("size") or {}).get("files") or {}
+    if full is True or not tree:
+        return pairs, None
+    kept = [p for p in pairs if p["entity"] in tree and p["coupled"] in tree]
+    hidden = len(pairs) - len(kept)
+    return kept, (f"{hidden} historical pair{'s' if hidden != 1 else ''} hidden; --full shows them" if hidden else None)
+
+
 def _empty_note(base, hidden_note, source_base=None) -> str:
     """The note that replaces a table with no rows left. When test rows were hidden the note has to
     carry the count, since the caption goes with the table, and what is left is the source rows."""
@@ -364,6 +375,8 @@ def hotspots_section(report: dict, full: bool = True, width=None) -> dict:
 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
     limit = _limit("Change coupling", full)
     rows = [(p["entity"], p["coupled"], f"{p['degree']}%", p["average-revs"]) for p in pairs[:limit]]
     columns = [("file", PATH), ("changes with", PATH), ("degree", RIGHT), ("avg revs", RIGHT)]

{gitmole-0.5.0 → gitmole-0.6.0}/gitmole.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitmole
-Version: 0.5.0
+Version: 0.6.0
 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.5.0 → gitmole-0.6.0}/tests/test_filetypes.py

@@ -91,6 +91,12 @@ class TestPaths(unittest.TestCase):
         for path in ("src/contest.py", "gitmole/render.py", "attest/x.py", "latest.md"):
             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"):
+            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"):
+            self.assertFalse(filetypes.is_doc_path(path), path)
+
 
 if __name__ == "__main__":
     unittest.main()

{gitmole-0.5.0 → gitmole-0.6.0}/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 files")
+        self.assertEqual(warn["title"], "2 secret(s) only in test 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,6 +56,15 @@ 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_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.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")
+
     def test_placeholder_shapes_are_not_a_finding(self):
         r = report(secrets=[self.row("h4", "web/package.json", placeholder=True)])
         self.assertEqual(findings.secrets_found(r), [])
@@ -75,6 +84,15 @@ class PlaceholderIdentity(unittest.TestCase):
         f = findings.placeholder_identity(r)
         self.assertEqual(f[0]["severity"], "warning")
         self.assertIn("64%", f[0]["detail"])
+        self.assertIn("Bob <bob@x.com> Your Name <you@example.com>", f[0]["advice"], "the .mailmap line, with the top real identity as the likely owner")
+        self.assertIn(".mailmap", f[0]["advice"])
+
+    def test_advice_without_a_real_identity_to_map_to(self):
+        r = report()
+        r["meta"]["identities"] = [{"name": "Your Name", "email": "you@example.com", "commits": 64}]
+        f = findings.placeholder_identity(r)
+        self.assertIn("Set user.name and user.email", f[0]["advice"])
+        self.assertNotIn("<you@example.com>", f[0]["advice"], "no real identity to suggest, so no invented line")
 
     def test_nothing_for_real_identities(self):
         self.assertEqual(findings.placeholder_identity(report()), [])
@@ -133,6 +151,19 @@ class SizerConcerns(unittest.TestCase):
         self.assertEqual(f[0]["advice"], "Move large files to Git LFS or rewrite them out of history.")
         self.assertEqual(f[1]["advice"], "Split the widest directory into subdirectories; a directory that wide slows every checkout and diff.")
 
+    def test_a_big_blob_that_left_the_tree_says_so(self):
+        r = report(sizer=[{"name": "Blobs: Maximum size", "value": "21.3 MiB", "concern": 2, "ref": "static/old.mp4"}],
+                   size={"files": {"static/coming-soon.mp4": {"code": 0, "complexity": 0}}})
+        f = findings.sizer_concerns(r)[0]
+        self.assertIn("static/old.mp4, no longer in the tree", f["detail"])
+        self.assertIn("a history rewrite is only worth it for clone size", f["advice"])
+        r["size"]["files"]["static/old.mp4"] = {"code": 0, "complexity": 0}
+        f = findings.sizer_concerns(r)[0]
+        self.assertNotIn("no longer", f["detail"])
+        self.assertEqual(f["advice"], "Move large files to Git LFS or rewrite them out of history.")
+        r["size"] = {}
+        self.assertNotIn("no longer", findings.sizer_concerns(r)[0]["detail"], "without a tree listing nothing is claimed")
+
     def test_advice_per_kind_of_concern(self):
         # keyed on the loader's "section: metric" names, which are the only ones that occur
         def advice(name, ref=""):
@@ -188,6 +219,16 @@ class TightCoupling(unittest.TestCase):
                  {"entity": "src/a.js", "coupled": "src/a.test.js", "degree": 100, "average-revs": 9}]
         self.assertEqual(findings.tight_coupling(report(coupling=pairs)), [])
 
+    def test_pairs_of_files_no_longer_in_the_tree_are_history(self):
+        pairs = [{"entity": "static/financial-reporting.html", "coupled": "static/internal-audit.html", "degree": 100, "average-revs": 10},
+                 {"entity": "sections/a.html", "coupled": "sections/b.html", "degree": 90, "average-revs": 8}]
+        tree = {"files": {"sections/a.html": {"code": 1, "complexity": 0}, "sections/b.html": {"code": 1, "complexity": 0}}}
+        f = findings.tight_coupling(report(coupling=pairs, size=tree))
+        self.assertIn("1 pair changes", f[0]["detail"])
+        self.assertNotIn("financial-reporting", f[0]["detail"])
+        f = findings.tight_coupling(report(coupling=pairs))
+        self.assertIn("2 pairs", f[0]["detail"], "without a tree listing every pair counts")
+
     def test_single_pair_reads_grammatically(self):
         pairs = [{"entity": "a", "coupled": "b", "degree": 100, "average-revs": 10}]
         f = findings.tight_coupling(report(coupling=pairs))

{gitmole-0.5.0 → gitmole-0.6.0}/tests/test_leaks.py

@@ -45,6 +45,20 @@ class Placeholder(unittest.TestCase):
         for value in [VERSION, "1.2.3", "10.4.0+build.7", "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9...", "abcdef…"]:
             self.assertTrue(leaks.is_placeholder(value), value)
 
+    def test_a_key_block_without_key_material_is_a_template(self):
+        # Google's service-account sample: header, a dotted body, footer; a real body is hundreds of base64 characters
+        for body in ["...", "\\n...\\n", "", "…", "xxxx"]:
+            self.assertTrue(leaks.is_placeholder(f"-----BEGIN PRIVATE KEY-----{body}-----END PRIVATE KEY-----"), body)
+        self.assertTrue(leaks.is_placeholder("-----BEGIN RSA PRIVATE KEY-----\\n...\\n-----END RSA PRIVATE KEY-----\\n"))
+        real = "-----BEGIN PRIVATE KEY-----\\n" + "MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQC" * 4 + "\\n-----END PRIVATE KEY-----"
+        self.assertFalse(leaks.is_placeholder(real))
+
+    def test_template_markers_are_placeholders(self):
+        for value in ["your-project-id", "YOUR_API_KEY", "<your-token-here>", "xxxxxxxxxxxxxxxxxxxx", "XXXX-XXXX-XXXX", "changeme", "CHANGE_ME", "replace-me"]:
+            self.assertTrue(leaks.is_placeholder(value), value)
+        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_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
@@ -136,12 +150,22 @@ class Group(unittest.TestCase):
         groups = leaks.group(rows)
         self.assertEqual([g["value"] for g in groups], ["h1", "h2", "h3"], "source first, then by places; placeholders left out")
         self.assertEqual(groups[0], {"value": "h1", "rule": "generic-api-key", "files": ["app/settings.py"], "commits": ["c1", "c2"],
-                                     "places": 2, "test": False})
+                                     "places": 2, "test": False, "docs": False})
         self.assertEqual(groups[1]["files"], ["tests/data/a.html", "app/tests/data/a.html"])
         self.assertEqual(groups[1]["places"], 2)
         self.assertTrue(groups[1]["test"])
         self.assertEqual(leaks.placeholders(rows), 1)
 
+    def test_a_value_only_in_documentation_is_flagged_as_such(self):
+        groups = leaks.group([self.row("h1", "docs/GA4-API-INTEGRATION.md", "c1"), self.row("h1", "README.md", "c2")])
+        self.assertTrue(groups[0]["docs"])
+        self.assertFalse(groups[0]["test"])
+        groups = leaks.group([self.row("h1", "docs/setup.md", "c1"), self.row("h1", "app/a.py", "c2")])
+        self.assertFalse(groups[0]["docs"], "one place in source is enough")
+        groups = leaks.group([self.row("h1", "tests/t.py", "c1")])
+        self.assertFalse(groups[0]["docs"])
+        self.assertTrue(groups[0]["test"])
+
     def test_a_value_seen_in_source_and_tests_counts_as_source(self):
         groups = leaks.group([self.row("h1", "tests/t.py", "c1"), self.row("h1", "app/a.py", "c2")])
         self.assertFalse(groups[0]["test"])

{gitmole-0.5.0 → gitmole-0.6.0}/tests/test_render.py

@@ -313,6 +313,18 @@ class Report(unittest.TestCase):
         hot = _section_text(rendered(r, [], width=200), "\u25c6 Hotspots")
         self.assertIn("no source hotspots; 1 test file hidden; --full shows them", hot)
 
+    def test_default_coupling_hides_pairs_of_deleted_files_and_says_so(self):
+        r = sample_report()   # the tree holds static/index.html and static/apps-metadata.json only
+        r["coupling"] = [{"entity": "static/index.html", "coupled": "static/apps-metadata.json", "degree": 90, "average-revs": 11},
+                         {"entity": "static/tax.html", "coupled": "static/treasury.html", "degree": 85, "average-revs": 11}]
+        coupling = _section_text(rendered(r, [], width=200), "Change coupling")
+        self.assertIn("static/index.html", coupling)
+        self.assertNotIn("static/tax.html", coupling)
+        self.assertIn("1 historical pair hidden; --full shows them", coupling)
+        full = _section_text(rendered(r, [], width=200, full=True), "Change coupling")
+        self.assertIn("static/tax.html", full)
+        self.assertNotIn("hidden", 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}]