gitmole 0.6.0__tar.gz → 0.6.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitmole
-Version: 0.6.0
+Version: 0.6.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
@@ -63,6 +63,7 @@ gitmole . --json report.json           # every table, the watch list and the fin
 gitmole . --fail-on warning            # exit 3 if any finding is a warning or worse
 gitmole . --risk main --risk-threshold 5   # exit 3 if the files changed since main are too risky
 gitmole . --since 2y --full            # the current team, every row and column
+gitmole --clean                        # list what gitmole left behind, delete on a yes
 ```
 
 A CI job that runs `gitmole . --fail-on critical --markdown - >> "$GITHUB_STEP_SUMMARY"`
@@ -144,8 +145,10 @@ Why these and not others: [docs/tools.md](https://github.com/antvinni/gitmole/bl
 
 - Everything is offline except the optional clone step, which uses your
   existing gh auth. None of the tools send data anywhere.
-- Remote targets are cloned into a fresh temp directory. Local clones are
-  only read, but the log export and the secrets scan touch all branches.
+- Remote targets are cloned into a fresh temp directory that is removed when
+  the run ends. Local clones are only read, but the log export and the
+  secrets scan touch all branches. `gitmole --clean` lists every directory
+  gitmole created and deletes them after a y/N question.
 - Secret values never reach the output directory. betterleaks reports to
   gitmole in memory, and gitmole stores a short keyed hash in place of the
   value, the matched text and the commit message. The key is random, made

{gitmole-0.6.0 → gitmole-0.6.2}/README.md

@@ -43,6 +43,7 @@ gitmole . --json report.json           # every table, the watch list and the fin
 gitmole . --fail-on warning            # exit 3 if any finding is a warning or worse
 gitmole . --risk main --risk-threshold 5   # exit 3 if the files changed since main are too risky
 gitmole . --since 2y --full            # the current team, every row and column
+gitmole --clean                        # list what gitmole left behind, delete on a yes
 ```
 
 A CI job that runs `gitmole . --fail-on critical --markdown - >> "$GITHUB_STEP_SUMMARY"`
@@ -124,8 +125,10 @@ Why these and not others: [docs/tools.md](https://github.com/antvinni/gitmole/bl
 
 - Everything is offline except the optional clone step, which uses your
   existing gh auth. None of the tools send data anywhere.
-- Remote targets are cloned into a fresh temp directory. Local clones are
-  only read, but the log export and the secrets scan touch all branches.
+- Remote targets are cloned into a fresh temp directory that is removed when
+  the run ends. Local clones are only read, but the log export and the
+  secrets scan touch all branches. `gitmole --clean` lists every directory
+  gitmole created and deletes them after a y/N question.
 - Secret values never reach the output directory. betterleaks reports to
   gitmole in memory, and gitmole stores a short keyed hash in place of the
   value, the matched text and the commit message. The key is random, made

{gitmole-0.6.0 → gitmole-0.6.2}/gitmole/__init__.py

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

gitmole-0.6.2/gitmole/clean.py

@@ -0,0 +1,90 @@
+"""What gitmole leaves behind, found by looking: temp clones in the temp folder and analysis-* output
+directories under a base. Pure functions; the CLI prints, asks and reports."""
+from __future__ import annotations
+
+import glob
+import os
+import shutil
+import tempfile
+
+from . import run
+
+TEMP_PREFIX = "gitmole-"      # tempfile.mkdtemp(prefix=...) in cli._resolve_target and cli._portfolio
+OUT_PREFIX = "analysis-"      # run.output_dir and cli._portfolio
+
+
+def temp_dir() -> str:
+    """Where the temp clones went: mkdtemp(dir=os.environ.get("TMPDIR")) resolves the same way."""
+    return os.environ.get("TMPDIR") or tempfile.gettempdir()
+
+
+def _is_output(path: str) -> bool:
+    return os.path.isdir(path) and os.path.isfile(os.path.join(path, "meta.json"))
+
+
+def _whole_portfolio(path: str) -> bool:
+    """A portfolio parent is gitmole's as a whole when every directory in it is a repo output and every
+    other entry is a portfolio.* export or a dotfile."""
+    names = os.listdir(path)
+    dirs = [n for n in names if os.path.isdir(os.path.join(path, n))]
+    rest = [n for n in names if n not in dirs and not n.startswith(".")]
+    return bool(dirs) and all(_is_output(os.path.join(path, n)) for n in dirs) and all(n.startswith("portfolio.") for n in rest)
+
+
+def _outputs(base: str) -> list:
+    candidates = sorted(glob.glob(os.path.join(base, OUT_PREFIX + "*")))
+    if os.path.isdir(os.path.join(base, ".git")):
+        candidates.append(run.output_dir("path", base, None))
+    found = []
+    for path in candidates:
+        if not os.path.isdir(path):
+            continue
+        if _is_output(path) or _whole_portfolio(path):
+            found.append(path)
+        else:
+            found += [c for c in sorted(glob.glob(os.path.join(path, "*"))) if _is_output(c)]
+    return sorted(set(found))
+
+
+def _clones(tmp: str) -> list:
+    paths = [p for p in glob.glob(os.path.join(tmp, TEMP_PREFIX + "*")) if os.path.isdir(p)]
+    return sorted(paths, key=lambda p: (os.path.getmtime(p), p))
+
+
+def tree_size(path: str) -> int:
+    total = 0
+    for root, _dirs, files in os.walk(path):
+        for name in files:
+            try:
+                total += os.lstat(os.path.join(root, name)).st_size
+            except OSError:
+                pass
+    return total
+
+
+def find(base: str, tmp: str) -> list:
+    """(path, bytes, mtime) for every directory gitmole left behind: temp clones oldest first, then
+    output directories under base sorted by path."""
+    paths = _clones(tmp) + _outputs(os.path.abspath(base))
+    return [(p, tree_size(p), os.path.getmtime(p)) for p in paths]
+
+
+def human(n) -> str:
+    units = ["B", "kB", "MB", "GB", "TB"]
+    x, i = float(n), 0
+    while x >= 1000 and i < len(units) - 1:
+        x /= 1000
+        i += 1
+    if i == 0:
+        return f"{int(x)} B"
+    return f"{x:.1f} {units[i]}" if x < 10 else f"{x:.0f} {units[i]}"
+
+
+def remove(paths: list) -> list:
+    """rmtree each path, best effort; returns the ones still present afterwards."""
+    failed = []
+    for p in paths:
+        shutil.rmtree(p, ignore_errors=True)
+        if os.path.exists(p):
+            failed.append(p)
+    return failed

{gitmole-0.6.0 → gitmole-0.6.2}/gitmole/cli.py

@@ -1,8 +1,9 @@
-"""Command line entry point: gitmole <path | owner/repo | url> [--out DIR] [--no-run]."""
+"""Command line entry point: gitmole <path | owner/repo | url> [--out DIR] [--no-run], or gitmole --clean [DIR]."""
 from __future__ import annotations
 
 import argparse
 import os
+import shutil
 import signal
 import sys
 import tempfile
@@ -19,7 +20,7 @@ from . import __version__, banner, filetypes, findings, load, loss, run
 
 def parse_args(argv):
     p = argparse.ArgumentParser(prog="gitmole", description="Analyse a git repository offline and print a report.")
-    p.add_argument("target", help="local clone path, owner/repo, or git URL")
+    p.add_argument("target", nargs="?", help="local clone path, owner/repo, or git URL; with --clean, the directory to look in (default .)")
     p.add_argument("--out", help="output directory (default: analysis-<repo> next to the clone, or in cwd for remote targets)")
     p.add_argument("--no-run", action="store_true", help="skip the tools; re-render the report from an existing output directory")
     p.add_argument("--workers", type=int, default=6, help="how many tools to run at once")
@@ -34,6 +35,8 @@ def parse_args(argv):
     p.add_argument("--gone", type=int, default=loss.DEFAULT_MONTHS, metavar="MONTHS", help="a person with no commits this many months before the last commit counts as gone (default 12)")
     p.add_argument("--file-types", metavar="LIST", help="comma-separated extensions to treat as code (default: a built-in source list), or 'all'")
     p.add_argument("--list-file-types", action="store_true", help="list the file types in the repository, with counts and whether they count as code, then exit")
+    p.add_argument("--clean", action="store_true", help="list the directories gitmole created (temp clones, analysis-* under the target) and delete them after a y/N question, then exit")
+    p.add_argument("--yes", action="store_true", help="with --clean: delete without asking")
     p.add_argument("--duplicates", action="store_true", help="also look for duplicated code blocks (minutes and gigabytes on a large repo; function metrics alone take seconds)")
     p.add_argument("--full", action="store_true", help="every column and every row in the terminal report, and the test files the default tables hide (the default is the tighter, readable one)")
     p.add_argument("--json", metavar="PATH", help="write the report and findings as JSON to PATH, or - for stdout")
@@ -54,7 +57,7 @@ def interrupt(*_):
 
 
 def main(argv=None, console: Console = None, tool_check=run.missing_tools, planner=run.plan, estimator=run.estimate_blames,
-         lister=run.list_repos, cloner=run.clone, lizard_check=run.has_lizard) -> int:
+         lister=run.list_repos, cloner=run.clone, lizard_check=run.has_lizard, ask=None) -> int:
     global _control
     _control = run.Control()
     if threading.current_thread() is threading.main_thread():
@@ -65,6 +68,8 @@ def main(argv=None, console: Console = None, tool_check=run.missing_tools, plann
     rc = _check_args(args, err)
     if rc is not None:
         return rc
+    if args.clean:
+        return _clean(args, console, ask or (lambda q: console.input(q, markup=False)))
     # When an export goes to stdout, everything else (banner, progress, report) moves to stderr.
     quiet = "-" in (args.json, args.markdown)
     ui = Console(stderr=True) if quiet else console
@@ -110,6 +115,9 @@ def main(argv=None, console: Console = None, tool_check=run.missing_tools, plann
     except NoCommits as e:
         err.print(f"[red]{e}[/red]")
         return 2
+    finally:
+        if kind == "remote":
+            shutil.rmtree(os.path.dirname(repo_dir), ignore_errors=True)   # the temp clone; nothing reads it after the run
     return _render(out_dir, console, ui, args, err)
 
 
@@ -117,7 +125,9 @@ def _check_args(args, err, kind=None) -> int | None:
     """The argument combinations that cannot work, in one place: 2 and a message, or None. Called
     once on the arguments alone, then again with the target's `kind` for the checks that need it."""
     if kind is None:
-        bad = "--risk-threshold needs --risk" if args.risk_threshold is not None and not args.risk else None
+        bad = ("--yes needs --clean" if args.yes and not args.clean else
+               "target required" if args.target is None and not args.clean else
+               "--risk-threshold needs --risk" if args.risk_threshold is not None and not args.risk else None)
     elif kind == "path":
         bad = None
     else:
@@ -165,6 +175,43 @@ def _no_run(args, console, ui, err) -> int:
     return _render(out_dir, console, ui, args, err)
 
 
+def _clean(args, console: Console, ask) -> int:
+    """Handle --clean: list what gitmole left behind, ask once, remove. ask(prompt) returns the answer."""
+    from . import clean, render
+
+    found = clean.find(args.target or ".", clean.temp_dir())
+    if not found:
+        console.print("nothing to clean")
+        return 0
+    total = sum(size for _, size, _ in found)
+    rows = [(path, clean.human(size), time.strftime("%Y-%m-%d", time.localtime(mtime))) for path, size, mtime in found]
+    sec = render._section("Left behind", [("directory", render.PATH), ("size", render.RIGHT), ("modified", {})], rows,
+                          caption=f"{_dirs(len(found))}, {clean.human(total)} in all")
+    render.print_section(console, sec)
+    console.print(Text(""))
+    if not args.yes:
+        if not console.is_terminal:
+            console.print("[red]--clean needs a terminal to confirm;[/red] pass --yes to skip the question")
+            return 2
+        try:
+            answer = ask(f"Delete {_dirs(len(found))} ({clean.human(total)})? [y/N] ")
+        except EOFError:
+            answer = ""
+        if answer.strip().lower() not in ("y", "yes"):
+            console.print("kept")
+            return 0
+    failed = clean.remove([p for p, _, _ in found])
+    removed = [(p, size) for p, size, _ in found if p not in failed]
+    console.print(f"removed {_dirs(len(removed))} ({clean.human(sum(s for _, s in removed))})")
+    for p in failed:
+        console.print(f"[red]could not remove[/red] {p}", soft_wrap=True)
+    return 1 if failed else 0
+
+
+def _dirs(n: int) -> str:
+    return f"{n} director{'y' if n == 1 else 'ies'}"
+
+
 def _resolve_target(kind, target, args, console, ui, err, planner, estimator, lister, cloner):
     """Resolve the classified target to (repo_dir, out_dir) for _analyse, or a final return code for the
     org and clone-failure paths. Returns (rc, repo_dir, out_dir); rc is None unless main should return early."""
@@ -177,6 +224,7 @@ def _resolve_target(kind, target, args, console, ui, err, planner, estimator, li
         try:
             repo_dir = cloner(target, parent)
         except run.GhError as e:
+            shutil.rmtree(parent, ignore_errors=True)
             err.print(f"[red]could not clone {target}:[/red] {e}", soft_wrap=True)
             return 2, None, None
     else:
@@ -325,23 +373,26 @@ def _portfolio(owner: str, args, console: Console, ui: Console, planner, estimat
         return 2
     parent = tempfile.mkdtemp(prefix="gitmole-", dir=os.environ.get("TMPDIR"))
     reports = []
-    for i, name in enumerate(repos, 1):
-        ui.print(f"[bold]{name}[/bold] [dim]({i}/{len(repos)})[/dim]")
-        try:
-            repo_dir = cloner(f"{owner}/{name}", parent)
-        except run.GhError as e:
-            ui.print(f"[red]could not clone {owner}/{name}:[/red] {e}", soft_wrap=True)
-            continue
-        out_dir = os.path.join(base, name)
-        try:
-            _analyse(repo_dir, out_dir, args, ui, planner, estimator)
-        except Interrupted:
-            return 130
-        except NoCommits as e:
-            ui.print(f"[yellow]{name}:[/yellow] {e}; skipped")
-            continue
-        report = load.load_report(out_dir)
-        reports.append((name, report, findings.evaluate(report)))
+    try:
+        for i, name in enumerate(repos, 1):
+            ui.print(f"[bold]{name}[/bold] [dim]({i}/{len(repos)})[/dim]")
+            try:
+                repo_dir = cloner(f"{owner}/{name}", parent)
+            except run.GhError as e:
+                ui.print(f"[red]could not clone {owner}/{name}:[/red] {e}", soft_wrap=True)
+                continue
+            out_dir = os.path.join(base, name)
+            try:
+                _analyse(repo_dir, out_dir, args, ui, planner, estimator)
+            except Interrupted:
+                return 130
+            except NoCommits as e:
+                ui.print(f"[yellow]{name}:[/yellow] {e}; skipped")
+                continue
+            report = load.load_report(out_dir)
+            reports.append((name, report, findings.evaluate(report)))
+    finally:
+        shutil.rmtree(parent, ignore_errors=True)   # the temp clones; nothing reads them after the run
 
     def export_path(p):
         return p if p == "-" or os.path.isabs(p) else os.path.join(base, p)

{gitmole-0.6.0 → gitmole-0.6.2}/gitmole/run.py

@@ -37,6 +37,9 @@ _URL = re.compile(r"^(https?://|git@|ssh://)")
 
 def classify_target(target: str) -> tuple:
     if os.path.isdir(target):
+        probe = subprocess.run(["git", "-C", target, "rev-parse", "--git-dir"], capture_output=True, text=True)
+        if probe.returncode != 0:
+            raise ValueError(f"{target} is not a git repository; pass a clone, owner/repo or owner/*")
         return ("path", os.path.abspath(target))
     if _ORG.match(target):
         return ("org", target[:-2])

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitmole
-Version: 0.6.0
+Version: 0.6.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
@@ -63,6 +63,7 @@ gitmole . --json report.json           # every table, the watch list and the fin
 gitmole . --fail-on warning            # exit 3 if any finding is a warning or worse
 gitmole . --risk main --risk-threshold 5   # exit 3 if the files changed since main are too risky
 gitmole . --since 2y --full            # the current team, every row and column
+gitmole --clean                        # list what gitmole left behind, delete on a yes
 ```
 
 A CI job that runs `gitmole . --fail-on critical --markdown - >> "$GITHUB_STEP_SUMMARY"`
@@ -144,8 +145,10 @@ Why these and not others: [docs/tools.md](https://github.com/antvinni/gitmole/bl
 
 - Everything is offline except the optional clone step, which uses your
   existing gh auth. None of the tools send data anywhere.
-- Remote targets are cloned into a fresh temp directory. Local clones are
-  only read, but the log export and the secrets scan touch all branches.
+- Remote targets are cloned into a fresh temp directory that is removed when
+  the run ends. Local clones are only read, but the log export and the
+  secrets scan touch all branches. `gitmole --clean` lists every directory
+  gitmole created and deletes them after a y/N question.
 - Secret values never reach the output directory. betterleaks reports to
   gitmole in memory, and gitmole stores a short keyed hash in place of the
   value, the matched text and the commit message. The key is random, made

{gitmole-0.6.0 → gitmole-0.6.2}/gitmole.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ gitmole/__main__.py
 gitmole/backtest.py
 gitmole/banner.py
 gitmole/blame.py
+gitmole/clean.py
 gitmole/cli.py
 gitmole/filetypes.py
 gitmole/findings.py
@@ -31,6 +32,7 @@ gitmole.egg-info/top_level.txt
 tests/test_backtest.py
 tests/test_banner.py
 tests/test_blame.py
+tests/test_clean.py
 tests/test_cli.py
 tests/test_filetypes.py
 tests/test_findings.py

gitmole-0.6.2/tests/test_clean.py

@@ -0,0 +1,109 @@
+import os
+import subprocess
+import tempfile
+import unittest
+
+from gitmole import clean
+
+
+def _output(path):
+    os.makedirs(path, exist_ok=True)
+    with open(os.path.join(path, "meta.json"), "w") as fh:
+        fh.write("{}")
+    with open(os.path.join(path, "size.json"), "w") as fh:
+        fh.write("x" * 100)
+
+
+class Find(unittest.TestCase):
+    def test_output_directory_with_meta_is_found_and_one_without_is_not(self):
+        with tempfile.TemporaryDirectory() as d, tempfile.TemporaryDirectory() as tmp:
+            _output(os.path.join(d, "analysis-a"))
+            os.makedirs(os.path.join(d, "analysis-b"))
+            found = clean.find(d, tmp)
+        self.assertEqual([p for p, _, _ in found], [os.path.join(d, "analysis-a")])
+
+    def test_size_and_mtime_come_with_the_path(self):
+        with tempfile.TemporaryDirectory() as d, tempfile.TemporaryDirectory() as tmp:
+            _output(os.path.join(d, "analysis-a"))
+            [(path, size, mtime)] = clean.find(d, tmp)
+        self.assertEqual(size, 102)   # meta.json "{}" plus 100 bytes
+        self.assertGreater(mtime, 0)
+
+    def test_whole_portfolio_is_listed_once(self):
+        with tempfile.TemporaryDirectory() as d, tempfile.TemporaryDirectory() as tmp:
+            pf = os.path.join(d, "analysis-acme")
+            _output(os.path.join(pf, "one"))
+            _output(os.path.join(pf, "two"))
+            with open(os.path.join(pf, "portfolio.md"), "w") as fh:
+                fh.write("# acme\n")
+            with open(os.path.join(pf, ".DS_Store"), "w") as fh:
+                fh.write("")
+            found = clean.find(d, tmp)
+        self.assertEqual([p for p, _, _ in found], [pf])
+
+    def test_partial_portfolio_lists_its_children(self):
+        with tempfile.TemporaryDirectory() as d, tempfile.TemporaryDirectory() as tmp:
+            pf = os.path.join(d, "analysis-acme")
+            _output(os.path.join(pf, "one"))
+            os.makedirs(os.path.join(pf, "notes"))
+            found = clean.find(d, tmp)
+        self.assertEqual([p for p, _, _ in found], [os.path.join(pf, "one")])
+
+    def test_temp_clones_come_first_oldest_first_and_only_from_tmp(self):
+        with tempfile.TemporaryDirectory() as d, tempfile.TemporaryDirectory() as tmp:
+            newer = os.path.join(tmp, "gitmole-bbb")
+            older = os.path.join(tmp, "gitmole-aaa")
+            os.makedirs(newer)
+            os.makedirs(older)
+            os.utime(older, (1, 1))
+            os.utime(newer, (2, 2))
+            os.makedirs(os.path.join(d, "gitmole-under-base"))
+            _output(os.path.join(d, "analysis-a"))
+            found = clean.find(d, tmp)
+        self.assertEqual([p for p, _, _ in found], [older, newer, os.path.join(d, "analysis-a")])
+
+    def test_a_clone_as_base_includes_its_own_output_next_to_it(self):
+        with tempfile.TemporaryDirectory() as d, tempfile.TemporaryDirectory() as tmp:
+            repo = os.path.join(d, "widgets")
+            subprocess.run(["git", "init", "-q", repo], check=True)
+            _output(os.path.join(d, "analysis-widgets"))
+            found = clean.find(repo, tmp)
+        self.assertEqual([p for p, _, _ in found], [os.path.join(d, "analysis-widgets")])
+
+    def test_nothing_found_is_an_empty_list(self):
+        with tempfile.TemporaryDirectory() as d, tempfile.TemporaryDirectory() as tmp:
+            self.assertEqual(clean.find(d, tmp), [])
+
+
+class Human(unittest.TestCase):
+    def test_boundaries(self):
+        self.assertEqual(clean.human(0), "0 B")
+        self.assertEqual(clean.human(999), "999 B")
+        self.assertEqual(clean.human(1200), "1.2 kB")
+        self.assertEqual(clean.human(1_200_000), "1.2 MB")
+        self.assertEqual(clean.human(340_000_000), "340 MB")
+        self.assertEqual(clean.human(2_100_000_000), "2.1 GB")
+
+
+class Remove(unittest.TestCase):
+    def test_removes_trees_and_reports_what_is_left(self):
+        with tempfile.TemporaryDirectory() as d:
+            gone = os.path.join(d, "analysis-a")
+            _output(gone)
+            failed = clean.remove([gone, os.path.join(d, "never-existed")])
+            self.assertFalse(os.path.exists(gone))
+        self.assertEqual(failed, [])
+
+
+class TempDir(unittest.TestCase):
+    def test_honours_tmpdir(self):
+        with tempfile.TemporaryDirectory() as d:
+            old = os.environ.get("TMPDIR")
+            os.environ["TMPDIR"] = d
+            try:
+                self.assertEqual(clean.temp_dir(), d)
+            finally:
+                if old is None:
+                    del os.environ["TMPDIR"]
+                else:
+                    os.environ["TMPDIR"] = old

{gitmole-0.6.0 → gitmole-0.6.2}/tests/test_cli.py

@@ -330,6 +330,59 @@ class GhFailures(unittest.TestCase):
         self.assertIn("repository not found", text)
 
 
+class TempClones(unittest.TestCase):
+    """A remote or portfolio run removes the temp parent it cloned into, whatever happened in between."""
+
+    def _cloner(self, parents):
+        def cloner(target, parent):
+            parents.append(parent)
+            d = os.path.join(parent, target.split("/")[-1])
+            os.makedirs(d)
+            _tiny_repo(d)
+            return d
+        return cloner
+
+    def _planner(self, argv):
+        return lambda repo, out, branch="HEAD", **kw: [{"name": "q", "argv": argv, "stdout": None, "deps": []}]
+
+    def test_remote_run_removes_its_clone_on_success(self):
+        parents = []
+        with tempfile.TemporaryDirectory() as work:
+            rc = cli.main(["acme/widgets", "--out", os.path.join(work, "out")], console=console(), tool_check=lambda **kw: [],
+                          planner=self._planner(["true"]), estimator=lambda repo, interval, **kw: {"files": 1, "samples": 1, "blames": 1},
+                          cloner=self._cloner(parents))
+        self.assertEqual(rc, 0)
+        self.assertEqual(len(parents), 1)
+        self.assertFalse(os.path.exists(parents[0]))
+
+    def test_remote_run_removes_its_clone_when_a_step_fails(self):
+        parents = []
+        with tempfile.TemporaryDirectory() as work:
+            cli.main(["acme/widgets", "--out", os.path.join(work, "out")], console=console(), tool_check=lambda **kw: [],
+                     planner=self._planner(["false"]), estimator=lambda repo, interval, **kw: {"files": 1, "samples": 1, "blames": 1},
+                     cloner=self._cloner(parents))
+        self.assertFalse(os.path.exists(parents[0]))
+
+    def test_failed_clone_leaves_no_parent(self):
+        parents = []
+        def cloner(target, parent):
+            parents.append(parent)
+            raise run.GhError("repository not found")
+        rc = cli.main(["acme/missing"], console=console(), tool_check=lambda **kw: [], cloner=cloner)
+        self.assertEqual(rc, 2)
+        self.assertFalse(os.path.exists(parents[0]))
+
+    def test_portfolio_run_removes_its_parent(self):
+        parents = []
+        with tempfile.TemporaryDirectory() as work:
+            rc = cli.main(["acme/*", "--out", os.path.join(work, "pf")], console=console(), tool_check=lambda **kw: [],
+                          planner=self._planner(["true"]), estimator=lambda repo, interval, **kw: {"files": 1, "samples": 1, "blames": 1},
+                          lister=lambda owner: ["one", "two"], cloner=self._cloner(parents))
+        self.assertEqual(rc, 0)
+        self.assertEqual(len(set(parents)), 1)
+        self.assertFalse(os.path.exists(parents[0]))
+
+
 class FileTypes(unittest.TestCase):
     def test_list_file_types_prints_the_tree_and_exits(self):
         with tempfile.TemporaryDirectory() as d:
@@ -516,8 +569,20 @@ class Arguments(unittest.TestCase):
         self.assertEqual(rc, 2)
         self.assertIn("not a repo", c.export_text())
 
+    def test_non_repo_directory_is_reported_not_raised(self):
+        with tempfile.TemporaryDirectory() as d:
+            target = os.path.join(d, "checkouts")
+            os.mkdir(target)
+            c = console()
+            rc = cli.main([target], console=c, tool_check=lambda **kw: [])
+            created = os.listdir(d)
+        self.assertEqual(rc, 2)
+        self.assertIn("not a git repository", c.export_text())
+        self.assertEqual(created, ["checkouts"])   # no analysis-checkouts/ next to a bad target
+
     def test_missing_tools_are_listed(self):
         with tempfile.TemporaryDirectory() as d:
+            _tiny_repo(d)
             c = console()
             rc = cli.main([d], console=c, tool_check=lambda **kw: ["scc"])
         text = c.export_text()
@@ -527,6 +592,120 @@ class Arguments(unittest.TestCase):
         self.assertNotIn("jar", text)
 
 
+class Clean(unittest.TestCase):
+    """--clean lists what gitmole left behind and deletes on a yes. TMPDIR is pointed at a scratch dir so the
+    real temp folder is never listed or touched."""
+
+    def _with_tmp(self, fn):
+        with tempfile.TemporaryDirectory() as work, tempfile.TemporaryDirectory() as tmp:
+            old = os.environ.get("TMPDIR")
+            os.environ["TMPDIR"] = tmp
+            try:
+                return fn(work, tmp)
+            finally:
+                if old is None:
+                    del os.environ["TMPDIR"]
+                else:
+                    os.environ["TMPDIR"] = old
+
+    def _output(self, path):
+        os.makedirs(path)
+        with open(os.path.join(path, "meta.json"), "w") as fh:
+            fh.write("{}")
+
+    def test_nothing_to_clean(self):
+        def go(work, tmp):
+            c = console()
+            rc = cli.main(["--clean", work], console=c)
+            return rc, c.export_text()
+        rc, text = self._with_tmp(go)
+        self.assertEqual(rc, 0)
+        self.assertIn("nothing to clean", text)
+
+    def test_lists_then_keeps_on_anything_but_yes(self):
+        def go(work, tmp):
+            self._output(os.path.join(work, "analysis-a"))
+            os.makedirs(os.path.join(tmp, "gitmole-x"))
+            c = Console(file=io.StringIO(), width=120, record=True, force_terminal=True, color_system=None)
+            asked = []
+            rc = cli.main(["--clean", work], console=c, ask=lambda q: asked.append(q) or "n")
+            return rc, c.export_text(), asked, os.path.isdir(os.path.join(work, "analysis-a")), os.path.isdir(os.path.join(tmp, "gitmole-x"))
+        rc, text, asked, out_kept, tmp_kept = self._with_tmp(go)
+        self.assertEqual(rc, 0)
+        self.assertIn("Left behind", text)
+        self.assertIn("analysis-a", text)
+        self.assertIn("gitmole-x", text)
+        self.assertEqual(len(asked), 1)
+        self.assertIn("Delete 2 directories", asked[0])
+        self.assertIn("kept", text)
+        self.assertTrue(out_kept)
+        self.assertTrue(tmp_kept)
+
+    def test_yes_answer_removes_and_reports(self):
+        def go(work, tmp):
+            self._output(os.path.join(work, "analysis-a"))
+            os.makedirs(os.path.join(tmp, "gitmole-x"))
+            c = Console(file=io.StringIO(), width=120, record=True, force_terminal=True, color_system=None)
+            rc = cli.main(["--clean", work], console=c, ask=lambda q: "Y")
+            return rc, c.export_text(), os.listdir(work), os.listdir(tmp)
+        rc, text, work_left, tmp_left = self._with_tmp(go)
+        self.assertEqual(rc, 0)
+        self.assertIn("removed 2 directories", text)
+        self.assertEqual(work_left, [])
+        self.assertEqual(tmp_left, [])
+
+    def test_default_base_is_the_current_directory(self):
+        def go(work, tmp):
+            self._output(os.path.join(work, "analysis-a"))
+            here = os.getcwd()
+            os.chdir(work)
+            try:
+                c = console()
+                rc = cli.main(["--clean", "--yes"], console=c)
+            finally:
+                os.chdir(here)
+            return rc, os.listdir(work)
+        rc, left = self._with_tmp(go)
+        self.assertEqual(rc, 0)
+        self.assertEqual(left, [])
+
+    def test_no_terminal_lists_and_refuses_without_yes(self):
+        def go(work, tmp):
+            self._output(os.path.join(work, "analysis-a"))
+            c = console()   # force_terminal=False
+            rc = cli.main(["--clean", work], console=c, ask=lambda q: self.fail("must not ask"))
+            return rc, c.export_text(), os.path.isdir(os.path.join(work, "analysis-a"))
+        rc, text, kept = self._with_tmp(go)
+        self.assertEqual(rc, 2)
+        self.assertIn("analysis-a", text)
+        self.assertIn("needs a terminal", text)
+        self.assertIn("--yes", text)
+        self.assertTrue(kept)
+
+    def test_yes_flag_skips_the_question(self):
+        def go(work, tmp):
+            self._output(os.path.join(work, "analysis-a"))
+            c = console()
+            rc = cli.main(["--clean", work, "--yes"], console=c, ask=lambda q: self.fail("must not ask"))
+            return rc, c.export_text(), os.listdir(work)
+        rc, text, left = self._with_tmp(go)
+        self.assertEqual(rc, 0)
+        self.assertIn("removed 1 directory", text)
+        self.assertEqual(left, [])
+
+    def test_yes_without_clean_is_an_error(self):
+        c = console()
+        rc = cli.main([".", "--yes"], console=c)
+        self.assertEqual(rc, 2)
+        self.assertIn("--yes needs --clean", c.export_text())
+
+    def test_no_target_without_clean_is_an_error(self):
+        c = console()
+        rc = cli.main([], console=c)
+        self.assertEqual(rc, 2)
+        self.assertIn("target required", c.export_text())
+
+
 class Risk(unittest.TestCase):
     def _repo(self, d):
         import subprocess

{gitmole-0.6.0 → gitmole-0.6.2}/tests/test_run.py

@@ -9,10 +9,17 @@ from gitmole import blame, run
 
 
 class ClassifyTarget(unittest.TestCase):
-    def test_existing_directory_is_a_path(self):
+    def test_existing_repository_is_a_path(self):
         with tempfile.TemporaryDirectory() as d:
+            subprocess.run(["git", "init", "-q", d], check=True)
             self.assertEqual(run.classify_target(d), ("path", os.path.abspath(d)))
 
+    def test_directory_that_is_not_a_repository_raises(self):
+        with tempfile.TemporaryDirectory() as d:
+            with self.assertRaises(ValueError) as cm:
+                run.classify_target(d)
+        self.assertIn("not a git repository", str(cm.exception))
+
     def test_owner_slash_repo_is_remote(self):
         self.assertEqual(run.classify_target("acme/widgets"), ("remote", "acme/widgets"))