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

{blot_git-0.3.1 → 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.1 → blot_git-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: blot-git
-Version: 0.3.1
+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.1 → 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.1 → 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.1 → blot_git-0.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "blot-git"
-version = "0.3.1"
+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.1 → blot_git-0.3.2}/src/blot/__init__.py

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

{blot_git-0.3.1 → 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.1 → 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.1 → blot_git-0.3.2}/src/blot/index.py

@@ -20,7 +20,7 @@ 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"
@@ -144,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)
 

{blot_git-0.3.1 → 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.1 → 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.1 → 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.1/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