Added release tools. (#1)

* Added release tools.

* Implement review feedback

* Update inline  usage comments of the cargo-version.py script

Author: razvan

release/README.md

@@ -0,0 +1,19 @@
+# Release tools
+
+## Install requirements
+
+Install Python 3 and required packages:
+
+    pip install -r release/requirements.txt
+
+Add the `release` folder to your `PATH`.
+
+## Usage
+
+Go to the folder containing a Cargo workspace or crate and run:
+
+    release.sh [major|minor|patch]
+
+This pushes two commits in a newly created release branch. When merging, __do not squash them__.
+
+

release/cargo-version.py

@@ -0,0 +1,161 @@
+#!/usr/bin/env python3
+#
+# Utility for viewing and managing versions of cargo workspaces and crates.
+# For workspaces, it assumes that all crate members use a single shared version.
+#
+# usage: cargo-version.py [-h] [-p PROJECT] [-r] [-n {major,minor,patch}] [-s SET] [-o]
+# 
+# Change versions of cargo projects.
+# 
+# optional arguments:
+#   -h, --help            show this help message and exit
+#   -p PROJECT, --project PROJECT
+#                         Project folder
+#   -r, --release         Version
+#   -n {major,minor,patch}, --next {major,minor,patch}
+#                         Version
+#   -s SET, --set SET     Version
+#   -o, --show            Version
+# 
+
+import toml
+import semver
+import argparse
+
+class Crate:
+    def __init__(self, path, name, version, dependencies):
+        self.path = path
+        self.name = name
+        self.version = version
+        self.dependencies = dependencies
+
+    def with_dependencies(self, names):
+        deps = {k:v for k,v in self.dependencies.items() if k in names}
+        return Crate(self.path, self.name, self.version, deps)
+
+    @classmethod
+    def finalize(cls, version):
+        return str(semver.VersionInfo.parse(version).finalize_version())
+
+    @classmethod
+    def bump_level(cls, version, level):
+        v = semver.VersionInfo.parse(version)
+        if level == 'major':
+            return str(v.bump_major())
+        elif level == 'minor':
+            return str(v.bump_minor())
+        elif level == 'patch':
+            return str(v.bump_patch())
+        else:
+            return str(v.bump_prerelease('nightly'))
+
+    def finalize_version(self):
+        return Crate(self.path, self.name, Crate.finalize(self.version), self.dependencies.copy())
+
+    def bump_version(self, level):
+        return Crate(self.path, self.name, Crate.bump_level(self.version, level), self.dependencies.copy())
+
+    def set_version(self, version):
+        return Crate(self.path, self.name, version, self.dependencies.copy())
+
+    def next_version(self):
+        return Crate(self.path, self.name, str(semver.VersionInfo.parse(self.version).next_version('patch')), self.dependencies.copy())
+
+    def show_version(self):
+        return self.version
+
+    def save(self, previous):
+        contents = []
+        cargo_file = f"{self.path}/Cargo.toml"
+        with open(cargo_file, 'r') as r:
+            for line in r.readlines():
+                if line.startswith("version"):
+                    line = line.replace(previous.version, self.version)
+                else:
+                    for dname, dversion in self.dependencies.items():
+                        if line.startswith(dname):
+                            line = line.replace(previous.dependencies[dname], dversion)
+                contents.append(line)
+
+        with open(cargo_file, 'w') as w:
+            w.write(''.join(contents))
+
+    def __str__(self):
+        return f'Crate({self.path}, {self.name}, {self.version}, {self.dependencies})'
+
+class Workspace:
+    def __init__(self, crates):
+        names = set([c.name for c in crates])
+        self.crates = {c.name: c.with_dependencies(names) for c in crates}
+
+    def finalize_version(self):
+        crates = {c.name: c.finalize_version() for c in self.crates.values()}
+        return Workspace(Workspace.update_dependencies(crates).values())
+
+    def bump_version(self, level):
+        crates = {c.name: c.bump_version(level) for c in self.crates.values()}
+        return Workspace(Workspace.update_dependencies(crates).values())
+
+    def set_version(self, version):
+        crates = {c.name: c.set_version(version) for c in self.crates.values()}
+        return Workspace(Workspace.update_dependencies(crates).values())
+
+    def next_version(self):
+        crates = {c.name: c.next_version() for c in self.crates.values()}
+        return Workspace(Workspace.update_dependencies(crates).values())
+
+    def show_version(self):
+        for c in self.crates.values():
+            return c.show_version()
+        return "0.0.0"
+
+    @classmethod
+    def update_dependencies(cls, crate_dict):
+        for crate in crate_dict.values():
+            for dep in crate.dependencies.keys():
+                crate.dependencies[dep] = crate_dict[dep].version
+        return crate_dict
+
+    def __str__(self):
+        return f'Workspace({[str(c) for c in self.crates.values()]})'
+
+    def save(self, previous):
+        for cn in self.crates.keys():
+            self.crates[cn].save(previous.crates[cn])
+
+def load(root):
+    r = toml.load(f"{root}/Cargo.toml")
+    if "workspace" in r:
+        return Workspace([load(f"{root}/{path}") for path in r["workspace"]["members"]]) 
+    else:
+        return Crate(path=root, name=r["package"]["name"], version=r["package"]["version"], dependencies={dn: r["dependencies"][dn]["version"] for dn in r["dependencies"] if "version" in r["dependencies"][dn]})
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Change versions of cargo projects.")
+    parser.add_argument("-p", "--project", help="Project folder", default=".")
+    parser.add_argument("-r", "--release", help="Version", action="store_true")
+    parser.add_argument("-n", "--next", help="Version", choices=['major', 'minor', 'patch'])
+    parser.add_argument("-s", "--set", help="Version" )
+    parser.add_argument("-o", "--show", help="Version", action="store_true")
+    return parser.parse_args()
+
+if __name__ == "__main__":
+    args = parse_args()
+
+    old = load(args.project.rstrip('/'))
+
+    if args.release:
+        new = old.finalize_version()
+        new.save(old)
+    elif args.next:
+        new = old.bump_version(args.next).bump_version("prerelease")
+        new.save(old)
+    elif args.set:
+        # sanity check
+        semver.VersionInfo.parse(args.set)
+        new = old.set_version(args.set)
+        new.save(old)
+    elif args.show:
+        print(old.show_version())
+
+

release/release.sh

@@ -0,0 +1,63 @@
+#!/usr/bin/env sh
+#
+# Usage: release.sh <level>
+#
+# <level> : "major", "minor" or "patch". Default: "minor".
+#
+BASE_BRANCH="main"
+REPOSITORY="origin"
+NOW_UTC=$(date -u '+%Y%m%d%H%M%S')
+RELEASE_BRANCH="release-$NOW_UTC"
+
+ensure_release_branch() {
+  local STATUS=$(git status -s | grep -v '??')
+
+  if [ "$STATUS" != "" ]; then
+    >&2 echo "ERROR Dirty working copy found! Stop."
+    exit 1
+  fi
+
+  git switch -c ${RELEASE_BRANCH} ${BASE_BRANCH}
+  git push -u ${REPOSITORY} ${RELEASE_BRANCH}
+}
+
+maybe_create_github_pr() {
+  local TAG=$1
+  GH_COMMAND=$(which gh)
+  if [ "$GH_COMMAND" != "" ]; then
+    gh pr create --base $BASE_BRANCH --head $RELEASE_BRANCH --reviewer "@stackabletech/rust-developers" --title "Release $TAG" --body "Release $TAG"
+  fi
+}
+
+main() {
+
+  local NEXT_LEVEL=${1:-minor}
+  local PUSH=${2:-true}
+
+  ensure_release_branch
+
+  #
+  # Release
+  #
+  cargo-version.py --release
+  cargo update --workspace
+  local TAG=$(cargo-version.py --show)
+  git commit -am "bump version $TAG"
+  git tag -a $TAG -m "release $TAG" HEAD
+
+  #
+  # Development
+  #
+  cargo-version.py --next ${NEXT_LEVEL}
+  cargo update --workspace
+  TAG=$(cargo-version.py --show)
+  git commit -am "bump version $TAG"
+
+  if [ "$PUSH" = "true" ]; then
+    git push ${REPOSITORY} ${RELEASE_BRANCH} 
+    git push --tags
+    maybe_create_github_pr $TAG_NAME
+  fi
+}
+
+main $@

release/requirements.txt

@@ -0,0 +1,2 @@
+semver==2.13.0
+toml==0.10.2