git-worktrees 0.6.0__tar.gz → 0.6.1__tar.gz

{git_worktrees-0.6.0 → git_worktrees-0.6.1}/.github/workflows/publish.yml

@@ -192,12 +192,27 @@ jobs:
           name: dist
           path: dist/
 
-      # The install check waits for PyPI to serve the files.
+      # The install check resolves the wheel alone, so the sdist can still be
+      # missing from PyPI here. A file PyPI does not serve yet is asked again,
+      # backing off from 15s over eight attempts as the install check does;
+      # any other failure ends the job at once.
       - name: Verify attestations on PyPI
         run: |
           for f in dist/*.whl dist/*.tar.gz; do
-            uvx pypi-attestations@0.0.30 verify pypi \
-              --repository "https://github.com/$GITHUB_REPOSITORY" "pypi:${f#dist/}"
+            file="${f#dist/}"
+            delay=15
+            for attempt in 1 2 3 4 5 6 7 8; do
+              code=0
+              uvx pypi-attestations@0.0.30 verify pypi \
+                --repository "https://github.com/$GITHUB_REPOSITORY" "pypi:$file" 2>err.txt || code=$?
+              cat err.txt >&2
+              [ "$code" -ne 0 ] || break
+              grep -q "Could not find the artifact" err.txt || exit 1
+              [ "$attempt" -lt 8 ] || exit 1
+              echo "waiting ${delay}s for PyPI to serve $file (attempt $attempt/8)..." >&2
+              sleep "$delay"
+              delay=$((delay * 2))
+            done
           done
 
   release:

{git_worktrees-0.6.0 → git_worktrees-0.6.1}/.releasetools.yaml

@@ -10,7 +10,9 @@ projects:
   - path: ./
     manifest: pyproject.toml
     changelog: CHANGELOG.md
-    bump: uv version {version}
+    # `uv version` for pyproject.toml and uv.lock, then the copies the shell
+    # plugins and the README's install lines carry.
+    bump: python3 scripts/bump_version.py {version}
 
 release:
   branch: main

{git_worktrees-0.6.0 → git_worktrees-0.6.1}/AGENTS.md

@@ -105,6 +105,14 @@ zsh/plugins/worktrees/completions/_gwa
 Neither manager puts a binary on `$PATH`. The console scripts arrive through
 `uv tool install` from the published package, which is a separate step.
 
+Both plugins export `WORKTREES_PLUGIN_VERSION`, the release they came from:
+`conf.d/worktrees.fish` and `worktrees.plugin.zsh`, one assignment each.
+`gwh` and `gw version` compare it with `__version__`, in Python; the shell
+files hold the value and no logic. Nothing built can stamp a file a plugin
+manager copies from git, so `scripts/bump_version.py` writes it at release,
+along with the tag in the README's install lines, and `tests/test_version.py`
+fails when a copy disagrees with `pyproject.toml`.
+
 Nothing installs this from a checkout on the user's disk. It is consumed as a
 third-party plugin and a third-party tool, so anything that assumes a local
 clone at a known path is wrong here.

{git_worktrees-0.6.0 → git_worktrees-0.6.1}/CHANGELOG.md

@@ -17,6 +17,25 @@ not in here, whatever it cost to build.
 A release closes with a `### Choices` section when a decision in it is worth
 the reader's time: what was chosen, and what the alternative failed to do.
 
+## 0.6.1 - 2026-11-02
+
+### Added
+
+`gwh` says which release the shell plugin in this shell came from, and whether
+it matches the commands. When the plugin is older, it names the tag to pin it
+to, and when newer, it gives the `uv tool upgrade git-worktrees` to run.
+`gw version` says the same on stderr, and its stdout is still the version
+alone. Both plugins export `WORKTREES_PLUGIN_VERSION` for this. A shell whose
+plugin predates this release reports none.
+
+### Changed
+
+The README installs the plugins at the release's tag, `fisher install
+MihaiBojin/worktrees@v0.6.1` for fish and `branch:v0.6.1` for Antidote, and
+says how to move each to another release. Moving an existing install onto a
+tag takes an edit to `fish_plugins` and `fisher update`, or `antidote purge
+MihaiBojin/worktrees` before editing the tag.
+
 ## 0.6.0 - 2026-11-02
 
 ### Changed

{git_worktrees-0.6.0 → git_worktrees-0.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: git-worktrees
-Version: 0.6.0
+Version: 0.6.1
 Summary: Git worktree commands that refuse to lose work.
 Project-URL: Bug reports, https://github.com/MihaiBojin/worktrees/issues/new
 Project-URL: Source, https://github.com/MihaiBojin/worktrees
@@ -132,21 +132,35 @@ That installs `gws`, `gwp`, `gwbs`, `gwbd`, `gwbc`, `gwrot`, and `gwh`. The
 four that land you somewhere need a shell function too, and every command has
 a completion, both of which arrive through a plugin manager.
 
+Install the plugin at the tag of the release `uv` installed. Without a tag
+both managers take `main`, which can be ahead of the last release, and the
+functions then call commands they were not tested against. `gwh` says which
+release the plugin here came from, and whether it is the same one.
+
+To upgrade, move both: `uv tool upgrade git-worktrees` for the commands, then
+the plugin's tag to the same release, as each manager below describes.
+
 ### fish
 
 ```console
-fisher install MihaiBojin/worktrees
+fisher install MihaiBojin/worktrees@v0.6.1
 ```
 
-Fisher copies `functions/` and `completions/` from the repository root, so the
-five functions and ten completions land together. Nothing has to be sourced.
+Fisher copies `functions/`, `completions/` and `conf.d/` from the repository
+root, so the functions for `gwa`, `gwl`, `gwm`, `gwr` and `gwr!` land together
+with a completion for every command. Nothing has to be sourced.
+
+To change release, edit the tag on that line of
+`$__fish_config_dir/fish_plugins` and run `fisher update`. The same edit moves
+an install without a tag onto one; `fisher install` with a tag refuses while
+the untagged one holds the files.
 
 ### zsh
 
-Antidote takes a `path:` into the repository:
+Antidote takes a `path:` into the repository, and `branch:` takes a tag:
 
 ```
-MihaiBojin/worktrees path:zsh/plugins/worktrees   # in zsh_plugins.txt
+MihaiBojin/worktrees branch:v0.6.1 path:zsh/plugins/worktrees   # in zsh_plugins.txt
 ```
 
 The plugin puts its own `functions/` and `completions/` on `fpath` and
@@ -157,6 +171,19 @@ run; without one, add it after the plugin loads:
 autoload -Uz compinit && compinit
 ```
 
+Antidote checks a tag out only when it clones, and `antidote update` leaves a
+tag where it is. To change release, remove the clone, then edit the tag, then
+open a new shell, which clones it again at the new tag:
+
+```zsh
+antidote purge MihaiBojin/worktrees
+```
+
+The order matters. Antidote rebuilds its bundle only when `zsh_plugins.txt` is
+newer than the bundle, so a tag edited before the purge leaves a new shell
+with no plugin until the file changes again. The same three steps move a clone
+without a tag onto one.
+
 ### What the shell code does
 
 Each function runs `command <name>` and `cd`s to what it printed, provided
@@ -166,6 +193,16 @@ somewhere to go and stays put when it is not. `gws`, `gwp`, `gwbc`, `gwrot` and
 change no directory, so they ship as console scripts alone and answer the same
 from a prompt and from a script.
 
+Both plugins export `WORKTREES_PLUGIN_VERSION`, the release they came from,
+since the environment is all a binary sees of the shell that started it. `gwh`
+and `gw version` compare it with their own and say whether the two match,
+which is older, and what to run: `gwh` in its text, `gw version` on stderr, so
+its stdout stays the version alone for a script to read.
+
+A shell without the variable has no plugin loaded, or one older than the
+release that started exporting it, and nothing can tell those two apart. A
+bash started from fish or zsh inherits the variable without the functions.
+
 The completions hold no candidate of their own. `gw --complete` prints every
 subcommand and shorthand, `gwl --complete` prints every worktree, and both
 shells narrow what those return, so the matching stays in one place and a
@@ -495,7 +532,7 @@ their own and `gwbc` puts them on a branch.
 
 ```console
 $ gwh
-worktrees 0.5.1: git worktree commands that refuse to lose work
+worktrees 0.6.1: git worktree commands that refuse to lose work
 
 COMMAND          GW                 DOES
 gws              gw status (s, st)  which worktrees are finished, and why
@@ -510,6 +547,11 @@ gwh              gw help (h)        every command and alias, this list
 gwbc NAME        gw branch create   branch off the head branch
 gwbs [NAME ...]  gw branch status   which branches are finished, and why
 gwbd [NAME ...]  gw branch delete   delete local branches proved finished
+
+gwa, gwl, gwm and gwr change the directory you are standing in.
+A binary cannot do that, so each needs the shell function of the same name
+from the plugin; the rest need nothing but $PATH.
+The shell plugin here is 0.6.1, the same release as these commands.
 ```
 
 `gw help`, `gw h` and `gw` with no subcommand print the same thing. One table

{git_worktrees-0.6.0 → git_worktrees-0.6.1}/README.md

@@ -106,21 +106,35 @@ That installs `gws`, `gwp`, `gwbs`, `gwbd`, `gwbc`, `gwrot`, and `gwh`. The
 four that land you somewhere need a shell function too, and every command has
 a completion, both of which arrive through a plugin manager.
 
+Install the plugin at the tag of the release `uv` installed. Without a tag
+both managers take `main`, which can be ahead of the last release, and the
+functions then call commands they were not tested against. `gwh` says which
+release the plugin here came from, and whether it is the same one.
+
+To upgrade, move both: `uv tool upgrade git-worktrees` for the commands, then
+the plugin's tag to the same release, as each manager below describes.
+
 ### fish
 
 ```console
-fisher install MihaiBojin/worktrees
+fisher install MihaiBojin/worktrees@v0.6.1
 ```
 
-Fisher copies `functions/` and `completions/` from the repository root, so the
-five functions and ten completions land together. Nothing has to be sourced.
+Fisher copies `functions/`, `completions/` and `conf.d/` from the repository
+root, so the functions for `gwa`, `gwl`, `gwm`, `gwr` and `gwr!` land together
+with a completion for every command. Nothing has to be sourced.
+
+To change release, edit the tag on that line of
+`$__fish_config_dir/fish_plugins` and run `fisher update`. The same edit moves
+an install without a tag onto one; `fisher install` with a tag refuses while
+the untagged one holds the files.
 
 ### zsh
 
-Antidote takes a `path:` into the repository:
+Antidote takes a `path:` into the repository, and `branch:` takes a tag:
 
 ```
-MihaiBojin/worktrees path:zsh/plugins/worktrees   # in zsh_plugins.txt
+MihaiBojin/worktrees branch:v0.6.1 path:zsh/plugins/worktrees   # in zsh_plugins.txt
 ```
 
 The plugin puts its own `functions/` and `completions/` on `fpath` and
@@ -131,6 +145,19 @@ run; without one, add it after the plugin loads:
 autoload -Uz compinit && compinit
 ```
 
+Antidote checks a tag out only when it clones, and `antidote update` leaves a
+tag where it is. To change release, remove the clone, then edit the tag, then
+open a new shell, which clones it again at the new tag:
+
+```zsh
+antidote purge MihaiBojin/worktrees
+```
+
+The order matters. Antidote rebuilds its bundle only when `zsh_plugins.txt` is
+newer than the bundle, so a tag edited before the purge leaves a new shell
+with no plugin until the file changes again. The same three steps move a clone
+without a tag onto one.
+
 ### What the shell code does
 
 Each function runs `command <name>` and `cd`s to what it printed, provided
@@ -140,6 +167,16 @@ somewhere to go and stays put when it is not. `gws`, `gwp`, `gwbc`, `gwrot` and
 change no directory, so they ship as console scripts alone and answer the same
 from a prompt and from a script.
 
+Both plugins export `WORKTREES_PLUGIN_VERSION`, the release they came from,
+since the environment is all a binary sees of the shell that started it. `gwh`
+and `gw version` compare it with their own and say whether the two match,
+which is older, and what to run: `gwh` in its text, `gw version` on stderr, so
+its stdout stays the version alone for a script to read.
+
+A shell without the variable has no plugin loaded, or one older than the
+release that started exporting it, and nothing can tell those two apart. A
+bash started from fish or zsh inherits the variable without the functions.
+
 The completions hold no candidate of their own. `gw --complete` prints every
 subcommand and shorthand, `gwl --complete` prints every worktree, and both
 shells narrow what those return, so the matching stays in one place and a
@@ -469,7 +506,7 @@ their own and `gwbc` puts them on a branch.
 
 ```console
 $ gwh
-worktrees 0.5.1: git worktree commands that refuse to lose work
+worktrees 0.6.1: git worktree commands that refuse to lose work
 
 COMMAND          GW                 DOES
 gws              gw status (s, st)  which worktrees are finished, and why
@@ -484,6 +521,11 @@ gwh              gw help (h)        every command and alias, this list
 gwbc NAME        gw branch create   branch off the head branch
 gwbs [NAME ...]  gw branch status   which branches are finished, and why
 gwbd [NAME ...]  gw branch delete   delete local branches proved finished
+
+gwa, gwl, gwm and gwr change the directory you are standing in.
+A binary cannot do that, so each needs the shell function of the same name
+from the plugin; the rest need nothing but $PATH.
+The shell plugin here is 0.6.1, the same release as these commands.
 ```
 
 `gw help`, `gw h` and `gw` with no subcommand print the same thing. One table

git_worktrees-0.6.1/conf.d/worktrees.fish

@@ -0,0 +1,7 @@
+# Fisher autoloads functions/ and completions/ on demand, and the binaries
+# come from `uv tool install` rather than from this package.
+#
+# The release this plugin came from, which `gwh` and `gw version` compare
+# with their own. Exported, because the environment is all a binary can see
+# of the shell that started it.
+set -gx WORKTREES_PLUGIN_VERSION 0.6.1

{git_worktrees-0.6.0 → git_worktrees-0.6.1}/docs/DEVELOPMENT.md

@@ -157,7 +157,7 @@ network. `GIT_CONFIG_GLOBAL` carries that: without it git still reads
 ```
 
 That does the whole of it: cut `release/v0.2.0` from `origin/main`,
-`uv version 0.2.0`, open the pull request, wait for its checks, squash-merge,
+`scripts/bump_version.py 0.2.0`, open the pull request, wait for its checks, squash-merge,
 wait for main's own run on the merged commit, and only then tag. The tag lands
 on a commit already proved green, so it never has to move.
 
@@ -201,13 +201,22 @@ published. Nothing is generated from pull request titles.
 By hand it is the same four commands:
 
 ```console
-uv version 0.2.0          # rewrites pyproject.toml and re-locks
+python3 scripts/bump_version.py 0.2.0   # uv version, then the plugins and README
 # open a pull request, review it, merge it
 git switch main && git pull
 git tag -a v0.2.0 -m v0.2.0
 git push origin v0.2.0
 ```
 
+`uv version` alone is not the bump. It rewrites `pyproject.toml` and
+`uv.lock`, and the shell plugins carry a copy it never sees: Fisher and
+Antidote install them from the tag rather than from anything built, so each
+exports `WORKTREES_PLUGIN_VERSION` written into it, and the README's install
+lines name the tag. `scripts/bump_version.py` writes every one of them, and
+checks each line matches before it writes any. `tests/test_version.py` fails
+when one disagrees with `pyproject.toml`, so a release pull request missing
+one fails its checks before anything is tagged.
+
 The version lives in `pyproject.toml`, in the repository, on every commit,
 and in git history. The tag agrees with it or nothing is published. A tag
 moved onto a commit carrying a different version is refused, which is the

{git_worktrees-0.6.0 → git_worktrees-0.6.1}/hatch_build.py

@@ -2,8 +2,8 @@
 
 Reading it back through `importlib.metadata` at import instead costs 10 ms of
 a 67 ms invocation, on every command, for a string two of them print. A
-constant in the wheel costs nothing, and `pyproject.toml` stays the one place
-the version is written.
+constant in the wheel costs nothing, and the package reads its version from
+`pyproject.toml` alone. The shell plugins' copy is `scripts/bump_version.py`'s.
 
 Not `hatch-vcs`: deriving the version from a tag inverts which of the two has
 to agree with the other, and `publish.yml` refuses a tag whose commit carries

{git_worktrees-0.6.0 → git_worktrees-0.6.1}/pyproject.toml

@@ -9,7 +9,7 @@ authors = [
 ]
 # Static, and the single source of truth for the version. Bump it in a pull
 # request and run `uv lock`; the release tag only has to agree with it.
-version = "0.6.0"
+version = "0.6.1"
 # The standard library answers every question this asks. A dependency here
 # would be paid on every invocation, and an invocation is 67 ms of which 25 ms
 # is the interpreter starting.

git_worktrees-0.6.1/scripts/bump_version.py

@@ -0,0 +1,77 @@
+"""Set the release version in every file that names it.
+
+    python3 scripts/bump_version.py 0.7.0
+
+`uv version` writes `pyproject.toml` and `uv.lock`, and the wheel reads it
+from there. The shell plugins carry a copy of their own, because Fisher and
+Antidote install them from a git tag rather than from anything built, and the
+README's install lines name that tag. `.releasetools.yaml` runs this as the
+release's bump, and `tests/test_version.py` fails when a copy disagrees with
+`pyproject.toml`.
+
+Every line is checked before anything is written: a line that no longer
+matches stops the bump with nothing changed, rather than releasing a version
+some copy never heard of.
+"""
+
+from __future__ import annotations
+
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+
+# Each file, and the lines in it that name the release, `{}` where it goes.
+STAMPS: dict[str, tuple[str, ...]] = {
+    "conf.d/worktrees.fish": ("set -gx WORKTREES_PLUGIN_VERSION {}",),
+    "zsh/plugins/worktrees/worktrees.plugin.zsh": (
+        "export WORKTREES_PLUGIN_VERSION={}",
+    ),
+    "README.md": (
+        "MihaiBojin/worktrees@v{}",
+        "MihaiBojin/worktrees branch:v{}",
+        "worktrees {}: git worktree commands",
+        "The shell plugin here is {}, the same release",
+    ),
+}
+
+
+def _pattern(template: str) -> re.Pattern[str]:
+    """The template with any version where `{}` is."""
+    before, after = (re.escape(part) for part in template.split("{}"))
+    return re.compile(before + r"[0-9][0-9A-Za-z.+]*" + after)
+
+
+def stamped(root: Path, version: str) -> dict[Path, str]:
+    """Every file's text with `version` written in, or SystemExit naming the
+    line that matched nothing."""
+    texts = {}
+    for name, templates in STAMPS.items():
+        path = root / name
+        text = path.read_text()
+        for template in templates:
+            # subn reads a backslash in the replacement as a group reference.
+            line = template.format(version).replace("\\", r"\\")
+            text, count = _pattern(template).subn(line, text)
+            if not count:
+                raise SystemExit(f"{name}: no line matches {template!r}")
+        texts[path] = text
+    return texts
+
+
+def main(argv: list[str]) -> int:
+    if len(argv) != 1:
+        print("usage: bump_version.py VERSION", file=sys.stderr)
+        return 2
+    (version,) = argv
+    texts = stamped(ROOT, version)
+    subprocess.run(["uv", "version", version], cwd=ROOT, check=True)
+    for path, text in texts.items():
+        path.write_text(text)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))

{git_worktrees-0.6.0 → git_worktrees-0.6.1}/src/worktrees/cli.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import argparse
+import os
 import sys
 import time
 from collections.abc import Callable
@@ -1059,9 +1060,64 @@ def run_remove(args: argparse.Namespace) -> int:
 # --------------------------------------------------------------------------
 
 
+# Exported by conf.d/worktrees.fish and worktrees.plugin.zsh, set to the
+# release each came from. scripts/bump_version.py writes both.
+PLUGIN_VERSION = "WORKTREES_PLUGIN_VERSION"
+
+
+def _release(version: str) -> tuple[int, ...] | None:
+    """`x.y.z` as numbers to compare, or None for anything else, such as the
+    `0+unknown` of a source tree nothing installed."""
+    parts = version.split(".")
+    if len(parts) != 3 or not all(p.isdigit() for p in parts):
+        return None
+    return tuple(int(p) for p in parts)
+
+
+def plugin_state() -> tuple[str, bool]:
+    """What the shell plugin here says about its release, against this
+    package's, and whether the two are the same release.
+
+    A shell without the variable has no plugin loaded, or one from before the
+    plugin carried it. Nothing here can tell those two apart.
+    """
+    plugin = os.environ.get(PLUGIN_VERSION, "")
+    if not plugin:
+        return (
+            "No shell plugin here says which release it is: none is loaded,\n"
+            "or it is older than the release that started saying so.",
+            False,
+        )
+    if plugin == __version__:
+        return (
+            f"The shell plugin here is {plugin}, the same release as these commands.",
+            True,
+        )
+    ours, theirs = _release(__version__), _release(plugin)
+    if ours and theirs and theirs < ours:
+        return (
+            f"The shell plugin here is {plugin}, older than these commands.\n"
+            f"Pin it to v{__version__}: https://github.com/MihaiBojin/worktrees#install",
+            False,
+        )
+    if ours and theirs:
+        return (
+            f"The shell plugin here is {plugin}, newer than these commands.\n"
+            "Upgrade them with `uv tool upgrade git-worktrees`.",
+            False,
+        )
+    return (
+        f"The shell plugin here is {plugin}, and these commands are {__version__}.",
+        False,
+    )
+
+
 def run_version(args: argparse.Namespace) -> int:
-    """The version of the installed distribution."""
+    """The version of the installed distribution on stdout, which is what a
+    script reads, and the shell plugin's on stderr."""
     print(__version__)
+    text, same = plugin_state()
+    _err(render.note(text) if same else render.warn(text))
     return 0
 
 
@@ -1109,6 +1165,8 @@ def run_help(args: argparse.Namespace) -> int:
         "standing in.\nA binary cannot do that, so each needs the shell function "
         "of the same name\nfrom the plugin; the rest need nothing but $PATH."
     )
+    text, same = plugin_state()
+    print(o(text, "" if same else YELLOW))
     print()
     # Which commands take the common flags is the table's answer, not a second
     # list here: a row with no flags takes none, and saying so in prose is how

{git_worktrees-0.6.0 → git_worktrees-0.6.1}/tests/test_shims.py

@@ -9,8 +9,10 @@ from __future__ import annotations
 
 import os
 import pty
+import shlex
 import shutil
 import subprocess
+import sys
 import tomllib
 from pathlib import Path
 from typing import NoReturn
@@ -323,6 +325,40 @@ def test_the_zsh_shim_prints_output_that_is_not_a_directory(tmp_path) -> None:
     assert out.splitlines() == [payload, "/"], out
 
 
+@pytest.mark.parametrize(
+    ("shell", "plugin"),
+    [
+        ("fish", ROOT / "conf.d" / "worktrees.fish"),
+        ("zsh", ROOT / "zsh/plugins/worktrees/worktrees.plugin.zsh"),
+    ],
+)
+def test_each_plugin_tells_the_binary_its_release(shell: str, plugin: Path) -> None:
+    """Through the environment, so only an exported variable arrives: a fish
+    `set -g` or a bare zsh assignment stays in the shell, and the binary then
+    reports no plugin at all."""
+    binary = shutil.which(shell)
+    if not binary:  # pragma: no cover
+        _missing(shell)
+    gw = shlex.join(
+        [
+            sys.executable,
+            "-c",
+            "from worktrees.cli import gw; raise SystemExit(gw())",
+            "version",
+        ]
+    )
+    no_config = "--no-config" if shell == "fish" else "-f"
+    env = {k: v for k, v in os.environ.items() if k != "WORKTREES_PLUGIN_VERSION"}
+    proc = subprocess.run(
+        [binary, no_config, "-c", f"source {shlex.quote(str(plugin))}; {gw}"],
+        capture_output=True,
+        text=True,
+        env=env,
+    )
+    assert proc.returncode == 0, proc.stderr
+    assert "the same release as these commands" in proc.stderr, proc.stderr
+
+
 # --------------------------------------------------------------------------
 # a line printed to be pasted lands in whichever shell the reader has
 # --------------------------------------------------------------------------

git_worktrees-0.6.1/tests/test_version.py

@@ -0,0 +1,233 @@
+"""`pyproject.toml` declares the version and `gw version` reads that one. The
+shell plugins and the README's install lines carry copies, which
+`scripts/bump_version.py` writes and these hold to it."""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import sys
+import tomllib
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+sys.path.insert(0, str(ROOT / "scripts"))
+
+import bump_version  # noqa: E402
+
+from worktrees import cli  # noqa: E402
+
+
+def _declared() -> str:
+    return str(
+        tomllib.loads((ROOT / "pyproject.toml").read_text())["project"]["version"]
+    )
+
+
+def test_the_package_declares_its_version_nowhere() -> None:
+    """A second copy is a second thing to bump, and `uv version` bumps one.
+
+    `uv version 0.2.0` rewrites pyproject.toml and uv.lock. It does not touch
+    Python source, so a literal here would survive a release and every
+    console script would report the version before it.
+    """
+    source = (ROOT / "src" / "worktrees" / "__init__.py").read_text()
+    declared = tomllib.loads((ROOT / "pyproject.toml").read_text())["project"][
+        "version"
+    ]
+    assert declared not in source, (
+        f"{declared} is written into __init__.py as well as pyproject.toml"
+    )
+    assert 'version("git-worktrees")' in source
+
+
+def test_version_matches_the_distribution() -> None:
+    from worktrees import __version__
+
+    declared = tomllib.loads((ROOT / "pyproject.toml").read_text())["project"][
+        "version"
+    ]
+    assert __version__ == declared
+
+
+def test_both_names_that_take_a_subcommand_report_it() -> None:
+    """Driven, because the console script is what a person runs."""
+    declared = tomllib.loads((ROOT / "pyproject.toml").read_text())["project"][
+        "version"
+    ]
+    for entry in ("gw", "main"):
+        proc = subprocess.run(
+            [
+                sys.executable,
+                "-c",
+                f"from worktrees.cli import {entry}; raise SystemExit({entry}())",
+                "version",
+            ],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        assert proc.returncode == 0, proc.stderr
+        assert proc.stdout.strip() == declared, entry
+
+
+def test_the_build_hook_writes_and_ships_the_version(tmp_path) -> None:
+    """Both halves, because either one alone fails in silence.
+
+    `.gitignore` keeps the generated file out of the repository, and hatchling
+    reads `.gitignore`, so a hook that only writes it builds a wheel without
+    it. Every install then falls back to the metadata lookup and nothing says
+    so.
+    """
+    import hatch_build
+
+    assert hatch_build.GENERATED.as_posix() in (ROOT / ".gitignore").read_text()
+
+    (tmp_path / hatch_build.GENERATED.parent).mkdir(parents=True)
+    build_data: dict[str, list[str]] = {}
+    written = hatch_build.generate(tmp_path, "9.9.9", build_data)
+
+    namespace: dict[str, str] = {}
+    exec(written.read_text(), namespace)
+    assert namespace["__version__"] == "9.9.9"
+    assert f"/{hatch_build.GENERATED.as_posix()}" in build_data["artifacts"]
+
+
+def test_a_checkout_falls_back_to_the_metadata_lookup() -> None:
+    """No generated file is the normal state of a clone, and it still answers."""
+    source = (ROOT / "src" / "worktrees" / "__init__.py").read_text()
+    assert "from ._version import __version__" in source
+    assert "except ImportError" in source
+
+
+# --------------------------------------------------------------------------
+# the copies the shell plugins carry
+# --------------------------------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    ("name", "template"),
+    [(n, t) for n, ts in bump_version.STAMPS.items() for t in ts],
+)
+def test_every_copy_names_the_declared_release(name: str, template: str) -> None:
+    """A release pull request whose bump missed a copy fails here, before
+    anything is tagged."""
+    assert template.format(_declared()) in (ROOT / name).read_text()
+
+
+def _copy(tmp_path: Path) -> Path:
+    """The script and the files it stamps, laid out as the repository has them."""
+    for name in [*bump_version.STAMPS, "scripts/bump_version.py"]:
+        (tmp_path / name).parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy(ROOT / name, tmp_path / name)
+    return tmp_path
+
+
+def _bump(root: Path, version: str) -> tuple[subprocess.CompletedProcess[str], Path]:
+    """Run the copied script with a `uv` that records what it was asked."""
+    seen = root / "uv-argv"
+    fake = root / "bin" / "uv"
+    fake.parent.mkdir()
+    fake.write_text(f'#!/bin/sh\necho "$PWD $*" > "{seen}"\n')
+    fake.chmod(0o755)
+    proc = subprocess.run(
+        [sys.executable, str(root / "scripts" / "bump_version.py"), version],
+        capture_output=True,
+        text=True,
+        env={**os.environ, "PATH": f"{fake.parent}{os.pathsep}{os.environ['PATH']}"},
+    )
+    return proc, seen
+
+
+def test_the_bump_writes_every_copy_and_runs_uv_version(tmp_path) -> None:
+    root = _copy(tmp_path)
+    proc, seen = _bump(root, "9.9.9")
+    assert proc.returncode == 0, proc.stderr
+    assert seen.read_text().split() == [str(root.resolve()), "version", "9.9.9"]
+    for name, templates in bump_version.STAMPS.items():
+        text = (root / name).read_text()
+        for template in templates:
+            assert template.format("9.9.9") in text, (name, template)
+            assert template.format(_declared()) not in text, (name, template)
+
+
+def test_a_line_the_bump_cannot_find_changes_nothing(tmp_path) -> None:
+    """Checked before anything is written, so a renamed variable stops the
+    release with every file as it was rather than half of them bumped."""
+    root = _copy(tmp_path)
+    zsh = root / "zsh/plugins/worktrees/worktrees.plugin.zsh"
+    zsh.write_text(zsh.read_text().replace("WORKTREES_PLUGIN_VERSION", "RENAMED"))
+    before = {name: (root / name).read_text() for name in bump_version.STAMPS}
+
+    proc, seen = _bump(root, "9.9.9")
+
+    assert proc.returncode != 0
+    assert "export WORKTREES_PLUGIN_VERSION" in proc.stderr
+    assert not seen.exists()
+    assert {name: (root / name).read_text() for name in bump_version.STAMPS} == before
+
+
+# --------------------------------------------------------------------------
+# what gwh and gw version say about the plugin
+# --------------------------------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    ("plugin", "same", "says"),
+    [
+        ("0.6.0", True, "the same release as these commands"),
+        ("0.5.1", False, "older than these commands.\nPin it to v0.6.0"),
+        ("0.10.0", False, "newer than these commands.\nUpgrade them"),
+        ("0.6.0.post1", False, "and these commands are 0.6.0"),
+        ("", False, "No shell plugin here says which release it is"),
+    ],
+)
+def test_the_plugin_is_compared_with_these_commands(
+    monkeypatch, plugin: str, same: bool, says: str
+) -> None:
+    """0.10.0 is newer than 0.6.0, which a string comparison gets backwards.
+    Anything that is not `x.y.z` is printed beside ours and not ranked."""
+    monkeypatch.setattr(cli, "__version__", "0.6.0")
+    monkeypatch.setenv(cli.PLUGIN_VERSION, plugin)
+    text, matched = cli.plugin_state()
+    assert matched is same
+    assert says in text
+
+
+def _gw(*args: str, plugin: str | None) -> subprocess.CompletedProcess[str]:
+    env = {k: v for k, v in os.environ.items() if k != cli.PLUGIN_VERSION}
+    if plugin is not None:
+        env[cli.PLUGIN_VERSION] = plugin
+    return subprocess.run(
+        [
+            sys.executable,
+            "-c",
+            "from worktrees.cli import gw; raise SystemExit(gw())",
+            *args,
+        ],
+        capture_output=True,
+        text=True,
+        env=env,
+    )
+
+
+@pytest.mark.parametrize("plugin", [None, "0.0.1", "99.0.0", _declared()])
+def test_gw_version_keeps_stdout_to_the_version(plugin: str | None) -> None:
+    """`scripts/verify-publish.bash` compares stdout with the version it asked
+    the index for, so what the plugin says goes to stderr."""
+    proc = _gw("version", plugin=plugin)
+    assert proc.returncode == 0, proc.stderr
+    assert proc.stdout == f"{_declared()}\n"
+    assert "shell plugin" in proc.stderr
+
+
+@pytest.mark.parametrize("plugin", [None, "0.0.1", "99.0.0", "0.6.0.post1789247568"])
+def test_gwh_says_what_the_plugin_is_inside_eighty_columns(plugin: str | None) -> None:
+    proc = _gw("help", plugin=plugin)
+    assert proc.returncode == 0, proc.stderr
+    assert "shell plugin" in proc.stdout
+    assert [ln for ln in proc.stdout.splitlines() if len(ln) > 80] == []

{git_worktrees-0.6.0 → git_worktrees-0.6.1}/uv.lock

@@ -40,7 +40,7 @@ wheels = [
 
 [[package]]
 name = "git-worktrees"
-version = "0.6.0"
+version = "0.6.1"
 source = { editable = "." }
 
 [package.optional-dependencies]

{git_worktrees-0.6.0 → git_worktrees-0.6.1}/zsh/plugins/worktrees/worktrees.plugin.zsh

@@ -3,7 +3,7 @@
 #
 # Everything else here is a console script and needs nothing: gws, gwp, gwbc
 # and gwrot answer the same from a prompt and from a script. A binary cannot
-# cd its caller, and that is the only reason this file exists.
+# cd its caller, and that is the reason this file exists.
 #
 # $PATH is the package's business. `uv tool install` puts the binaries in
 # ~/.local/bin; nothing here adds a directory to it.
@@ -13,3 +13,8 @@
 
 fpath+=("${0:h}/functions" "${0:h}/completions")
 autoload -Uz gwa gwl gwm gwr 'gwr!'
+
+# The release this plugin came from, which `gwh` and `gw version` compare
+# with their own. Exported, because the environment is all a binary can see
+# of the shell that started it.
+export WORKTREES_PLUGIN_VERSION=0.6.1

git_worktrees-0.6.0/conf.d/worktrees.fish

@@ -1,3 +0,0 @@
-# Nothing to initialise. Fisher autoloads functions/ and completions/ on
-# demand, and the binaries come from `uv tool install` rather than from this
-# package.

git_worktrees-0.6.0/tests/test_version.py

@@ -1,87 +0,0 @@
-"""The version is written once, and `gw version` reads that one."""
-
-from __future__ import annotations
-
-import subprocess
-import sys
-import tomllib
-from pathlib import Path
-
-ROOT = Path(__file__).resolve().parents[1]
-sys.path.insert(0, str(ROOT))
-
-
-def test_the_package_declares_its_version_nowhere() -> None:
-    """A second copy is a second thing to bump, and `uv version` bumps one.
-
-    `uv version 0.2.0` rewrites pyproject.toml and uv.lock. It does not touch
-    Python source, so a literal here would survive a release and every
-    console script would report the version before it.
-    """
-    source = (ROOT / "src" / "worktrees" / "__init__.py").read_text()
-    declared = tomllib.loads((ROOT / "pyproject.toml").read_text())["project"][
-        "version"
-    ]
-    assert declared not in source, (
-        f"{declared} is written into __init__.py as well as pyproject.toml"
-    )
-    assert 'version("git-worktrees")' in source
-
-
-def test_version_matches_the_distribution() -> None:
-    from worktrees import __version__
-
-    declared = tomllib.loads((ROOT / "pyproject.toml").read_text())["project"][
-        "version"
-    ]
-    assert __version__ == declared
-
-
-def test_both_names_that_take_a_subcommand_report_it() -> None:
-    """Driven, because the console script is what a person runs."""
-    declared = tomllib.loads((ROOT / "pyproject.toml").read_text())["project"][
-        "version"
-    ]
-    for entry in ("gw", "main"):
-        proc = subprocess.run(
-            [
-                sys.executable,
-                "-c",
-                f"from worktrees.cli import {entry}; raise SystemExit({entry}())",
-                "version",
-            ],
-            capture_output=True,
-            text=True,
-            check=False,
-        )
-        assert proc.returncode == 0, proc.stderr
-        assert proc.stdout.strip() == declared, entry
-
-
-def test_the_build_hook_writes_and_ships_the_version(tmp_path) -> None:
-    """Both halves, because either one alone fails in silence.
-
-    `.gitignore` keeps the generated file out of the repository, and hatchling
-    reads `.gitignore`, so a hook that only writes it builds a wheel without
-    it. Every install then falls back to the metadata lookup and nothing says
-    so.
-    """
-    import hatch_build
-
-    assert hatch_build.GENERATED.as_posix() in (ROOT / ".gitignore").read_text()
-
-    (tmp_path / hatch_build.GENERATED.parent).mkdir(parents=True)
-    build_data: dict[str, list[str]] = {}
-    written = hatch_build.generate(tmp_path, "9.9.9", build_data)
-
-    namespace: dict[str, str] = {}
-    exec(written.read_text(), namespace)
-    assert namespace["__version__"] == "9.9.9"
-    assert f"/{hatch_build.GENERATED.as_posix()}" in build_data["artifacts"]
-
-
-def test_a_checkout_falls_back_to_the_metadata_lookup() -> None:
-    """No generated file is the normal state of a clone, and it still answers."""
-    source = (ROOT / "src" / "worktrees" / "__init__.py").read_text()
-    assert "from ._version import __version__" in source
-    assert "except ImportError" in source