Replace zest.releaser with release and changelog tooling

- Remove [tool.zest-releaser] from pyproject.toml
- Remove zest.releaser and check-manifest from tests/requirements.txt
- Add make_changelog.py for preparing releases and adding UNRELEASED
- Add check_changelog.py CI check (diffs UNRELEASED against main on
  PRs, verifies version section on tags)
- Add RELEASE_PROCESS.md documenting the tag-based release flow
- Merge deploy workflow into CI: publish is gated on tests passing
- Add MANIFEST.in to exclude dev files from sdist

Author: graingert

.github/workflows/deploy.yml

@@ -1,10 +1,12 @@
-name: Test
+name: CI
 
 on:
   push:
     branches:
       - main
       - "test-me-*"
+    tags:
+      - "v*"
 
   pull_request:
     branches:
@@ -19,10 +21,28 @@ concurrency:
   cancel-in-progress: true
 
 jobs:
+  changelog:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Check changelog (tagged release)
+        if: github.ref_type == 'tag'
+        run: python check_changelog.py --tag "${{ github.ref_name }}"
+
+      - name: Check changelog (PR has new entries)
+        if: github.event_name == 'pull_request'
+        run: |
+          git fetch origin main --depth=1
+          python check_changelog.py
+
   package:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+
       - name: Build and Check Package
         uses: hynek/build-and-inspect-python-package@v2.17
 
@@ -59,3 +79,45 @@ jobs:
         shell: bash
         run: |
           tox run -e py --installpkg `find dist/*.tar.gz`
+
+  pypi-publish:
+    if: github.ref_type == 'tag'
+    needs: [changelog, package, test]
+    runs-on: ubuntu-latest
+    environment: release
+    permissions:
+      id-token: write
+
+    steps:
+      - name: Download Package
+        uses: actions/download-artifact@v8
+        with:
+          name: Packages
+          path: dist
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@v1.13.0
+        with:
+          attestations: true
+
+  github-release:
+    if: github.ref_type == 'tag'
+    needs: [pypi-publish]
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Download Package
+        uses: actions/download-artifact@v8
+        with:
+          name: Packages
+          path: dist
+
+      - name: Create GitHub Release
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          gh release create "${{ github.ref_name }}" --generate-notes dist/*

.github/workflows/test.yml

@@ -0,0 +1,8 @@
+exclude .gitignore
+exclude RELEASE_PROCESS.md
+exclude make_changelog.py
+exclude check_changelog.py
+exclude DEVELOPER.rst
+exclude RELEASING.rst
+exclude tox.ini
+prune .github

MANIFEST.in

@@ -0,0 +1,42 @@
+# Release Process
+
+unittest2pytest uses [setuptools-scm](https://github.com/pypa/setuptools-scm)
+for version management. Versions are derived automatically from git tags.
+
+## Cutting a Release
+
+1. **Update `CHANGELOG.rst`:**
+
+   ```
+   python make_changelog.py X.Y.Z
+   git commit -am "Prepare release X.Y.Z"
+   git push origin main
+   ```
+
+   This replaces the `UNRELEASED` section with a dated `X.Y.Z` section.
+   Review the result and add any missing entries before committing.
+
+2. **Tag and push:**
+
+   ```
+   git tag -s vX.Y.Z -m "unittest2pytest X.Y.Z"
+   git push origin vX.Y.Z
+   ```
+
+   Pushing the tag triggers the release workflow, which builds,
+   publishes to PyPI, and creates a GitHub release.
+
+3. **Start the next development cycle:**
+
+   ```
+   python make_changelog.py UNRELEASED
+   git commit -am "Start next development cycle"
+   git push origin main
+   ```
+
+## How Versioning Works
+
+- Tagged commits (e.g. `v0.6`) produce version `0.6`.
+- Commits after a tag produce dev versions like `0.7.dev3+gabcdef`.
+- The version is written to `unittest2pytest/_version.py` at build time.
+  This file is git-ignored and should not be committed.

RELEASE_PROCESS.md

@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+"""
+check_changelog.py — Verify CHANGELOG.rst is up to date.
+
+Usage:
+    python check_changelog.py              Check UNRELEASED has new entries vs main.
+    python check_changelog.py --tag v0.6   Check a version section exists for the tag.
+"""
+
+from __future__ import annotations
+
+import argparse
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+CHANGELOG = Path(__file__).resolve().parent / "CHANGELOG.rst"
+REPO_ROOT = CHANGELOG.parent
+
+
+def _unreleased_content(text: str) -> str | None:
+    """Extract the body of the UNRELEASED section, or None if missing."""
+    header = re.search(
+        r"^UNRELEASED\n-+\n\n\*UNRELEASED\*\n",
+        text,
+        re.MULTILINE,
+    )
+    if not header:
+        return None
+    rest = text[header.end() :]
+    next_section = re.search(r"^\S+\n[-=]+\n", rest, re.MULTILINE)
+    content = rest[: next_section.start()] if next_section else rest
+    return content.strip()
+
+
+def _main_changelog() -> str | None:
+    """Read CHANGELOG.rst from the main branch, or None if unavailable."""
+    for ref in ("origin/main", "main"):
+        result = subprocess.run(
+            ["git", "show", f"{ref}:CHANGELOG.rst"],
+            capture_output=True,
+            text=True,
+            cwd=REPO_ROOT,
+        )
+        if result.returncode == 0:
+            return result.stdout
+    return None
+
+
+def check_unreleased() -> int:
+    text = CHANGELOG.read_text()
+
+    current = _unreleased_content(text)
+    if current is None:
+        print("ERROR: No UNRELEASED section found", file=sys.stderr)
+        return 1
+
+    if not current:
+        print("ERROR: UNRELEASED section is empty — add a changelog entry", file=sys.stderr)
+        return 1
+
+    main_text = _main_changelog()
+    if main_text is not None:
+        main_content = _unreleased_content(main_text)
+        if current == (main_content or ""):
+            print(
+                "ERROR: UNRELEASED section is unchanged from main — add a changelog entry",
+                file=sys.stderr,
+            )
+            return 1
+
+    print("OK: UNRELEASED section has new content")
+    return 0
+
+
+def check_tag(tag: str) -> int:
+    text = CHANGELOG.read_text()
+
+    # Strip leading v from tag
+    version = tag.removeprefix("v")
+
+    # Look for a section matching this version
+    pattern = re.compile(
+        rf"^{re.escape(version)}\n-+\n",
+        re.MULTILINE,
+    )
+    if not pattern.search(text):
+        print(
+            f"ERROR: No changelog section found for {version}",
+            file=sys.stderr,
+        )
+        return 1
+
+    # UNRELEASED should not be present in a tagged release
+    if re.search(r"^UNRELEASED\n-+\n", text, re.MULTILINE):
+        print(
+            "ERROR: UNRELEASED section still present in tagged release",
+            file=sys.stderr,
+        )
+        return 1
+
+    print(f"OK: Changelog has section for {version}")
+    return 0
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--tag", help="Git tag to check against (e.g. v0.6)")
+    args = parser.parse_args()
+
+    if args.tag:
+        return check_tag(args.tag)
+    return check_unreleased()
+
+
+if __name__ == "__main__":
+    sys.exit(main())

check_changelog.py

@@ -0,0 +1,84 @@
+#!/usr/bin/env python3
+"""
+make_changelog.py — Update CHANGELOG.rst for releases.
+
+Usage:
+    python make_changelog.py <version>    Replace UNRELEASED with a dated section.
+    python make_changelog.py UNRELEASED   Add a new UNRELEASED section.
+"""
+
+from __future__ import annotations
+
+import argparse
+import re
+import sys
+from datetime import date
+from pathlib import Path
+
+CHANGELOG = Path(__file__).resolve().parent / "CHANGELOG.rst"
+
+UNRELEASED_SECTION = """\
+UNRELEASED
+----------
+
+*UNRELEASED*
+
+"""
+
+
+def add_unreleased() -> int:
+    text = CHANGELOG.read_text()
+
+    if re.search(r"^UNRELEASED\n-+\n", text, re.MULTILINE):
+        print("ERROR: UNRELEASED section already exists", file=sys.stderr)
+        return 1
+
+    # Insert after the top-level heading
+    match = re.search(r"^(Changelog\n=+\n)\n", text, re.MULTILINE)
+    if not match:
+        print("ERROR: Could not find Changelog heading", file=sys.stderr)
+        return 1
+
+    insert_at = match.end()
+    new_text = text[:insert_at] + UNRELEASED_SECTION + "\n" + text[insert_at:]
+    CHANGELOG.write_text(new_text)
+
+    print("CHANGELOG.rst updated: added UNRELEASED section")
+    return 0
+
+
+def cut_release(version: str) -> int:
+    today = date.today().strftime("%Y-%m-%d")
+    text = CHANGELOG.read_text()
+
+    pattern = re.compile(
+        r"^UNRELEASED\n-+\n\n\*UNRELEASED\*\n",
+        re.MULTILINE,
+    )
+    match = pattern.search(text)
+    if not match:
+        print("ERROR: Could not find UNRELEASED section in CHANGELOG.rst", file=sys.stderr)
+        return 1
+
+    underline = "-" * len(version)
+    replacement = f"{version}\n{underline}\n\n*{today}*\n"
+
+    new_text = text[: match.start()] + replacement + text[match.end() :]
+    CHANGELOG.write_text(new_text)
+
+    print(f"CHANGELOG.rst updated: UNRELEASED → {version} ({today})")
+    return 0
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("version", help="Release version (e.g. 0.6) or UNRELEASED")
+    args = parser.parse_args()
+
+    if args.version == "UNRELEASED":
+        return add_unreleased()
+    return cut_release(args.version)
+
+
+if __name__ == "__main__":
+    sys.exit(main())