km3net-cmake-setup-makefile-version.py

Go to the documentation of this file.

#!/usr/bin/env python3
"""Emit KM3NeT version metadata for CMake and non-CMake builds."""
 
import argparse
import json
import os
import re
import subprocess
from pathlib import Path
 
 
def run_git(source_dir, *args):
    try:
        completed = subprocess.run(
            ["git", *args],
            cwd=source_dir,
            check=True,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            text=True,
        )
    except (FileNotFoundError, subprocess.CalledProcessError):
        return None
    return completed.stdout.strip()
 
 
def parse_version(value):
    match = re.match(r"^v?([0-9]+)(?:\.([0-9]+))?(?:\.([0-9]+))?", value.strip())
    if not match:
        return 0, 0, 0
 
    major = int(match.group(1))
    minor = int(match.group(2) or 0)
    patch = int(match.group(3) or 0)
    return major, minor, patch
 
 
def fallback_version(source_dir):
    codemeta = source_dir / "codemeta.json"
    if codemeta.exists():
        with codemeta.open(encoding="utf-8") as stream:
            metadata = json.load(stream)
        return parse_version(str(metadata.get("version", "0.0.0"))), True
 
    version_file = source_dir / "VERSION"
    if version_file.exists():
        return parse_version(version_file.read_text(encoding="utf-8")), True
 
    return (0, 0, 0), False
 
 
def collect_metadata(source_dir, package_name):
    is_git_repo = run_git(source_dir, "status") is not None
    git_tag = ""
    git_describe = ""
    git_commit = ""
    git_short_hash = ""
    git_dirty = False
    commits_since_tag = 0
 
    if is_git_repo:
        source_available = True
        git_describe = run_git(source_dir, "--no-pager", "describe", "--tags", "--always", "--dirty") or ""
        git_commit = run_git(source_dir, "rev-parse", "HEAD") or ""
        git_short_hash = run_git(source_dir, "rev-parse", "--short", "HEAD") or ""
        git_status = run_git(source_dir, "status", "--porcelain") or ""
        git_dirty = bool(git_status)
        git_tag = run_git(source_dir, "--no-pager", "describe", "--tags", "--abbrev=0") or ""
 
        if git_tag:
            major, minor, patch = parse_version(git_tag)
            commits_since_tag_text = run_git(source_dir, "rev-list", "--count", f"{git_tag}..HEAD")
            commits_since_tag = int(commits_since_tag_text or 0)
        else:
            major, minor, patch = 0, 0, 0
    else:
        (major, minor, patch), source_available = fallback_version(source_dir)
 
    return {
        "package_name": package_name,
        "version": f"{major}.{minor}.{patch}",
        "version_major": major,
        "version_minor": minor,
        "version_patch": patch,
        "git_tag": git_tag,
        "git_describe": git_describe,
        "git_commit": git_commit,
        "git_short_hash": git_short_hash,
        "git_dirty": git_dirty,
        "commits_since_tag": commits_since_tag,
        "source_available": source_available,
    }
 
 
def sanitize_identifier(value):
    result = re.sub(r"[^a-zA-Z0-9_]", "_", value)
    result = re.sub(r"^([0-9])", r"_\1", result)
    return result.upper()
 
 
def namespace_block(namespace):
    parts = [part for part in namespace.split("::") if part]
    open_block = "".join(f"namespace {part} {{\n" for part in parts)
    close_block = "".join(f"}} // namespace {part}\n" for part in reversed(parts))
    return open_block, close_block
 
 
def cpp_bool(value):
    return "true" if value else "false"
 
 
def cpp_string(value):
    return json.dumps(value)
 
 
def write_header(path, metadata, namespace):
    guard = f"{sanitize_identifier(str(path))}_H"
    open_block, close_block = namespace_block(namespace)
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(
        f"""#ifndef {guard}
#define {guard}
 
#include <string>
 
{open_block}
std::string getPackageName();
std::string getVersion();
 
unsigned int getVersionMajor();
unsigned int getVersionMinor();
unsigned int getVersionPatch();
 
std::string getGitTag();
std::string getGitDescribe();
std::string getGitCommit();
bool getGitDirty();
bool hasVersionMetadata();
 
std::string getShortHash();
unsigned int getCommitsSinceTag();
 
{close_block}
#endif
""",
        encoding="utf-8",
    )
 
 
def write_source(path, metadata, namespace, include):
    open_block, close_block = namespace_block(namespace)
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(
        f"""#include "{include}"
 
{open_block}
std::string getPackageName() {{
return {cpp_string(metadata["package_name"])};
}}
 
std::string getVersion() {{
return {cpp_string(metadata["version"])};
}}
 
unsigned int getVersionMajor() {{ return {metadata["version_major"]}; }}
unsigned int getVersionMinor() {{ return {metadata["version_minor"]}; }}
unsigned int getVersionPatch() {{ return {metadata["version_patch"]}; }}
 
std::string getGitTag() {{ return {cpp_string(metadata["git_tag"])}; }}
std::string getGitDescribe() {{ return {cpp_string(metadata["git_describe"])}; }}
std::string getGitCommit() {{ return {cpp_string(metadata["git_commit"])}; }}
bool getGitDirty() {{ return {cpp_bool(metadata["git_dirty"])}; }}
bool hasVersionMetadata() {{ return {cpp_bool(metadata["source_available"])}; }}
 
std::string getShortHash() {{ return {cpp_string(metadata["git_short_hash"])}; }}
unsigned int getCommitsSinceTag() {{ return {metadata["commits_since_tag"]}; }}
 
{close_block}
""",
        encoding="utf-8",
    )
 
 
def write_main(path, namespace, include):
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(
        f"""#include "{include}"
 
#include <iostream>
#include <string>
 
namespace {{
 
std::string jsonEscape(const std::string& input) {{
  std::string output;
  for (const char character : input) {{
    switch (character) {{
      case '\\\"':
        output += "\\\\\\\"";
        break;
      case '\\\\':
        output += "\\\\\\\\";
        break;
      case '\\b':
        output += "\\\\b";
        break;
      case '\\f':
        output += "\\\\f";
        break;
      case '\\n':
        output += "\\\\n";
        break;
      case '\\r':
        output += "\\\\r";
        break;
      case '\\t':
        output += "\\\\t";
        break;
      default:
        output += character;
        break;
    }}
  }}
  return output;
}}
 
void printText() {{
  std::cout
    << "package_name=" << {namespace}::getPackageName() << '\\n'
    << "version=" << {namespace}::getVersion() << '\\n'
    << "version_major=" << {namespace}::getVersionMajor() << '\\n'
    << "version_minor=" << {namespace}::getVersionMinor() << '\\n'
    << "version_patch=" << {namespace}::getVersionPatch() << '\\n'
    << "git_tag=" << {namespace}::getGitTag() << '\\n'
    << "git_describe=" << {namespace}::getGitDescribe() << '\\n'
    << "git_commit=" << {namespace}::getGitCommit() << '\\n'
    << "git_short_hash=" << {namespace}::getShortHash() << '\\n'
    << "git_dirty=" << ({namespace}::getGitDirty() ? "true" : "false") << '\\n'
    << "commits_since_tag=" << {namespace}::getCommitsSinceTag() << '\\n'
    << "source_available=" << ({namespace}::hasVersionMetadata() ? "true" : "false") << '\\n';
}}
 
void printJson() {{
  std::cout
    << "{{\\n"
    << "  \\"package_name\\": \\"" << jsonEscape({namespace}::getPackageName()) << "\\",\\n"
    << "  \\"version\\": \\"" << jsonEscape({namespace}::getVersion()) << "\\",\\n"
    << "  \\"version_major\\": " << {namespace}::getVersionMajor() << ",\\n"
    << "  \\"version_minor\\": " << {namespace}::getVersionMinor() << ",\\n"
    << "  \\"version_patch\\": " << {namespace}::getVersionPatch() << ",\\n"
    << "  \\"git_tag\\": \\"" << jsonEscape({namespace}::getGitTag()) << "\\",\\n"
    << "  \\"git_describe\\": \\"" << jsonEscape({namespace}::getGitDescribe()) << "\\",\\n"
    << "  \\"git_commit\\": \\"" << jsonEscape({namespace}::getGitCommit()) << "\\",\\n"
    << "  \\"git_short_hash\\": \\"" << jsonEscape({namespace}::getShortHash()) << "\\",\\n"
    << "  \\"git_dirty\\": " << ({namespace}::getGitDirty() ? "true" : "false") << ",\\n"
    << "  \\"commits_since_tag\\": " << {namespace}::getCommitsSinceTag() << ",\\n"
    << "  \\"source_available\\": " << ({namespace}::hasVersionMetadata() ? "true" : "false") << '\\n'
    << "}}\\n";
}}
 
}} // namespace
 
int main(int argc, char** argv) {{
  if (argc == 1) {{
    printText();
    return 0;
  }}
 
  if (argc == 2 && std::string(argv[1]) == "--json") {{
    printJson();
    return 0;
  }}
 
  std::cerr << "usage: " << argv[0] << " [--json]\\n";
  return 1;
}}
""",
        encoding="utf-8",
    )
 
 
def project_name_to_namespace(package_name):
    return re.sub(r"[^a-zA-Z0-9]+", "::", package_name).strip(":").lower()
 
 
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--source-dir", default=os.getcwd())
    parser.add_argument("--package-name")
    parser.add_argument("--namespace")
    parser.add_argument("--include", default=None)
    parser.add_argument("--output-dir")
    parser.add_argument("--header")
    parser.add_argument("--source")
    parser.add_argument("--main")
    args = parser.parse_args()
 
    source_dir = Path(args.source_dir).resolve()
    package_name = args.package_name or source_dir.name
    namespace = args.namespace or project_name_to_namespace(package_name)
    include = args.include or f"km3net/{package_name}/version.h"
    metadata = collect_metadata(source_dir, package_name)
 
    output_dir = Path(args.output_dir) if args.output_dir else None
    header_path = Path(args.header) if args.header else None
    source_path = Path(args.source) if args.source else None
    main_path = Path(args.main) if args.main else None
 
    if output_dir:
        header_path = header_path or output_dir / "include" / include
        source_path = source_path or output_dir / f"{package_name}-version.cc"
        main_path = main_path or output_dir / f"{package_name}-version-command.cc"
 
    if not (header_path or source_path or main_path):
        print(json.dumps(metadata, indent=2))
 
    if header_path:
        write_header(header_path, metadata, namespace)
    if source_path:
        write_source(source_path, metadata, namespace, include)
    if main_path:
        write_main(main_path, namespace, include)
 
 
if __name__ == "__main__":
    main()