Add support for pre-commit plugins

Enhance `pre-commit` task to support plugins and extensions. Implement an extension to update versions of GitHub actions in workflow templates.

---------
Co-authored-by: Jannis Mittenzwei <[email protected]>

Author: Jannis-Mittenzwei

.github/PULL_REQUEST_TEMPLATE/pull_request_template.md

@@ -10,9 +10,4 @@
 * [ ] Have you checked to ensure there aren't other open Pull Requests for the same update/change?
 * [ ] Are you mentioning the issue which this PullRequest fixes ("Fixes...")
 
-# 🦺 Github Actions
-* [ ] Did you update the version pinning in the action(s)
-  * security-issues (exasol-toolbox)
-    -> Only for releases!!
-
 Note: If any of the above is not relevant to your PR just check the box.

doc/changes/unreleased.md

@@ -44,6 +44,11 @@
     nox -s prepare-release -- -h 
     ```
 
+* **Added Plugin Support for Nox Task `prepare-release`**
+
+    - For further details on the plugin specification, refer to `exasol.toolbox.nox.plugin`.
+    - For an example of usage, refer to the `noxconfig` of the Python toolbox.
+
 ## 📚 Documentation
 * Fixed typos and updated documentation
 

exasol/toolbox/nox/_release.py

@@ -15,6 +15,7 @@
     Mode,
     _version,
 )
+from exasol.toolbox.nox.plugin import NoxTasks
 from exasol.toolbox.release import (
     Version,
     extract_release_notes,
@@ -108,9 +109,15 @@ def prepare_release(session: Session, python=False) -> None:
     if not args.no_branch and not args.no_add:
         session.run("git", "switch", "-c", f"release/prepare-{new_version}")
 
+    pm = NoxTasks.plugin_manager(PROJECT_CONFIG)
+
     _ = _update_project_version(session, new_version)
     changelog, changes, unreleased = _update_changelog(new_version)
 
+    pm.hook.prepare_release_update_version(
+        session=session, config=PROJECT_CONFIG, version=new_version
+    )
+
     if args.no_add:
         return
 
@@ -124,6 +131,9 @@ def prepare_release(session: Session, python=False) -> None:
             PROJECT_CONFIG.version_file,
         ],
     )
+    pm.hook.prepare_release_add_files(
+        session=session, config=PROJECT_CONFIG, add=_add_files_to_index
+    )
     session.run("git", "commit", "-m", f"Prepare release {new_version}")
 
     if not args.no_pr:

exasol/toolbox/nox/plugin.py

@@ -0,0 +1,53 @@
+import pluggy
+
+_PLUGIN_MARKER = "python-toolbox"
+hookspec = pluggy.HookspecMarker("python-toolbox")
+hookimpl = pluggy.HookimplMarker("python-toolbox")
+
+
+class NoxTasks:
+    @hookspec
+    def prepare_release_update_version(self, session, config, version):
+        """
+        This hook is called during version updating when a release is being prepared.
+        Implementors can add their own logic and tasks required to be run during the version update here.
+
+        Args:
+            session (nox.Session):
+                The nox session running the release preparation.
+                This it can be used to run commands, etc.
+
+            config (class):
+                The project configuration object from the noxconfig.py file.
+
+            version (str):
+                A string representation of the version to be released.
+                This follows the pattern of Semantic Versioning, i.e., "MAJOR.MINOR.PATCH".
+                An example would be "1.4.2".
+        """
+
+    @hookspec
+    def prepare_release_add_files(self, session, config, add):
+        """
+        Files which should be added to the prepare relase commit should be added using add.
+
+        Args:
+            session (nox.Session):
+                The nox session running the release preparation.
+                This it can be used to run commands, etc.
+
+            config (class):
+                The project configuration object from the noxconfig.py file.
+
+            add (function):
+                Function which takes a nox session and a list of files which will be added to the index.
+                e.g. `add(session, ["file1.txt", "file2.txt"])`
+        """
+
+    @staticmethod
+    def plugin_manager(config) -> pluggy.PluginManager:
+        pm = pluggy.PluginManager(_PLUGIN_MARKER)
+        pm.add_hookspecs(NoxTasks)
+        for plugin in getattr(config, "plugins", []):
+            pm.register(plugin())
+        return pm

exasol/toolbox/tools/replace_version.py

@@ -0,0 +1,34 @@
+from pathlib import Path
+from typing import List
+
+
+def update_workflow(template: Path, version: str) -> None:
+    """Updates versions of XYZ in GitHub workflow ..."""
+    with open(template, encoding="utf-8") as file:
+        content = file.readlines()
+
+    content = update_versions(
+        lines=content, matcher="exasol/python-toolbox/.github/", version=version
+    )
+
+    with open(template, "w", encoding="utf-8") as file:
+        file.writelines(content)
+
+
+def is_update_required(line, matcher):
+    return matcher in line and "@" in line
+
+
+def update_version(line, version):
+    keep = line[: line.index("@") + 1]
+    updated = f"{version}\n"
+    return f"{keep}{updated}"
+
+
+def update_versions(lines, matcher, version) -> List[str]:
+    result = []
+    for line in lines:
+        if is_update_required(line, matcher):
+            line = update_version(line, version)
+        result.append(line)
+    return result

noxconfig.py

@@ -11,6 +11,28 @@
 
 from nox import Session
 
+from exasol.toolbox.nox.plugin import hookimpl
+from exasol.toolbox.tools.replace_version import update_workflow
+
+
+class UpdateTemplates:
+    TEMPLATE_PATH: Path = Path(__file__).parent / "exasol" / "toolbox" / "templates"
+
+    @property
+    def workflows(self):
+        gh_workflows = self.TEMPLATE_PATH / "github" / "workflows"
+        gh_workflows = [f for f in gh_workflows.iterdir() if f.is_file()]
+        return gh_workflows
+
+    @hookimpl
+    def prepare_release_update_version(self, session, config, version):
+        for workflow in self.workflows:
+            update_workflow(workflow, version)
+
+    @hookimpl
+    def prepare_release_add_files(self, session, config, add):
+        add(session, self.workflows)
+
 
 @dataclass(frozen=True)
 class Config:
@@ -20,6 +42,7 @@ class Config:
     doc: Path = Path(__file__).parent / "doc"
     version_file: Path = Path(__file__).parent / "exasol" / "toolbox" / "version.py"
     path_filters: Iterable[str] = ("dist", ".eggs", "venv", "metrics-schema")
+    plugins = [UpdateTemplates]
 
     @staticmethod
     def pre_integration_tests_hook(

noxfile.py

@@ -6,3 +6,60 @@
 
 # default actions to be run if nothing is explicitly specified with the -s option
 nox.options.sessions = ["fix"]
+
+
+def main() -> None:
+    """
+    This excerpt was taken from nox.__main__.py. Generally, users should invoke Nox using the CLI provided by the Nox package.
+    However, when using Nox directly, it spawns a process and therefore, debugging isn't straightforward.
+    To cope with this issue, this entry point was added to enable a straightforward way to debug Nox tasks.
+    """
+    import sys
+    from typing import Any
+
+    from nox import (
+        _options,
+        tasks,
+        workflow,
+    )
+    from nox._version import get_nox_version
+    from nox.logger import setup_logging
+
+    def execute_workflow(args: Any) -> int:
+        """
+        Execute the appropriate tasks.
+        """
+        return workflow.execute(
+            global_config=args,
+            workflow=(
+                tasks.load_nox_module,
+                tasks.merge_noxfile_options,
+                tasks.discover_manifest,
+                tasks.filter_manifest,
+                tasks.honor_list_request,
+                tasks.run_manifest,
+                tasks.print_summary,
+                tasks.create_report,
+                tasks.final_reduce,
+            ),
+        )
+
+    args = _options.options.parse_args()
+
+    if args.help:
+        _options.options.print_help()
+        return
+
+    if args.version:
+        print(get_nox_version(), file=sys.stderr)
+        return
+
+    setup_logging(
+        color=args.color, verbose=args.verbose, add_timestamp=args.add_timestamp
+    )
+    exit_code = execute_workflow(args)
+    sys.exit(exit_code)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

poetry.lock

@@ -51,6 +51,7 @@ typer = {extras = ["all"], version = ">=0.7.0"}
 prysk = {extras = ["pytest-plugin"], version = "^0.17.0"}
 importlib-resources = ">=5.12.0"
 myst-parser = "^2.0.0"
+pluggy = "^1.5.0"
 
 
 [tool.poetry.group.dev.dependencies]

pyproject.toml

@@ -0,0 +1,59 @@
+import pytest
+
+from exasol.toolbox.tools.replace_version import (
+    is_update_required,
+    update_version,
+    update_versions,
+)
+
+
+@pytest.mark.parametrize(
+    "line,matcher,expected",
+    [
+        ("hallo/world@all", "hallo", True),
+        ("hallo/world@all", "foo", False),
+        ("hallo/world/all", "hallo", False),
+        ("hallo/world/all", "foo", False),
+    ],
+)
+def test_is_update_required(line, matcher, expected):
+    actual = is_update_required(line, matcher)
+    assert actual == expected
+
+
+@pytest.mark.parametrize(
+    "line,version,expected",
+    [
+        ("hallo/[email protected]\n", "2.3.4", "hallo/[email protected]\n"),
+        ("hallo/[email protected]\n", "9.9.9", "hallo/[email protected]\n"),
+    ],
+)
+def test_update_version(line, version, expected):
+    actual = update_version(line, version)
+    assert actual == expected
+
+
+@pytest.mark.parametrize(
+    "lines,matcher,version,expected",
+    [
+        (
+            [
+                "hallo/[email protected]\n",
+                "foo/[email protected]\n",
+                "hallo/world/3.4.5\n",
+                "foo/world/3.4.5\n",
+            ],
+            "hallo",
+            "4.5.6",
+            [
+                "hallo/[email protected]\n",
+                "foo/[email protected]\n",
+                "hallo/world/3.4.5\n",
+                "foo/world/3.4.5\n",
+            ],
+        )
+    ],
+)
+def test_update_versions(lines, matcher, version, expected):
+    actual = update_versions(lines, matcher, version)
+    assert actual == expected