commit-and-tag-version 0.0.1__py3-none-any.whl

commit_and_tag_version/__init__.py

@@ -0,0 +1,68 @@
+"""Versioning using semver and CHANGELOG generation powered by Conventional Commits."""
+
+from pathlib import Path
+
+from commit_and_tag_version.checkpoint import print_error
+from commit_and_tag_version.git import get_latest_semver_tag
+from commit_and_tag_version.lifecycles.bump import bump
+from commit_and_tag_version.lifecycles.changelog import (
+    START_OF_LAST_RELEASE_PATTERN,
+    changelog,
+)
+from commit_and_tag_version.lifecycles.commit import commit
+from commit_and_tag_version.lifecycles.tag import tag
+from commit_and_tag_version.models import Config
+from commit_and_tag_version.updaters import resolve_updater_object
+
+
+def commit_and_tag_version(config: Config) -> None:
+    if config.header and START_OF_LAST_RELEASE_PATTERN.search(config.header):
+        raise ValueError(
+            f"custom changelog header must not match {START_OF_LAST_RELEASE_PATTERN.pattern}"
+        )
+
+    pkg = None
+    version = None
+
+    for package_file in config.package_files:
+        updater_obj = resolve_updater_object(package_file)
+        if not updater_obj:
+            continue
+        pkg_path = Path.cwd() / updater_obj["filename"]
+        try:
+            contents = pkg_path.read_text(encoding="utf-8")
+            updater = updater_obj["updater"]
+            pkg = {
+                "version": updater.read_version(contents),
+                "private": (
+                    updater.is_private(contents) if hasattr(updater, "is_private") else False
+                ),
+            }
+            version = pkg["version"]
+            break
+        except (FileNotFoundError, KeyError, ValueError):
+            continue
+
+    all_skipped = (
+        config.skip.bump and config.skip.changelog and config.skip.commit and config.skip.tag
+    )
+
+    if version is None:
+        if all_skipped:
+            return
+        if config.git_tag_fallback:
+            version = get_latest_semver_tag(config.tag_prefix)
+        else:
+            raise RuntimeError("no package file found")
+
+    if all_skipped:
+        return
+
+    try:
+        new_version = bump(config, version) if not config.skip.bump else version
+        changelog(config, new_version)
+        commit(config, new_version)
+        tag(new_version, pkg["private"] if pkg else False, config)
+    except Exception as err:
+        print_error(str(err), silent=config.silent)
+        raise

commit_and_tag_version/checkpoint.py

@@ -0,0 +1,18 @@
+import sys
+
+
+def checkpoint(msg: str, args: list[str], silent: bool = False, dry_run: bool = False) -> None:
+    if silent:
+        return
+    figure = "\u2713" if not dry_run else "\u2299"
+    formatted_args = [f"\033[1m{a}\033[0m" for a in args]
+    formatted_msg = msg
+    for arg in formatted_args:
+        formatted_msg = formatted_msg.replace("%s", arg, 1)
+    print(f"  {figure} {formatted_msg}", file=sys.stderr)
+
+
+def print_error(msg: str, silent: bool = False) -> None:
+    if silent:
+        return
+    print(f"\033[31m{msg}\033[0m", file=sys.stderr)

commit_and_tag_version/cli.py

@@ -0,0 +1,76 @@
+import sys
+
+import click
+
+from commit_and_tag_version import commit_and_tag_version
+from commit_and_tag_version.config import load_config
+
+
+@click.command(name="commit-and-tag-version")
+@click.option(
+    "--release-as", "-r", type=str, default=None, help="Specify release type or exact version"
+)
+@click.option(
+    "--prerelease",
+    "-p",
+    type=str,
+    default=None,
+    is_flag=False,
+    flag_value="",
+    help="Make a prerelease with optional tag id",
+)
+@click.option(
+    "--first-release", "-f", is_flag=True, default=False, help="Is this the first release?"
+)
+@click.option("--sign", "-s", is_flag=True, default=False, help="GPG sign commits and tags")
+@click.option("--signoff", is_flag=True, default=False, help="Add Signed-off-by trailer")
+@click.option("--no-verify", "-n", is_flag=True, default=False, help="Bypass git hooks")
+@click.option("--commit-all", "-a", is_flag=True, default=False, help="Commit all staged changes")
+@click.option("--dry-run", is_flag=True, default=False, help="Simulate without making changes")
+@click.option("--silent", is_flag=True, default=False, help="Suppress output")
+@click.option("--tag-prefix", "-t", type=str, default=None, help="Tag prefix (default: v)")
+@click.option("--tag-force", is_flag=True, default=False, help="Replace existing tag")
+@click.option("--config", "-c", type=click.Path(), default=None, help="Custom config file path")
+@click.option("--infile", "-i", type=str, default=None, help="Changelog file path")
+@click.option("--release-count", type=int, default=None, help="Number of releases in changelog")
+@click.option("--header", type=str, default=None, help="Custom changelog header")
+@click.option(
+    "--release-commit-message-format", type=str, default=None, help="Commit message format"
+)
+@click.option("--commit-url-format", type=str, default=None, help="Commit URL format template")
+@click.option("--compare-url-format", type=str, default=None, help="Compare URL format template")
+@click.option("--issue-url-format", type=str, default=None, help="Issue URL format template")
+@click.option(
+    "--git-tag-fallback/--no-git-tag-fallback",
+    default=None,
+    help="Fallback to git tags for version",
+)
+@click.option("--path", type=str, default=None, help="Only populate commits under this path")
+@click.option("--skip-bump", is_flag=True, default=False, help="Skip version bump")
+@click.option("--skip-changelog", is_flag=True, default=False, help="Skip changelog generation")
+@click.option("--skip-commit", is_flag=True, default=False, help="Skip git commit")
+@click.option("--skip-tag", is_flag=True, default=False, help="Skip git tag")
+@click.version_option()
+def main(**kwargs):
+    """Versioning using semver and CHANGELOG generation powered by Conventional Commits."""
+    cli_args = {k: v for k, v in kwargs.items() if v is not None}
+
+    skip_args = {}
+    for skip_flag in ["skip_bump", "skip_changelog", "skip_commit", "skip_tag"]:
+        val = cli_args.pop(skip_flag, None)
+        if val:
+            field = skip_flag.replace("skip_", "")
+            skip_args[field] = True
+
+    try:
+        config = load_config(cli_args)
+
+        if skip_args:
+            for k, v in skip_args.items():
+                setattr(config.skip, k, v)
+
+        commit_and_tag_version(config)
+    except Exception as err:
+        if not kwargs.get("silent"):
+            click.echo(f"Error: {err}", err=True)
+        sys.exit(1)

commit_and_tag_version/commit_parser.py

@@ -0,0 +1,77 @@
+import re
+
+import semver as semver_mod
+
+from commit_and_tag_version.models import ParsedCommit
+
+COMMIT_PATTERN = re.compile(
+    r"^(?P<type>\w+)(?:\((?P<scope>[^)]+)\))?(?P<breaking>!)?:\s*(?P<subject>.+)"
+)
+BREAKING_CHANGE_PATTERN = re.compile(r"^BREAKING[\- ]CHANGE:\s*(?P<note>.+)", re.MULTILINE)
+ISSUE_PATTERN = re.compile(r"#(\d+)")
+
+
+def parse_commit(raw: str) -> ParsedCommit | None:
+    lines = raw.strip().split("\n")
+    if not lines:
+        return None
+
+    header = lines[0]
+    match = COMMIT_PATTERN.match(header)
+    if not match:
+        return None
+
+    body_lines = []
+    if len(lines) > 2:
+        body_lines = lines[2:]
+    body = "\n".join(body_lines) if body_lines else None
+    full_text = raw.strip()
+
+    breaking = match.group("breaking") == "!"
+    breaking_note = None
+
+    breaking_match = BREAKING_CHANGE_PATTERN.search(full_text)
+    if breaking_match:
+        breaking = True
+        breaking_note = breaking_match.group("note").strip()
+
+    references = []
+    for issue_match in ISSUE_PATTERN.finditer(full_text):
+        ref = f"#{issue_match.group(1)}"
+        if ref not in references:
+            references.append(ref)
+
+    return ParsedCommit(
+        type=match.group("type"),
+        scope=match.group("scope"),
+        subject=match.group("subject").strip(),
+        body=body,
+        breaking=breaking,
+        breaking_note=breaking_note,
+        references=references,
+        raw=raw.strip(),
+    )
+
+
+def recommend_bump(
+    commits: list[ParsedCommit | None],
+    current_version: str = "1.0.0",
+) -> str:
+    has_breaking = False
+    has_feat = False
+
+    for commit in commits:
+        if commit is None:
+            continue
+        if commit.breaking:
+            has_breaking = True
+        if commit.type == "feat":
+            has_feat = True
+
+    pre_major = semver_mod.Version.parse(current_version) < semver_mod.Version.parse("1.0.0")
+
+    if has_breaking:
+        return "minor" if pre_major else "major"
+    if has_feat:
+        return "minor"
+    return "patch"

commit_and_tag_version/config.py

@@ -0,0 +1,109 @@
+import json
+from pathlib import Path
+
+from commit_and_tag_version.defaults import get_default_config
+from commit_and_tag_version.models import Config
+
+try:
+    import tomllib
+except ModuleNotFoundError:
+    try:
+        import tomli as tomllib  # type: ignore[no-redef]
+    except ModuleNotFoundError:
+        tomllib = None  # type: ignore[assignment]
+
+CAMEL_TO_SNAKE: dict[str, str] = {
+    "tagPrefix": "tag_prefix",
+    "releaseAs": "release_as",
+    "noVerify": "no_verify",
+    "commitAll": "commit_all",
+    "firstRelease": "first_release",
+    "dryRun": "dry_run",
+    "tagForce": "tag_force",
+    "releaseCount": "release_count",
+    "releaseCommitMessageFormat": "release_commit_message_format",
+    "commitUrlFormat": "commit_url_format",
+    "compareUrlFormat": "compare_url_format",
+    "issueUrlFormat": "issue_url_format",
+    "gitTagFallback": "git_tag_fallback",
+    "packageFiles": "package_files",
+    "bumpFiles": "bump_files",
+}
+
+
+def _normalize_keys(raw: dict) -> dict:
+    normalized: dict = {}
+    for key, value in raw.items():
+        snake_key = CAMEL_TO_SNAKE.get(key, key)
+        normalized[snake_key] = value
+    return normalized
+
+
+def _load_json_file(path: Path) -> dict:
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def _load_pyproject_toml(path: Path) -> dict:
+    if tomllib is None:
+        return {}
+    with open(path, "rb") as f:
+        data = tomllib.load(f)
+    return data.get("tool", {}).get("commit-and-tag-version", {})
+
+
+def _discover_file_config(config_path: str | None = None) -> dict:
+    if config_path:
+        path = Path(config_path)
+        if path.exists():
+            return _normalize_keys(_load_json_file(path))
+        return {}
+
+    cwd = Path.cwd()
+
+    versionrc = cwd / ".versionrc"
+    if versionrc.exists():
+        return _normalize_keys(_load_json_file(versionrc))
+
+    versionrc_json = cwd / ".versionrc.json"
+    if versionrc_json.exists():
+        return _normalize_keys(_load_json_file(versionrc_json))
+
+    pyproject = cwd / "pyproject.toml"
+    if pyproject.exists():
+        raw = _load_pyproject_toml(pyproject)
+        if raw:
+            return _normalize_keys(raw)
+
+    return {}
+
+
+def _apply_to_config(config: Config, overrides: dict) -> None:
+    skip_raw = overrides.pop("skip", None)
+    scripts_raw = overrides.pop("scripts", None)
+
+    for key, value in overrides.items():
+        if hasattr(config, key):
+            setattr(config, key, value)
+
+    if skip_raw and isinstance(skip_raw, dict):
+        for k, v in skip_raw.items():
+            if hasattr(config.skip, k):
+                setattr(config.skip, k, v)
+
+    if scripts_raw and isinstance(scripts_raw, dict):
+        for k, v in scripts_raw.items():
+            if hasattr(config.scripts, k):
+                setattr(config.scripts, k, v)
+
+
+def load_config(cli_args: dict) -> Config:
+    config = get_default_config()
+
+    config_path = cli_args.pop("config", None)
+    file_overrides = _discover_file_config(config_path)
+    _apply_to_config(config, file_overrides)
+
+    cli_overrides = {k: v for k, v in cli_args.items() if v is not None}
+    _apply_to_config(config, cli_overrides)
+
+    return config

commit_and_tag_version/defaults.py

@@ -0,0 +1,68 @@
+from commit_and_tag_version.models import Config, ScriptsConfig, SkipConfig
+
+DEFAULT_PACKAGE_FILES: list[str] = ["package.json", "bower.json", "manifest.json"]
+
+DEFAULT_BUMP_FILES: list[str] = [
+    "package.json",
+    "bower.json",
+    "manifest.json",
+    "package-lock.json",
+    "npm-shrinkwrap.json",
+]
+
+DEFAULT_INFILE = "CHANGELOG.md"
+DEFAULT_TAG_PREFIX = "v"
+DEFAULT_RELEASE_COUNT = 1
+DEFAULT_PRESET = "conventionalcommits"
+
+DEFAULT_RELEASE_COMMIT_MESSAGE_FORMAT = "chore(release): {{currentTag}}"
+
+DEFAULT_HEADER = (
+    "# Changelog\n\nAll notable changes to this project will be documented in this file. "
+    "See [commit-and-tag-version](https://github.com/absolute-version/commit-and-tag-version) "
+    "for commit guidelines.\n"
+)
+
+DEFAULT_COMMIT_TYPES: list[dict] = [
+    {"type": "feat", "section": "Features"},
+    {"type": "fix", "section": "Bug Fixes"},
+    {"type": "chore", "section": "Chores", "hidden": True},
+    {"type": "docs", "section": "Documentation", "hidden": True},
+    {"type": "style", "section": "Styles", "hidden": True},
+    {"type": "refactor", "section": "Refactoring", "hidden": True},
+    {"type": "perf", "section": "Performance", "hidden": True},
+    {"type": "test", "section": "Tests", "hidden": True},
+    {"type": "build", "section": "Build System", "hidden": True},
+    {"type": "ci", "section": "CI", "hidden": True},
+]
+
+
+def get_default_config() -> Config:
+    return Config(
+        package_files=list(DEFAULT_PACKAGE_FILES),
+        bump_files=list(DEFAULT_BUMP_FILES),
+        infile=DEFAULT_INFILE,
+        tag_prefix=DEFAULT_TAG_PREFIX,
+        preset=DEFAULT_PRESET,
+        release_as=None,
+        prerelease=None,
+        sign=False,
+        signoff=False,
+        no_verify=False,
+        commit_all=False,
+        first_release=False,
+        dry_run=False,
+        silent=False,
+        tag_force=False,
+        release_count=DEFAULT_RELEASE_COUNT,
+        skip=SkipConfig(),
+        scripts=ScriptsConfig(),
+        header=DEFAULT_HEADER,
+        commit_url_format=None,
+        compare_url_format=None,
+        issue_url_format=None,
+        release_commit_message_format=DEFAULT_RELEASE_COMMIT_MESSAGE_FORMAT,
+        git_tag_fallback=True,
+        path=None,
+        types=None,
+    )

commit_and_tag_version/format_commit_message.py

@@ -0,0 +1,2 @@
+def format_commit_message(raw_msg: str, new_version: str) -> str:
+    return str(raw_msg).replace("{{currentTag}}", new_version)

commit_and_tag_version/git.py

@@ -0,0 +1,115 @@
+import re
+import subprocess
+
+import semver
+
+
+def _run_git(args: list[str], dry_run: bool = False) -> str:
+    if dry_run:
+        return ""
+    result = subprocess.run(
+        ["git", *args],
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    return result.stdout
+
+
+def git_add(files: list[str], dry_run: bool = False) -> None:
+    _run_git(["add", *files], dry_run=dry_run)
+
+
+def git_commit(
+    message: str,
+    sign: bool = False,
+    signoff: bool = False,
+    no_verify: bool = False,
+    dry_run: bool = False,
+    files: list[str] | None = None,
+) -> None:
+    cmd = ["commit"]
+    if sign:
+        cmd.append("--gpg-sign")
+    if signoff:
+        cmd.append("--signoff")
+    if no_verify:
+        cmd.append("--no-verify")
+    cmd.extend(["-m", message])
+    if files:
+        cmd.extend(files)
+    _run_git(cmd, dry_run=dry_run)
+
+
+def git_tag(
+    name: str,
+    message: str,
+    sign: bool = False,
+    force: bool = False,
+    dry_run: bool = False,
+) -> None:
+    cmd = ["tag"]
+    if sign:
+        cmd.append("-s")
+    else:
+        cmd.append("-a")
+    if force:
+        cmd.append("-f")
+    cmd.extend([name, "-m", message])
+    _run_git(cmd, dry_run=dry_run)
+
+
+def get_current_branch() -> str:
+    return _run_git(["rev-parse", "--abbrev-ref", "HEAD"]).strip()
+
+
+def get_semver_tags(tag_prefix: str, prerelease: str | None = None) -> list[str]:
+    output = _run_git(["tag", "-l", f"{tag_prefix}*"])
+    if not output.strip():
+        return []
+
+    tags = []
+    prefix_pattern = re.compile(f"^{re.escape(tag_prefix)}")
+    for line in output.strip().split("\n"):
+        stripped = prefix_pattern.sub("", line.strip())
+        if semver.Version.is_valid(stripped):
+            tags.append(stripped)
+
+    if prerelease is not None:
+        filtered = []
+        for tag in tags:
+            v = semver.Version.parse(tag)
+            if v.prerelease is None:
+                filtered.append(tag)
+            elif v.prerelease.split(".")[0] == prerelease:
+                filtered.append(tag)
+        tags = filtered
+
+    tags.sort(key=lambda t: semver.Version.parse(t), reverse=True)
+    return tags
+
+
+def get_latest_semver_tag(tag_prefix: str, prerelease: str | None = None) -> str:
+    tags = get_semver_tags(tag_prefix, prerelease=prerelease)
+    if not tags:
+        return "1.0.0"
+    return tags[0]
+
+
+def git_log_raw(
+    from_tag: str | None = None,
+    to: str = "HEAD",
+    path: str | None = None,
+) -> list[str]:
+    if from_tag:
+        range_spec = f"{from_tag}..{to}"
+    else:
+        range_spec = to
+    cmd = ["log", range_spec, "--format=%B%x00"]
+    if path:
+        cmd.extend(["--", path])
+    output = _run_git(cmd)
+    if not output.strip():
+        return []
+    messages = [m.strip() for m in output.split("\x00") if m.strip()]
+    return messages