gitmole 0.7.0__tar.gz → 0.7.2__tar.gz

{gitmole-0.7.0 → gitmole-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitmole
-Version: 0.7.0
+Version: 0.7.2
 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
@@ -26,14 +26,13 @@ A toolkit for digging into any cloned git repository: who works on it,
 where the risk is, how old the code is, whether the repo itself is healthy,
 and whether anything sensitive was ever committed.
 
-Any stack. Free. Offline. No token. No AI. Light.
+Free. Any Stack. Local. Offline. Deterministic. Fast. 
 
-- **Free.** MIT licence, no paid tier, no account. The tools it runs are open source too.
+- **Free.** MIT licence, no paid tier, no account, no token. A local clone needs no credentials, and a public `owner/repo` is cloned with plain git. Your `gh` login is only used for private repositories and for `owner/*`, and only when you ask for them. The tools it runs are open source too.
 - **Any stack.** It reads what every repository has: the git log, git blame and the files themselves.
-- **Offline.** Everything runs against a clone on your machine. Nothing is uploaded, nothing phones home; the vulnerability database is a copy you download once.
-- **No token.** A local clone needs no credentials. The optional `owner/repo` shortcut uses the `gh` login you already have, and you ask for it.
-- **No AI.** Every finding is a plain rule over counts you can recompute by hand. The same clone gives the same report every time.
-- **Light.** A 4,400-commit repository takes under thirty seconds. A few thousand lines of Python plus two libraries.
+- **Local & Offline.** Everything runs against a clone on your machine. Nothing is uploaded, nothing phones home; the vulnerability database is a copy you download once.
+- **Deterministic.** No AI at runtime. Every finding is a plain rule over counts you can recompute by hand. The same clone gives the same report every time. 
+- **Fast.** A 4,400-commit repository takes under thirty seconds.
 
 ## Install
 
@@ -72,47 +71,64 @@ blocks on secrets in source files and still posts the report. Every option:
 
 ## What you get
 
-Running `gitmole .` inside this repository:
+The opening of the report for [react](https://github.com/facebook/react), 35,263 commits
+since 2013, at a pinned commit:
 
 ```text
-╭─ gitmole ────────────────────────────────────────────────────────────────────────────────────────╮
-│ 185 commits  ·  2026-09-15 → 2026-09-17  ·  1 identity  ·  branch main                           │
-│ 9,475 lines in 52 files  ·  Python, Ruby                                                         │
-│ most commits on Wed at 20:00  ·  4% of commits are fixes  ·  100% of surviving code from 2026    │
-│ 3 warnings, 1 note                                                                               │
-╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
-╭─ Findings (4) ───────────────────────────────────────────────────────────────────────────────────╮
-│ ▲ Bus factor of one                                                                              │
-│   vinni wrote 100% of the code that survives today                                               │
-│   ↳ Pair someone with vinni on gitmole/ first; it is 100% theirs.                                │
-│ ▲ Hotspots getting more complex                                                                  │
-│   4 of the 10 top source hotspots grew by 25% or more in a year: gitmole/render.py (+194%),      │
-│   gitmole/findings.py (+360%), gitmole/cli.py (+64%), gitmole/run.py (+34%)                      │
-│   ↳ Split gitmole/render.py before the next change; its complexity grew 194% in a year.          │
-│ ▲ Knowledge islands                                                                              │
-│   1 area(s) with at least 200 lines were written almost entirely by one person: gitmole/ (vinni  │
-│   100%). That is 98% of all lines added                                                          │
-│   ↳ Pair someone with vinni on gitmole/ first; it is the largest at 7,607 lines.                 │
-│ ● Bug magnets                                                                                    │
-│   5 file(s) were fixed 3+ times in the last six months: gitmole/load.py (4 recent, 4 total);     │
-│   gitmole/cli.py (3 recent, 3 total); gitmole/findings.py (3 recent, 3 total); gitmole/render.py │
-│   (3 recent, 3 total); gitmole/run.py (3 recent, 3 total)                                        │
-│   ↳ Review gitmole/load.py and gitmole/cli.py before the next release; expect the next bug       │
-│   there.                                                                                         │
-│ ✔ No secrets in history                                                                          │
-│   betterleaks scanned every commit on every branch; 28 placeholder-shaped hits left out          │
+╭─ react ──────────────────────────────────────────────────────────────────────────────────────────╮
+│ 35263 commits  ·  2013-05-28 → 2026-09-16  ·  1880 identities  ·  branch main                    │
+│ 681,078 lines in 4781 files  ·  JavaScript, TypeScript, Rust, CSS                                │
+│ most commits on Wed at 16:00  ·  13% of commits are fixes  ·  1% of commits are reverts  ·  19%  │
+│ of surviving code from 2026                                                                      │
+│ 1 critical, 6 warnings, 8 notes                                                                  │
 ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
+
+◎ Watch list
+  file                                              why                                             
+  ──────────────────────────────────────────────────────────────────────────────────────────────────
+  compiler/packages/babel-plugin-react-compiler/s   changed 331 times · fixed twice in six months · 
+  rc/Inference/InferMutationAliasingEffects.ts      Joe Savona wrote 98% of it ·                    
+                                                    findNonMutatedDestructureSpreads() complexity 39
+  packages/react-server/src/ReactFlightServer.js    changed 377 times · fixed once in six months ·  
+                                                    renderModelDestructive() complexity 544         
+  packages/shared/forks/ReactFeatureFlags.www.js    changed 583 times · fixed once in six months ·  
+                                                    changes with                                    
+                                                    packages/shared/forks/ReactFeatureFlags.test-ren
+                                                    derer.www.js (77%) and 5 others                 
+  packages/shared/ReactFeatureFlags.js              changed 575 times · fixed 6 times · changes with
+                                                    packages/shared/forks/ReactFeatureFlags.test-ren
+                                                    derer.js (80%) and 4 others                     
+  packages/react-reconciler/src/ReactFiberWorkLoo   changed 342 times · fixed 4 times in six months 
+  p.js                                              · flushSpawnedWork() complexity 48              
+  ranked by churn × recent fixes × complexity × single ownership                                    
+  6 months ago this list would have named 6 of the 211 files fixed since (a random 15 of the 1979   
+  files that had changed more than once would name 0.3)                                             
 ```
 
-Below that: a watch list of the five files where the next bug is most
-likely, with the reasons in words and a backtest of how the list would have
-done; then tables for people, the knowledge map, the timeline, hotspots with
-their complexity trend, change coupling, complex functions and repo health.
-The full report is in
-[docs/example.md](https://github.com/antvinni/gitmole/blob/main/docs/example.md),
-and every section is explained in
+The watch list is the point: the five files where the next bug is most
+likely, the reasons in words, and a backtest that says how the same list,
+drawn six months earlier, would have done against the fixes that followed.
+Between the header and that list the full report puts its findings, 15 for
+react (1 critical, 6 warnings, 8 notes); below it, tables for people, the
+knowledge map, the timeline, hotspots with their complexity trend, change
+coupling, complex functions and repo health. Every section is explained in
 [docs/output.md](https://github.com/antvinni/gitmole/blob/main/docs/output.md).
 
+Reports on repositories you know, each at a pinned commit with a fixed
+reference date, published as gitmole wrote them; the repo-health numbers
+come from git-sizer over the whole clone, so a fresh clone can differ there:
+
+| Repository | Commits | Lines | Watch list backtest |
+|---|---:|---:|---|
+| [curl](https://github.com/antvinni/gitmole/blob/main/docs/examples/curl.md) | 39,894 | 247,179 | named 15 of the 239 files fixed in the next six months; a random pick would name 5.0 |
+| [django](https://github.com/antvinni/gitmole/blob/main/docs/examples/django.md) | 52,832 | 431,749 | named 13 of the 213 files fixed in the next six months; a random pick would name 2.8 |
+| [react](https://github.com/antvinni/gitmole/blob/main/docs/examples/react.md) | 35,263 | 681,078 | named 6 of the 211 files fixed in the next six months; a random pick would name 0.3 |
+| [kubernetes](https://github.com/antvinni/gitmole/blob/main/docs/examples/kubernetes.md) | 161,803 | 4,180,715 | named 7 of the 338 files fixed in the next six months; a random pick would name 0.4 |
+
+kubernetes's code-age step was skipped on gitmole's default time budget and
+its report says so; the duplicates step was skipped on the memory budget too
+and produced no section.
+
 ## The tool set
 
 One tool per question; together they cover what a single command can tell
@@ -138,7 +154,7 @@ Why these and not others: [docs/tools.md](https://github.com/antvinni/gitmole/bl
 - [Install](https://github.com/antvinni/gitmole/blob/main/docs/install.md): macOS, Linux, pipx, the check, pinned releases.
 - [Command line](https://github.com/antvinni/gitmole/blob/main/docs/cli.md): every option, portfolio mode, exports and CI gates, big repositories.
 - [The report and the output files](https://github.com/antvinni/gitmole/blob/main/docs/output.md): what each section and each file means.
-- [Full example report](https://github.com/antvinni/gitmole/blob/main/docs/example.md): the whole `gitmole .` output for this repository.
+- [Example reports](https://github.com/antvinni/gitmole/tree/main/docs/examples): curl, django, react and kubernetes at pinned commits, regenerated by `bin/render-examples`.
 - [Why these tools](https://github.com/antvinni/gitmole/blob/main/docs/tools.md): the rationale, what was left out, licences.
 - [Development](https://github.com/antvinni/gitmole/blob/main/docs/development.md): setup, tests, releases, code layout.
 - [Contributing](https://github.com/antvinni/gitmole/blob/main/CONTRIBUTING.md): bugs, ideas, pull requests, security reports.

{gitmole-0.7.0 → gitmole-0.7.2}/README.md

@@ -6,14 +6,13 @@ A toolkit for digging into any cloned git repository: who works on it,
 where the risk is, how old the code is, whether the repo itself is healthy,
 and whether anything sensitive was ever committed.
 
-Any stack. Free. Offline. No token. No AI. Light.
+Free. Any Stack. Local. Offline. Deterministic. Fast. 
 
-- **Free.** MIT licence, no paid tier, no account. The tools it runs are open source too.
+- **Free.** MIT licence, no paid tier, no account, no token. A local clone needs no credentials, and a public `owner/repo` is cloned with plain git. Your `gh` login is only used for private repositories and for `owner/*`, and only when you ask for them. The tools it runs are open source too.
 - **Any stack.** It reads what every repository has: the git log, git blame and the files themselves.
-- **Offline.** Everything runs against a clone on your machine. Nothing is uploaded, nothing phones home; the vulnerability database is a copy you download once.
-- **No token.** A local clone needs no credentials. The optional `owner/repo` shortcut uses the `gh` login you already have, and you ask for it.
-- **No AI.** Every finding is a plain rule over counts you can recompute by hand. The same clone gives the same report every time.
-- **Light.** A 4,400-commit repository takes under thirty seconds. A few thousand lines of Python plus two libraries.
+- **Local & Offline.** Everything runs against a clone on your machine. Nothing is uploaded, nothing phones home; the vulnerability database is a copy you download once.
+- **Deterministic.** No AI at runtime. Every finding is a plain rule over counts you can recompute by hand. The same clone gives the same report every time. 
+- **Fast.** A 4,400-commit repository takes under thirty seconds.
 
 ## Install
 
@@ -52,47 +51,64 @@ blocks on secrets in source files and still posts the report. Every option:
 
 ## What you get
 
-Running `gitmole .` inside this repository:
+The opening of the report for [react](https://github.com/facebook/react), 35,263 commits
+since 2013, at a pinned commit:
 
 ```text
-╭─ gitmole ────────────────────────────────────────────────────────────────────────────────────────╮
-│ 185 commits  ·  2026-09-15 → 2026-09-17  ·  1 identity  ·  branch main                           │
-│ 9,475 lines in 52 files  ·  Python, Ruby                                                         │
-│ most commits on Wed at 20:00  ·  4% of commits are fixes  ·  100% of surviving code from 2026    │
-│ 3 warnings, 1 note                                                                               │
-╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
-╭─ Findings (4) ───────────────────────────────────────────────────────────────────────────────────╮
-│ ▲ Bus factor of one                                                                              │
-│   vinni wrote 100% of the code that survives today                                               │
-│   ↳ Pair someone with vinni on gitmole/ first; it is 100% theirs.                                │
-│ ▲ Hotspots getting more complex                                                                  │
-│   4 of the 10 top source hotspots grew by 25% or more in a year: gitmole/render.py (+194%),      │
-│   gitmole/findings.py (+360%), gitmole/cli.py (+64%), gitmole/run.py (+34%)                      │
-│   ↳ Split gitmole/render.py before the next change; its complexity grew 194% in a year.          │
-│ ▲ Knowledge islands                                                                              │
-│   1 area(s) with at least 200 lines were written almost entirely by one person: gitmole/ (vinni  │
-│   100%). That is 98% of all lines added                                                          │
-│   ↳ Pair someone with vinni on gitmole/ first; it is the largest at 7,607 lines.                 │
-│ ● Bug magnets                                                                                    │
-│   5 file(s) were fixed 3+ times in the last six months: gitmole/load.py (4 recent, 4 total);     │
-│   gitmole/cli.py (3 recent, 3 total); gitmole/findings.py (3 recent, 3 total); gitmole/render.py │
-│   (3 recent, 3 total); gitmole/run.py (3 recent, 3 total)                                        │
-│   ↳ Review gitmole/load.py and gitmole/cli.py before the next release; expect the next bug       │
-│   there.                                                                                         │
-│ ✔ No secrets in history                                                                          │
-│   betterleaks scanned every commit on every branch; 28 placeholder-shaped hits left out          │
+╭─ react ──────────────────────────────────────────────────────────────────────────────────────────╮
+│ 35263 commits  ·  2013-05-28 → 2026-09-16  ·  1880 identities  ·  branch main                    │
+│ 681,078 lines in 4781 files  ·  JavaScript, TypeScript, Rust, CSS                                │
+│ most commits on Wed at 16:00  ·  13% of commits are fixes  ·  1% of commits are reverts  ·  19%  │
+│ of surviving code from 2026                                                                      │
+│ 1 critical, 6 warnings, 8 notes                                                                  │
 ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
+
+◎ Watch list
+  file                                              why                                             
+  ──────────────────────────────────────────────────────────────────────────────────────────────────
+  compiler/packages/babel-plugin-react-compiler/s   changed 331 times · fixed twice in six months · 
+  rc/Inference/InferMutationAliasingEffects.ts      Joe Savona wrote 98% of it ·                    
+                                                    findNonMutatedDestructureSpreads() complexity 39
+  packages/react-server/src/ReactFlightServer.js    changed 377 times · fixed once in six months ·  
+                                                    renderModelDestructive() complexity 544         
+  packages/shared/forks/ReactFeatureFlags.www.js    changed 583 times · fixed once in six months ·  
+                                                    changes with                                    
+                                                    packages/shared/forks/ReactFeatureFlags.test-ren
+                                                    derer.www.js (77%) and 5 others                 
+  packages/shared/ReactFeatureFlags.js              changed 575 times · fixed 6 times · changes with
+                                                    packages/shared/forks/ReactFeatureFlags.test-ren
+                                                    derer.js (80%) and 4 others                     
+  packages/react-reconciler/src/ReactFiberWorkLoo   changed 342 times · fixed 4 times in six months 
+  p.js                                              · flushSpawnedWork() complexity 48              
+  ranked by churn × recent fixes × complexity × single ownership                                    
+  6 months ago this list would have named 6 of the 211 files fixed since (a random 15 of the 1979   
+  files that had changed more than once would name 0.3)                                             
 ```
 
-Below that: a watch list of the five files where the next bug is most
-likely, with the reasons in words and a backtest of how the list would have
-done; then tables for people, the knowledge map, the timeline, hotspots with
-their complexity trend, change coupling, complex functions and repo health.
-The full report is in
-[docs/example.md](https://github.com/antvinni/gitmole/blob/main/docs/example.md),
-and every section is explained in
+The watch list is the point: the five files where the next bug is most
+likely, the reasons in words, and a backtest that says how the same list,
+drawn six months earlier, would have done against the fixes that followed.
+Between the header and that list the full report puts its findings, 15 for
+react (1 critical, 6 warnings, 8 notes); below it, tables for people, the
+knowledge map, the timeline, hotspots with their complexity trend, change
+coupling, complex functions and repo health. Every section is explained in
 [docs/output.md](https://github.com/antvinni/gitmole/blob/main/docs/output.md).
 
+Reports on repositories you know, each at a pinned commit with a fixed
+reference date, published as gitmole wrote them; the repo-health numbers
+come from git-sizer over the whole clone, so a fresh clone can differ there:
+
+| Repository | Commits | Lines | Watch list backtest |
+|---|---:|---:|---|
+| [curl](https://github.com/antvinni/gitmole/blob/main/docs/examples/curl.md) | 39,894 | 247,179 | named 15 of the 239 files fixed in the next six months; a random pick would name 5.0 |
+| [django](https://github.com/antvinni/gitmole/blob/main/docs/examples/django.md) | 52,832 | 431,749 | named 13 of the 213 files fixed in the next six months; a random pick would name 2.8 |
+| [react](https://github.com/antvinni/gitmole/blob/main/docs/examples/react.md) | 35,263 | 681,078 | named 6 of the 211 files fixed in the next six months; a random pick would name 0.3 |
+| [kubernetes](https://github.com/antvinni/gitmole/blob/main/docs/examples/kubernetes.md) | 161,803 | 4,180,715 | named 7 of the 338 files fixed in the next six months; a random pick would name 0.4 |
+
+kubernetes's code-age step was skipped on gitmole's default time budget and
+its report says so; the duplicates step was skipped on the memory budget too
+and produced no section.
+
 ## The tool set
 
 One tool per question; together they cover what a single command can tell
@@ -118,7 +134,7 @@ Why these and not others: [docs/tools.md](https://github.com/antvinni/gitmole/bl
 - [Install](https://github.com/antvinni/gitmole/blob/main/docs/install.md): macOS, Linux, pipx, the check, pinned releases.
 - [Command line](https://github.com/antvinni/gitmole/blob/main/docs/cli.md): every option, portfolio mode, exports and CI gates, big repositories.
 - [The report and the output files](https://github.com/antvinni/gitmole/blob/main/docs/output.md): what each section and each file means.
-- [Full example report](https://github.com/antvinni/gitmole/blob/main/docs/example.md): the whole `gitmole .` output for this repository.
+- [Example reports](https://github.com/antvinni/gitmole/tree/main/docs/examples): curl, django, react and kubernetes at pinned commits, regenerated by `bin/render-examples`.
 - [Why these tools](https://github.com/antvinni/gitmole/blob/main/docs/tools.md): the rationale, what was left out, licences.
 - [Development](https://github.com/antvinni/gitmole/blob/main/docs/development.md): setup, tests, releases, code layout.
 - [Contributing](https://github.com/antvinni/gitmole/blob/main/CONTRIBUTING.md): bugs, ideas, pull requests, security reports.

{gitmole-0.7.0 → gitmole-0.7.2}/gitmole/__init__.py

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

{gitmole-0.7.0 → gitmole-0.7.2}/gitmole/banner.py

@@ -83,8 +83,9 @@ def _sprite_rows(look: int = 0) -> list:
     return rows
 
 
-def neon(offset: int = 0, look: int = 0) -> Text:
-    """The banner with the palette rotated down by `offset` rows, and the mole beside it."""
+def neon(offset: int = 0, look: int = 0, version: str = None) -> Text:
+    """The banner with the palette rotated down by `offset` rows, and the mole beside it.
+    With `version`, a dim `v1.2.3` row underneath: the report's reproducibility stamp."""
     text = Text()
     sprite = _sprite_rows(look)
     for i, row in enumerate(ART.split("\n")):
@@ -93,15 +94,17 @@ def neon(offset: int = 0, look: int = 0) -> Text:
         text.append(" " * GAP)
         text.append_text(sprite[i])
         text.append("\n")
+    if version:
+        text.append(f"v{version}\n", style="dim")
     return text
 
 
 LOOK_EVERY = 5  # frames per glance; at 10 fps the eyes move every half second
 
 
-def frames():
+def frames(version: str = None):
     """Endless generator of banner frames: gradient flowing down, eyes glancing side to side."""
     n = 0
     while True:
-        yield neon(offset=n % len(NEON), look=(n // LOOK_EVERY) % 2)
+        yield neon(offset=n % len(NEON), look=(n // LOOK_EVERY) % 2, version=version)
         n += 1

{gitmole-0.7.0 → gitmole-0.7.2}/gitmole/cli.py

@@ -171,7 +171,7 @@ def _no_run(args, console, ui, err) -> int:
         err.print(f"[red]no gitmole output found in {out_dir}[/red] (expected meta.json)")
         return 2
     if ui.is_terminal:
-        ui.print(banner.neon())
+        ui.print(banner.neon(version=__version__))
     return _render(out_dir, console, ui, args, err)
 
 
@@ -437,7 +437,7 @@ def _execute(steps, log_path, repo_dir, workers, console, timeout=None) -> dict:
     active, lock = set(), threading.Lock()
     started = time.monotonic()
     spinner = Spinner("dots", style="cyan")
-    frame = banner.frames()
+    frame = banner.frames(version=__version__)
 
     def label() -> str:
         with lock:
@@ -466,7 +466,7 @@ def _execute(steps, log_path, repo_dir, workers, console, timeout=None) -> dict:
         while worker.is_alive():
             live.update(view())
             worker.join(0.1)
-        live.update(Group(banner.neon(), Text("")) if console.is_terminal else Text(""))
+        live.update(Group(banner.neon(version=__version__), Text("")) if console.is_terminal else Text(""))
     console.print(f"[dim]{len(steps)} steps in {time.monotonic() - started:.1f}s[/dim]\n")
     return results
 

{gitmole-0.7.0 → gitmole-0.7.2}/gitmole/findings.py

@@ -442,10 +442,11 @@ def _partial_functions(report: dict) -> str:
 
 def brain_methods(report: dict, min_ccn: int = 15, min_lines: int = 100) -> list:
     """Functions that are both long and complex, in this repository's own source files: test files,
-    example code, vendored code and generated files (amalgamations included) are left out. A warning
-    when one sits in a hotspot."""
+    example code, vendored code and generated files (amalgamations included) are left out, and so is
+    a span the function step marked suspect, since a mis-parse that swallowed the next function is
+    long and complex by construction. A warning when one sits in a hotspot."""
     generated, vendored = _generated(report), filetypes.vendor_dirs(report)
-    big = [f for f in report.get("functions") or [] if f["ccn"] >= min_ccn and f["nloc"] >= min_lines
+    big = [f for f in report.get("functions") or [] if f["ccn"] >= min_ccn and f["nloc"] >= min_lines and not f.get("suspect")
            and not (filetypes.is_test_path(f["file"]) or filetypes.is_sample_path(f["file"]) or filetypes.is_vendored(f["file"], vendored)
                     or f["file"] in generated)]
     if not big:
@@ -456,7 +457,7 @@ def brain_methods(report: dict, min_ccn: int = 15, min_lines: int = 100) -> list
     listed = "; ".join(f"{f['function']} ({_place(f)}) complexity {f['ccn']}, {f['nloc']} lines, {f['params']} params" for f in big[:5])
     more = f" and {len(big) - 5} more" if len(big) > 5 else ""
     first = big[0]
-    which = f"the anonymous function at {_place(first)}" if first["function"] == ANONYMOUS else f"{first['function']} in {first['file']}"
+    which = f"the anonymous function at {_place(first)}" if _anonymous(first) else f"{first['function']} in {first['file']}"
     return [_f(sev, "Brain methods",
                f"{len(big)} function(s) are both long and complex: {listed}{more}.{_partial_functions(report)}",
                f"Split {which} first, before the next change lands there.")]
@@ -465,9 +466,15 @@ def brain_methods(report: dict, min_ccn: int = 15, min_lines: int = 100) -> list
 ANONYMOUS = "(anonymous)"
 
 
+def _anonymous(f: dict) -> bool:
+    """A function lizard could not name: it goes by its start line's text (or "(anonymous)" in an
+    older functions.csv), which is not a name to search for."""
+    return f.get("anonymous", f["function"] == ANONYMOUS)
+
+
 def _place(f: dict) -> str:
     """Where a function is: its file, or file:line when it has no name to find it by."""
-    return f"{f['file']}:{f['start']}" if f["function"] == ANONYMOUS else f["file"]
+    return f"{f['file']}:{f['start']}" if _anonymous(f) else f["file"]
 
 
 def _generated(report: dict) -> set:

gitmole-0.7.2/gitmole/functions.py

@@ -0,0 +1,182 @@
+#!/usr/bin/env python3
+"""Function-level metrics from lizard, over the tracked code files only.
+
+Runs as its own process (a pipeline step) and drives lizard through its Python API rather
+than its command line: the file list never touches a shell or a list file, the analysed
+repository is never on sys.path, only files lizard has a reader for are measured, and the
+CSV is streamed so a killed step still leaves what was measured. Duplicated blocks are
+jscpd's job (duplicates.py); lizard's own finder kept a hash node per token and ran to gigabytes."""
+from __future__ import annotations
+
+import argparse
+import csv
+import os
+import sys
+
+import lizard
+
+try:
+    from . import blame, filetypes
+except ImportError:  # run as a script: the package directory is sys.path[0]
+    import blame
+    import filetypes
+
+
+def select_files(repo: str, ignore=(), types_spec: str = None) -> list:
+    """Tracked text files lizard can parse. Without --file-types that is every language lizard
+    knows (a superset of gitmole's default code list, e.g. Fortran); with it, the intersection."""
+    types = filetypes.parse(types_spec)
+    files = blame.text_files(repo, ignore) if types_spec is None else blame.code_files(repo, ignore, types)
+    return [f for f in files if lizard.get_reader_for(f) is not None]
+
+
+NAME_CAP = 200        # a deeply nested fixture gives lizard a dotted name of megabytes; nobody reads past this
+LONG_NAME_CAP = 500
+
+
+def _cut(text: str, cap: int) -> str:
+    return text if len(text) <= cap else text[:cap - 1] + "…"
+
+
+ANONYMOUS = "(anonymous)"   # lizard's name for a JavaScript function expression; a Go literal gets ""
+SPARSE_LINES = 40           # a span this long...
+SPARSE_SHARE = 0.25         # ...with under this share of code lines is more likely a mis-parse than a function
+
+OPENS_FUNCTION = ("=>", "->", "func", "lambda")   # what a line that opens a nameless function holds: "func" covers "function"
+NEARBY = (0, -1, 1, 2, 3, 4, 5)
+
+
+def nameless(fn) -> bool:
+    return fn.name in ("", ANONYMOUS)
+
+
+def _opener(lines: list, fn) -> int | None:
+    """The line near a nameless function's start that opens a function, or None. lizard puts an arrow
+    whose body starts on the next line at the body's line, and a callback in a JSX attribute at the
+    tag's line, so the start line is tried first, then the line before, then a few lines on."""
+    for offset in NEARBY:
+        n = fn.start_line + offset
+        if 1 <= n <= len(lines) and any(m in lines[n - 1] for m in OPENS_FUNCTION):
+            return n
+    return None
+
+
+def label(lines: list, fn) -> str:
+    """What to call a function lizard could not name: the line it starts on, whitespace collapsed, in
+    any language. `app.post("/api/x", async (req, res) => {` finds the callback; `(anonymous)` does not.
+    When a nearby line opens a function and the start line does not, that line is the label."""
+    if not nameless(fn) or not 1 <= fn.start_line <= len(lines):
+        return ""
+    n = _opener(lines, fn) or fn.start_line
+    return _cut(" ".join(lines[n - 1].split()), NAME_CAP)
+
+
+def suspect(lines: list, fn) -> str:
+    """Why a span looks like a mis-parse, or "". lizard fails by losing its place (a template literal,
+    JSX) and swallowing what follows into one function, so a swallowed span is long with little code
+    in it, or holds a line that opens a block at the indentation of the function's own start: a
+    sibling that should have ended it. A line that starts by closing a bracket (`}: Props) {`)
+    continues the function's own signature, and a bare `{` is the function's own body brace in
+    the C styles that put it on its own line; neither counts. It also reads a JSX ternary as a
+    nameless function: all code, all deeper than its start, and nothing near the start line opens a
+    function."""
+    if fn.length >= SPARSE_LINES and fn.nloc < SPARSE_SHARE * fn.length:
+        return f"{fn.nloc} of {fn.length} lines are code"
+    if nameless(fn) and 1 <= fn.start_line <= len(lines) and _opener(lines, fn) is None:
+        return f"nothing opens a function within {max(NEARBY)} lines of line {fn.start_line}"
+    span = lines[max(fn.start_line, 1) - 1:fn.end_line]
+    if len(span) < 3:
+        return ""
+    depth = _indent(span[0])
+    for number, line in enumerate(span[1:-1], start=fn.start_line + 1):
+        text = line.rstrip()
+        if text.endswith("{") and _indent(text) <= depth and text.lstrip()[0] not in "{)]}":
+            return f"opens a block at line {number} no deeper than its own start"
+    return ""
+
+
+def _indent(line: str) -> int:
+    return len(line) - len(line.lstrip())
+
+
+def csv_row(info, fn, lines: list = ()) -> list:
+    """The columns `lizard --csv` prints, then gitmole's own two: a label for nameless functions and
+    why the span looks mis-parsed. Names are cut to what a table can show, so one pathological
+    fixture cannot make the file unreadable."""
+    name = _cut(fn.name, NAME_CAP)
+    return [fn.nloc, fn.cyclomatic_complexity, fn.token_count, fn.parameter_count, fn.length,
+            f"{name}@{fn.start_line}-{fn.end_line}@{info.filename}", info.filename, name, _cut(fn.long_name, LONG_NAME_CAP), fn.start_line, fn.end_line,
+            label(lines, fn), suspect(lines, fn)]
+
+
+def _lines(path: str) -> list:
+    try:
+        with open(path, encoding="utf-8", errors="replace") as fh:
+            return fh.read().splitlines()
+    except OSError:
+        return []
+
+
+def keep_newlines(tokens, reader):
+    """lizard's own preprocessing, after splitting whitespace tokens that hold newlines into bare ones.
+    lizard 1.24 drops any whitespace token but "\\n" there, and its JSX tokenizer hands it the newline
+    before a child element joined with the indentation after it: one line lost per child, so every
+    function after a JSX block in a .tsx file reports lines before its own."""
+    def split(tokens):
+        for t in tokens:
+            if t != "\n" and t.isspace() and "\n" in t:
+                for _ in range(t.count("\n")):
+                    yield "\n"
+            else:
+                yield t
+    return lizard.preprocessing(split(tokens), reader)
+
+
+def extensions() -> list:
+    """lizard's metric extensions, with keep_newlines in place of its preprocessing."""
+    return [keep_newlines if e is lizard.preprocessing else e for e in lizard.get_extensions([])]
+
+
+def analyze(files: list, procs: int, exts: list):
+    """lizard.analyze_files without its extension bookkeeping: per-file analysis over `procs` workers."""
+    return lizard.map_files_to_analyzer(files, lizard.FileAnalyzer(exts), procs)
+
+
+def measure(repo: str, files: list, out: str, procs: int) -> int:
+    """Stream functions.csv while lizard runs. Returns 0, or 1 when lizard gave up on a file (whatever
+    was measured by then stays on disk)."""
+    exts = extensions()
+    rc = 0
+    cwd = os.getcwd()
+    os.chdir(repo)   # lizard opens the paths as given; relative ones keep the CSV repo-relative
+    try:
+        with open(os.path.join(out, "functions.csv"), "w", encoding="utf-8", newline="") as fh:
+            writer = csv.writer(fh, quoting=csv.QUOTE_NONNUMERIC)
+            try:
+                for info in analyze(files, procs, exts):
+                    lines = _lines(info.filename) if info.function_list else []
+                    for fn in info.function_list:
+                        writer.writerow(csv_row(info, fn, lines))
+                    fh.flush()
+            except Exception as e:  # lizard re-raises its parse failures; keep what we have
+                print(f"lizard stopped: {e!r}", file=sys.stderr)
+                rc = 1
+    finally:
+        os.chdir(cwd)
+    return rc
+
+
+def main(argv=None) -> int:
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument("repo")
+    p.add_argument("out")
+    p.add_argument("--procs", type=int, default=1)
+    p.add_argument("--ignore", action="append", default=[])
+    p.add_argument("--types", default=None, help="file types spec as for gitmole --file-types")
+    args = p.parse_args(argv)
+    files = select_files(args.repo, args.ignore, args.types)
+    return measure(os.path.abspath(args.repo), files, os.path.abspath(args.out), max(1, args.procs))
+
+
+if __name__ == "__main__":
+    sys.exit(main())

{gitmole-0.7.0 → gitmole-0.7.2}/gitmole/load.py

@@ -155,13 +155,18 @@ def _cut(name: str, cap: int = NAME_CAP) -> str:
 
 
 def parse_functions(text: str) -> list:
-    """lizard --csv rows: nloc, ccn, tokens, params, length, location, file, function, long name, start, end."""
+    """lizard --csv rows: nloc, ccn, tokens, params, length, location, file, function, long name, start, end;
+    then, from gitmole's own step, a label for a nameless function (its start line) and why the span
+    looks mis-parsed. A nameless function goes by its label, or "(anonymous)" in an older file, and
+    stays marked anonymous so the report can say where it is."""
     rows = []
     for r in csv.reader(io.StringIO(text)):
         if len(r) < 11:
             continue
-        rows.append({"file": _rel(r[6]), "function": _cut(r[7]) or "(anonymous)", "ccn": _num(r[1]), "nloc": _num(r[0]), "params": _num(r[3]),
-                     "start": _num(r[9]), "end": _num(r[10])})
+        name, label, suspect = r[7], r[11] if len(r) > 11 else "", r[12] if len(r) > 12 else ""
+        anonymous = name in ("", "(anonymous)")
+        rows.append({"file": _rel(r[6]), "function": _cut(label if anonymous and label else name) or "(anonymous)", "anonymous": anonymous,
+                     "ccn": _num(r[1]), "nloc": _num(r[0]), "params": _num(r[3]), "start": _num(r[9]), "end": _num(r[10]), "suspect": suspect})
     return rows