debian-version.py

Go to the documentation of this file.

#!/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())