proj-flow 0.9.3__py3-none-any.whl → 0.10.0__py3-none-any.whl

proj_flow/ext/cplusplus/cmake/steps.py

@@ -0,0 +1,142 @@
+# Copyright (c) 2025 Marcin Zdun
+# This code is licensed under MIT license (see LICENSE for details)
+
+"""
+The **proj_flow.ext.cplusplus.cmake.steps** defines steps for configuring,
+building and archiving.
+"""
+
+import os
+from typing import Dict, List, cast
+
+from proj_flow import api
+from proj_flow.api import env, step
+
+from .__version__ import CMAKE_VERSION
+
+
+class CMakeBase(api.step.Step):
+    _name: str
+    _runs_after: List[str] = []
+    _runs_before: List[str] = []
+
+    @property
+    def name(self):
+        return self._name
+
+    @property
+    def runs_after(self):
+        return self._runs_after
+
+    @property
+    def runs_before(self):
+        return self._runs_before
+
+    def __init__(
+        self, name: str, runs_after: List[str] = [], runs_before: List[str] = []
+    ):
+        super().__init__()
+        self._name = name
+        self._runs_after = runs_after
+        self._runs_before = runs_before
+
+    def is_active(self, config: api.env.Config, rt: api.env.Runtime) -> int:
+        return os.path.isfile("CMakeLists.txt") and os.path.isfile("CMakePresets.json")
+
+    def platform_dependencies(self):
+        return [f"cmake>={CMAKE_VERSION}"]
+
+    def dep_with_tool(self, tool: str):
+        return [f"cmake>={CMAKE_VERSION}", f"{tool}>={CMAKE_VERSION}"]
+
+
+@step.register
+class CMakeConfig(CMakeBase):
+    """Configures the project using ``preset`` config."""
+
+    def __init__(self):
+        super().__init__(name="CMake")
+
+    def is_active(self, config: env.Config, rt: env.Runtime) -> int:
+        return os.path.isfile("CMakeLists.txt") and os.path.isfile("CMakePresets.json")
+
+    def directories_to_remove(self, config: env.Config) -> List[str]:
+        return [f"build/{config.build_type}"]
+
+    def run(self, config: env.Config, rt: env.Runtime) -> int:
+        cmake_vars = cast(Dict[str, str], rt._cfg.get("cmake", {}).get("vars", {}))
+        defines: List[str] = []
+        for var in cmake_vars:
+            value = cmake_vars[var]
+
+            is_flag = value.startswith("?")
+            if is_flag:
+                value = value[1:]
+
+            if value.startswith("config:"):
+                value = value[len("config:")]
+                value = config.get_path(value)
+            elif value.startswith("runtime:"):
+                value = value[len("runtime:")]
+                value = getattr(rt, value, None)
+
+            if is_flag:
+                value = "ON" if value else "OFF"
+
+            defines.append(f"-D{var}={value}")
+
+        return rt.cmd(
+            "cmake",
+            "--preset",
+            f"{config.preset}-{config.build_generator}",
+            *defines,
+        )
+
+
+@step.register()
+class CMakeBuild(CMakeBase):
+    """Builds the project using ``preset`` config."""
+
+    def __init__(self):
+        super().__init__(name="Build", runs_after=["CMake"])
+
+    def run(self, config: env.Config, rt: env.Runtime) -> int:
+        return rt.cmd("cmake", "--build", "--preset", config.preset, "--parallel")
+
+
+@step.register
+class CMakeTest(CMakeBase):
+    """Runs tests in the project using ``preset`` config."""
+
+    def __init__(self):
+        super().__init__(name="Test", runs_after=["Build"])
+
+    def platform_dependencies(self):
+        return self.dep_with_tool("ctest")
+
+    def run(self, config: env.Config, rt: env.Runtime) -> int:
+        return rt.cmd("ctest", "--preset", config.preset)
+
+
+@step.register
+class PackStep(CMakeBase):
+    """
+    Packs archives and installers from ``cpack_generator`` config, using
+    ``preset`` config.
+    """
+
+    def __init__(self):
+        super().__init__(name="Pack", runs_after=["Build"])
+
+    def platform_dependencies(self):
+        return self.dep_with_tool("cpack")
+
+    def is_active(self, config: env.Config, rt: env.Runtime) -> int:
+        return (
+            super().is_active(config, rt)
+            and len(config.items.get("cpack_generator", [])) > 0
+        )
+
+    def run(self, config: env.Config, rt: env.Runtime) -> int:
+        generators = ";".join(config.items.get("cpack_generator", []))
+        return rt.cmd("cpack", "--preset", config.preset, "-G", generators)

proj_flow/ext/cplusplus/cmake/version.py

@@ -0,0 +1,35 @@
+# Copyright (c) 2025 Marcin Zdun
+# This code is licensed under MIT license (see LICENSE for details)
+
+"""
+The **proj_flow.ext.cplusplus.cmake.version** provides project suite plugin.
+"""
+
+import os
+import re
+from typing import NamedTuple, Optional
+
+import toml
+
+from proj_flow.api import env, release
+from proj_flow.ext.cplusplus.cmake.parser import get_project
+
+
+class QuickProjectInfo(NamedTuple):
+    name: Optional[str] = None
+    path: Optional[str] = None
+    pattern: Optional[str] = None
+
+
+@release.project_suites.add
+class ProjectSuite(release.ProjectSuite):
+    def get_project(self, rt: env.Runtime) -> Optional[release.Project]:
+        project = get_project(rt.root)
+        if project is None:
+            return None
+        return release.Project(
+            project.name.value, release.Version(project.version, project.stability)
+        )
+
+    def get_version_file_path(self, rt: env.Runtime) -> Optional[str]:
+        return "CMakeLists.txt"

proj_flow/{plugins → ext/cplusplus}/conan/__init__.py

@@ -2,14 +2,15 @@
 # This code is licensed under MIT license (see LICENSE for details)
 
 """
-The **proj_flow.plugins.conan** provides the ``"Conan"`` step.
+The **proj_flow.ext.cplusplus.conan** provides the ``"Conan"`` step.
 """
 
 import os
 import textwrap
 from typing import List
 
-from proj_flow.api import ctx, env, step
+from proj_flow.api import env, step
+from proj_flow.project import cplusplus
 
 from ._conan import conan_api
 
@@ -23,6 +24,7 @@ class ConanConfig:
     """Configures the project for ``preset`` config using ``build_type`` config."""
 
     name = "Conan"
+    runs_before = ["CMake"]
 
     def platform_dependencies(self):
         return ["conan"]
@@ -63,4 +65,6 @@ class ConanConfig:
         return 0
 
 
-ctx.register_switch("with_conan", "Use Conan for dependency manager", True)
+cplusplus.project.register_switch(
+    "with_conan", "Use Conan for dependency manager", True
+)

proj_flow/{plugins → ext/cplusplus}/conan/_conan.py

@@ -2,16 +2,18 @@
 # This code is licensed under MIT license (see LICENSE for details)
 
 """
-The **proj_flow.plugins.conan._conan** adds support for both Conan v1 and v2.
+The **proj_flow.ext.cplusplus.conan._conan** adds support for both Conan v1
+and v2.
 """
 
 import shutil
+import subprocess
 from abc import ABC, abstractmethod
 from typing import Callable, List, cast
 
 from proj_flow.api.env import Config, Runtime
 from proj_flow.base import cmd
-from proj_flow.flow.dependency import VER_REGEX
+from proj_flow.dependency import VER_REGEX
 
 
 class conan(ABC):
@@ -119,7 +121,10 @@ def _conan_version():
     if found is None:
         return 1
 
-    proc = cmd.run(found, "--version", capture_output=True)
+    proc = cast(
+        subprocess.CompletedProcess[str],
+        cmd.run(found, "--version", capture_output=True),
+    )
     if proc.returncode != 0:
         return 1
     m = VER_REGEX.search(proc.stdout)

proj_flow/ext/github/__init__.py

@@ -6,6 +6,6 @@ The **proj_flow.ext.github** provides GitHub support through CLI and GitHub
 hosting plugin.
 """
 
-from . import cli, hosting
+from . import cli, hosting, switches
 
-__all__ = ["cli", "hosting"]
+__all__ = ["cli", "hosting", "switches"]

proj_flow/ext/github/cli.py

@@ -16,22 +16,13 @@ import typing
 
 from proj_flow import log
 from proj_flow.api import arg, env
+from proj_flow.base.name_list import name_list
 from proj_flow.flow.configs import Configs
 from proj_flow.log import commit, hosting, rich_text
 
 FORCED_LEVEL_CHOICES = list(commit.FORCED_LEVEL.keys())
 
 
-def _name_list(names: typing.List[str]) -> str:
-    if len(names) == 0:
-        return ""
-
-    prefix = ", ".join(names[:-1])
-    if prefix:
-        prefix += " and "
-    return f"{prefix}{names[-1]}"
-
-
 @arg.command("github")
 def github():
     """Interact with GitHub workflows and releases"""
@@ -81,7 +72,7 @@ def release(
         typing.Optional[str],
         arg.Argument(
             help="Ignore the version change from changelog and instead use this value. "
-            f"Allowed values are: {_name_list(FORCED_LEVEL_CHOICES)}",
+            f"Allowed values are: {name_list(FORCED_LEVEL_CHOICES)}",
             meta="level",
             choices=FORCED_LEVEL_CHOICES,
         ),

proj_flow/{plugins/github.py → ext/github/switches.py}

@@ -1,13 +1,13 @@
 # Copyright (c) 2025 Marcin Zdun
 # This code is licensed under MIT license (see LICENSE for details)
 """
-The **proj_flow.plugins.github** provides GitHub-related switches for new
+The **proj_flow.ext.github.switches** provides GitHub-related switches for new
 projects.
 """
 
 from proj_flow.api import ctx
 
-ctx.register_switch("with_github_actions", "Use Github Actions", True)
-ctx.register_switch(
+ctx.register_common_switch("with_github_actions", "Use Github Actions", True)
+ctx.register_common_switch(
     "with_github_social", "Use Github ISSUE_TEMPLATE, CONTRIBUTING.md, etc.", True
 )

proj_flow/ext/{markdown_changelist.py → markdown_changelog.py}

@@ -2,7 +2,8 @@
 # This code is licensed under MIT license (see LICENSE for details)
 
 """
-The **proj_flow.ext.markdown_changelist** .
+The **proj_flow.ext.markdown_changelog** registers a
+:class:`api.ChangelogGenerator` plugin implemented for markdown changelogs.
 """
 
 from proj_flow.log.rich_text.api import changelog_generators

proj_flow/ext/python/rtdocs.py

@@ -2,7 +2,7 @@
 # This code is licensed under MIT license (see LICENSE for details)
 
 """
-The **proj_flow.ext.python.steps.rtdocs** defines RTDocs step, which uses
+The **proj_flow.ext.python.rtdocs** defines RTDocs step (`"RTD"`), which uses
 .readthedocs.yaml to build the HTML documentation.
 """
 

proj_flow/ext/python/version.py

@@ -2,8 +2,7 @@
 # This code is licensed under MIT license (see LICENSE for details)
 
 """
-The **proj_flow.ext.python.steps** defines steps for building, installing and
-documenting.
+The **proj_flow.ext.python.version** provides project suite plugin.
 """
 
 import os

proj_flow/ext/{re_structured_changelist.py → re_structured_changelog.py}

@@ -2,7 +2,9 @@
 # This code is licensed under MIT license (see LICENSE for details)
 
 """
-The **proj_flow.ext.re_structured_text** .
+The **proj_flow.ext.re_structured_changelog** registers a
+:class:`api.ChangelogGenerator` plugin implemented for reStructuredText
+changelogs.
 """
 
 from proj_flow.log.rich_text.api import changelog_generators

proj_flow/{plugins → ext}/sign/__init__.py

@@ -2,7 +2,7 @@
 # This code is licensed under MIT license (see LICENSE for details)
 
 """
-The **proj_flow.plugins.sign** provides the ``"Sign"`` and ``"SignPackages"``
+The **proj_flow.ext.sign** provides the ``"Sign"`` and ``"SignPackages"``
 steps.
 """
 
@@ -14,23 +14,7 @@ from typing import List, cast
 
 from proj_flow.api import env, init, step
 
-if sys.platform == "win32":
-    from . import win32
-
-else:
-
-    class win32:
-        @staticmethod
-        def is_active(*args):
-            return False
-
-        @staticmethod
-        def sign(*args):
-            return 0
-
-        @staticmethod
-        def is_pe_exec(arg):
-            return False
+from . import api, win32
 
 
 def should_exclude(filename: str, exclude: List[str], config_os: str):
@@ -44,34 +28,69 @@ def should_exclude(filename: str, exclude: List[str], config_os: str):
 
 
 class SignBase(step.Step):
+    _name: str
+    _runs_after: List[str] = []
+    _runs_before: List[str] = []
+
+    _active_tools: List[api.SigningTool] = []
+
+    @property
+    def name(self):
+        return self._name
+
+    @property
+    def runs_after(self):
+        return self._runs_after
+
+    @property
+    def runs_before(self):
+        return self._runs_before
+
+    def __init__(
+        self, name: str, runs_after: List[str] = [], runs_before: List[str] = []
+    ):
+        super().__init__()
+        self._name = name
+        self._runs_after = runs_after
+        self._runs_before = runs_before
+
     def is_active(self, config: env.Config, rt: env.Runtime) -> int:
-        return win32.is_active(config.os, rt)
+        self._active_tools = [
+            tool for tool in api.signing_tool.get() if tool.is_active(config, rt)
+        ]
+        return len(self._active_tools) > 0
 
     @abstractmethod
-    def get_files(self, config: env.Config, rt: env.Runtime) -> List[str]: ...
+    def get_files(
+        self, tool: api.SigningTool, config: env.Config, rt: env.Runtime
+    ) -> List[str]: ...
 
     def run(self, config: env.Config, rt: env.Runtime) -> int:
-        files = [file.replace(os.sep, "/") for file in self.get_files(config, rt)]
-        if len(files) == 0:
-            return 0
+        for tool in self._active_tools:
+            files = [
+                file.replace(os.sep, "/") for file in self.get_files(tool, config, rt)
+            ]
 
-        rt.print("signtool", *(os.path.basename(file) for file in files))
+            if len(files) == 0:
+                continue
 
-        if rt.dry_run:
-            return 0
+            result = tool.sign(config, rt, files)
+            if result:
+                return result
 
-        return win32.sign(files, rt)
+        return 0
 
 
 @step.register
 class SignFiles(SignBase):
     """*(Windows)* Signs executable files in build directory"""
 
-    name = "Sign"
-    runs_after = ["Build"]
-    runs_before = ["Pack"]
+    def __init__(self):
+        super().__init__(name="Sign", runs_after=["Build"], runs_before=["Pack"])
 
-    def get_files(self, config: env.Config, rt: env.Runtime) -> List[str]:
+    def get_files(
+        self, tool: api.SigningTool, config: env.Config, rt: env.Runtime
+    ) -> List[str]:
         cfg = cast(dict, rt._cfg.get("sign", {}))
         roots = cfg.get("directories", ["bin", "lib", "libexec", "share"])
         exclude = cfg.get("exclude", ["*-test"])
@@ -85,10 +104,8 @@ class SignFiles(SignBase):
                         continue
 
                     full_path = os.path.join(curr_dir, filename)
-                    if not win32.is_pe_exec(full_path):
-                        continue
-
-                    result.append(full_path)
+                    if tool.is_executable(full_path, as_package=False):
+                        result.append(full_path)
         return result
 
 
@@ -96,26 +113,29 @@ class SignFiles(SignBase):
 class SignMsi(SignBase):
     """*(Windows)* Signs MSI installers in build directory"""
 
-    name = "SignPackages"
-    runs_after = ["Pack"]
-    runs_before = ["StorePackages", "Store"]
+    def __init__(self):
+        super().__init__(
+            name="SignPackages",
+            runs_after=["Pack"],
+            runs_before=["StorePackages", "Store"],
+        )
 
     def is_active(self, config: env.Config, rt: env.Runtime) -> int:
         return super().is_active(config, rt) and "WIX" in config.items.get(
             "cpack_generator", []
         )
 
-    def get_files(self, config: env.Config, rt: env.Runtime) -> List[str]:
+    def get_files(
+        self, tool: api.SigningTool, config: env.Config, rt: env.Runtime
+    ) -> List[str]:
         result: List[str] = []
         pkg_dir = os.path.join(config.build_dir, "packages")
         for curr_dir, dirnames, filenames in os.walk(pkg_dir):
             dirnames[:] = []
             for filename in filenames:
-                _, ext = os.path.splitext(filename)
-                if ext.lower() != ".msi":
-                    continue
-
-                result.append(os.path.join(curr_dir, filename))
+                full_path = os.path.join(curr_dir, filename)
+                if tool.is_executable(full_path, as_package=False):
+                    result.append(full_path)
 
         return result
 

proj_flow/ext/sign/api.py

@@ -0,0 +1,83 @@
+# Copyright (c) 2025 Marcin Zdun
+# This code is licensed under MIT license (see LICENSE for details)
+
+"""
+The **proj_flow.ext.sign.api** defines an extension point for per-platform
+sign tools.
+"""
+
+import base64
+import json
+import os
+from abc import ABC, abstractmethod
+from typing import List, NamedTuple, Optional
+
+from proj_flow import base
+from proj_flow.api import env
+
+ENV_KEY = "SIGN_TOKEN"
+
+
+class Key(NamedTuple):
+    token: str
+    secret: bytes
+
+
+def _get_key_from_contents(key: str, rt: env.Runtime):
+    try:
+        obj = json.loads(key)
+    except json.decoder.JSONDecodeError:
+        rt.message("sign: the signature is not a valid JSON document")
+        return None
+
+    if not isinstance(obj, dict):
+        rt.message("sign: the signature is missing required fields")
+        return None
+
+    token = obj.get("token")
+    secret = obj.get("secret")
+    if not isinstance(token, str) or not isinstance(secret, str):
+        rt.message("sign: the signature is missing required fields")
+        return None
+
+    return Key(
+        base64.b64decode(token).decode("UTF-8"),
+        base64.b64decode(secret),
+    )
+
+
+def get_key(rt: env.Runtime) -> Optional[Key]:
+    rt.message(f"sign: trying ${ENV_KEY}")
+    env = os.environ.get(ENV_KEY)
+    if env:
+        key = _get_key_from_contents(env, rt)
+        if key is not None:
+            return key
+    local_signature = os.path.join(".", "signature.key")
+    home_signature = os.path.join(os.path.expanduser("~"), "signature.key")
+    for filename in [local_signature, home_signature]:
+        rt.message(f"sign: trying {filename}")
+        if os.path.isfile(filename):
+            with open(filename, encoding="UTF-8") as file:
+                result = file.read().strip()
+                key = _get_key_from_contents(result, rt)
+                if key is not None:
+                    return key
+
+    rt.message("sign: no key set up")
+
+    return None
+
+
+class SigningTool(ABC):
+    @abstractmethod
+    def is_active(self, config: env.Config, rt: env.Runtime): ...
+
+    @abstractmethod
+    def sign(self, config: env.Config, rt: env.Runtime, files: List[str]): ...
+
+    @abstractmethod
+    def is_executable(self, filename: str, as_package: bool): ...
+
+
+signing_tool = base.registry.Registry[SigningTool]("SigningTool")