Moved folders #405

bot/tools/set_version/__init__.py

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+
+"""
+set-version CPL internal tool to set version from branch name
+~~~~~~~~~~~~~~~~~~~
+
+CPL internal tool to set version from branch name
+
+:copyright: (c) 2022 sh-edraft.de
+:license: MIT, see LICENSE for more details.
+
+"""
+
+__title__ = "set_version"
+__author__ = "Sven Heidemann"
+__license__ = "MIT"
+__copyright__ = "Copyright (c) 2022 sh-edraft.de"
+__version__ = "2022.7.0"
+
+from collections import namedtuple
+
+
+# imports:
+
+VersionInfo = namedtuple("VersionInfo", "major minor micro")
+version_info = VersionInfo(major="2022", minor="7", micro="0")

bot/tools/set_version/application.py

@@ -0,0 +1,150 @@
+import os
+import traceback
+
+from cpl_cli.configuration import ProjectSettings
+from cpl_cli.configuration.version_settings_name_enum import VersionSettingsNameEnum
+from cpl_cli.configuration.workspace_settings import WorkspaceSettings
+from cpl_core.application.application_abc import ApplicationABC
+from cpl_core.configuration.configuration_abc import ConfigurationABC
+from cpl_core.console.console import Console
+from cpl_core.dependency_injection.service_provider_abc import ServiceProviderABC
+from cpl_core.pipes.version_pipe import VersionPipe
+from cpl_core.utils import String
+
+from set_version.git_service import GitService
+from set_version.version_setter_service import VersionSetterService
+
+
+class Application(ApplicationABC):
+    def __init__(self, config: ConfigurationABC, services: ServiceProviderABC):
+        ApplicationABC.__init__(self, config, services)
+
+        self._workspace: WorkspaceSettings = config.get_configuration(WorkspaceSettings)
+
+        self._git_service: GitService = self._services.get_service(GitService)
+        self._version_setter: VersionSetterService = self._services.get_service(
+            VersionSetterService
+        )
+        self._version_pipe: VersionPipe = self._services.get_service(VersionPipe)
+
+    def configure(self):
+        self._configuration.parse_console_arguments(self._services)
+
+    def main(self):
+        Console.write_line("Set versions:")
+
+        args = self._configuration.additional_arguments
+        version = {}
+        branch = ""
+        suffix = ""
+        force = False
+        if "--force" in args:
+            args.remove("--force")
+            force = True
+
+        if len(args) > 1:
+            Console.error(f'Unexpected argument(s): {", ".join(args[1:])}')
+            return
+
+        if len(args) == 1:
+            suffix = args[0]
+
+        try:
+            branch = self._git_service.get_active_branch_name()
+            Console.write_line(f"Found branch: {branch}")
+        except Exception as e:
+            Console.error("Branch not found", traceback.format_exc())
+            return
+
+        try:
+            if branch.startswith("#"):
+                self._configuration.add_json_file(
+                    self._workspace.projects[self._workspace.default_project],
+                    optional=False,
+                    output=False,
+                )
+                ps: ProjectSettings = self._configuration.get_configuration(
+                    ProjectSettings
+                )
+
+                version[VersionSettingsNameEnum.major.value] = ps.version.major
+                version[VersionSettingsNameEnum.minor.value] = ps.version.minor
+                version[
+                    VersionSettingsNameEnum.micro.value
+                ] = f'dev{branch.split("#")[1]}'
+            else:
+                if "." not in branch and "." in suffix:
+                    branch = suffix
+                    suffix = ""
+
+                version[VersionSettingsNameEnum.major.value] = branch.split(".")[0]
+                version[VersionSettingsNameEnum.minor.value] = branch.split(".")[1]
+                if len(branch.split(".")) == 2:
+                    if suffix == "":
+                        suffix = "0"
+                    version[VersionSettingsNameEnum.micro.value] = f"{suffix}"
+                else:
+                    if not suffix.startswith(".") and suffix != "":
+                        suffix = f".{suffix}"
+                    version[
+                        VersionSettingsNameEnum.micro.value
+                    ] = f'{branch.split(".")[2]}{suffix}'
+        except Exception as e:
+            Console.error(f"Branch {branch} does not contain valid version")
+            return
+
+        diff_paths = []
+        for file in self._git_service.get_diff_files():
+            if "kdb-bot/src" in file:
+                file = file.replace("kdb-bot/src", "")
+
+            if file.startswith("tools") or "kdb-web/src" in file:
+                continue
+
+            if "/" in file:
+                file = file.split("/")[1]
+            else:
+                file = os.path.basename(os.path.dirname(file))
+
+            if file in diff_paths:
+                continue
+
+            diff_paths.append(file)
+
+        try:
+            skipped = []
+            for project in self._workspace.projects:
+                if (
+                    project not in diff_paths
+                    and String.convert_to_snake_case(project) not in diff_paths
+                    and not force
+                ):
+                    # Console.write_line(f'Skipping {project} due to missing changes')
+                    skipped.append(project)
+                    continue
+
+                Console.write_line(
+                    f"Set dependencies {self._version_pipe.transform(version)} for {project}"
+                )
+                self._version_setter.set_dependencies(
+                    self._workspace.projects[project],
+                    version,
+                    "Dependencies",
+                    skipped=skipped,
+                )
+                self._version_setter.set_dependencies(
+                    self._workspace.projects[project],
+                    version,
+                    "DevDependencies",
+                    skipped=skipped,
+                )
+
+                Console.write_line(
+                    f"Set version {self._version_pipe.transform(version)} for {project}"
+                )
+                self._version_setter.set_version(
+                    self._workspace.projects[project], version
+                )
+        except Exception as e:
+            Console.error("Version could not be set", traceback.format_exc())
+            return

bot/tools/set_version/git_service.py

@@ -0,0 +1,17 @@
+import os
+
+from cpl_core.environment import ApplicationEnvironmentABC
+from git import Repo
+
+
+class GitService:
+    def __init__(self, env: ApplicationEnvironmentABC):
+        self._env = env
+        self._repo = Repo(os.path.abspath(os.path.join(env.working_directory, "../")))
+
+    def get_active_branch_name(self) -> str:
+        branch = self._repo.active_branch
+        return branch.name
+
+    def get_diff_files(self) -> list[str]:
+        return [item.a_path for item in self._repo.index.diff(None)]

bot/tools/set_version/main.py

@@ -0,0 +1,14 @@
+from cpl_core.application import ApplicationBuilder
+
+from set_version.application import Application
+from set_version.startup import Startup
+
+
+def main():
+    app_builder = ApplicationBuilder(Application)
+    app_builder.use_startup(Startup)
+    app_builder.build().run()
+
+
+if __name__ == "__main__":
+    main()

bot/tools/set_version/set-version.json

@@ -0,0 +1,45 @@
+{
+  "ProjectSettings": {
+    "Name": "set-version",
+    "Version": {
+      "Major": "1",
+      "Minor": "2",
+      "Micro": "0"
+    },
+    "Author": "Sven Heidemann",
+    "AuthorEmail": "sven.heidemann@sh-edraft.de",
+    "Description": "CPL internal tool to set version from branch name",
+    "LongDescription": "CPL internal tool to set version from branch name",
+    "URL": "https://www.sh-edraft.de",
+    "CopyrightDate": "2022",
+    "CopyrightName": "sh-edraft.de",
+    "LicenseName": "MIT",
+    "LicenseDescription": "MIT, see LICENSE for more details.",
+    "Dependencies": [
+      "cpl-core==2022.12.0",
+      "GitPython==3.1.27"
+    ],
+    "DevDependencies": [
+      "cpl-cli==2022.12.0"
+    ],
+    "PythonVersion": ">=3.10.4",
+    "PythonPath": {},
+    "Classifiers": []
+  },
+  "BuildSettings": {
+    "ProjectType": "console",
+    "SourcePath": "",
+    "OutputPath": "../../dist",
+    "Main": "set_version.main",
+    "EntryPoint": "set-version",
+    "IncludePackageData": false,
+    "Included": [],
+    "Excluded": [
+      "*/__pycache__",
+      "*/logs",
+      "*/tests"
+    ],
+    "PackageData": {},
+    "ProjectReferences": []
+  }
+}

bot/tools/set_version/startup.py

@@ -0,0 +1,38 @@
+import os
+
+from cpl_cli.configuration import WorkspaceSettings
+from cpl_core.application import StartupABC
+from cpl_core.configuration import ConfigurationABC
+from cpl_core.dependency_injection import ServiceProviderABC, ServiceCollectionABC
+from cpl_core.environment import ApplicationEnvironment
+from cpl_core.pipes.version_pipe import VersionPipe
+from set_version.git_service import GitService
+from set_version.version_setter_service import VersionSetterService
+
+
+class Startup(StartupABC):
+    def __init__(self):
+        StartupABC.__init__(self)
+
+    def configure_configuration(
+        self, configuration: ConfigurationABC, environment: ApplicationEnvironment
+    ) -> ConfigurationABC:
+        configuration.add_json_file("cpl-workspace.json", optional=True, output=False)
+        if configuration.get_configuration(WorkspaceSettings) is None:
+            environment.set_working_directory(
+                os.path.join(environment.working_directory, "../../")
+            )
+            configuration.add_json_file(
+                "cpl-workspace.json", optional=False, output=False
+            )
+
+        return configuration
+
+    def configure_services(
+        self, services: ServiceCollectionABC, environment: ApplicationEnvironment
+    ) -> ServiceProviderABC:
+        services.add_pipes()
+        services.add_singleton(GitService)
+        services.add_transient(VersionSetterService)
+
+        return services.build_service_provider()

bot/tools/set_version/version_setter_service.py

@@ -0,0 +1,72 @@
+import json
+import os
+from string import ascii_letters
+
+from cpl_core.environment import ApplicationEnvironmentABC
+from cpl_core.utils import String
+
+
+class VersionSetterService:
+    def __init__(self, env: ApplicationEnvironmentABC):
+        self._env = env
+
+    def _read_file(self, file: str) -> dict:
+        project_json = {}
+        with open(
+            os.path.join(self._env.working_directory, file), "r", encoding="utf-8"
+        ) as f:
+            # load json
+            project_json = json.load(f)
+            f.close()
+
+        return project_json
+
+    def _write_file(self, file: str, project_json: dict):
+        with open(
+            os.path.join(self._env.working_directory, file), "w", encoding="utf-8"
+        ) as f:
+            f.write(json.dumps(project_json, indent=2))
+            f.close()
+
+    def set_version(self, file: str, version: dict):
+        project_json = self._read_file(file)
+        project_json["ProjectSettings"]["Version"] = version
+        self._write_file(file, project_json)
+
+    def set_dependencies(self, file: str, version: dict, key: str, skipped=None):
+        project_json = self._read_file(file)
+        if key not in project_json["ProjectSettings"]:
+            project_json["ProjectSettings"][key] = []
+
+        dependencies = project_json["ProjectSettings"][key]
+        new_deps = []
+        for dependency in dependencies:
+            if not dependency.startswith("cpl-"):
+                new_deps.append(dependency)
+                continue
+
+            dep_version = dependency.split("=")[1]
+            dep_name = dependency.split("=")[0]
+            if dep_name[len(dep_name) - 1] not in ascii_letters:
+                dep_name = dep_name[: len(dep_name) - 1]
+
+            if (
+                skipped is not None
+                and (
+                    dep_name in skipped
+                    or String.convert_to_snake_case(dep_name) in skipped
+                )
+                or dep_version == ""
+            ):
+                new_deps.append(dependency)
+                continue
+
+            new_deps.append(
+                dependency.replace(
+                    dep_version,
+                    f'{version["Major"]}.{version["Minor"]}.{version["Micro"]}',
+                )
+            )
+
+        project_json["ProjectSettings"][key] = new_deps
+        self._write_file(file, project_json)