gitmole 0.7.1__tar.gz → 0.7.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitmole
-Version: 0.7.1
+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,8 +26,6 @@ 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.
 
-<img src="https://raw.githubusercontent.com/antvinni/gitmole/main/docs/report.svg" width="912" alt="gitmole on react: the summary, and the watch list of files where the next bug is likely, with a backtest">
-
 Free. Any Stack. Local. Offline. Deterministic. Fast. 
 
 - **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.
@@ -74,7 +72,7 @@ blocks on secrets in source files and still posts the report. Every option:
 ## What you get
 
 The opening of the report for [react](https://github.com/facebook/react), 35,263 commits
-since 2013, at a pinned commit; the picture above, as text:
+since 2013, at a pinned commit:
 
 ```text
 ╭─ react ──────────────────────────────────────────────────────────────────────────────────────────╮

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

@@ -6,8 +6,6 @@ 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.
 
-<img src="https://raw.githubusercontent.com/antvinni/gitmole/main/docs/report.svg" width="912" alt="gitmole on react: the summary, and the watch list of files where the next bug is likely, with a backtest">
-
 Free. Any Stack. Local. Offline. Deterministic. Fast. 
 
 - **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.
@@ -54,7 +52,7 @@ blocks on secrets in source files and still posts the report. Every option:
 ## What you get
 
 The opening of the report for [react](https://github.com/facebook/react), 35,263 commits
-since 2013, at a pinned commit; the picture above, as text:
+since 2013, at a pinned commit:
 
 ```text
 ╭─ react ──────────────────────────────────────────────────────────────────────────────────────────╮

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

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

{gitmole-0.7.1 → 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.1 → 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
 
 

{gitmole-0.7.1 → gitmole-0.7.2}/gitmole/render.py

@@ -515,7 +515,10 @@ def functions_section(report: dict, full: bool = True, width=None) -> dict:
     funcs, generated_note = _hide_generated(funcs, lambda f: f["file"], report, full, noun="function in a generated file", plural="functions in generated files")
     hidden_note = _join_hidden(hidden_note, vendor_note, sample_note, generated_note)
     limit = _limit("Complex functions", full)
-    rows = [(f["function"], f["file"], f["ccn"], f["nloc"], f["params"]) for f in funcs[:limit]]
+    shown = funcs[:limit]
+    rows = [(f["function"], _where(f), f"{f['ccn']}{SUSPECT_MARK}" if f.get("suspect") else f["ccn"], f["nloc"], f["params"]) for f in shown]
+    suspects = sum(1 for f in shown if f.get("suspect"))
+    suspect_note = f"{SUSPECT_MARK} marks {suspects} span{'s' if suspects != 1 else ''} lizard may have mis-parsed" if suspects else None
     columns = [("function", {"overflow": "fold"}), ("file", PATH), ("ccn", RIGHT), ("lines", RIGHT), ("params", RIGHT)]
     if full is not True:
         rows = _shorten(rows, width, columns, path_columns=(1,))
@@ -533,10 +536,19 @@ def functions_section(report: dict, full: bool = True, width=None) -> dict:
                            f"nothing over complexity {CCN_FLOOR} in source files {counted}")
     else:
         note = None
-    caption = "; ".join(c for c in (_more(len(funcs), limit), None if note else hidden_note, partial) if c) or None
+    caption = "; ".join(c for c in (_more(len(funcs), limit), None if note else hidden_note, partial, suspect_note) if c) or None
     return _section("Complex functions", columns, rows, note=note, caption=caption)
 
 
+SUSPECT_MARK = "?"
+
+
+def _where(f: dict) -> str:
+    """A named function is found by its name in its file; a nameless one goes by its start line's text,
+    so the row says which line."""
+    return f"{f['file']}:{f['start']}" if f.get("anonymous") else f["file"]
+
+
 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)
@@ -811,7 +823,7 @@ def report(report: dict, findings: list, console: Console, full: bool = False, r
 
 def excerpt(report: dict, findings: list, console: Console, full: bool = False) -> None:
     """The report's opening on its own: the header, whose tally counts the findings, and the watch
-    list. What the README's picture shows; the findings themselves are in the full report."""
+    list. What the README's text block shows; the findings themselves are in the full report."""
     console.print(header(report, findings))
     print_section(console, watch_section(report, full=full, width=console.width))
 

{gitmole-0.7.1 → gitmole-0.7.2}/gitmole/watch.py

@@ -50,9 +50,11 @@ def _companions(report: dict) -> dict:
 
 
 def _worst_function(report: dict) -> dict:
+    """The most complex function per file, passing over spans the function step marked as likely
+    mis-parsed: a swallowed span's complexity is not the file's."""
     worst = {}
     for f in report.get("functions") or []:
-        if f["file"] not in worst or f["ccn"] > worst[f["file"]]["ccn"]:
+        if not f.get("suspect") and (f["file"] not in worst or f["ccn"] > worst[f["file"]]["ccn"]):
             worst[f["file"]] = f
     return worst
 
@@ -120,7 +122,8 @@ def _reasons(r: dict) -> list:
         out.append(f"{r['owner']} wrote {round(100 * r['owner_share'])}% of it")
     fn = r["function"]
     if fn and fn["ccn"] >= CCN_FLOOR:
-        out.append(f"{fn['function']}() complexity {fn['ccn']}")
+        named = f"the function at line {fn['start']}" if fn.get("anonymous") else f"{fn['function']}()"
+        out.append(f"{named} complexity {fn['ccn']}")
     if r["companions"]:
         other, degree = r["companions"][0]
         more = len(r["companions"]) - 1

{gitmole-0.7.1 → gitmole-0.7.2}/gitmole.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitmole
-Version: 0.7.1
+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,8 +26,6 @@ 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.
 
-<img src="https://raw.githubusercontent.com/antvinni/gitmole/main/docs/report.svg" width="912" alt="gitmole on react: the summary, and the watch list of files where the next bug is likely, with a backtest">
-
 Free. Any Stack. Local. Offline. Deterministic. Fast. 
 
 - **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.
@@ -74,7 +72,7 @@ blocks on secrets in source files and still posts the report. Every option:
 ## What you get
 
 The opening of the report for [react](https://github.com/facebook/react), 35,263 commits
-since 2013, at a pinned commit; the picture above, as text:
+since 2013, at a pinned commit:
 
 ```text
 ╭─ react ──────────────────────────────────────────────────────────────────────────────────────────╮

{gitmole-0.7.1 → gitmole-0.7.2}/tests/test_findings.py

@@ -474,6 +474,22 @@ class BrainMethods(unittest.TestCase):
         self.assertIn("(anonymous) (completions.go:316) complexity 47, 136 lines, 1 params", f[0]["detail"])
         self.assertEqual(f[0]["advice"], "Split the anonymous function at completions.go:316 first, before the next change lands there.")
 
+    def test_a_labelled_nameless_function_is_listed_by_its_label_and_placed_by_its_line(self):
+        fns = [{"file": "server/routes.ts", "function": 'app.post("/api/x", async (req, res) => {', "anonymous": True,
+                "ccn": 47, "nloc": 136, "params": 1, "start": 316, "end": 585, "suspect": ""}]
+        f = findings.brain_methods(report(functions=fns))
+        self.assertIn('app.post("/api/x", async (req, res) => { (server/routes.ts:316) complexity 47, 136 lines, 1 params', f[0]["detail"])
+        self.assertEqual(f[0]["advice"], "Split the anonymous function at server/routes.ts:316 first, before the next change lands there.")
+
+    def test_a_suspect_span_is_not_a_brain_method(self):
+        fns = [{"file": "core/parser.py", "function": "parse", "ccn": 41, "nloc": 220, "params": 9, "start": 10, "end": 300,
+                "suspect": "opens a block at line 120 no deeper than its own start"},
+               {"file": "core/util.py", "function": "tidy", "ccn": 16, "nloc": 120, "params": 2, "start": 1, "end": 130, "suspect": ""}]
+        f = findings.brain_methods(report(functions=fns))
+        self.assertNotIn("parse", f[0]["detail"], "a span lizard may have mis-parsed is not advice")
+        self.assertEqual(f[0]["advice"], "Split tidy in core/util.py first, before the next change lands there.")
+        self.assertEqual(findings.brain_methods(report(functions=fns[:1])), [])
+
     def test_generated_files_are_not_brain_methods(self):
         fns = [{"file": "lib/config-validator.js", "function": "validate10", "ccn": 373, "nloc": 1150, "params": 5, "start": 1, "end": 1150},
                {"file": "lib/reply.js", "function": "onSendEnd", "ccn": 34, "nloc": 180, "params": 2, "start": 1, "end": 180}]

gitmole-0.7.2/tests/test_functions.py

@@ -0,0 +1,187 @@
+import os
+import subprocess
+import tempfile
+import unittest
+
+from gitmole import functions
+
+
+def make_repo(d, extra=()):
+    def git(*args):
+        e = dict(os.environ, GIT_CONFIG_GLOBAL="/dev/null", GIT_CONFIG_SYSTEM="/dev/null",
+                 GIT_AUTHOR_NAME="Ann", GIT_AUTHOR_EMAIL="a@x", GIT_COMMITTER_NAME="Ann", GIT_COMMITTER_EMAIL="a@x")
+        subprocess.run(["git", *args], cwd=d, check=True, capture_output=True, env=e)
+    git("init", "-q")
+    os.makedirs(os.path.join(d, "vendor"))
+    files = {
+        "app.py": "def tracked(a, b):\n    if a:\n        return b\n    return a\n",
+        "vendor/lib.py": "def vendored():\n    return 1\n",
+        "notes.md": "def not_code():\n    pass\n",
+        "page.js": "function scripted(a) {\n  if (a) { return 1; }\n  return 0;\n}\n",
+        "run.sh": "shelled() {\n  if [ -n \"$1\" ]; then echo hi; fi\n}\n",
+        "sim.f90": "subroutine fortran_sub(x)\n  integer :: x\n  if (x > 0) then\n    x = 1\n  end if\nend subroutine\n",
+    }
+    files.update(extra)
+    for name, text in files.items():
+        with open(os.path.join(d, name), "w") as fh:
+            fh.write(text)
+    git("add", "-A")
+    git("commit", "-q", "-m", "one")
+    with open(os.path.join(d, "untracked.py"), "w") as fh:
+        fh.write("def untracked():\n    return 2\n")
+
+
+def run(d, *args):
+    out = os.path.join(d, "out")
+    os.makedirs(out, exist_ok=True)
+    rc = functions.main([d, out, "--procs", "1", *args])
+    with open(os.path.join(out, "functions.csv")) as fh:
+        csv = fh.read()
+    return rc, csv, sorted(os.listdir(out))
+
+
+class FunctionsScript(unittest.TestCase):
+    def test_measures_tracked_files_lizard_can_read(self):
+        with tempfile.TemporaryDirectory() as d:
+            make_repo(d)
+            rc, csv, written = run(d, "--ignore", "vendor/**")
+        self.assertEqual(rc, 0)
+        self.assertIn('"tracked"', csv)
+        self.assertIn('"fortran_sub"', csv, "every language lizard knows, not only gitmole's default code list")
+        self.assertNotIn("untracked", csv, "not tracked by git")
+        self.assertNotIn("vendored", csv, "--ignore applies")
+        self.assertNotIn("not_code", csv, "markdown is not code")
+        self.assertNotIn("shelled", csv, "no lizard reader for shell: no guessing with the C-like fallback")
+        self.assertEqual(written, ["functions.csv"], "duplicates are jscpd's step, not lizard's")
+
+    def test_a_huge_nested_name_is_cut_before_it_is_written(self):
+        from types import SimpleNamespace
+        name = ".".join("a" for _ in range(100_000))
+        fn = SimpleNamespace(nloc=5, cyclomatic_complexity=3, token_count=40, parameter_count=1, length=5, name=name,
+                             long_name=name + "( )", start_line=1, end_line=5)
+        row = functions.csv_row(SimpleNamespace(filename="a.py"), fn)
+        self.assertEqual(len(row[7]), functions.NAME_CAP)
+        self.assertTrue(row[7].endswith("…"))
+        self.assertLessEqual(len(row[8]), functions.LONG_NAME_CAP)
+        self.assertLessEqual(len(row[5]), functions.NAME_CAP + len("@1-5@a.py"))
+
+    def test_csv_is_lizards_own_layout_then_the_label_and_suspect_columns(self):
+        with tempfile.TemporaryDirectory() as d:
+            make_repo(d)
+            rc, csv, _ = run(d, "--types", "py", "--ignore", "vendor/**")
+        self.assertEqual(csv, '4,2,14,2,4,"tracked@1-4@app.py","app.py","tracked","tracked( a , b )",1,4,"",""\n')
+
+    def test_a_nameless_function_is_labelled_by_its_start_line(self):
+        route = 'app.post("/api/actions/:id/assign", async (req, res) => {\n  if (!req.params.id) { return res.status(400).send(); }\n  res.send(req.params.id);\n});\n'
+        literal = "package main\n\nfunc main() {\n\tf := func(x int) int {\n\t\tif x > 0 {\n\t\t\treturn 1\n\t\t}\n\t\treturn 0\n\t}\n\t_ = f\n}\n"
+        with tempfile.TemporaryDirectory() as d:
+            make_repo(d, extra={"routes.js": route, "lit.go": literal})
+            rc, csv, _ = run(d, "--types", "js,go")
+        self.assertIn('"(anonymous)","(anonymous)",1,4,"app.post(""/api/actions/:id/assign"", async (req, res) => {",""', csv)
+        self.assertIn('""," x int",4,9,"f := func(x int) int {",""', csv, "a Go literal has an empty name and the same kind of label")
+        self.assertIn('"main","main",3,11,"",""', csv, "a named function needs no label")
+
+    def test_the_label_is_the_nearest_line_that_opens_a_function_when_lizard_is_a_line_off(self):
+        # 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: the label looks a line back and a few lines on for the `=>`
+        src = ("const xs = items.filter((m) =>\n  prev.includes(m)\n);\n"
+               "function A() {\n  return (\n    <Input\n      onChange={(e) => {\n        set(e.target.value);\n      }}\n    />\n  );\n}\n")
+        with tempfile.TemporaryDirectory() as d:
+            make_repo(d, extra={"near.tsx": src})
+            rc, csv, _ = run(d, "--types", "tsx")
+        self.assertIn('"(anonymous)","(anonymous)",2,2,"const xs = items.filter((m) =>",""', csv)
+        self.assertIn('"(anonymous)","(anonymous)",6,8,"onChange={(e) => {",""', csv)
+
+    def test_a_span_that_swallows_a_sibling_is_marked_suspect(self):
+        # lizard loses its place in a template literal and folds the next function into `tpl`
+        src = ("const tpl = (name) => `\n<html>\n  <body>\n    ${name ? `<h1>${name}</h1>` : \"\"}\n  </body>\n</html>`;\n\n"
+               "function after(a) {\n  if (a) { return 1; }\n  return 0;\n}\n")
+        with tempfile.TemporaryDirectory() as d:
+            make_repo(d, extra={"tpl.js": src})
+            rc, csv, _ = run(d, "--types", "js")
+        self.assertNotIn('"after"', csv, "the fixture only holds if lizard still swallows the sibling")
+        self.assertIn('"tpl","tpl ( name )",1,9,"","opens a block at line 8 no deeper than its own start"', csv)
+        self.assertIn('"scripted","scripted ( a )",1,4,"",""', csv, "a closing line is not a sibling")
+
+    def test_a_signature_that_closes_its_parameter_list_on_a_later_line_is_not_a_sibling(self):
+        src = ("function Panel({\n  title,\n  onClose,\n}: PanelProps) {\n  if (!title) { return null; }\n  return onClose;\n}\n"
+               "class Store {\n  async summary(filters?: {\n    siteId?: string;\n  }): Promise<any> {\n    if (filters) { return 1; }\n    return 0;\n  }\n}\n")
+        with tempfile.TemporaryDirectory() as d:
+            make_repo(d, extra={"sig.ts": src})
+            rc, csv, _ = run(d, "--types", "ts")
+        self.assertIn('"Panel","Panel ( title , onClose , PanelProps )",1,7,"",""', csv)
+        self.assertIn('"summary","summary ( filters siteId )",9,14,"",""', csv)
+
+    def test_a_c_function_with_its_brace_on_its_own_line_and_a_goto_label_is_not_a_sibling(self):
+        # curl's style: the body brace alone at column 0, labels at column 0
+        src = "static int opt_bool(int a)\n{\n  if(a) {\n    return 1;\n  }\nout:\n  return 0;\n}\n"
+        with tempfile.TemporaryDirectory() as d:
+            make_repo(d, extra={"tool.c": src})
+            rc, csv, _ = run(d, "--types", "c")
+        self.assertIn('"opt_bool","opt_bool( int a)",1,8,"",""', csv)
+
+    def test_jsx_children_on_their_own_lines_do_not_shift_the_line_numbers(self):
+        # lizard 1.24 merges the newline before a JSX child with its indentation into one whitespace token,
+        # and its preprocessing drops whitespace tokens other than a bare newline: one line lost per child
+        src = ('function A() {\n  return (\n    <div className="grid">\n      <div className="lg">\n      </div>\n'
+               '        <Skeleton className="h-48" />\n    </div>\n  );\n}\nfunction B() {\n  return 1;\n}\n')
+        with tempfile.TemporaryDirectory() as d:
+            make_repo(d, extra={"page.tsx": src})
+            rc, csv, _ = run(d, "--types", "tsx")
+        self.assertIn('"B","B ( )",10,12,"",""', csv)
+        self.assertIn('"A","A ( )",1,9,"",""', csv)
+
+    def test_a_nameless_span_where_nothing_opens_a_function_is_marked_suspect(self):
+        # lizard reports a JSX ternary as a function: all code, all deeper than its start, so only the
+        # missing `=>` or `function` near its start line gives it away
+        src = "function A() {\n  return (\n    <div>\n      {isLoading ? (\n        <p>x</p>\n      ) : (\n        <p>y</p>\n      )}\n    </div>\n  );\n}\n"
+        with tempfile.TemporaryDirectory() as d:
+            make_repo(d, extra={"ternary.tsx": src})
+            rc, csv, _ = run(d, "--types", "tsx")
+        self.assertIn('"(anonymous)","(anonymous) ( x )",4,8,"{isLoading ? (","nothing opens a function within 5 lines of line 4"', csv)
+        self.assertIn('"A","A ( )",1,11,"",""', csv)
+
+    def test_a_long_span_that_is_mostly_not_code_is_marked_suspect(self):
+        body = "".join(f"  // note {i}\n" for i in range(40))
+        src = "function sparse(a) {\n" + body + "  if (a) { return 1; }\n  return 0;\n}\n"
+        with tempfile.TemporaryDirectory() as d:
+            make_repo(d, extra={"sparse.js": src})
+            rc, csv, _ = run(d, "--types", "js")
+        self.assertIn('"sparse","sparse ( a )",1,44,"","4 of 44 lines are code"', csv)
+
+    def test_file_types_restrict_what_is_measured(self):
+        with tempfile.TemporaryDirectory() as d:
+            make_repo(d)
+            rc, csv, _ = run(d, "--types", "js")
+        self.assertEqual(rc, 0)
+        self.assertIn("scripted", csv)
+        self.assertNotIn("tracked", csv)
+        self.assertNotIn("fortran", csv)
+
+    def test_no_code_files_still_writes_an_empty_csv(self):
+        with tempfile.TemporaryDirectory() as d:
+            make_repo(d)
+            rc, csv, _ = run(d, "--ignore", "*.py", "--ignore", "*.js", "--ignore", "*.f90")
+        self.assertEqual(rc, 0)
+        self.assertEqual(csv, "")
+
+    def test_a_lizard_module_in_the_analysed_repo_is_data_not_code_to_run(self):
+        bomb = "import sys\nsys.stderr.write('REPO LIZARD RAN')\nsys.exit(7)\n"
+        with tempfile.TemporaryDirectory() as d:
+            make_repo(d, extra={"lizard.py": bomb, "lizard_ext/__init__.py": bomb} if False else {"lizard.py": bomb})
+            rc, csv, _ = run(d, "--types", "py", "--ignore", "vendor/**")
+        self.assertEqual(rc, 0)
+        self.assertIn('"tracked"', csv)
+        self.assertNotIn("REPO LIZARD RAN", csv)
+
+    def test_a_file_lizard_cannot_read_does_not_stop_the_files_after_it(self):
+        with tempfile.TemporaryDirectory() as d:
+            make_repo(d, extra={"b_gone.py": "def gone():\n    return 3\n", "c_after.py": "def after(a):\n    return a\n"})
+            os.remove(os.path.join(d, "b_gone.py"))   # still in the index, no longer on disk
+            rc, csv, _ = run(d, "--types", "py", "--ignore", "vendor/**")
+        self.assertEqual(rc, 0)
+        self.assertIn('"after"', csv, "files after the unreadable one are still measured")
+
+
+if __name__ == "__main__":
+    unittest.main()

{gitmole-0.7.1 → gitmole-0.7.2}/tests/test_load.py

@@ -131,7 +131,8 @@ class ParseFunctions(unittest.TestCase):
 
     def test_rows_with_clean_paths(self):
         rows = load.parse_functions(self.CSV)
-        self.assertEqual(rows[0], {"file": "gitmole/findings.py", "function": "_f", "ccn": 1, "nloc": 2, "params": 3, "start": 14, "end": 15})
+        self.assertEqual(rows[0], {"file": "gitmole/findings.py", "function": "_f", "anonymous": False, "ccn": 1, "nloc": 2, "params": 3,
+                                   "start": 14, "end": 15, "suspect": ""})
         self.assertEqual(rows[1]["file"], "src/parser.py")
         self.assertEqual((rows[1]["ccn"], rows[1]["nloc"], rows[1]["params"]), (41, 120, 9))
 
@@ -154,7 +155,18 @@ class ParseFunctions(unittest.TestCase):
     def test_a_nameless_function_is_called_anonymous(self):
         # lizard names Go function literals with an empty string where it names JavaScript's "(anonymous)"
         rows = load.parse_functions('136,47,926,1,270,"@316-585@completions.go","completions.go",""," c * Command",316,585\n')
-        self.assertEqual((rows[0]["function"], rows[0]["start"]), ("(anonymous)", 316))
+        self.assertEqual((rows[0]["function"], rows[0]["start"], rows[0]["anonymous"], rows[0]["suspect"]), ("(anonymous)", 316, True, ""))
+
+    def test_a_nameless_function_goes_by_its_label_and_stays_marked_anonymous(self):
+        rows = load.parse_functions('136,47,926,1,270,"@316-585@completions.go","completions.go",""," c * Command",316,585,"Run: func(c *Command) {",""\n'
+                                    '4,2,36,0,4,"(anonymous)@1-4@routes.js","routes.js","(anonymous)","(anonymous)",1,4,"app.post(""/api/x"", async (req, res) => {",""\n'
+                                    '4,2,14,2,4,"tracked@1-4@app.py","app.py","tracked","tracked( a , b )",1,4,"",""\n')
+        self.assertEqual([(r["function"], r["anonymous"]) for r in rows],
+                         [("Run: func(c *Command) {", True), ('app.post("/api/x", async (req, res) => {', True), ("tracked", False)])
+
+    def test_a_suspect_span_carries_its_reason(self):
+        rows = load.parse_functions('9,1,21,1,9,"tpl@1-9@tpl.js","tpl.js","tpl","tpl ( name )",1,9,"","opens a block at line 8 no deeper than its own start"\n')
+        self.assertEqual(rows[0]["suspect"], "opens a block at line 8 no deeper than its own start")
 
     def test_a_row_cut_short_by_a_killed_step_does_not_abort_the_report(self):
         rows = load.parse_functions(self.CSV + '5,3,40,1,5,"g@1-5@a.py","a.py","g","g( )",1,\n')

{gitmole-0.7.1 → gitmole-0.7.2}/tests/test_render.py

@@ -341,6 +341,25 @@ 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_a_nameless_function_shows_its_label_and_its_file_with_the_line(self):
+        r = sample_report()
+        r["functions"].append({"file": "server/routes.ts", "function": 'app.post("/api/x", async (req, res) => {', "anonymous": True,
+                               "ccn": 25, "nloc": 60, "params": 0, "start": 1162, "end": 1240, "suspect": ""})
+        fn = _section_text(rendered(r, [], width=200), "Complex functions")
+        self.assertIn('app.post("/api/x", async (req, res) => {', fn)
+        self.assertIn("server/routes.ts:1162", fn)
+        self.assertNotIn("static/js/app.js:", fn, "a named function is found by its name; the row shows the file alone")
+
+    def test_a_suspect_span_is_marked_and_the_caption_says_what_the_mark_means(self):
+        r = sample_report()
+        r["functions"].append({"file": "lib/tpl.js", "function": "tpl", "anonymous": False, "ccn": 30, "nloc": 9, "params": 1, "start": 1, "end": 9,
+                               "suspect": "opens a block at line 8 no deeper than its own start"})
+        fn = _section_text(rendered(r, [], width=200), "Complex functions")
+        self.assertIn("30?", fn)
+        self.assertIn("? marks 1 span lizard may have mis-parsed", fn)
+        plain = _section_text(rendered(sample_report(), [], width=200), "Complex functions")
+        self.assertNotIn("?", plain)
+
     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})

{gitmole-0.7.1 → gitmole-0.7.2}/tests/test_watch.py

@@ -47,6 +47,16 @@ class Risks(unittest.TestCase):
         self.assertEqual(by["core/util.py"]["reasons"], ["changed 30 times", "fixed twice", "Ann wrote 95% of it"])
         self.assertEqual(by["web/index.html"]["reasons"], ["changed 60 times"])
 
+    def test_a_nameless_function_is_named_by_its_line_and_a_suspect_span_is_passed_over(self):
+        r = report()
+        r["functions"] = [{"file": "core/parser.py", "function": 'app.post("/api/x", async (req, res) => {', "anonymous": True,
+                           "ccn": 125, "nloc": 500, "params": 0, "start": 1162, "end": 1891, "suspect": "opens a block at line 1214 no deeper than its own start"},
+                          {"file": "core/parser.py", "function": 'router.get("/x", (req, res) => {', "anonymous": True,
+                           "ccn": 41, "nloc": 220, "params": 0, "start": 10, "end": 300, "suspect": ""}]
+        top = watch.risks(r)[0]
+        self.assertIn("the function at line 10 complexity 41", top["reasons"], "a label is not a name to put () after; a suspect span is not this file's complexity")
+        self.assertNotIn("complexity 125", " ".join(top["reasons"]))
+
     def test_leaves_out_tests_deleted_files_and_one_offs(self):
         files = [r["file"] for r in watch.risks(report())]
         self.assertNotIn("tests/test_parser.py", files)

gitmole-0.7.1/gitmole/functions.py

@@ -1,90 +0,0 @@
-#!/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] + "…"
-
-
-def csv_row(info, fn) -> list:
-    """The columns `lizard --csv` prints, so the loader does not care which produced the file. Names
-    are cut to what a table can show, so one pathological fixture cannot make the file unreadable."""
-    name = _cut(fn.name, NAME_CAP)
-    return [fn.nloc, fn.cyclomatic_complexity, fn.token_count, fn.parameter_count, fn.length,
-            f"{name}@{fn.start_line}-{fn.end_line}@{info.filename}", info.filename, name, _cut(fn.long_name, LONG_NAME_CAP), fn.start_line, fn.end_line]
-
-
-def 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 = lizard.get_extensions([])   # lizard's metric 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):
-                    for fn in info.function_list:
-                        writer.writerow(csv_row(info, fn))
-                    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.1/tests/test_functions.py

@@ -1,109 +0,0 @@
-import os
-import subprocess
-import tempfile
-import unittest
-
-from gitmole import functions
-
-
-def make_repo(d, extra=()):
-    def git(*args):
-        e = dict(os.environ, GIT_CONFIG_GLOBAL="/dev/null", GIT_CONFIG_SYSTEM="/dev/null",
-                 GIT_AUTHOR_NAME="Ann", GIT_AUTHOR_EMAIL="a@x", GIT_COMMITTER_NAME="Ann", GIT_COMMITTER_EMAIL="a@x")
-        subprocess.run(["git", *args], cwd=d, check=True, capture_output=True, env=e)
-    git("init", "-q")
-    os.makedirs(os.path.join(d, "vendor"))
-    files = {
-        "app.py": "def tracked(a, b):\n    if a:\n        return b\n    return a\n",
-        "vendor/lib.py": "def vendored():\n    return 1\n",
-        "notes.md": "def not_code():\n    pass\n",
-        "page.js": "function scripted(a) {\n  if (a) { return 1; }\n  return 0;\n}\n",
-        "run.sh": "shelled() {\n  if [ -n \"$1\" ]; then echo hi; fi\n}\n",
-        "sim.f90": "subroutine fortran_sub(x)\n  integer :: x\n  if (x > 0) then\n    x = 1\n  end if\nend subroutine\n",
-    }
-    files.update(extra)
-    for name, text in files.items():
-        with open(os.path.join(d, name), "w") as fh:
-            fh.write(text)
-    git("add", "-A")
-    git("commit", "-q", "-m", "one")
-    with open(os.path.join(d, "untracked.py"), "w") as fh:
-        fh.write("def untracked():\n    return 2\n")
-
-
-def run(d, *args):
-    out = os.path.join(d, "out")
-    os.makedirs(out, exist_ok=True)
-    rc = functions.main([d, out, "--procs", "1", *args])
-    with open(os.path.join(out, "functions.csv")) as fh:
-        csv = fh.read()
-    return rc, csv, sorted(os.listdir(out))
-
-
-class FunctionsScript(unittest.TestCase):
-    def test_measures_tracked_files_lizard_can_read(self):
-        with tempfile.TemporaryDirectory() as d:
-            make_repo(d)
-            rc, csv, written = run(d, "--ignore", "vendor/**")
-        self.assertEqual(rc, 0)
-        self.assertIn('"tracked"', csv)
-        self.assertIn('"fortran_sub"', csv, "every language lizard knows, not only gitmole's default code list")
-        self.assertNotIn("untracked", csv, "not tracked by git")
-        self.assertNotIn("vendored", csv, "--ignore applies")
-        self.assertNotIn("not_code", csv, "markdown is not code")
-        self.assertNotIn("shelled", csv, "no lizard reader for shell: no guessing with the C-like fallback")
-        self.assertEqual(written, ["functions.csv"], "duplicates are jscpd's step, not lizard's")
-
-    def test_a_huge_nested_name_is_cut_before_it_is_written(self):
-        from types import SimpleNamespace
-        name = ".".join("a" for _ in range(100_000))
-        fn = SimpleNamespace(nloc=5, cyclomatic_complexity=3, token_count=40, parameter_count=1, length=5, name=name,
-                             long_name=name + "( )", start_line=1, end_line=5)
-        row = functions.csv_row(SimpleNamespace(filename="a.py"), fn)
-        self.assertEqual(len(row[7]), functions.NAME_CAP)
-        self.assertTrue(row[7].endswith("…"))
-        self.assertLessEqual(len(row[8]), functions.LONG_NAME_CAP)
-        self.assertLessEqual(len(row[5]), functions.NAME_CAP + len("@1-5@a.py"))
-
-    def test_csv_matches_lizards_own_layout(self):
-        with tempfile.TemporaryDirectory() as d:
-            make_repo(d)
-            rc, csv, _ = run(d, "--types", "py", "--ignore", "vendor/**")
-        self.assertEqual(csv, '4,2,14,2,4,"tracked@1-4@app.py","app.py","tracked","tracked( a , b )",1,4\n')
-
-    def test_file_types_restrict_what_is_measured(self):
-        with tempfile.TemporaryDirectory() as d:
-            make_repo(d)
-            rc, csv, _ = run(d, "--types", "js")
-        self.assertEqual(rc, 0)
-        self.assertIn("scripted", csv)
-        self.assertNotIn("tracked", csv)
-        self.assertNotIn("fortran", csv)
-
-    def test_no_code_files_still_writes_an_empty_csv(self):
-        with tempfile.TemporaryDirectory() as d:
-            make_repo(d)
-            rc, csv, _ = run(d, "--ignore", "*.py", "--ignore", "*.js", "--ignore", "*.f90")
-        self.assertEqual(rc, 0)
-        self.assertEqual(csv, "")
-
-    def test_a_lizard_module_in_the_analysed_repo_is_data_not_code_to_run(self):
-        bomb = "import sys\nsys.stderr.write('REPO LIZARD RAN')\nsys.exit(7)\n"
-        with tempfile.TemporaryDirectory() as d:
-            make_repo(d, extra={"lizard.py": bomb, "lizard_ext/__init__.py": bomb} if False else {"lizard.py": bomb})
-            rc, csv, _ = run(d, "--types", "py", "--ignore", "vendor/**")
-        self.assertEqual(rc, 0)
-        self.assertIn('"tracked"', csv)
-        self.assertNotIn("REPO LIZARD RAN", csv)
-
-    def test_a_file_lizard_cannot_read_does_not_stop_the_files_after_it(self):
-        with tempfile.TemporaryDirectory() as d:
-            make_repo(d, extra={"b_gone.py": "def gone():\n    return 3\n", "c_after.py": "def after(a):\n    return a\n"})
-            os.remove(os.path.join(d, "b_gone.py"))   # still in the index, no longer on disk
-            rc, csv, _ = run(d, "--types", "py", "--ignore", "vendor/**")
-        self.assertEqual(rc, 0)
-        self.assertIn('"after"', csv, "files after the unreadable one are still measured")
-
-
-if __name__ == "__main__":
-    unittest.main()