anastasis

debian-version.py (3578B)

---

 #!/usr/bin/env python3
 # This file is in the public domain.
 """Derive CI versions from the highest supported SemVer tag in the repository.
 
 Keep this helper and test_version.py identical across Buildbot Debian publishers.
 Only vX.Y.Z and vX.Y.Z-dev.K (optionally with build metadata) are release tags.
 Snapshots use X.Y.(Z+1)-0.N or X.Y.Z-dev.K.N in SemVer, and replace the
 prerelease separator with '~' and 'dev.' with 'dev' for Debian. Metadata and
 commit hashes do not affect either version. N counts tag..HEAD commits; only
 commit identity, not a zero count, makes a build an exact tagged release.
 """
 
 import re
 import subprocess
 import sys
 
 NUMBER = r"(0|[1-9][0-9]*)"
 TAG = re.compile(
     rf"v{NUMBER}\.{NUMBER}\.{NUMBER}(?:-dev\.{NUMBER})?"
     r"(?:\+([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?"
 )
 
 
 def parse_tag(name):
     """Return a sortable precedence tuple, or None for an unsupported tag."""
     match = TAG.fullmatch(name)
     if match is None:
         return None
     major, minor, patch, dev, _ = match.groups()
     return (int(major), int(minor), int(patch), dev is None,
             0 if dev is None else int(dev))
 
 
 def select_tag(names):
     candidates = []
     for name in names:
         rank = parse_tag(name)
         if rank is None:
             print(f"Ignoring unsupported version tag: {name}", file=sys.stderr)
         else:
             candidates.append((rank, name))
     if not candidates:
         raise ValueError("no supported version tags (expected vX.Y.Z or vX.Y.Z-dev.K)")
     highest = max(rank for rank, _ in candidates)
     # Metadata is irrelevant to precedence. Prefer the plain tag, then the
     # lexically first tag name, independent of Git's configured tag sorting.
     return min((name for rank, name in candidates if rank == highest),
                key=lambda name: ("+" in name, name))
 
 
 def versions(tag, exact, count):
     major, minor, patch, stable, dev = parse_tag(tag)
     if stable:
         base = f"{major}.{minor}.{patch if exact else patch + 1}"
         suffix = "" if exact else f"0.{count}"
     else:
         base = f"{major}.{minor}.{patch}"
         suffix = f"dev.{dev}" + ("" if exact else f".{count}")
     semver = base + (f"-{suffix}" if suffix else "")
     debian = base + ("~" + suffix.replace("dev.", "dev", 1) if suffix else "")
     return semver, debian
 
 
 def git(*args):
     return subprocess.check_output(["git", *args], text=True).strip()
 
 
 def main():
     try:
         if git("rev-parse", "--is-shallow-repository") != "false":
             raise ValueError("a full Git checkout is required; disable shallow cloning")
         head = git("rev-parse", "HEAD")
         # Fetch the scheduled commit, including on detached HEADs, and all tags.
         # Do not impose a depth limit or move HEAD to the selected tag.
         subprocess.run(["git", "fetch", "--no-recurse-submodules", "--tags",
                         "origin", head], check=True, stdout=sys.stderr)
         tag = select_tag(git("tag", "--list").splitlines())
         tagged_commit = git("rev-parse", f"{tag}^{{commit}}")
         count = int(git("rev-list", "--count", f"{tag}..{head}"))
         semver, debian = versions(tag, head == tagged_commit, count)
         print(f"Version tag: {tag}; HEAD: {head}; commits: {count}; "
               f"SemVer: {semver}; Debian: {debian}", file=sys.stderr)
         print(debian)
         return 0
     except (OSError, subprocess.CalledProcessError, ValueError) as error:
         print(f"Cannot determine CI version: {error}", file=sys.stderr)
         return 1
 
 
 if __name__ == "__main__":
     sys.exit(main())