chore: add scripts for release

Author: Maksim Ryzhikov

scripts/release_version.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+
+# A script that increments the language server version,
+# updates the npm package versions of the editor extensions,
+# updates the changelog and creates an annotated Git tag.
+
+import argparse
+import subprocess
+import re
+import os
+import tempfile
+from pathlib import Path
+
+from utils.cli import prompt_by, title
+from utils.properties import PropertiesFile
+from utils.changelog import ChangelogFile
+
+class Version:
+    def __init__(self, major, minor, patch):
+        self.major = major
+        self.minor = minor
+        self.patch = patch
+
+    def __str__(self):
+        return f"{self.major}.{self.minor}.{self.patch}"
+
+def parse_version(s):
+    match = re.search(r"(\d+)\.(\d+)\.(\d+)", s)
+    if match == None:
+        raise ValueError(f"Incorrectly formatted version: {s}")
+    return Version(int(match.group(1)), int(match.group(2)), int(match.group(3)))
+
+def increment_major(ver):
+    return Version(ver.major + 1, 0, 0)
+
+def increment_minor(ver):
+    return Version(ver.major, ver.minor + 1, 0)
+
+def increment_patch(ver):
+    return Version(ver.major, ver.minor, ver.patch + 1)
+
+def command_output(cmd, cwd):
+    return subprocess.check_output(cmd, cwd=cwd).decode("utf-8").strip()
+
+def git_last_tag(repo_path):
+    return command_output(["git", "describe", "--abbrev=0"], cwd=repo_path)
+
+def git_history_since_last_tag(repo_path):
+    return re.split(r"[\r\n]+", command_output(["git", "log", "--oneline", f"{git_last_tag(repo_path)}..HEAD"], cwd=repo_path))
+
+def git_branch(repo_path):
+    return command_output(["git", "rev-parse", "--abbrev-ref", "HEAD"], cwd=repo_path)
+
+def git_working_dir_is_clean(repo_path):
+    return len(command_output(["git", "status", "--porcelain"], cwd=repo_path)) == 0
+
+INCREMENTS = {
+    "major": increment_major,
+    "minor": increment_minor,
+    "patch": increment_patch
+}
+EDITOR = os.environ.get("EDITOR", "vim") # https://stackoverflow.com/questions/6309587/call-up-an-editor-vim-from-a-python-script
+PROJECT_DIR = Path(__file__).parent.parent
+PROJECT_VERSION_KEY = "projectVersion"
+
+def main():
+    parser = argparse.ArgumentParser(description="A small utility for updating the project's version and creating tags.")
+    parser.add_argument("--bump-only", action="store_true", help="Whether only the version should be bumped, without tagging the current version.")
+
+    args = parser.parse_args()
+
+    title("Project Version Updater")
+
+    if not git_working_dir_is_clean(PROJECT_DIR):
+        print("Commit any pending changes first to make sure the working directory is in a clean state!")
+        return
+    if git_branch(PROJECT_DIR) != "main":
+        print("Switch to the main branch first!")
+        return
+
+    properties = PropertiesFile(str(PROJECT_DIR / "gradle.properties"))
+    version = parse_version(properties[PROJECT_VERSION_KEY])
+
+    # Current version
+
+    if not args.bump_only:
+        print()
+        print(f"Releasing version {version}.")
+        print()
+
+        # Fetch new changelog message from user
+        temp = tempfile.NamedTemporaryFile(delete=False)
+        temp_path = Path(temp.name).absolute()
+
+        history = git_history_since_last_tag(PROJECT_DIR)
+        formatted_history = [f"# {commit}" for commit in history]
+        initial_message = [
+            "",
+            "",
+            "# Please enter a changelog/release message.",
+            f"# This is the history since the last tag:"
+        ] + formatted_history
+
+        with open(temp_path, "w") as temp_contents:
+            temp_contents.write("\n".join(initial_message))
+
+        subprocess.call([EDITOR, str(temp_path)])
+
+        with open(temp_path, "r") as temp_contents:
+            changelog_message = [line.strip() for line in temp_contents.readlines() if not line.startswith("#") and len(line.strip()) > 0]
+
+        temp.close()
+        temp_path.unlink()
+
+        if not changelog_message:
+            print("No message, exiting...")
+            return
+
+        print("Updating changelog...")
+        changelog = ChangelogFile(PROJECT_DIR / "CHANGELOG.md")
+        changelog.prepend_version(version, changelog_message)
+
+        print("Creating Git tag...")
+        tag_message = "\n".join([f"Version {version}", ""] + changelog_message)
+        subprocess.run(["git", "tag", "-a", f"{version}", "-m", tag_message], cwd=PROJECT_DIR)
+
+    # Next version
+
+    increment = None
+    while increment not in INCREMENTS.keys():
+        increment = input("How do you want to increment? [major/minor/patch] ")
+
+    new_version = INCREMENTS[increment](version)
+
+    # Apply new (development) version to project
+    print(f"Updating next dev version to {new_version}...")
+    properties[PROJECT_VERSION_KEY] = str(new_version)
+
+    print("Creating Git commit for next dev version...")
+    commit_message = f"Bump version to {new_version}"
+    subprocess.run(["git", "add", "."], cwd=PROJECT_DIR)
+    subprocess.run(["git", "commit", "-m", commit_message], cwd=PROJECT_DIR)
+
+main()

scripts/utils/__init__.py

@@ -0,0 +1,58 @@
+import pathlib
+import re
+import collections
+
+class ChangelogFile:
+    def __init__(self, file_path):
+        self.file_path = file_path
+
+        if not file_path.exists():
+            raise ValueError(f"{file_path} does not exist!")
+
+        self.parse()
+
+    def parse(self):
+        self.first_paragraph = []
+        self.versions = collections.deque()
+
+        with open(self.file_path, "r") as contents:
+            parsing_first_paragraph = False
+            version = None
+            version_message = None
+
+            for line in contents.readlines():
+                trimmed_line = line.strip()
+                title_match = re.search(r"^#\s+(.+)", trimmed_line)
+                version_match = re.search(r"^##\s+\[(.+)\]", trimmed_line)
+
+                if title_match != None:
+                    parsing_first_paragraph = True
+                    self.title = title_match.group(1)
+                elif version_match != None:
+                    if version != None:
+                        self.versions.append((version, version_message))
+                    parsing_first_paragraph = False
+                    version = version_match.group(1)
+                    version_message = []
+                elif parsing_first_paragraph:
+                    self.first_paragraph.append(trimmed_line)
+                elif version != None and len(trimmed_line) > 0:
+                    version_message.append(trimmed_line)
+
+            if version_message != None and len(version_message) > 0:
+                self.versions.append((version, version_message))
+
+    def prepend_version(self, version, version_message):
+        self.versions.appendleft((version, version_message))
+        self.save()
+
+    def save(self):
+        lines = [f"# {self.title}"] + self.first_paragraph
+
+        for (version, version_message) in self.versions:
+            lines.append(f"## [{version}]")
+            lines += version_message
+            lines.append("")
+
+        with open(self.file_path, "w") as contents:
+            contents.write("\n".join(lines))

scripts/utils/__pycache__/__init__.cpython-39.pyc

@@ -0,0 +1,41 @@
+import sys
+import re
+
+alphanum_pattern = re.compile(r"(\d+)|(\D+)")
+
+def title(s, padding=2):
+    length = len(s) + (2 * padding)
+    print("=" * length)
+    print(f"  {s}  ")
+    print("=" * length)
+
+def confirm(what):
+    result = input(what + " [y/n] ")
+    return result.lower().startswith("y")
+
+def alphanum_sort_key(item):
+    # Source: https://stackoverflow.com/questions/2669059/how-to-sort-alpha-numeric-set-in-python
+    return tuple(int(num) if num else alpha for num, alpha in alphanum_pattern.findall(item))
+
+def require_not_none(description, x):
+    if x == None:
+        sys.exit(description + " not present")
+
+def prompt_by(what, nodes, describer, default=None):
+    node_dict = {describer(node): node for node in nodes}
+    sorted_described = sorted(node_dict.keys(), key=alphanum_sort_key)
+
+    print()
+    print(sorted_described)
+    print()
+
+    last_entry = sorted_described[-1] if len(sorted_described) > 0 else None
+    choice = input(f"Enter a {what} to choose [default: {last_entry}]: ").strip()
+    print()
+
+    if len(choice) == 0 and last_entry:
+        return node_dict[last_entry]
+    elif choice not in node_dict.keys():
+        return default
+    else:
+        return node_dict[choice]

scripts/utils/__pycache__/changelog.cpython-39.pyc

@@ -0,0 +1,2 @@
+def first(ls):
+    return ls[0] if len(ls) > 0 else None

scripts/utils/__pycache__/cli.cpython-39.pyc

@@ -0,0 +1,60 @@
+import os
+import fileinput
+import itertools
+
+class PropertiesFile:
+    def __init__(self, file_path):
+        self.file_path = file_path
+        self.entries = {}
+
+        if not os.path.exists(file_path):
+            raise ValueError(file_path + " does not exist!")
+
+        self.parse()
+
+    def __getitem__(self, key):
+        return self.entries[key]["value"]
+
+    def __setitem__(self, key, value):
+        str_value = str(value)
+
+        if key in self.entries:
+            line_index = self.entries[key]["line"]
+        else:
+            line_index = self.total_lines
+            self.total_lines += 1
+
+        self.write_line(line_index, key + "=" + str_value)
+        self.entries[key] = {"line": line_index, "value": str_value}
+
+    def apply_changes(self, change_dict):
+        for key, value in change_dict.items():
+            self[key] = value
+
+    def write_line(self, index, content):
+        with open(self.file_path, "r") as file:
+            lines = file.readlines()
+
+        line_count = len(lines)
+
+        if line_count > 0:
+            ending = "".join(itertools.takewhile(str.isspace, lines[0][::-1]))[::-1]
+        else:
+            ending = os.linesep
+
+        content_with_ending = content.rstrip() + ending
+
+        if index >= line_count:
+            lines.append(content_with_ending)
+        else:
+            lines[index] = content_with_ending
+
+        with open(self.file_path, "w") as file:
+            file.writelines(lines)
+
+    def parse(self):
+        with open(self.file_path, "r") as file:
+            for i, line in enumerate(file.readlines()):
+                entry = line.split("=")
+                self.entries[entry[0].strip()] = {"line": i, "value": entry[1].strip()}
+            self.total_lines = i + 1