dev-bubble 0.7.18__tar.gz → 0.7.19__tar.gz

{dev_bubble-0.7.18/dev_bubble.egg-info → dev_bubble-0.7.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dev-bubble
-Version: 0.7.18
+Version: 0.7.19
 Summary: Containerized development environments powered by Incus
 Author-email: Kim Morrison <kim@tqft.net>
 License-Expression: Apache-2.0

{dev_bubble-0.7.18 → dev_bubble-0.7.19}/bubble/__init__.py

@@ -1,3 +1,3 @@
 """bubble: Containerized development environments."""
 
-__version__ = "0.7.18"
+__version__ = "0.7.19"

{dev_bubble-0.7.18 → dev_bubble-0.7.19}/bubble/finalization.py

@@ -38,11 +38,11 @@ def finalize_bubble(
     before any clone/fetch operations.
     """
     q_short = shlex.quote(short)
-    repo_dir = f"/home/user/{short}"
-    subdir = hook.project_subdir() if hook else ""
-    project_dir = f"{repo_dir}/{subdir}" if subdir else repo_dir
+    project_dir = f"/home/user/{short}"
     if hook:
         hook.post_clone(runtime, name, project_dir)
+        for note in hook.notices():
+            click.echo(note, err=True)
 
     # Add a "github" remote with SSH-format URL for gh CLI host discovery.
     # The global url.insteadOf rewrites HTTPS github.com URLs to the proxy,
@@ -52,7 +52,7 @@ def finalize_bubble(
     # letting gh discover the host without needing to actually use the remote.
     if t.owner and t.repo:
         q_repo = shlex.quote(f"git@github.com:{t.owner}/{t.repo}.git")
-        q_dir = shlex.quote(repo_dir)
+        q_dir = shlex.quote(project_dir)
         add_cmd = f"cd {q_dir} && git remote add github {q_repo} 2>/dev/null || true"
         try:
             runtime.exec(name, ["su", "-", "user", "-c", add_cmd])

{dev_bubble-0.7.18 → dev_bubble-0.7.19}/bubble/hooks/__init__.py

@@ -69,13 +69,13 @@ class Hook(ABC):
         """Return absolute path to a .code-workspace file to open, or None."""
         return None
 
-    def project_subdir(self) -> str:
-        """Subdirectory within the repo where the project lives.
+    def notices(self) -> list[str]:
+        """One-shot human-readable notes to print after detection.
 
-        Returns "" if the project is at the repo root (the common case).
-        Only populated after detect() returns True.
+        Used for warnings the user should see when a bubble is created (but
+        not on every reattach). Only populated after detect() returns True.
         """
-        return ""
+        return []
 
 
 def discover_hooks() -> list[Hook]:

{dev_bubble-0.7.18 → dev_bubble-0.7.19}/bubble/hooks/lean.py

@@ -34,15 +34,17 @@ def _is_safe_subdir(subdir: str) -> bool:
 
 
 def _has_lakefile(bare_repo_path: Path, ref: str, subdir: str) -> bool:
-    """Confirm a sibling lakefile exists next to a discovered lean-toolchain.
+    """Check for a sibling lakefile alongside a discovered lean-toolchain.
 
     Filters out vendored/example/doc directories that happen to ship a
-    lean-toolchain without being the project root.
+    `lean-toolchain` without being a buildable Lean project — e.g. a Python
+    repo with `vendor/lean-toolchain` shouldn't be mistaken for a Lean repo.
     """
+    prefix = f"{subdir}/" if subdir else ""
     for name in ("lakefile.toml", "lakefile.lean"):
         try:
             subprocess.run(
-                ["git", "-C", str(bare_repo_path), "cat-file", "-e", f"{ref}:{subdir}/{name}"],
+                ["git", "-C", str(bare_repo_path), "cat-file", "-e", f"{ref}:{prefix}{name}"],
                 capture_output=True,
                 check=True,
             )
@@ -70,18 +72,14 @@ def _read_lean_toolchain(bare_repo_path: Path, ref: str, subdir: str = "") -> st
         return None
 
 
-def _find_lean_toolchain_subdir(bare_repo_path: Path, ref: str) -> str | None:
-    """Search for a non-root `lean-toolchain` file in the bare repo at `ref`.
+def _find_lean_toolchain_subdirs(bare_repo_path: Path, ref: str) -> list[str]:
+    """Return every directory containing a `lean-toolchain` file at `ref`.
 
-    Returns the relative directory containing the file, or None if there are
-    zero or multiple matches, or if the unique match doesn't sit next to a
-    lakefile. The root is handled separately by the caller; this only fires
-    on the slow path when root has no lean-toolchain.
-
-    Uses `git ls-tree -z` (NUL-delimited) and streams output, stopping after
-    the second match so a huge tree with no Lean project doesn't pay for the
-    full listing. NUL-delimited mode also avoids git's quotePath escaping for
-    paths with unusual bytes.
+    Empty string represents the repo root. Uses `git ls-tree -rz` so paths
+    with unusual bytes aren't quoted, and streams output through a single
+    decode/split pass. Unsafe path components (traversal, control chars,
+    non-ASCII) are silently dropped — they'd be unsafe to plumb into shell
+    commands later.
     """
     try:
         proc = subprocess.Popen(
@@ -90,59 +88,37 @@ def _find_lean_toolchain_subdir(bare_repo_path: Path, ref: str) -> str | None:
             stderr=subprocess.DEVNULL,
         )
     except (OSError, FileNotFoundError):
-        return None
+        return []
 
-    matches: list[str] = []
+    subdirs: list[str] = []
+    suffix = b"/lean-toolchain"
     try:
         assert proc.stdout is not None
-        buf = b""
-        suffix = b"/lean-toolchain"
-        while True:
-            chunk = proc.stdout.read(65536)
-            if not chunk:
-                buf += b""
-                # Flush whatever's left.
-                for entry in buf.split(b"\0"):
-                    if entry.endswith(suffix):
-                        matches.append(entry.decode("utf-8", "replace"))
-                        if len(matches) >= 2:
-                            break
-                break
-            buf += chunk
-            parts = buf.split(b"\0")
-            buf = parts[-1]  # last fragment may be incomplete
-            for entry in parts[:-1]:
-                if entry.endswith(suffix):
-                    matches.append(entry.decode("utf-8", "replace"))
-            if len(matches) >= 2:
-                break
+        data = proc.stdout.read()
     finally:
         try:
-            proc.stdout.close()
+            proc.stdout.close()  # type: ignore[union-attr]
         except Exception:
             pass
         try:
-            proc.terminate()
             proc.wait(timeout=2)
         except Exception:
-            pass
-
-    if not matches:
-        return None
-    if len(matches) >= 2:
-        dirs = sorted(m[: -len("/lean-toolchain")] for m in matches)
-        click.echo(
-            f"Multiple lean-toolchain files found ({', '.join(dirs)}); "
-            "cannot auto-detect Lean project subdirectory.",
-            err=True,
-        )
-        return None
-    subdir = matches[0][: -len("/lean-toolchain")]
-    if not _is_safe_subdir(subdir):
-        return None
-    if not _has_lakefile(bare_repo_path, ref, subdir):
-        return None
-    return subdir
+            try:
+                proc.terminate()
+            except Exception:
+                pass
+
+    for entry in data.split(b"\0"):
+        if entry == b"lean-toolchain":
+            subdirs.append("")
+        elif entry.endswith(suffix):
+            try:
+                subdir = entry[: -len(suffix)].decode("utf-8")
+            except UnicodeDecodeError:
+                continue
+            if _is_safe_subdir(subdir):
+                subdirs.append(subdir)
+    return subdirs
 
 
 def _parse_lean_version(toolchain_str: str) -> str | None:
@@ -218,48 +194,110 @@ class LeanHook(Hook):
         self._is_lean4: bool = False
         self._git_deps: list[GitDependency] = []
         self._subdir: str = ""
+        self._multi_project: bool = False
+        self._notices: list[str] = []
 
     def name(self) -> str:
         return "Lean 4"
 
-    def detect(self, bare_repo_path: Path, ref: str) -> bool:
-        """Check for lean-toolchain file at the given ref in the bare repo.
+    def _reset_state(self) -> None:
+        self._toolchain = None
+        self._subdir = ""
+        self._needs_cache = False
+        self._is_lean4 = False
+        self._git_deps = []
+        self._multi_project = False
+        self._notices = []
 
-        Tries the repo root first (the common case). If that fails, scans the
-        tree for a single non-root `lean-toolchain` file and uses its
-        directory. Bails out (returns False) when there are multiple matches.
+    def detect(self, bare_repo_path: Path, ref: str) -> bool:
+        """Fire if there is any `lean-toolchain` file at the given ref.
+
+        The repo root is preferred when present. For repos with one or more
+        `lean-toolchain` files in subdirectories, the hook still fires (so
+        elan + the VS Code extension end up in the bubble), but VS Code
+        always opens at the repo root. When multiple files exist the
+        auto-build is skipped and a notice is emitted; when their contents
+        disagree the plain `lean` image is used and elan installs toolchains
+        on demand.
         """
-        content = _read_lean_toolchain(bare_repo_path, ref)
-        subdir = ""
-        if content is None:
-            found = _find_lean_toolchain_subdir(bare_repo_path, ref)
-            if found is not None:
-                content = _read_lean_toolchain(bare_repo_path, ref, found)
-                if content is not None:
-                    subdir = found
-
-        if content is not None:
+        self._reset_state()
+        root_content = _read_lean_toolchain(bare_repo_path, ref)
+
+        if root_content is not None:
+            # Root lean-toolchain wins — treat the repo as a single-root
+            # project even if additional lean-toolchain files exist deeper
+            # in the tree. Subdir copies in real repos are almost always
+            # vendored/test fixtures (e.g. lean4 itself ships them under
+            # tests/), so demoting to multi-project would be wrong.
+            self._toolchain = root_content
+            self._subdir = ""
+            self._configure_for_single_project(bare_repo_path, ref, "")
+            return True
+
+        # Only count subdirs that look like real Lean projects (sibling
+        # lakefile). This filters out e.g. a Python repo with a vendored
+        # `lean-toolchain` that has no lakefile next to it.
+        candidates = [
+            s
+            for s in _find_lean_toolchain_subdirs(bare_repo_path, ref)
+            if _has_lakefile(bare_repo_path, ref, s)
+        ]
+        if not candidates:
+            return False
+
+        if len(candidates) == 1:
+            subdir = candidates[0]
+            content = _read_lean_toolchain(bare_repo_path, ref, subdir)
+            if content is None:
+                return False
             self._toolchain = content
             self._subdir = subdir
-            self._is_lean4 = bare_repo_path.name == "lean4.git"
-            if self._is_lean4:
-                self._git_deps = []
-                self._needs_cache = False
-            else:
-                self._git_deps = _parse_git_dependencies(bare_repo_path, ref, subdir)
-                self._needs_cache = bare_repo_path.name == "mathlib4.git" or any(
-                    d.name == "mathlib" for d in self._git_deps
-                )
+            self._configure_for_single_project(bare_repo_path, ref, subdir)
             return True
-        self._toolchain = None
-        self._subdir = ""
-        self._needs_cache = False
+
+        # Multiple buildable Lean projects across subdirectories.
+        self._multi_project = True
+        self._subdir = ""  # we don't pick one for the auto-build
+        contents: list[str] = []
+        for s in candidates:
+            c = _read_lean_toolchain(bare_repo_path, ref, s)
+            if c is not None:
+                contents.append(c)
+        unique = sorted(set(contents))
+        dirs_label = ", ".join(sorted(candidates))
+        if len(unique) == 1:
+            self._toolchain = contents[0]
+            self._notices.append(
+                f"Multiple Lean projects detected ({dirs_label}); skipping auto-build."
+                " Run `lake build` in your project's subdirectory."
+            )
+        else:
+            self._toolchain = None  # forces image_name() to plain `lean`
+            versions_label = ", ".join(unique)
+            self._notices.append(
+                f"Multiple Lean toolchains detected across {dirs_label}: {versions_label}."
+                " Using the base `lean` image; elan will install each toolchain"
+                " on demand the first time you run `lake build` in a subdirectory."
+            )
         self._is_lean4 = False
         self._git_deps = []
-        return False
+        self._needs_cache = False
+        return True
+
+    def _configure_for_single_project(self, bare_repo_path: Path, ref: str, subdir: str) -> None:
+        """Populate is_lean4 / git_deps / needs_cache for a single-project repo."""
+        self._is_lean4 = bare_repo_path.name == "lean4.git"
+        if self._is_lean4:
+            self._git_deps = []
+            self._needs_cache = False
+        else:
+            self._git_deps = _parse_git_dependencies(bare_repo_path, ref, subdir)
+            self._needs_cache = bare_repo_path.name == "mathlib4.git" or any(
+                d.name == "mathlib" for d in self._git_deps
+            )
 
-    def project_subdir(self) -> str:
-        return self._subdir
+    def notices(self) -> list[str]:
+        return list(self._notices)
 
     def image_name(self) -> str:
         """Return the image name based on the lean-toolchain version.
@@ -287,15 +325,25 @@ class LeanHook(Hook):
         return None
 
     def post_clone(self, runtime: ContainerRuntime, container: str, project_dir: str):
-        """Pre-populate Lake dependencies, then set up auto build command."""
+        """Pre-populate Lake dependencies, then set up auto build command.
+
+        ``project_dir`` is always the repo root. The hook's stored ``_subdir``
+        controls where ``lake build`` actually runs. For multi-project repos
+        the auto-build is skipped entirely.
+        """
+        if self._multi_project:
+            return
+
         if self._is_lean4:
             self._setup_lean4_build(runtime, container, project_dir)
             return
 
+        build_dir = f"{project_dir}/{self._subdir}" if self._subdir else project_dir
+
         if self._git_deps:
-            self._populate_lake_packages(runtime, container, project_dir)
+            self._populate_lake_packages(runtime, container, build_dir)
 
-        q_dir = shlex.quote(project_dir)
+        q_dir = shlex.quote(build_dir)
         if self._needs_cache:
             cmd = f"cd {q_dir} && lake exe cache get && lake build"
             msg = "Mathlib cache download and build will start automatically."

{dev_bubble-0.7.18 → dev_bubble-0.7.19/dev_bubble.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dev-bubble
-Version: 0.7.18
+Version: 0.7.19
 Summary: Containerized development environments powered by Incus
 Author-email: Kim Morrison <kim@tqft.net>
 License-Expression: Apache-2.0

{dev_bubble-0.7.18 → dev_bubble-0.7.19}/tests/test_hooks.py

@@ -254,11 +254,16 @@ def nested_subdir_lean_repo(tmp_path):
 
 
 @pytest.fixture
-def subdir_no_lakefile_repo(tmp_path):
-    """Subdirectory has lean-toolchain but no sibling lakefile (vendored/doc dir)."""
+def vendor_only_lean_repo(tmp_path):
+    """Repo whose only lean-toolchain lives in a directory with no lakefile.
+
+    Detection should NOT fire — this is the false-positive guard: a Python
+    repo could plausibly vendor a lean-toolchain file, and we don't want
+    that to inject the Lean image and a failing `lake build`.
+    """
     return _make_hook_repo(
         tmp_path,
-        "no-lakefile",
+        "vendor-only",
         {
             "README.md": "# Root\n",
             "vendor/lean-toolchain": "leanprover/lean4:v4.20.0\n",
@@ -267,25 +272,38 @@ def subdir_no_lakefile_repo(tmp_path):
 
 
 @pytest.fixture
-def ambiguous_lean_repo(tmp_path):
-    """Create a bare git repo with multiple non-root lean-toolchain files."""
+def multi_identical_lean_repo(tmp_path):
+    """Multiple lean-toolchain files in subdirs, all with identical content."""
     return _make_hook_repo(
         tmp_path,
-        "ambig-work",
+        "multi-same",
         {
             "a/lean-toolchain": "leanprover/lean4:v4.20.0\n",
+            "a/lakefile.toml": "name = 'a'\n",
             "b/lean-toolchain": "leanprover/lean4:v4.20.0\n",
+            "b/lakefile.toml": "name = 'b'\n",
         },
     )
 
 
 @pytest.fixture
-def root_and_subdir_lean_repo(tmp_path):
-    """Repo with lean-toolchain at root AND in a subdirectory.
+def multi_versions_lean_repo(tmp_path):
+    """Multiple lean-toolchain files in subdirs with different versions."""
+    return _make_hook_repo(
+        tmp_path,
+        "multi-versions",
+        {
+            "a/lean-toolchain": "leanprover/lean4:v4.20.0\n",
+            "a/lakefile.toml": "name = 'a'\n",
+            "b/lean-toolchain": "leanprover/lean4:v4.21.0\n",
+            "b/lakefile.toml": "name = 'b'\n",
+        },
+    )
 
-    The root file should win — we don't enter the slow scan path when root
-    has lean-toolchain, even if other copies exist deeper in the tree.
-    """
+
+@pytest.fixture
+def root_and_subdir_lean_repo(tmp_path):
+    """Root lean-toolchain plus extra copies in subdirs — root wins."""
     return _make_hook_repo(
         tmp_path,
         "root-and-sub",
@@ -300,44 +318,117 @@ class TestSubdirDetection:
     def test_detect_subdir_lean_repo(self, subdir_lean_repo):
         hook = LeanHook()
         assert hook.detect(subdir_lean_repo, "HEAD") is True
-        assert hook.project_subdir() == "myproj"
+        assert hook._subdir == "myproj"
         assert hook.image_name() == "lean-v4.20.0"
+        assert hook._multi_project is False
+        assert hook.notices() == []
 
     def test_detect_nested_subdir(self, nested_subdir_lean_repo):
         hook = LeanHook()
         assert hook.detect(nested_subdir_lean_repo, "HEAD") is True
-        assert hook.project_subdir() == "src/lean"
+        assert hook._subdir == "src/lean"
         assert hook.image_name() == "lean-v4.21.0"
 
-    def test_ambiguous_repo_not_detected(self, ambiguous_lean_repo):
+    def test_vendor_only_not_detected(self, vendor_only_lean_repo):
+        """A non-root lean-toolchain without a sibling lakefile is ignored.
+
+        Guards against false positives like a Python repo with a vendored
+        lean-toolchain ending up on the Lean image with a failing auto-build.
+        """
         hook = LeanHook()
-        assert hook.detect(ambiguous_lean_repo, "HEAD") is False
-        assert hook.project_subdir() == ""
+        assert hook.detect(vendor_only_lean_repo, "HEAD") is False
+        assert hook._subdir == ""
 
     def test_root_wins_over_subdir(self, root_and_subdir_lean_repo):
         hook = LeanHook()
         assert hook.detect(root_and_subdir_lean_repo, "HEAD") is True
-        assert hook.project_subdir() == ""
+        assert hook._subdir == ""
+        assert hook._multi_project is False
+        assert hook.image_name() == "lean-v4.19.0"
+
+    def test_root_wins_even_with_buildable_subdir(self, tmp_path):
+        """Root lean-toolchain takes precedence even if a buildable subdir exists.
+
+        Subdir lean-toolchain files in real repos (e.g. lean4 itself) are
+        almost always test/vendor fixtures, so root is canonical.
+        """
+        repo = _make_hook_repo(
+            tmp_path,
+            "root-plus-buildable-sub",
+            {
+                "lean-toolchain": "leanprover/lean4:v4.19.0\n",
+                "lakefile.toml": "name = 'main'\n",
+                "sub/lean-toolchain": "leanprover/lean4:v4.20.0\n",
+                "sub/lakefile.toml": "name = 'sub'\n",
+            },
+        )
+        hook = LeanHook()
+        assert hook.detect(repo, "HEAD") is True
+        assert hook._subdir == ""
+        assert hook._multi_project is False
         assert hook.image_name() == "lean-v4.19.0"
+        assert hook.notices() == []
 
-    def test_root_repo_has_empty_subdir(self, lean_repo):
+    def test_root_repo_subdir_empty(self, lean_repo):
         hook = LeanHook()
         hook.detect(lean_repo, "HEAD")
-        assert hook.project_subdir() == ""
+        assert hook._subdir == ""
 
-    def test_subdir_cleared_on_redetect_failure(self, subdir_lean_repo, non_lean_repo):
-        """Re-running detect() on a non-Lean repo must clear stale subdir state."""
+    def test_state_cleared_on_redetect_failure(self, subdir_lean_repo, non_lean_repo):
         hook = LeanHook()
         hook.detect(subdir_lean_repo, "HEAD")
-        assert hook.project_subdir() == "myproj"
+        assert hook._subdir == "myproj"
         assert hook.detect(non_lean_repo, "HEAD") is False
-        assert hook.project_subdir() == ""
+        assert hook._subdir == ""
+        assert hook._multi_project is False
+        assert hook.notices() == []
+
 
-    def test_subdir_without_lakefile_rejected(self, subdir_no_lakefile_repo):
-        """A lean-toolchain in a subdir with no sibling lakefile is ignored."""
+class TestMultiProject:
+    def test_identical_toolchains_pick_image_skip_build(
+        self, multi_identical_lean_repo, mock_runtime
+    ):
         hook = LeanHook()
-        assert hook.detect(subdir_no_lakefile_repo, "HEAD") is False
-        assert hook.project_subdir() == ""
+        assert hook.detect(multi_identical_lean_repo, "HEAD") is True
+        assert hook._multi_project is True
+        assert hook.image_name() == "lean-v4.20.0"
+        assert hook._subdir == ""
+        notes = hook.notices()
+        assert len(notes) == 1
+        assert "Multiple Lean projects" in notes[0]
+        assert "a" in notes[0] and "b" in notes[0]
+
+        hook.post_clone(mock_runtime, "c", "/home/user/repo")
+        marker_calls = [
+            c
+            for c in mock_runtime.calls
+            if c[0] == "exec" and ".bubble-fetch-cache" in " ".join(c[2])
+        ]
+        assert marker_calls == []
+
+    def test_differing_toolchains_use_plain_lean(self, multi_versions_lean_repo):
+        hook = LeanHook()
+        assert hook.detect(multi_versions_lean_repo, "HEAD") is True
+        assert hook._multi_project is True
+        assert hook.image_name() == "lean"
+        notes = hook.notices()
+        assert len(notes) == 1
+        assert "Multiple Lean toolchains" in notes[0]
+        assert "v4.20.0" in notes[0] and "v4.21.0" in notes[0]
+        assert "elan will install" in notes[0]
+
+    def test_subdir_build_dir(self, subdir_lean_repo, mock_runtime):
+        """Single-subdir auto-build runs in the subdir, not the repo root."""
+        hook = LeanHook()
+        hook.detect(subdir_lean_repo, "HEAD")
+        hook.post_clone(mock_runtime, "c", "/home/user/repo")
+        marker_calls = [
+            c
+            for c in mock_runtime.calls
+            if c[0] == "exec" and ".bubble-fetch-cache" in " ".join(c[2])
+        ]
+        assert len(marker_calls) == 1
+        assert "/home/user/repo/myproj" in " ".join(marker_calls[0][2])
 
 
 class TestSafeSubdir: