blot-git 0.3.0__tar.gz → 0.3.2__tar.gz

{blot_git-0.3.0 → blot_git-0.3.2}/.pre-commit-hooks.yaml

@@ -1,11 +1,14 @@
 # Lets users of the pre-commit framework add blot with:
 #   - repo: https://github.com/Sym-jay/Blot
-#     rev: v0.1.0
+#     rev: v0.3.2
 #     hooks: [{id: blot}]
+# The first commit indexes the repo's history; later commits refresh the index incrementally.
 - id: blot
   name: blot (history-aware checks)
   entry: blot check --staged
   language: python
   pass_filenames: false
   always_run: true
+  # blot warns without failing the commit, and pre-commit hides output of passing hooks
+  verbose: true
   stages: [pre-commit]

{blot_git-0.3.0 → blot_git-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: blot-git
-Version: 0.3.0
+Version: 0.3.2
 Summary: A pre-commit check that has read your project's history: warns when a change removes a fix, re-adds a fixed bug, or forgets a file that always changes too.
 Project-URL: Homepage, https://github.com/Sym-jay/Blot
 Project-URL: Issues, https://github.com/Sym-jay/Blot/issues
@@ -40,7 +40,7 @@ It runs locally, needs no account or AI, and stays quiet unless the history give
 ```bash
 pip install blot-git
 cd your-repo
-blot index           # one-time, builds .git/blot.db
+blot index           # optional: the first check indexes history itself
 blot install-hook    # adds Blot to your pre-commit hook
 blot why src/app.py:42   # which commit explains this line, skipping refactors
 blot index --github  # optional: issue/PR titles and labels via the gh CLI

{blot_git-0.3.0 → blot_git-0.3.2}/README.md

@@ -49,7 +49,7 @@ Sora comes in four warm palettes:
 ```bash
 pip install blot-git  # the PyPI name is blot-git; the command is just `blot`
 cd your-repo
-blot index            # one-time, builds .git/blot.db (refreshes incrementally after that)
+blot index            # optional: the first check builds .git/blot.db itself and keeps it current
 blot install-hook     # adds Blot to .git/hooks/pre-commit without touching existing hooks
 ```
 

{blot_git-0.3.0 → blot_git-0.3.2}/docs/PYPI.md

@@ -15,7 +15,7 @@ It runs locally, needs no account or AI, and stays quiet unless the history give
 ```bash
 pip install blot-git
 cd your-repo
-blot index           # one-time, builds .git/blot.db
+blot index           # optional: the first check indexes history itself
 blot install-hook    # adds Blot to your pre-commit hook
 blot why src/app.py:42   # which commit explains this line, skipping refactors
 blot index --github  # optional: issue/PR titles and labels via the gh CLI

{blot_git-0.3.0 → blot_git-0.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "blot-git"
-version = "0.3.0"
+version = "0.3.2"
 description = "A pre-commit check that has read your project's history: warns when a change removes a fix, re-adds a fixed bug, or forgets a file that always changes too."
 readme = "docs/PYPI.md"  # text-only; the GitHub README's relative Sora images break on PyPI
 license = { text = "MIT" }

{blot_git-0.3.0 → blot_git-0.3.2}/src/blot/__init__.py

@@ -1,3 +1,3 @@
 """blot: history-aware pre-commit checks."""
 
-__version__ = "0.3.0"
+__version__ = "0.3.2"

{blot_git-0.3.0 → blot_git-0.3.2}/src/blot/cli.py

@@ -11,6 +11,7 @@ Commands:
 from __future__ import annotations
 
 import argparse
+import os
 import sys
 
 from blot import __version__
@@ -42,17 +43,28 @@ def _cmd_index(args: argparse.Namespace) -> int:
     return 0
 
 
+def _open_index(repo: str):
+    """Open the index, building or refreshing it first.
+
+    The pre-commit framework installs Blot where users can't easily run `blot index`, so the hook
+    must look after the index itself: one full build on first use, then cheap incremental refreshes.
+    """
+    from blot.index import build_index
+    from blot.store import Store
+
+    if not os.path.exists(Store.db_path(repo)):
+        print("blot: first run, indexing this repo's history once (big repos can take a minute)...",
+              file=sys.stderr)
+    build_index(repo)
+    return Store.open(repo)
+
+
 def _cmd_check(args: argparse.Namespace) -> int:
     from blot.diff import read_changes
-    from blot.store import Store
 
     try:
         config = load_config(args.repo)
-        store = Store.open(args.repo)
-        if store is None:
-            # Never break a commit because the index is missing; just say how to fix it.
-            print("blot: no index yet, run `blot index` (commit allowed)", file=sys.stderr)
-            return 0
+        store = _open_index(args.repo)
         changes = read_changes(args.repo, rev_range=args.range)
         findings = [f for check in all_checks(config) for f in check.run(changes, store, config)]
     except Exception as exc:  # Blot's own failures must never block a commit
@@ -63,13 +75,9 @@ def _cmd_check(args: argparse.Namespace) -> int:
 
 
 def _cmd_why(args: argparse.Namespace) -> int:
-    from blot.store import Store
     from blot.why import WhyError, explain, render
 
-    store = Store.open(args.repo)
-    if store is None:
-        print("blot: no index yet, run `blot index` first", file=sys.stderr)
-        return 1
+    store = _open_index(args.repo)
     try:
         path, explained = explain(store, args.location, args.rev)
     except WhyError as exc:
@@ -90,7 +98,7 @@ def _cmd_install_hook(args: argparse.Namespace) -> int:
     status = hooks.install(args.repo)
     print(f"blot: pre-commit hook {status} ({hooks.hook_path(args.repo)})")
     if status != "already installed":
-        print("blot: run `blot index` once so the checks have history to work with")
+        print("blot: the first commit indexes this repo's history (or run `blot index` now)")
     return 0
 
 

{blot_git-0.3.0 → blot_git-0.3.2}/src/blot/git.py

@@ -34,6 +34,46 @@ def git_dir(repo: str) -> str:
     return run_git(repo, "rev-parse", "--absolute-git-dir").strip()
 
 
+def head_sha(repo: str) -> str | None:
+    """The commit HEAD points at, read from .git files (the hook calls this on every commit).
+
+    Handles loose and packed refs, detached HEAD and worktrees (`commondir`). Anything else, such as
+    the reftable format, falls back to `git rev-parse`.
+    """
+    gd = git_dir(repo)
+    try:
+        with open(os.path.join(gd, "HEAD"), encoding="utf-8") as f:
+            head = f.read().strip()
+        if not head.startswith("ref: "):
+            return head if len(head) == 40 else None
+        ref = head[5:]
+        bases = [gd]
+        common = os.path.join(gd, "commondir")
+        if os.path.isfile(common):
+            with open(common, encoding="utf-8") as f:
+                bases.append(os.path.normpath(os.path.join(gd, f.read().strip())))
+        for base in bases:
+            loose = os.path.join(base, *ref.split("/"))
+            if os.path.isfile(loose):
+                with open(loose, encoding="utf-8") as f:
+                    return f.read().strip()
+            packed = os.path.join(base, "packed-refs")
+            if os.path.isfile(packed):
+                with open(packed, encoding="utf-8") as f:
+                    for line in f:
+                        sha, _, name = line.strip().partition(" ")
+                        if name == ref:
+                            return sha
+        if not os.path.isdir(os.path.join(gd, "reftable")):
+            return None  # unborn branch: no commits yet
+    except OSError:
+        pass
+    try:
+        return run_git(repo, "rev-parse", "--verify", "-q", "HEAD").strip() or None
+    except subprocess.CalledProcessError:
+        return None
+
+
 def run_git(repo: str, *args: str) -> str:
     result = subprocess.run(
         ["git", "-C", repo, *args],

{blot_git-0.3.0 → blot_git-0.3.2}/src/blot/index.py

@@ -10,15 +10,17 @@ Targets: under 60 s for 50k commits on a laptop; incremental refresh under 1 s.
 
 from __future__ import annotations
 
+import os
 import re
 import subprocess
 import time
+from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass
 
 from blot.classify import CommitInfo, fix_severity, is_refactor, linked_issues
 from blot.config import Config, load_config
 from blot.diff import is_trivial_line, line_hash, normalize_line, parse_unified_diff
-from blot.git import run_git
+from blot.git import head_sha, run_git
 from blot.store import CommitRow, Store
 
 _RECORD, _FIELD = "\x1e", "\x1f"
@@ -85,12 +87,43 @@ def _head(repo: str, rev: str = "HEAD") -> str | None:
         return None
 
 
+_FORMAT = f"--format={_RECORD}%H{_FIELD}%aI{_FIELD}%s{_FIELD}%b{_FIELD}"
+# Most of indexing is git computing --numstat line counts, one commit after another. Big histories
+# are split into slices that separate git processes read in parallel (Django: 34k commits, ~170 s
+# serially). The result is the same set of commits; order doesn't matter to the index.
+_PARALLEL_FROM = 2000
+
+
+def _workers() -> int:
+    return max(1, min(8, (os.cpu_count() or 2) - 1))
+
+
+def _git_stdin(repo: str, args: list[str], revs: list[str]) -> str:
+    done = subprocess.run(["git", "-C", repo, *args], input="\n".join(revs) + "\n", capture_output=True,
+                          text=True, encoding="utf-8", errors="replace", check=True)
+    return done.stdout
+
+
+def _read_history(repo: str, rev: str) -> list[tuple[CommitInfo, str, list[str]]]:
+    args = ["log", "--no-walk=unsorted", "--stdin", "-M", "--numstat", _FORMAT]
+    shas = run_git(repo, "rev-list", "--no-merges", rev).split()
+    if len(shas) < _PARALLEL_FROM:
+        return _parse_log(_git_stdin(repo, args, shas)) if shas else []
+    # interleaved slices have similar sizes; never pass an empty one (git log would fall back to HEAD)
+    slices = [part for i in range(_workers() * 2) if (part := shas[i::_workers() * 2])]
+    with ThreadPoolExecutor(_workers()) as pool:
+        outs = pool.map(lambda part: _git_stdin(repo, args, part), slices)
+        return [commit for out in outs for commit in _parse_log(out)]
+
+
 def _removed_lines(repo: str, shas: list[str]) -> list[tuple[str, str, str]]:
     """(line_hash, path, sha) for every meaningful line the given commits deleted."""
+    batches = [shas[i : i + _SHOW_BATCH] for i in range(0, len(shas), _SHOW_BATCH)]
+    show = ["show", f"--format={_RECORD}%H", "-U0", "--no-color", "--no-ext-diff", "-M"]
+    with ThreadPoolExecutor(_workers()) as pool:
+        outs = list(pool.map(lambda batch: run_git(repo, *show, *batch), batches))
     rows: list[tuple[str, str, str]] = []
-    for i in range(0, len(shas), _SHOW_BATCH):
-        batch = shas[i : i + _SHOW_BATCH]
-        out = run_git(repo, "show", f"--format={_RECORD}%H", "-U0", "--no-color", "--no-ext-diff", "-M", *batch)
+    for out in outs:
         for chunk in out.split(_RECORD)[1:]:
             sha, _, diff_text = chunk.partition("\n")
             for change in parse_unified_diff(diff_text):
@@ -111,13 +144,15 @@ def build_index(
 ) -> IndexResult:
     """Index history up to `upto` into `db_path` (default .git/blot.db). Bench replays use both."""
     start = time.perf_counter()
-    config = config or load_config(repo)
-    head = _head(repo, upto)
+    head = head_sha(repo) if upto == "HEAD" else _head(repo, upto)
 
     store = Store.open(repo, db_path)
     last = store.get_meta("last_sha") if store else None
     if store:
         store.close()
+    if not full and head is not None and last == head:  # already current: `blot check` hits this on every commit
+        return IndexResult(0, 0, time.perf_counter() - start, False)
+    config = config or load_config(repo)
     rebuild = full or not last or (head is not None and not _is_ancestor(repo, last, head))
     store = Store.create(repo, fresh=rebuild, path=db_path)
 
@@ -128,9 +163,7 @@ def build_index(
         return IndexResult(0, 0, time.perf_counter() - start, rebuild)
 
     rev = head if rebuild else f"{last}..{head}"
-    fmt = f"--format={_RECORD}%H{_FIELD}%aI{_FIELD}%s{_FIELD}%b{_FIELD}"
-    log = run_git(repo, "log", "--no-merges", "-M", "--numstat", fmt, rev)
-    parsed = _parse_log(log)
+    parsed = _read_history(repo, rev)
 
     fix_shas = []
     for info, date, paths in parsed:

{blot_git-0.3.0 → blot_git-0.3.2}/tests/test_cli.py

@@ -11,10 +11,26 @@ def test_registry_has_three_checks():
     assert [c.id for c in REGISTRY] == ["removed-fix", "readded-bug", "forgot-related-file"]
 
 
-def test_check_without_index_never_blocks(make_repo, capsys):
+def test_check_builds_the_index_on_first_run_then_refreshes_it(make_repo, capsys):
+    import subprocess
+
+    from test_checks import AFTER, BEFORE, GUARD
+
     repo = make_repo([("feat: init", {"a.py": "x = 1\n"})])
     assert main(["--repo", str(repo), "check"]) == 0
-    assert "run `blot index`" in capsys.readouterr().err
+    assert "first run, indexing" in capsys.readouterr().err
+    assert main(["--repo", str(repo), "check"]) == 0
+    assert capsys.readouterr().err == ""  # already indexed: silent
+
+    # a fix committed after the first check must be known to the next one (incremental refresh)
+    for message, content in (("Add app", BEFORE), ("Break reference cycle in App (fixes #3761)", AFTER)):
+        (repo / "app.py").write_text(content, encoding="utf-8")
+        subprocess.run(["git", "-C", str(repo), "add", "-A"], check=True)
+        subprocess.run(["git", "-C", str(repo), "commit", "-q", "-m", message], check=True)
+    (repo / "app.py").write_text(AFTER.replace(GUARD, "self_ref = self"), encoding="utf-8")
+    subprocess.run(["git", "-C", str(repo), "add", "-A"], check=True)
+    assert main(["--repo", str(repo), "check"]) == 0
+    assert "removed-fix" in capsys.readouterr().out
 
 
 def test_render_text():

blot_git-0.3.2/tests/test_git.py

@@ -0,0 +1,36 @@
+import os
+import subprocess
+
+from blot.git import git_dir, head_sha, run_git
+
+
+def test_head_sha_matches_git_in_every_ref_layout(make_repo, tmp_path, monkeypatch):
+    monkeypatch.delenv("GIT_DIR", raising=False)
+    repo = make_repo([("one", {"a.py": "x = 1\n"}), ("two", {"a.py": "x = 2\n"})])
+    rev = lambda path: run_git(str(path), "rev-parse", "HEAD").strip()  # noqa: E731
+
+    assert head_sha(str(repo)) == rev(repo)  # loose ref
+    run_git(str(repo), "pack-refs", "--all")
+    assert head_sha(str(repo)) == rev(repo)  # packed-refs only
+    wt = tmp_path / "wt"
+    subprocess.run(["git", "-C", str(repo), "worktree", "add", "-q", "-b", "side", str(wt)], check=True)
+    assert head_sha(str(wt)) == rev(wt)  # worktree: ref lives in the common dir
+    run_git(str(repo), "checkout", "-q", "--detach", "HEAD~1")
+    assert head_sha(str(repo)) == rev(repo)  # detached HEAD
+    empty = tmp_path / "empty"
+    subprocess.run(["git", "init", "-q", str(empty)], check=True)
+    assert head_sha(str(empty)) is None  # no commits yet
+
+
+def test_git_dir_matches_git_from_root_subdir_and_worktree(make_repo, tmp_path, monkeypatch):
+    monkeypatch.delenv("GIT_DIR", raising=False)
+    repo = make_repo([("init", {"pkg/a.py": "x = 1\n"})])
+    expected = os.path.normcase(os.path.normpath(run_git(str(repo), "rev-parse", "--absolute-git-dir").strip()))
+
+    assert os.path.normcase(git_dir(str(repo))) == expected
+    assert os.path.normcase(git_dir(str(repo / "pkg"))) == expected
+
+    wt = tmp_path / "wt"
+    subprocess.run(["git", "-C", str(repo), "worktree", "add", "-q", str(wt)], check=True)
+    wt_expected = os.path.normcase(os.path.normpath(run_git(str(wt), "rev-parse", "--absolute-git-dir").strip()))
+    assert os.path.normcase(git_dir(str(wt))) == wt_expected

{blot_git-0.3.0 → blot_git-0.3.2}/tests/test_hooks.py

@@ -43,7 +43,7 @@ def test_real_commit_runs_hook_and_is_not_blocked(make_repo):
     subprocess.run(["git", "-C", str(repo), "add", "a.py"], check=True)
     done = subprocess.run(["git", "-C", str(repo), "commit", "-m", "change"], capture_output=True, text=True)
     assert done.returncode == 0
-    assert "no index yet" in done.stderr  # the hook really ran
+    assert "first run, indexing" in done.stderr  # the hook really ran, and indexed the repo
 
 
 def test_uninstall_deletes_hook_blot_created(make_repo):

{blot_git-0.3.0 → blot_git-0.3.2}/tests/test_index.py

@@ -66,6 +66,20 @@ def test_index_db_lives_in_git_dir(make_repo):
     assert os.path.exists(repo / ".git" / "blot.db")
 
 
+def test_parallel_history_read_matches_serial(make_repo, tmp_path, monkeypatch):
+    import blot.index as ix
+
+    repo = make_repo(history())
+    build_index(str(repo), db_path=str(tmp_path / "s.db"))
+    monkeypatch.setattr(ix, "_PARALLEL_FROM", 1)  # force slicing even for 3 commits
+    monkeypatch.setattr(ix, "_workers", lambda: 3)  # 6 slices for 3 commits: some would be empty
+    build_index(str(repo), db_path=str(tmp_path / "p.db"))
+    a, b = Store.open(str(repo), str(tmp_path / "s.db")), Store.open(str(repo), str(tmp_path / "p.db"))
+    for table in ("commits", "fix_removed_lines", "file_commits", "cochange"):
+        rows = lambda s: sorted(s.conn.execute(f"SELECT * FROM {table}").fetchall())  # noqa: E731
+        assert rows(a) == rows(b), table
+
+
 def test_empty_repo(tmp_path):
     subprocess.run(["git", "init", "-q", str(tmp_path)], check=True)
     assert build_index(str(tmp_path)).commits == 0

{blot_git-0.3.0 → blot_git-0.3.2}/tests/test_why_github.py

@@ -46,9 +46,8 @@ def test_why_traces_past_a_refactor(make_repo):
 
 def test_why_cli_and_errors(make_repo, capsys):
     repo = make_repo(history())
-    assert main(["--repo", str(repo), "why", "core.py:1"]) == 1  # no index yet
-    assert "run `blot index`" in capsys.readouterr().err
-    main(["--repo", str(repo), "index", "--quiet"])
+    assert main(["--repo", str(repo), "why", "core.py:1"]) == 0  # builds the index itself
+    assert "first run, indexing" in capsys.readouterr().err
     assert main(["--repo", str(repo), "why", "missing.py:1"]) == 1
     assert "not tracked" in capsys.readouterr().err
     assert main(["--repo", str(repo), "why", "core.py:999"]) == 1

blot_git-0.3.0/tests/test_git.py

@@ -1,18 +0,0 @@
-import os
-import subprocess
-
-from blot.git import git_dir, run_git
-
-
-def test_git_dir_matches_git_from_root_subdir_and_worktree(make_repo, tmp_path, monkeypatch):
-    monkeypatch.delenv("GIT_DIR", raising=False)
-    repo = make_repo([("init", {"pkg/a.py": "x = 1\n"})])
-    expected = os.path.normcase(os.path.normpath(run_git(str(repo), "rev-parse", "--absolute-git-dir").strip()))
-
-    assert os.path.normcase(git_dir(str(repo))) == expected
-    assert os.path.normcase(git_dir(str(repo / "pkg"))) == expected
-
-    wt = tmp_path / "wt"
-    subprocess.run(["git", "-C", str(repo), "worktree", "add", "-q", str(wt)], check=True)
-    wt_expected = os.path.normcase(os.path.normpath(run_git(str(wt), "rev-parse", "--absolute-git-dir").strip()))
-    assert os.path.normcase(git_dir(str(wt))) == wt_expected