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

proj_flow/ext/sign/win32.py

@@ -0,0 +1,152 @@
+# Copyright (c) 2025 Marcin Zdun
+# This code is licensed under MIT license (see LICENSE for details)
+
+"""
+The **proj_flow.ext.sign.win32** provides code signing with SignTool
+from Windows SDKs.
+"""
+
+import base64
+import json
+import os
+import platform
+import struct
+import subprocess
+import sys
+from typing import Iterable, List, Optional, Tuple
+
+from proj_flow.api.env import Config, Msg, Runtime
+
+from .api import ENV_KEY, SigningTool, get_key, signing_tool
+
+if sys.platform == "win32":
+    import winreg
+
+    @signing_tool.add
+    class Win32SigningTool(SigningTool):
+        def is_active(self, config: Config, rt: Runtime):
+            return _is_active(config.os, rt)
+
+        def sign(self, config: Config, rt: Runtime, files: List[str]):
+            rt.print("signtool", *(os.path.basename(file) for file in files))
+            return _sign(files, rt)
+
+        def is_signable(self, filename: str, as_package: bool):
+            if as_package:
+                _, ext = os.path.splitext(filename)
+                return ext.lower() == ".msi"
+            return _is_pe_exec(filename)
+
+    Version = Tuple[int, int, int]
+
+    machine = {"ARM64": "arm64", "AMD64": "x64", "X86": "x86"}.get(
+        platform.machine(), "x86"
+    )
+
+    def _find_sign_tool(rt: Runtime) -> Optional[str]:
+        with winreg.OpenKeyEx(  # type: ignore
+            winreg.HKEY_LOCAL_MACHINE, r"SOFTWARE\Microsoft\Windows Kits\Installed Roots"  # type: ignore
+        ) as kits:
+            try:
+                kits_root = winreg.QueryValueEx(kits, "KitsRoot10")[0]  # type: ignore
+            except FileNotFoundError:
+                rt.message("sign/win32: No KitsRoot10 value")
+                return None
+
+            versions: List[Tuple[Version, str]] = []
+            try:
+                index = 0
+                while True:
+                    ver_str = winreg.EnumKey(kits, index)  # type: ignore
+                    ver = tuple(int(chunk) for chunk in ver_str.split("."))
+                    index += 1
+                    versions.append((ver, ver_str))  # type: ignore
+            except OSError:
+                pass
+        versions.sort()
+        versions.reverse()
+        rt.message(
+            "sign/win32: Regarding versions:",
+            ", ".join(version[1] for version in versions),
+        )
+        for _, version in versions:
+            # C:\Program Files (x86)\Windows Kits\10\bin\10.0.22621.0\x64\signtool.exe
+            sign_tool = os.path.join(kits_root, "bin", version, machine, "signtool.exe")
+            if os.path.isfile(sign_tool):
+                rt.message("sign/win32: using:", sign_tool)
+                return sign_tool
+        return None
+
+    def _is_active(os_name: str, rt: Runtime):
+        if os_name != "windows":
+            return False
+        key = get_key(rt)
+        return (
+            key is not None
+            and key.token is not None
+            and key.secret is not None
+            and _find_sign_tool(rt) is not None
+        )
+
+    _IMAGE_DOS_HEADER = "HHHHHHHHHHHHHH8sHH20sI"
+    _IMAGE_NT_HEADERS_Signature = "H"
+    _IMAGE_DOS_HEADER_size = struct.calcsize(_IMAGE_DOS_HEADER)
+    _IMAGE_NT_HEADERS_Signature_size = struct.calcsize(_IMAGE_NT_HEADERS_Signature)
+    _MZ = 23117
+    _PE = 17744
+
+    def _is_pe_exec(path: str):
+        with open(path, "rb") as exe:
+            mz_header = exe.read(_IMAGE_DOS_HEADER_size)
+            dos_header = struct.unpack(_IMAGE_DOS_HEADER, mz_header)
+            if dos_header[0] != _MZ:
+                return False
+
+            PE_offset = dos_header[-1]
+            if PE_offset < _IMAGE_DOS_HEADER_size:
+                return False
+
+            if PE_offset > _IMAGE_DOS_HEADER_size:
+                exe.read(PE_offset - _IMAGE_DOS_HEADER_size)
+
+            pe_header = exe.read(_IMAGE_NT_HEADERS_Signature_size)
+            signature = struct.unpack(_IMAGE_NT_HEADERS_Signature, pe_header)[0]
+            return signature == _PE
+
+    def _sign(files: Iterable[str], rt: Runtime):
+        key = get_key(rt)
+
+        if key is None or key.token is None or key.secret is None:
+            rt.fatal("sign: the key is missing")
+
+        sign_tool = _find_sign_tool(rt)
+        if sign_tool is None:
+            rt.message("proj-flow: sign: signtool.exe not found", level=Msg.ALWAYS)
+            return 0
+
+        with open("temp.pfx", "wb") as pfx:
+            pfx.write(key.secret)
+
+        args = [
+            sign_tool,
+            "sign",
+            "/f",
+            "temp.pfx",
+            "/p",
+            key.token,
+            "/tr",
+            "http://timestamp.digicert.com",
+            "/fd",
+            "sha256",
+            "/td",
+            "sha256",
+            *files,
+        ]
+
+        result = 1
+        try:
+            result = subprocess.run(args, shell=False).returncode
+        finally:
+            os.remove("temp.pfx")
+
+        return result

proj_flow/{plugins/store/store_packages.py → ext/store.py}

@@ -2,18 +2,17 @@
 # This code is licensed under MIT license (see LICENSE for details)
 
 """
-The **proj_flow.plugins.store** provides ``"StorePackages"`` step.
+The **proj_flow.ext.store** provides ``"Store"``, ``"StoreTests"`` and
+``"StorePackages"`` steps.
 """
 
 import os
 import shutil
 from typing import List, cast
 
-from proj_flow.api import env, step
+from proj_flow.api import env, release, step
 from proj_flow.base.uname import uname
 
-from ..cmake.parser import get_project
-
 _system, _version, _arch = uname()
 _version = "" if _version is None else f"-{_version}"
 _project_pkg = None
@@ -26,12 +25,24 @@ def _package_name(config: env.Config, pkg: str, group: str):
     return f"{pkg}-{_system}{_version}-{_arch}{debug}{suffix}"
 
 
+def _get_project(rt: env.Runtime):
+    def wrap(suite: release.ProjectSuite):
+        return suite.get_project(rt)
+
+    return wrap
+
+
 @step.register
-class StorePackages:
+class StorePackages(step.Step):
     """Stores archives and installers build for ``preset`` config value."""
 
-    name = "StorePackages"
-    runs_after = ["Pack"]
+    @property
+    def name(self):
+        return "StorePackages"
+
+    @property
+    def runs_after(self):
+        return ["Pack"]
 
     def run(self, config: env.Config, rt: env.Runtime) -> int:
         if not rt.dry_run:
@@ -41,10 +52,10 @@ class StorePackages:
 
         global _project_pkg
         if _project_pkg is None:
-            project = get_project("")
+            _, project = release.project_suites.find(_get_project(rt))
             if project is None:
                 rt.fatal(f"Cannot get project information from {rt.root}")
-            _project_pkg = project.pkg
+            _project_pkg = project.archive_name
 
         main_group = cast(str, rt._cfg.get("package", {}).get("main-group"))
         if main_group is not None and not rt.dry_run:
@@ -77,3 +88,34 @@ class StorePackages:
             "build/artifacts/packages",
             f"^{_project_pkg}-.*$",
         )
+
+
+@step.register
+class StoreTests(step.Step):
+    """Stores test results gathered during tests for ``preset`` config value."""
+
+    @property
+    def name(self):
+        return "StoreTests"
+
+    @property
+    def runs_after(self):
+        return ["Test"]
+
+    def run(self, config: env.Config, rt: env.Runtime) -> int:
+        return rt.cp(
+            f"build/{config.preset}/test-results", "build/artifacts/test-results"
+        )
+
+
+@step.register
+class StoreBoth(step.SerialStep):
+    """Stores all artifacts created for ``preset`` config value."""
+
+    @property
+    def name(self):
+        return "Store"
+
+    def __init__(self):
+        super().__init__()
+        self.children = [StoreTests(), StorePackages()]

proj_flow/flow/__init__.py

@@ -6,6 +6,6 @@ The **proj_flow.flow** contains the inner workings of various *Project Flow*
 components.
 """
 
-from . import configs, dependency, init, interact, layer, steps
+from . import configs, layer, steps
 
-__all__ = ["configs", "dependency", "init", "interact", "layer", "steps"]
+__all__ = ["configs", "layer", "steps"]

proj_flow/log/release.py

@@ -134,4 +134,4 @@ def add_release(
         if draft_url:
             rt.message("Visit draft at", draft_url, level=env.Msg.ALWAYS)
 
-    return setup.curr_tag
+    return setup.curr_tag

proj_flow/log/rich_text/markdown.py

@@ -2,7 +2,7 @@
 # This code is licensed under MIT license (see LICENSE for details)
 
 """
-The **proj_flow.log.rich.markdown** provides details of making Markdown
+The **proj_flow.log.rich_text.markdown** provides details of making Markdown
 changelogs.
 """
 

proj_flow/log/rich_text/re_structured_text.py

@@ -2,7 +2,7 @@
 # This code is licensed under MIT license (see LICENSE for details)
 
 """
-The **proj_flow.log.rich.re_structured_text** provides details of making
+The **proj_flow.log.rich_text.re_structured_text** provides details of making
 reStructuredText changelogs.
 """
 

proj_flow/minimal/__init__.py

@@ -6,6 +6,6 @@ The **proj_flow.minimal** defines minimal extension package: ``bootstrap``
 and ``run`` commands, with basic set of steps.
 """
 
-from . import bootstrap, list, run, system
+from . import bootstrap, init, list, run, system
 
-__all__ = ["bootstrap", "list", "run", "system"]
+__all__ = ["bootstrap", "init", "list", "run", "system"]

proj_flow/{plugins → minimal}/base.py

@@ -2,8 +2,8 @@
 # This code is licensed under MIT license (see LICENSE for details)
 
 """
-The **proj_flow.plugins.base** provides basic initialization setup for new
-projects.
+The **proj_flow.minimal.base** provides basic initialization setup for all
+new projects.
 """
 
 from proj_flow import __version__, api
@@ -26,5 +26,6 @@ api.init.register_init_step(GitInit())
 api.ctx.register_init_setting(
     api.ctx.Setting("__flow_version__", value=__version__),
     api.ctx.Setting("${", value="${"),
+    project=None,
     is_hidden=True,
 )

proj_flow/{plugins/commands → minimal}/init.py

@@ -2,7 +2,7 @@
 # This code is licensed under MIT license (see LICENSE for details)
 
 """
-The **proj_flow.plugins.commands.init** implements ``proj-flow init`` command.
+The **proj_flow.minimal.init** implements ``proj-flow init`` command.
 """
 
 import json
@@ -10,12 +10,36 @@ import os
 import sys
 from typing import Annotated, Optional
 
-from proj_flow import flow
+import yaml
+
+from proj_flow import dependency, flow
 from proj_flow.api import arg, ctx, env, init
+from proj_flow.base.name_list import name_list
+from proj_flow.project import api, interact
+
+
+def _project_types():
+    return list(map(lambda proj: proj.id, api.project_type.get()))
+
+
+def _project_help():
+    return (
+        "Type of project to create. "
+        f"Allowed values are: {name_list(_project_types())}"
+    )
 
 
 @arg.command("init")
 def main(
+    project: Annotated[
+        str,
+        arg.Argument(
+            help=_project_help,
+            meta="project",
+            pos=True,
+            choices=_project_types,
+        ),
+    ],
     path: Annotated[
         Optional[str],
         arg.Argument(
@@ -38,26 +62,35 @@ def main(
 ):
     """Initialize new project"""
 
+    try:
+        current_project = api.get_project_type(project)
+    except api.ProjectNotFound:
+        print(f"proj-flow init: error: project type `{project}` is not known")
+        return 1
+
     if path is not None:
         os.makedirs(path, exist_ok=True)
         os.chdir(path)
 
-    errors = flow.dependency.verify(flow.dependency.gather(init.__steps))
+    errors = dependency.verify(dependency.gather(init.__steps))
     if len(errors) > 0:
         if not rt.silent:
             for error in errors:
                 print(f"proj-flow: {error}", file=sys.stderr)
         return 1
 
-    context = flow.init.fixup(
-        flow.init.all_default() if non_interactive else flow.interact.prompt()
-    )
+    context = current_project.get_context(not non_interactive)
     if not non_interactive and not rt.silent:
         print()
 
-    if save_context:
-        with open(".context.json", "w", encoding="UTF-8") as jsonf:
-            json.dump(context, jsonf, ensure_ascii=False, indent=4)
+    if save_context and rt.verbose:
+        lines = yaml.dump(context, indent=4).rstrip().split("\n")
+        for line in lines:
+            rt.message("[CONTEXT]", line)
+
+    if save_context and not rt.dry_run:
+        with open(".context.yaml", "w", encoding="UTF-8") as jsonf:
+            yaml.dump(context, jsonf, indent=4)
 
     flow.layer.copy_license(rt, context)
     if not rt.silent:
@@ -67,9 +100,9 @@ def main(
     for fs_layer in layers:
         fs_layer.run(rt, context)
 
-    if save_context:
+    if save_context and not rt.dry_run:
         with open(".gitignore", "ab") as ignoref:
-            ignoref.write("\n/.context.json\n".encode("UTF-8"))
+            ignoref.write("\n/.context.yaml\n".encode("UTF-8"))
 
     for step in init.__steps:
         step.postprocess(rt, context)

proj_flow/minimal/run.py

@@ -11,9 +11,8 @@ import sys
 from contextlib import contextmanager
 from typing import Annotated, List, Optional, Set, cast
 
-from proj_flow import api
+from proj_flow import api, dependency
 from proj_flow.base import matrix
-from proj_flow.flow import dependency
 from proj_flow.flow.configs import Configs
 
 

proj_flow/project/__init__.py

@@ -0,0 +1,11 @@
+# Copyright (c) 2025 Marcin Zdun
+# This code is licensed under MIT license (see LICENSE for details)
+
+"""
+The **proj_flow.project** contains the inner workings of ``proj-flow init``
+command.
+"""
+
+from . import api, cplusplus, data, interact
+
+__all__ = ["api", "cplusplus", "data", "interact"]

proj_flow/project/api.py

@@ -0,0 +1,51 @@
+# Copyright (c) 2025 Marcin Zdun
+# This code is licensed under MIT license (see LICENSE for details)
+
+"""
+The **proj_flow.project.api** defines an extension point for project suites.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any, List, NamedTuple, Optional
+
+from proj_flow import base
+from proj_flow.api import ctx
+from proj_flow.project import interact
+
+
+class ProjectType(ABC):
+    name: str
+    id: str
+
+    def __init__(self, name: str, id: str):
+        self.name = name
+        self.id = id
+
+    def register_switch(self, key: str, prompt: str, enabled: bool):
+        ctx.register_switch(key, prompt, enabled, self.id)
+
+    def register_internal(self, key: str, value: Any):
+        ctx.register_internal(key, value)
+
+    def register_init_setting(self, *settings: ctx.Setting, is_hidden=False):
+        ctx.register_init_setting(*settings, is_hidden=is_hidden, project=self.id)
+
+    def get_context(self, interactive: bool):
+        return interact.get_context(interactive, self.id)
+
+
+project_type = base.registry.Registry[ProjectType]("ProjectType")
+
+
+class ProjectNotFound(Exception):
+    name: str
+
+    def __init__(self, name: str):
+        self.name = name
+
+
+def get_project_type(id: str):
+    result, _ = project_type.find(lambda proj: proj.id == id)
+    if result is None:
+        raise ProjectNotFound(id)
+    return result

proj_flow/project/cplusplus.py

@@ -0,0 +1,17 @@
+# Copyright (c) 2025 Marcin Zdun
+# This code is licensed under MIT license (see LICENSE for details)
+
+"""
+The **proj_flow.project.cplusplus** registers a ``"C++"`` projects support.
+"""
+
+from proj_flow.project import api
+
+
+@api.project_type.add
+class CPlusPlus(api.ProjectType):
+    def __init__(self):
+        super().__init__("C++ + CMake + Conan", "cxx")
+
+
+project = api.get_project_type("cxx")

proj_flow/project/data.py

@@ -0,0 +1,14 @@
+# Copyright (c) 2025 Marcin Zdun
+# This code is licensed under MIT license (see LICENSE for details)
+
+"""
+The **proj_flow.project.data** supports the ``init`` command.
+"""
+
+from typing import Any
+
+from proj_flow.api import ctx
+
+
+def get_internal(key: str, value: Any = None):
+    return ctx.internals.get(key, value)