git-tag-release 0.4.8__tar.gz

git_tag_release-0.4.8/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Egor Tensin <egor@tensin.name>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

git_tag_release-0.4.8/Makefile

@@ -0,0 +1,17 @@
+include prelude.mk
+
+PKG_NAME ?= tag-release
+DESTDIR  ?=
+
+$(eval $(call noexpand,PKG_NAME))
+$(eval $(call noexpand,DESTDIR))
+
+.PHONY: all
+all:
+
+.PHONY: install
+install:
+	install -D -m 0644 -t '$(call escape,$(DESTDIR))/usr/share/$(call escape,$(PKG_NAME))/'     LICENSE.txt
+	install -D -m 0644 -t '$(call escape,$(DESTDIR))/usr/share/doc/$(call escape,$(PKG_NAME))/' README.md
+
+	install -D -m 0755 -T src/release.py '$(call escape,$(DESTDIR))/usr/bin/$(call escape,$(PKG_NAME))'

git_tag_release-0.4.8/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: git-tag-release
+Version: 0.4.8
+Summary: Automate creation of semantic versioning tags
+Author-email: Egor Tensin <egor@tensin.name>
+License-Expression: MIT
+Project-URL: homepage, https://github.com/egor-tensin/tag-release
+Project-URL: issues, https://github.com/egor-tensin/tag-release/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.8
+License-File: LICENSE.txt
+Dynamic: license-file

git_tag_release-0.4.8/README.md

@@ -0,0 +1,75 @@
+tag-release
+===========
+
+[![CI](https://github.com/egor-tensin/tag-release/actions/workflows/ci.yml/badge.svg)](https://github.com/egor-tensin/tag-release/actions/workflows/ci.yml)
+[![Packages (Debian)](https://github.com/egor-tensin/tag-release/actions/workflows/debian.yml/badge.svg)](https://github.com/egor-tensin/tag-release/actions/workflows/debian.yml)
+[![Publish (Launchpad)](https://github.com/egor-tensin/tag-release/actions/workflows/ppa.yml/badge.svg)](https://github.com/egor-tensin/tag-release/actions/workflows/ppa.yml)
+
+I'm tired of looking up the correct tag name to use, hence this script.
+It follows the semantic versioning rules.
+Should work with any semi-recent Python version.
+
+Usage
+-----
+
+* View usage info:
+
+      ./src/release.py -h
+
+* Make a new patch version release in the current repo.
+Tries to parse the latest tag (say, v2.1.3) and will add a new tag (in this
+case, v2.1.4).
+
+      ../path/to/tag-release/src/release.py patch
+
+* Make a new minor version release in the current repo (v2.1.3 -> v2.2.0):
+
+      ../path/to/tag-release/src/release.py minor
+
+* Similar for major versions (v2.1.3 -> v3.0.0):
+
+      ../path/to/tag-release/src/release.py major
+
+* Accepts path to repository as an optional argument:
+
+      ./src/release.py patch path/to/your/repo
+
+* You can customize the version prefix ("v" by default).
+It will search for the latest tag with the given prefix then.
+For example, this command, given that tag "2.1.3" exists, will create tag
+"2.1.4":
+
+      ../path/to/tag-release/src/release.py -p '' patch
+
+* A prefix can be anything, basically; this will create tag "release/v2.2.0"
+if the latest tag is "release/v2.1.3":
+
+      ../path/to/tag-release/src/release.py -p 'release/v' minor
+
+* If no tags were found, the implicit version 0.0.0 is assumed.
+In a repository with no matching tags, this will create tag "v1.0.0":
+
+      ../path/to/tag-release/src/release.py major
+
+* Customize the tag message:
+
+      ../path/to/tag-release/src/release.py -m 'Release: version {}' patch
+
+* You can "retag" parent versions.
+For example, given that the latest tag is "v1.1.3", this will create/update
+tags "v1" & "v1.1" to point to the new tag "v1.1.4":
+
+      ../path/to/tag-release/src/release.py -r patch
+
+* Create lightweight tags, if you wish (using annotated tags, which is the
+default, is almost always the preferred option):
+
+      ../path/to/tag-release/src/release.py -l patch
+
+License
+-------
+
+Distributed under the MIT License.
+See [LICENSE.txt] for details.
+
+[LICENSE.txt]: LICENSE.txt

git_tag_release-0.4.8/prelude.mk

@@ -0,0 +1,29 @@
+# Please see https://tensin.name/blog/notes/makefile.html
+
+MAKEFLAGS += --no-builtin-rules --no-builtin-variables --warn-undefined-variables
+unexport MAKEFLAGS
+.DEFAULT_GOAL := all
+.DELETE_ON_ERROR:
+.SUFFIXES:
+SHELL := bash
+.SHELLFLAGS := -eu -o pipefail -c
+
+escape = $(subst ','\'',$(1))
+
+define noexpand
+ifeq ($$(origin $(1)),environment)
+    $(1) := $$(value $(1))
+endif
+ifeq ($$(origin $(1)),environment override)
+    $(1) := $$(value $(1))
+endif
+ifeq ($$(origin $(1)),command line)
+    override $(1) := $$(value $(1))
+endif
+endef
+
+# A helper target to force execution of pattern rules (works like .PHONY for
+# them): https://www.gnu.org/software/make/manual/html_node/Phony-Targets.html
+#
+.PHONY: DO
+DO:

git_tag_release-0.4.8/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+# The SPDX license identifiers are available from 77.0.3:
+# https://packaging.python.org/en/latest/guides/writing-pyproject-toml/#license-and-license-files
+requires = ["setuptools >= 77.0.3", "setuptools-scm"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "git-tag-release"
+description = "Automate creation of semantic versioning tags"
+license = "MIT"
+license-files = ["LICENSE.txt"]
+dynamic = ["version"]
+authors = [{name = "Egor Tensin", email = "egor@tensin.name"}]
+requires-python = ">=3.8"
+# ^^^ For shlex.join, at least?
+
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+]
+
+[project.urls]
+homepage = "https://github.com/egor-tensin/tag-release"
+issues = "https://github.com/egor-tensin/tag-release/issues"
+
+[project.scripts]
+tag-release = "release:main"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+py-modules = ["release"]
+
+[tool.setuptools_scm]

git_tag_release-0.4.8/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

git_tag_release-0.4.8/src/git_tag_release.egg-info/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: git-tag-release
+Version: 0.4.8
+Summary: Automate creation of semantic versioning tags
+Author-email: Egor Tensin <egor@tensin.name>
+License-Expression: MIT
+Project-URL: homepage, https://github.com/egor-tensin/tag-release
+Project-URL: issues, https://github.com/egor-tensin/tag-release/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.8
+License-File: LICENSE.txt
+Dynamic: license-file

git_tag_release-0.4.8/src/git_tag_release.egg-info/SOURCES.txt

@@ -0,0 +1,30 @@
+LICENSE.txt
+Makefile
+README.md
+prelude.mk
+pyproject.toml
+src/release.py
+src/git_tag_release.egg-info/PKG-INFO
+src/git_tag_release.egg-info/SOURCES.txt
+src/git_tag_release.egg-info/dependency_links.txt
+src/git_tag_release.egg-info/entry_points.txt
+src/git_tag_release.egg-info/scm_file_list.json
+src/git_tag_release.egg-info/scm_version.json
+src/git_tag_release.egg-info/top_level.txt
+test/main.sh
+test/tst-basic-major.sh
+test/tst-basic-minor.sh
+test/tst-basic-patch.sh
+test/tst-custom-message.sh
+test/tst-lightweight-tags.sh
+test/tst-no-tags-major.sh
+test/tst-no-tags-patch.sh
+test/tst-prefix-custom.sh
+test/tst-prefix-empty.sh
+test/tst-retag-lightweight.sh
+test/tst-retag.sh
+test/tst-strict-no.sh
+test/tst-strict-yes-prefix.sh
+test/tst-strict-yes.sh
+test/lib/log.sh
+test/lib/test.sh

git_tag_release-0.4.8/src/git_tag_release.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

git_tag_release-0.4.8/src/git_tag_release.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+tag-release = release:main

git_tag_release-0.4.8/src/git_tag_release.egg-info/scm_file_list.json

@@ -0,0 +1,27 @@
+{
+  "files": [
+    "LICENSE.txt",
+    "Makefile",
+    "README.md",
+    "prelude.mk",
+    "pyproject.toml",
+    "src/release.py",
+    "test/lib/log.sh",
+    "test/lib/test.sh",
+    "test/main.sh",
+    "test/tst-basic-major.sh",
+    "test/tst-basic-minor.sh",
+    "test/tst-basic-patch.sh",
+    "test/tst-custom-message.sh",
+    "test/tst-lightweight-tags.sh",
+    "test/tst-no-tags-major.sh",
+    "test/tst-no-tags-patch.sh",
+    "test/tst-prefix-custom.sh",
+    "test/tst-prefix-empty.sh",
+    "test/tst-retag-lightweight.sh",
+    "test/tst-retag.sh",
+    "test/tst-strict-no.sh",
+    "test/tst-strict-yes-prefix.sh",
+    "test/tst-strict-yes.sh"
+  ]
+}

git_tag_release-0.4.8/src/git_tag_release.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.4.8",
+  "distance": 0,
+  "node": "g0f3a28d95c826c0c5a10512c79b281f840161d57",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-09-30"
+}

git_tag_release-0.4.8/src/git_tag_release.egg-info/top_level.txt

@@ -0,0 +1 @@
+release

git_tag_release-0.4.8/src/release.py

@@ -0,0 +1,424 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2026 Egor Tensin <egor@tensin.name>
+# This file is part of the "tag-release" project.
+# For details, see https://github.com/egor-tensin/tag-release
+# Distributed under the MIT License.
+
+R"""
+This script automates the creation of git tags in accordance with the semantic
+versioning policy. It follows the convention of tags being in the MAJOR.MINOR.PATCH
+format (with an optional prefix - "v" by default). You can then use it to bump
+either of the major/minor/patch version numbers, and it will take care of
+creating the proper tag for you.
+"""
+
+import argparse
+from contextlib import contextmanager
+from dataclasses import dataclass
+from enum import Enum
+import logging
+import os
+import re
+import shlex
+import subprocess
+import sys
+
+
+@contextmanager
+def setup_logging(verbose=False):
+    level_names = {
+        logging.DEBUG: "DBG",
+        logging.INFO: "INFO",
+        logging.WARNING: "WARN",
+        logging.ERROR: "ERR",
+        logging.CRITICAL: "CRIT",
+    }
+    for lvl, name in level_names.items():
+        logging.addLevelName(lvl, name)
+
+    logging.basicConfig(
+        datefmt="%Y-%m-%d %H:%M:%S%z",
+        format="%(asctime)s | %(levelname)4s | %(message)s",
+        level=logging.DEBUG if verbose else logging.INFO,
+        stream=sys.stdout,
+    )
+    try:
+        yield
+    except Exception as e:
+        logging.exception(e)
+        sys.exit(1)
+
+
+def _run_log_output(level, output):
+    if not output:
+        logging.log(level, "... No output")
+        return
+    logging.log(level, "Output (%d characters):", len(output))
+    for line in output.splitlines():
+        logging.log(level, "    %s", line)
+
+
+def run(*args, **kwargs):
+    stdout = subprocess.PIPE
+    stderr = subprocess.STDOUT
+
+    logging.info("Running: %s", shlex.join(args))
+    try:
+        result = subprocess.run(
+            args, check=True, stdout=stdout, stderr=stderr, encoding="utf-8", **kwargs
+        )
+    except subprocess.CalledProcessError as e:
+        logging.error("... Returned exit code %d", e.returncode)
+        _run_log_output(logging.ERROR, e.output)
+        raise
+
+    _run_log_output(logging.DEBUG, result.stdout)
+    return result.stdout
+
+
+def go_to_repo(repo_dir=None):
+    if repo_dir is not None:
+        os.chdir(repo_dir)
+    try:
+        run(*["git", "rev-parse", "--is-inside-work-tree"])
+    except subprocess.CalledProcessError as e:
+        logging.error("%s doesn't seem to be a git working directory", os.getcwd())
+        raise
+
+
+class ReleaseScope(Enum):
+    MAJOR = "major"
+    MINOR = "minor"
+    PATCH = "patch"
+
+    def __str__(self):
+        return self.value
+
+    def next_version(self, version):
+        version = version.extend(len(ReleaseScope))
+        version = version.upgrade(self._index)
+        return version
+
+    @property
+    def _index(self):
+        if self is ReleaseScope.MAJOR:
+            return 0
+        if self is ReleaseScope.MINOR:
+            return 1
+        if self is ReleaseScope.PATCH:
+            return 2
+        raise NotImplementedError(f"Unknown release scope: {self}")
+
+
+class Version:
+    def __init__(self, nums):
+        nums = list(nums)
+        if len(nums) > len(ReleaseScope):
+            raise ValueError(f"Too many version components: {nums}")
+
+        while nums and nums[-1] is None:
+            nums.pop()
+        if not nums:
+            raise ValueError("Must provide at least the major version number")
+        if any((n is None for n in nums)):
+            raise ValueError(f"Some version components are invalid: {nums}")
+
+        self._nums = tuple(nums)
+
+    @staticmethod
+    def parse(src, strict=False):
+        invalid_msg = f"Invalid version: {src}"
+
+        match = re.fullmatch(r"(\d+)(?:\.(\d+)(?:\.(\d+))?)?", src)
+        if not match:
+            if strict:
+                raise ValueError(invalid_msg)
+            logging.warning("%s", invalid_msg)
+            return None
+        assert len(match.groups()) == 3
+
+        nums = [int(n) if n is not None else None for n in match.groups()]
+        return Version(nums)
+
+    def __str__(self):
+        return ".".join(map(str, self._nums))
+
+    def __eq__(self, other):
+        return self._nums == other._nums
+
+    def __lt__(self, other):
+        # Attempting to sort the way `sort -V` does it (so v1 < v1.0 for example).
+        for a, b in zip(self._nums, other._nums):
+            if a > b:
+                return False
+            if a < b:
+                return True
+        return len(self._nums) < len(other._nums)
+
+    def __hash__(self):
+        return hash(self._nums)
+
+    def extend(self, new_len):
+        if new_len < 1 or new_len > len(ReleaseScope):
+            raise ValueError(f"Invalid version length {new_len}")
+        if len(self._nums) >= new_len:
+            return Version(self._nums)
+        nums = list(self._nums)
+        nums.extend([0 for i in range(new_len - len(self._nums))])
+        return Version(nums)
+
+    def upgrade(self, idx):
+        assert idx < len(ReleaseScope)
+        if idx < 0 or len(self._nums) < idx + 1:
+            raise ValueError(
+                f"Can't increment version number at index {idx} for version {self}"
+            )
+        nums = list(self._nums[:idx])
+        nums.append(self._nums[idx] + 1)
+        nums.extend([0 for i in range(len(self._nums) - idx - 1)])
+        return Version(nums)
+
+    @property
+    def has_parent(self):
+        return len(self._nums) > 1
+
+    def get_parent(self):
+        return Version(self._nums[:-1])
+
+
+@dataclass
+class Tag:
+    name: str
+    version: Version
+    lightweight: bool
+
+    def git_cmd_create(self, message=None, target=None):
+        cmd = ["git", "tag"]
+        if self.lightweight:
+            return cmd + [self.name]
+        if message is None:
+            raise ValueError("Must provide a tag message for annotated tags")
+        cmd += ["-a", "-m", message, self.name]
+        if target is not None:
+            cmd.append(target.name + "^{}")
+            # ^^^ Avoid tags-to-tags, which is somehow bad, idk.
+        return cmd
+
+    def git_cmd_update(self, target):
+        cmd = ["git", "tag"]
+        if self.lightweight:
+            return cmd + ["-f", self.name, target.name]
+        cmd += ["-a", "-f", self.name]
+        cmd.append(target.name + "^{}")
+        # ^^^ Avoid tags-to-tags, which is somehow bad, idk.
+        return cmd
+
+
+class TagManager:
+    DEFAULT_PREFIX = "v"
+    DEFAULT_VERSION = Version((0 for _ in range(len(ReleaseScope))))
+    DEFAULT_MESSAGE_FMT = "{}"
+
+    def __init__(self, prefix=None, strict=False, lightweight=False, message_fmt=None):
+        if prefix is None:
+            prefix = TagManager.DEFAULT_PREFIX
+        self._prefix = prefix
+        self._strict = strict
+        self._lightweight = lightweight
+        if message_fmt is None:
+            message_fmt = TagManager.DEFAULT_MESSAGE_FMT
+        self._message_fmt = message_fmt
+
+        tags = self._git_query_tags()
+        tags = self._git_filter_tags(tags)
+        tags = self._git_parse_tags(tags)
+        tags = list(tags)
+        if not tags:
+            version = TagManager.DEFAULT_VERSION
+            tags = [Tag(self._format_tag_name(version), version, lightweight)]
+
+        self._tag_lst = sorted(tags, key=lambda tag: tag.version)
+        self._tag_map = {tag.version: tag for tag in tags}
+
+    def _format_tag_name(self, version):
+        return f"{self._prefix}{version}"
+
+    @staticmethod
+    def _git_query_tags():
+        cmd = [
+            "git",
+            "for-each-ref",
+            "--format=%(refname:short) %(objecttype)",
+            "refs/tags/",
+        ]
+
+        output = run(*cmd)
+        lines = output.splitlines()
+
+        for line in lines:
+            line = line.split()
+            assert len(line) == 2
+            yield line
+
+    def _git_filter_tags(self, tags):
+        for refname, objecttype in tags:
+            if not refname.startswith(self._prefix):
+                msg = f"Unexpected tag name: {refname}"
+                if self._strict:
+                    raise RuntimeError(msg)
+                logging.warning("%s", msg)
+                continue
+            yield refname.removeprefix(self._prefix), objecttype
+
+    @staticmethod
+    def _is_tag_lightweight(objecttype):
+        if objecttype == "commit":
+            return True
+        if objecttype == "tag":
+            return False
+        raise ValueError(f"Unexpected %(objecttype) value: {objecttype}")
+
+    def _git_parse_tags(self, tags):
+        for refname, objecttype in tags:
+            version = Version.parse(refname, strict=self._strict)
+            if version is None:
+                continue
+            lightweight = self._is_tag_lightweight(objecttype)
+            yield Tag(self._format_tag_name(version), version, lightweight)
+
+    def __len__(self):
+        return len(self._tag_lst)
+
+    @property
+    def latest(self):
+        if not self:
+            raise RuntimeError("No tags, can't get the latest")
+        return self._tag_lst[-1]
+
+    def create(self, tag, target=None):
+        if tag.version in self._tag_map:
+            raise RuntimeError(f"Tag {tag.name} already exists")
+
+        cmd = tag.git_cmd_create(
+            message=self._message_fmt.format(tag.name), target=target
+        )
+        run(*cmd)
+
+        self._tag_lst.append(tag)
+        self._tag_lst.sort(key=lambda tag: tag.version)
+        self._tag_map[tag.version] = tag
+
+    def update(self, parent, child):
+        if parent.version not in self._tag_map:
+            raise RuntimeError(f"Tag {parent.name} doesn't exist")
+        if child.version not in self._tag_map:
+            raise RuntimeError(f"Tag {child.name} doesn't exist")
+
+        cmd = parent.git_cmd_update(child)
+        env = os.environ.copy()
+        env["GIT_EDITOR"] = "true"
+        run(*cmd, env=env)
+
+    def release_next(self, scope):
+        version = scope.next_version(self.latest.version)
+        tag = Tag(f"{self._prefix}{version}", version, self._lightweight)
+        self.create(tag)
+        return tag
+
+    def retag_parents(self, child):
+        while child.version.has_parent:
+            parent_version = child.version.get_parent()
+            if parent_version in self._tag_map:
+                parent = self._tag_map[parent_version]
+                self.update(parent, child)
+                child = parent
+                continue
+            parent = Tag(
+                self._format_tag_name(parent_version),
+                parent_version,
+                self._lightweight,
+            )
+            self.create(parent, target=child)
+            child = parent
+
+
+def parse_args(argv=None):
+    if argv is None:
+        argv = sys.argv[1:]
+
+    epilog = R"""
+The tag message (--message) can include Python's str.format() placeholders.
+It will be format()ted with a single argument: the full tag name (for example,
+v1.2.3).
+"""
+
+    parser = argparse.ArgumentParser(description=__doc__, epilog=epilog)
+
+    parser.add_argument("-v", "--verbose", action="store_true", help="verbose output")
+    parser.add_argument(
+        "-p",
+        "--prefix",
+        default=TagManager.DEFAULT_PREFIX,
+        metavar="STR",
+        help=f"""tag prefix ("{TagManager.DEFAULT_PREFIX}" by default)""",
+    )
+    parser.add_argument(
+        "-s",
+        "--strict",
+        action="store_true",
+        help="error out on discovering malformed tags",
+    )
+    parser.add_argument(
+        "-l",
+        "--lightweight",
+        action="store_true",
+        help="create lightweight tags (annotated by default)",
+    )
+    parser.add_argument(
+        "-m",
+        "--message",
+        metavar="FMT",
+        dest="message_fmt",
+        default=TagManager.DEFAULT_MESSAGE_FMT,
+        help="tag message format string",
+    )
+    parser.add_argument(
+        "-r",
+        "--retag",
+        action="store_true",
+        help="update parent version tags (i.e. for tag v2.1.1, update tags v2 & v2.1 to point to it)",
+    )
+    parser.add_argument(
+        "release_scope",
+        choices=ReleaseScope,
+        type=ReleaseScope,
+        help="release scope",
+    )
+    parser.add_argument(
+        "repo_dir",
+        metavar="DIR",
+        nargs="?",
+        help="path to repository (working directory by default)",
+    )
+
+    return parser.parse_args(argv)
+
+
+def main(argv=None):
+    args = parse_args(argv)
+    with setup_logging(args.verbose):
+        go_to_repo(args.repo_dir)
+        tags = TagManager(
+            prefix=args.prefix,
+            strict=args.strict,
+            lightweight=args.lightweight,
+            message_fmt=args.message_fmt,
+        )
+        new = tags.release_next(args.release_scope)
+        if args.retag:
+            tags.retag_parents(new)
+
+
+if __name__ == "__main__":
+    main()

git_tag_release-0.4.8/test/lib/log.sh

@@ -0,0 +1,139 @@
+# Copyright (c) 2026 Egor Tensin <egor@tensin.name>
+# This file is part of the "tag-release" project.
+# For details, see https://github.com/egor-tensin/tag-release
+# Distributed under the MIT License.
+
+log() {
+    local msg
+    for msg; do
+        echo -e "$test_file | $msg" >&2
+    done
+}
+
+log_run() {
+    if [ "$#" -lt 1 ]; then
+        log "usage: ${FUNCNAME[0]} ARGV0 [ARG...]"
+        return 1
+    fi
+
+    local msg='Running:'
+    msg="$msg$( printf -- ' %q' "$@" )"
+    log "$msg"
+}
+
+fail() {
+    local msg
+    for msg; do
+        log "FAIL: $msg"
+    done
+}
+
+fail_details() {
+    local msg
+    for msg; do
+        fail "    $msg"
+    done
+}
+
+log_numof_tests_ok=0
+log_numof_tests_failed=0
+declare -a log_tests_failed=()
+declare -A log_tests_should_fail=()
+
+log_test_start() {
+    if [ "$#" -ne 1 ]; then
+        echo "usage: ${FUNCNAME[0]} TEST_FILE" >&2
+        return 1
+    fi
+
+    local test_file="$1"
+
+    if [ -n "${test_should_fail:-}" ]; then
+        log_tests_should_fail["$test_file"]=1
+    fi
+
+    cat <<EOF >&2
+
+======================================================================
+TEST: $test_file
+======================================================================
+EOF
+
+    log "Should fail: ${test_should_fail:-No}"
+}
+
+log_test_ok() {
+    if [ "$#" -ne 1 ]; then
+        echo "usage: ${FUNCNAME[0]} TEST_FILE" >&2
+        return 1
+    fi
+
+    log_numof_tests_ok=$((log_numof_tests_ok + 1))
+
+    cat <<EOF >&2
+----------------------------------------------------------------------
+OK: $1
+----------------------------------------------------------------------
+EOF
+}
+
+log_test_fail() {
+    if [ "$#" -ne 1 ]; then
+        echo "usage: ${FUNCNAME[0]} TEST_FILE" >&2
+        return 1
+    fi
+
+    log_numof_tests_failed=$((log_numof_tests_failed + 1))
+    log_tests_failed+=("$1")
+
+    cat <<EOF >&2
+----------------------------------------------------------------------
+FAIL: $1
+----------------------------------------------------------------------
+EOF
+}
+
+log_test_finish() {
+    if [ "$#" -ne 2 ]; then
+        echo "usage: ${FUNCNAME[0]} TEST_FILE EXIT_CODE" >&2
+        return 1
+    fi
+
+    local test_file="$1"
+    local ret="$2"
+    local test_should_fail
+    test_should_fail="${log_tests_should_fail["$test_file"]:+x}"
+
+    if [ "$ret" -eq 0 ] || [ -n "$test_should_fail" ]; then
+        log_test_ok "$test_file"
+    else
+        log_test_fail "$test_file"
+    fi
+}
+
+log_tests_summary() {
+    cat <<EOF >&2
+
+======================================================================
+SUMMARY
+======================================================================
+OK:   $log_numof_tests_ok
+FAIL: $log_numof_tests_failed
+EOF
+
+    local test_file
+    for test_file in ${log_tests_failed[@]+"${log_tests_failed[@]}"}; do
+        cat <<EOF >&2
+FAIL: $test_file
+EOF
+    done
+
+    cat <<EOF >&2
+----------------------------------------------------------------------
+EOF
+
+    local ret=0
+    [ "$log_numof_tests_failed" -gt 0 ] && ret=1
+
+    return "$ret"
+}

git_tag_release-0.4.8/test/lib/test.sh

@@ -0,0 +1,198 @@
+# Copyright (c) 2026 Egor Tensin <egor@tensin.name>
+# This file is part of the "tag-release" project.
+# For details, see https://github.com/egor-tensin/tag-release
+# Distributed under the MIT License.
+
+test_should_fail=
+test_root_dir=
+
+test_repo_workdir=
+
+test_setup() {
+    test_root_dir="$( mktemp -d )"
+
+    test_repo_workdir="$test_root_dir/workdir"
+    mkdir -- "$test_repo_workdir"
+
+    log "Root directory: $test_root_dir"
+    log "Working directory: $test_repo_workdir"
+
+    git -C "$test_repo_workdir" init -q
+    git -C "$test_repo_workdir" config user.name 'Test user'
+    git -C "$test_repo_workdir" config user.email 'test@example.com'
+}
+
+test_cleanup_default() {
+    if [ -n "$test_root_dir" ]; then
+        log "Removing test's root directory: $test_root_dir"
+        rm -rf -- "$test_root_dir"
+    fi
+}
+
+test_make_commit() {
+    local file
+    file="$( mktemp "--tmpdir=$test_repo_workdir" )"
+
+    log "Commiting file $file in $test_repo_workdir..."
+    touch -- "$file"
+    git -C "$test_repo_workdir" add "$file"
+    git -C "$test_repo_workdir" commit -q -m "$file"
+}
+
+_validate_tag_kind() {
+    if [ "$#" -ne 1 ]; then
+        log "usage: ${FUNCNAME[0]} {lightweight|annotated}"
+        return 1
+    fi
+
+    case "$1" in
+        lightweight|annotated)
+            echo "$1"
+            ;;
+        *)
+            log "${FUNCNAME[1]}: invalid tag type: $kind"
+            return 1
+            ;;
+    esac
+}
+
+test_get_tags() {
+    if [ "$#" -gt 1 ]; then
+        log "usage: ${FUNCNAME[0]} [{lightweight|annotated}]"
+        return 1
+    fi
+
+    local kind=
+    [ "$#" -gt 0 ] && kind="$( _validate_tag_kind "$1" )"
+
+    log "Reading tags in $test_repo_workdir..."
+
+    local objecttype
+    local refname
+
+    git -C "$test_repo_workdir" for-each-ref refs/tags/ \
+        '--format=%(objecttype)%0a%(refname:short)' |
+    while IFS= read -r objecttype; do
+        IFS= read -r refname
+
+        case "$kind-$objecttype" in
+            lightweight-commit|annotated-tag|-*)
+                echo "$refname"
+                ;;
+        esac
+    done | sort -V
+}
+
+test_get_tag_message() {
+    if [ "$#" -ne 1 ]; then
+        log "usage: ${FUNCNAME[0]} TAG"
+        return 1
+    fi
+
+    local tag="$1"
+
+    git -C "$test_repo_workdir" for-each-ref "refs/tags/$tag" '--format=%(contents)'
+}
+
+test_get_tag_commit() {
+    if [ "$#" -ne 1 ]; then
+        log "usage: ${FUNCNAME[0]} TAG"
+        return 1
+    fi
+
+    local tag="$1"
+
+    git -C "$test_repo_workdir" rev-list -n 1 "$tag" --
+}
+
+test_create_tags() {
+    local tag
+    for tag; do
+        log "Creating simple tag: $tag"
+        touch -- "$test_repo_workdir/$tag"
+        git -C "$test_repo_workdir" add "$test_repo_workdir/$tag"
+        git -C "$test_repo_workdir" commit -q -m "$tag"
+        git -C "$test_repo_workdir" tag -a -m "$tag" "$tag"
+    done
+}
+
+test_validate_tags() {
+    if [ "$#" -lt 1 ] || [ "$#" -gt 2 ]; then
+        log "usage: ${FUNCNAME[0]} REPO_DIR EXPECTED_TAGS [{lightweight,annotated}]"
+        return 1
+    fi
+
+    local expected="$1"
+
+    local kind=
+    [ "$#" -gt 1 ] && kind="$( _validate_tag_kind "$2" )"
+
+    local actual
+    actual="$( test_get_tags $kind | paste -s -d ',' )"
+
+    log "Validating tags in $test_repo_workdir..."
+
+    [ "$actual" == "$expected" ] && return 0
+
+    fail "Unexpected tags"
+    fail_details "Expected tags: $expected"
+    fail_details "Actual tags:   $actual"
+    return 1
+}
+
+test_validate_tag_message() {
+    if [ "$#" -ne 2 ]; then
+        log "usage: ${FUNCNAME[0]} TAG EXPECTED_MSG"
+        return 1
+    fi
+
+    local tag="$1"
+    local expected="$2"
+
+    log "Validating tag message for tag: $tag"
+
+    local actual
+    actual="$( test_get_tag_message "$tag" )"
+
+    [ "$actual" == "$expected" ] && return 0
+
+    fail "Unexpected message for tag $tag:"
+    fail_details "Expected: $expected"
+    fail_details "Actual: $actual"
+    return 1
+}
+
+test_validate_tags_same_target() {
+    if [ "$#" -lt 2 ]; then
+        log "usage: ${FUNCNAME[0]} TAG1 TAG2 [TAG...]"
+        return 1
+    fi
+
+    local tgt=
+
+    local tag
+    for tag; do
+        log "Validating tag target for tag: $tag"
+
+        local output
+        output="$( test_get_tag_commit "$tag" )"
+
+        if [ -z "$tgt" ]; then
+            tgt="$output"
+            continue
+        fi
+
+        if [ "$tgt" != "$output" ]; then
+            fail "Tag '$tag' doesn't point to the expected revision"
+            fail_details "Expected: $tgt"
+            fail_details "Actual: $output"
+            return 1
+        fi
+    done
+}
+
+test_run_release_script() {
+    local cmd=("$script_dir/../src/release.py" --verbose "$@" "$test_repo_workdir")
+    log_run "${cmd[@]}"
+    "${cmd[@]}"
+}

git_tag_release-0.4.8/test/main.sh

@@ -0,0 +1,77 @@
+#!/usr/bin/env bash
+
+# Copyright (c) 2026 Egor Tensin <egor@tensin.name>
+# This file is part of the "tag-release" project.
+# For details, see https://github.com/egor-tensin/tag-release
+# Distributed under the MIT License.
+
+set -o errexit -o nounset -o pipefail
+shopt -s inherit_errexit lastpipe
+
+script_dir="$( dirname -- "${BASH_SOURCE[0]}" )"
+script_dir="$( cd -- "$script_dir" && pwd )"
+readonly script_dir
+script_name="$( basename -- "${BASH_SOURCE[0]}" )"
+readonly script_name
+
+source "$script_dir/lib/log.sh"
+
+run_test_file() {
+    local test_file
+    for test_file; do
+        source "$script_dir/lib/test.sh"
+        source "$script_dir/$test_file"
+
+        log_test_start "$test_file"
+
+        set +e
+        (
+            set -o errexit -o nounset -o pipefail
+            shopt -s inherit_errexit lastpipe
+
+            if [ "$( type -t test_cleanup )" == function ]; then
+                trap test_cleanup EXIT
+            else
+                trap test_cleanup_default EXIT
+            fi
+
+            test_run
+        )
+        local ret="$?"
+        set -e
+
+        log_test_finish "$test_file" "$ret"
+    done
+}
+
+main() {
+    if [ "$#" -gt 1 ]; then
+        echo "usage: $script_name [PATTERN]" >&2
+        return 1
+    fi
+
+    local -a test_files=()
+    local test_file
+
+    local pattern='*'
+    [ "$#" -gt 0 ] && pattern="$1"
+
+    find "$script_dir" \
+        -mindepth 1 \
+        -maxdepth 1 \
+        -type f \
+        -regex '.*/tst-.*\.sh$' \
+        -regextype posix-basic \
+        -name "$pattern" \
+        -printf '%P\0' \
+        | sort -z \
+        | \
+    while IFS= read -d '' -r test_file; do
+        test_files+=("$test_file")
+    done
+
+    run_test_file ${test_files[@]+"${test_files[@]}"}
+    log_tests_summary
+}
+
+main "$@"

git_tag_release-0.4.8/test/tst-basic-major.sh

@@ -0,0 +1,6 @@
+test_run() {
+    test_setup
+    test_create_tags v1
+    test_run_release_script major
+    test_validate_tags v1,v2.0.0
+}

git_tag_release-0.4.8/test/tst-basic-minor.sh

@@ -0,0 +1,6 @@
+test_run() {
+    test_setup
+    test_create_tags v1
+    test_run_release_script minor
+    test_validate_tags v1,v1.1.0
+}

git_tag_release-0.4.8/test/tst-basic-patch.sh

@@ -0,0 +1,6 @@
+test_run() {
+    test_setup
+    test_create_tags v1
+    test_run_release_script patch
+    test_validate_tags v1,v1.0.1
+}

git_tag_release-0.4.8/test/tst-custom-message.sh

@@ -0,0 +1,17 @@
+test_run() {
+    test_setup
+    test_create_tags v1.0.0
+
+    test_run_release_script -l -m "shouldn't be visible" major
+    test_run_release_script -m "minor release" minor
+    test_run_release_script -p 'debian/' --message "Debian release {}" patch
+    test_run_release_script -m $'foo\n\nbar' patch
+
+    test_validate_tags debian/0.0.1,v1.0.0,v2.0.0,v2.1.0,v2.1.1
+    test_validate_tags debian/0.0.1,v1.0.0,v2.1.0,v2.1.1 annotated
+    test_validate_tags v2.0.0 lightweight
+
+    test_validate_tag_message v2.1.0 'minor release'
+    test_validate_tag_message debian/0.0.1 'Debian release debian/0.0.1'
+    test_validate_tag_message v2.1.1 $'foo\n\nbar'
+}

git_tag_release-0.4.8/test/tst-lightweight-tags.sh

@@ -0,0 +1,12 @@
+test_run() {
+    test_setup
+    test_create_tags v1.0.0
+
+    test_run_release_script --lightweight major
+    test_run_release_script minor
+    test_run_release_script --l patch
+
+    test_validate_tags v1.0.0,v2.0.0,v2.1.0,v2.1.1
+    test_validate_tags v1.0.0,v2.1.0 annotated
+    test_validate_tags v2.0.0,v2.1.1 lightweight
+}

git_tag_release-0.4.8/test/tst-no-tags-major.sh

@@ -0,0 +1,6 @@
+test_run() {
+    test_setup
+    test_make_commit
+    test_run_release_script major
+    test_validate_tags v1.0.0
+}

git_tag_release-0.4.8/test/tst-no-tags-patch.sh

@@ -0,0 +1,6 @@
+test_run() {
+    test_setup
+    test_make_commit
+    test_run_release_script patch
+    test_validate_tags v0.0.1
+}

git_tag_release-0.4.8/test/tst-prefix-custom.sh

@@ -0,0 +1,6 @@
+test_run() {
+    test_setup
+    test_create_tags V1 V2 V2.1
+    test_run_release_script -p V major
+    test_validate_tags V1,V2,V2.1,V3.0.0
+}

git_tag_release-0.4.8/test/tst-prefix-empty.sh

@@ -0,0 +1,6 @@
+test_run() {
+    test_setup
+    test_create_tags 1 2 2.1
+    test_run_release_script -p '' major
+    test_validate_tags 1,2,2.1,3.0.0
+}

git_tag_release-0.4.8/test/tst-retag-lightweight.sh

@@ -0,0 +1,21 @@
+test_run() {
+    test_setup
+
+    test_create_tags v1
+    test_make_commit
+    test_run_release_script minor
+    test_make_commit
+    test_run_release_script patch
+
+    test_validate_tags v1,v1.1.0,v1.1.1 annotated
+
+    test_make_commit
+    test_run_release_script -l -r patch
+
+    test_validate_tags v1,v1.1,v1.1.0,v1.1.1,v1.1.2
+    test_validate_tags v1,v1.1.0,v1.1.1 annotated
+    test_validate_tags v1.1,v1.1.2 lightweight
+
+    test_validate_tags_same_target v1 v1.1 v1.1.2
+    test_validate_tag_message v1 v1
+}

git_tag_release-0.4.8/test/tst-retag.sh

@@ -0,0 +1,20 @@
+test_run() {
+    test_setup
+
+    test_create_tags v1
+    test_make_commit
+    test_run_release_script minor
+    test_make_commit
+    test_run_release_script patch
+
+    test_validate_tags v1,v1.1.0,v1.1.1 annotated
+
+    test_make_commit
+    test_run_release_script -r patch
+
+    test_validate_tags v1,v1.1,v1.1.0,v1.1.1,v1.1.2 annotated
+
+    test_validate_tags_same_target v1 v1.1 v1.1.2
+    test_validate_tag_message v1 v1
+    test_validate_tag_message v1.1 v1.1
+}

git_tag_release-0.4.8/test/tst-strict-no.sh

@@ -0,0 +1,6 @@
+test_run() {
+    test_setup
+    test_create_tags v1 test_tag v2
+    test_run_release_script patch
+    test_validate_tags test_tag,v1,v2,v2.0.1
+}

git_tag_release-0.4.8/test/tst-strict-yes-prefix.sh

@@ -0,0 +1,8 @@
+test_should_fail=Yes
+
+test_run() {
+    test_setup
+    test_create_tags v1 vinvalid v2
+    test_run_release_script --strict patch
+    test_validate_tags vinvalid,v1,v2,v2.0.1
+}

git_tag_release-0.4.8/test/tst-strict-yes.sh

@@ -0,0 +1,7 @@
+test_should_fail=Yes
+
+test_run() {
+    test_setup
+    test_create_tags v1 test_tag v2
+    test_run_release_script --strict patch
+}