proj-flow 0.8.1__py3-none-any.whl

proj_flow/plugins/conan/_conan.py

@@ -0,0 +1,146 @@
+# Copyright (c) 2025 Marcin Zdun
+# 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.
+"""
+
+import shutil
+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
+
+
+class conan(ABC):
+    version: int
+
+    def __init__(self, version: int = 1):
+        self.version = version
+
+    def settings(self, cfg: Config):
+        result: List[str] = []
+        for threshold, name in enumerate(
+            ["conan_settings", "conan2_settings"],
+        ):
+            if self.version <= threshold:
+                break
+            result = cast(List[str], cfg.items.get(name, result))
+        return result
+
+    @abstractmethod
+    def config(
+        self,
+        rt: Runtime,
+        conan_output_dir: str,
+        compiler_profile_name: str,
+        build_type_profile_name: str,
+    ) -> int: ...
+
+
+class conan_1(conan):
+    def __init__(self):
+        super().__init__(1)
+
+    def config(
+        self,
+        rt: Runtime,
+        conan_output_dir: str,
+        compiler_profile_name: str,
+        build_type_profile_name: str,
+    ) -> int:
+        if rt.cmd(
+            "conan",
+            "profile",
+            "new",
+            "--detect",
+            "--force",
+            compiler_profile_name,
+        ):
+            return 1
+
+        return rt.cmd(
+            "conan",
+            "install",
+            "-if",
+            conan_output_dir,
+            "-of",
+            conan_output_dir,
+            "--build",
+            "missing",
+            "-pr:b",
+            build_type_profile_name,
+            "-pr:h",
+            build_type_profile_name,
+            ".",
+        )
+
+
+class conan_2(conan):
+    def __init__(self):
+        super().__init__(2)
+
+    def config(
+        self,
+        rt: Runtime,
+        conan_output_dir: str,
+        compiler_profile_name: str,
+        build_type_profile_name: str,
+    ) -> int:
+        if rt.cmd(
+            "conan",
+            "profile",
+            "detect",
+            "--force",
+            "--name",
+            compiler_profile_name,
+        ):
+            return 1
+
+        return rt.cmd(
+            "conan",
+            "install",
+            "-of",
+            conan_output_dir,
+            "--build",
+            "missing",
+            "-pr:b",
+            build_type_profile_name,
+            "-pr:h",
+            build_type_profile_name,
+            ".",
+        )
+
+
+def _conan_version():
+    found = shutil.which("conan")
+    if found is None:
+        return 1
+
+    proc = cmd.run(found, "--version", capture_output=True)
+    if proc.returncode != 0:
+        return 1
+    m = VER_REGEX.search(proc.stdout)
+    version = m.group(0) if m is not None else None
+    if version is None:
+        return 1
+    chunks = [int(v.strip()) for v in version.split(".")]
+    if len(chunks) < 1:
+        return 1
+    return chunks[0]
+
+
+ctors: List[Callable[[], conan]] = [
+    conan_1,
+    conan_2,
+]
+
+
+def conan_api() -> conan:
+    version = _conan_version()
+    index = version - 1
+    if index >= len(ctors):
+        return ctors[-1]()
+    return ctors[index]()

proj_flow/plugins/github.py

@@ -0,0 +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
+projects.
+"""
+
+from proj_flow.api import ctx
+
+ctx.register_switch("with_github_actions", "Use Github Actions", True)
+ctx.register_switch(
+    "with_github_social", "Use Github ISSUE_TEMPLATE, CONTRIBUTING.md, etc.", True
+)

proj_flow/plugins/sign/__init__.py

@@ -0,0 +1,130 @@
+# Copyright (c) 2025 Marcin Zdun
+# This code is licensed under MIT license (see LICENSE for details)
+
+"""
+The **proj_flow.plugins.sign** provides the ``"Sign"`` and ``"SignPackages"``
+steps.
+"""
+
+import fnmatch
+import os
+import sys
+from abc import abstractmethod
+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
+
+
+def should_exclude(filename: str, exclude: List[str], config_os: str):
+    basename = os.path.splitext(filename)[0] if config_os == "windows" else filename
+
+    for pattern in exclude:
+        if fnmatch.fnmatch(basename, pattern):
+            return True
+
+    return False
+
+
+class SignBase(step.Step):
+    def is_active(self, config: env.Config, rt: env.Runtime) -> int:
+        return win32.is_active(config.os, rt)
+
+    @abstractmethod
+    def get_files(self, 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
+
+        rt.print("signtool", *(os.path.basename(file) for file in files))
+
+        if rt.dry_run:
+            return 0
+
+        return win32.sign(files, rt)
+
+
+@step.register
+class SignFiles(SignBase):
+    """*(Windows)* Signs executable files in build directory"""
+
+    name = "Sign"
+    runs_after = ["Build"]
+    runs_before = ["Pack"]
+
+    def get_files(self, 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"])
+
+        result: List[str] = []
+        build_dir = config.build_dir
+        for root in roots:
+            for curr_dir, _, filenames in os.walk(os.path.join(build_dir, root)):
+                for filename in filenames:
+                    if should_exclude(filename, exclude, config.os):
+                        continue
+
+                    full_path = os.path.join(curr_dir, filename)
+                    if not win32.is_pe_exec(full_path):
+                        continue
+
+                    result.append(full_path)
+        return result
+
+
+@step.register
+class SignMsi(SignBase):
+    """*(Windows)* Signs MSI installers in build directory"""
+
+    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]:
+        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))
+
+        return result
+
+
+class SignInit(init.InitStep):
+    def postprocess(self, rt: env.Runtime, context: dict):
+        if sys.platform == "win32":
+            with open(".gitignore", "ab") as ignoref:
+                ignoref.write("\n/signature.key\n".encode("UTF-8"))
+
+
+init.register_init_step(SignInit())

proj_flow/plugins/sign/win32.py

@@ -0,0 +1,191 @@
+# Copyright (c) 2025 Marcin Zdun
+# This code is licensed under MIT license (see LICENSE for details)
+
+"""
+The **proj_flow.plugins.sign.win32** provides code signing with SignTool
+from Windows SDKs.
+"""
+
+import base64
+import json
+import os
+import platform
+import struct
+import subprocess
+import sys
+import winreg
+from typing import Iterable, List, NamedTuple, Optional, Tuple
+
+from proj_flow.api.env import Runtime
+
+ENV_KEY = "SIGN_TOKEN"
+
+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(
+        winreg.HKEY_LOCAL_MACHINE, r"SOFTWARE\Microsoft\Windows Kits\Installed Roots"
+    ) as kits:
+        try:
+            kits_root = winreg.QueryValueEx(kits, "KitsRoot10")[0]
+        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)
+                ver = tuple(int(chunk) for chunk in ver_str.split("."))
+                index += 1
+                versions.append((ver, ver_str))
+        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
+
+
+class Key(NamedTuple):
+    token: str
+    secret: bytes
+
+
+def _get_key_from_contents(key: str, rt: Runtime):
+    try:
+        obj = json.loads(key)
+    except json.decoder.JSONDecodeError:
+        rt.message("sign/win32: the signature is not a valid JSON document")
+        return None
+
+    if not isinstance(obj, dict):
+        rt.message("sign/win32: 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/win32: the signature is missing required fields")
+        return None
+
+    return Key(
+        base64.b64decode(token).decode("UTF-8"),
+        base64.b64decode(secret),
+    )
+
+
+def get_key(rt: Runtime) -> Optional[Key]:
+    rt.message(f"sign/win32: 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/win32: 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/win32: no key set up")
+
+    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:
+        print("proj-flow: sign: the key is missing", file=sys.stderr)
+        return 1
+
+    sign_tool = find_sign_tool(rt)
+    if sign_tool is None:
+        print("proj-flow: sign: signtool.exe not found", file=sys.stderr)
+        sys.exit(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/__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.plugins.store** provides ``"Store"``, ``"StoreTests"`` and
+``"StorePackages"`` steps.
+"""
+
+from . import store_both, store_packages, store_tests
+
+__all__ = ["store_both", "store_tests", "store_packages"]

proj_flow/plugins/store/store_both.py

@@ -0,0 +1,22 @@
+# Copyright (c) 2025 Marcin Zdun
+# This code is licensed under MIT license (see LICENSE for details)
+
+"""
+The **proj_flow.plugins.store** provides ``"Store"`` step.
+"""
+
+from proj_flow.api import step
+
+from .store_packages import StorePackages
+from .store_tests import StoreTests
+
+
+@step.register
+class StoreBoth(step.SerialStep):
+    """Stores all artifacts created for ``preset`` config value."""
+
+    name = "Store"
+
+    def __init__(self):
+        super().__init__()
+        self.children = [StoreTests(), StorePackages()]

proj_flow/plugins/store/store_packages.py

@@ -0,0 +1,79 @@
+# Copyright (c) 2025 Marcin Zdun
+# This code is licensed under MIT license (see LICENSE for details)
+
+"""
+The **proj_flow.plugins.store** provides ``"StorePackages"`` step.
+"""
+
+import os
+import shutil
+from typing import List, cast
+
+from proj_flow.api import env, 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
+
+
+def _package_name(config: env.Config, pkg: str, group: str):
+    debug = "-dbg" if config.build_type.lower() == "debug" else ""
+    suffix = group and f"-{group}" or ""
+
+    return f"{pkg}-{_system}{_version}-{_arch}{debug}{suffix}"
+
+
+@step.register
+class StorePackages:
+    """Stores archives and installers build for ``preset`` config value."""
+
+    name = "StorePackages"
+    runs_after = ["Pack"]
+
+    def run(self, config: env.Config, rt: env.Runtime) -> int:
+        if not rt.dry_run:
+            os.makedirs("build/artifacts", exist_ok=True)
+
+        packages_dir = f"build/{config.preset}/packages"
+
+        global _project_pkg
+        if _project_pkg is None:
+            project = get_project("")
+            if project is None:
+                rt.fatal(f"Cannot get project information from {rt.root}")
+            _project_pkg = project.pkg
+
+        main_group = cast(str, rt._cfg.get("package", {}).get("main-group"))
+        if main_group is not None and not rt.dry_run:
+            src = _package_name(config, _project_pkg, main_group)
+            dst = _package_name(config, _project_pkg, "")
+            rt.print("mv", *(f"{package}.*" for package in (src, dst)), raw=True)
+            for _, dirnames, filenames in os.walk(packages_dir):
+                dirnames[:] = []
+                extensions = [
+                    filename[len(src) :]
+                    for filename in filenames
+                    if len(filename) > len(src)
+                    and filename[: len(src)] == src
+                    and filename[len(src)] == "."
+                ]
+            for extension in extensions:
+                shutil.move(
+                    f"{packages_dir}/{src}{extension}",
+                    f"{packages_dir}/{dst}{extension}",
+                )
+
+        GITHUB_OUTPUT = os.environ.get("GITHUB_OUTPUT")
+        if GITHUB_OUTPUT is not None:
+            with open(GITHUB_OUTPUT, "a", encoding="UTF-8") as github_output:
+                generators = ",".join(config.items.get("cpack_generator", []))
+                print(f"CPACK_GENERATORS={generators}", file=github_output)
+
+        return rt.cp(
+            packages_dir,
+            "build/artifacts/packages",
+            f"^{_project_pkg}-.*$",
+        )

proj_flow/plugins/store/store_tests.py

@@ -0,0 +1,21 @@
+# Copyright (c) 2025 Marcin Zdun
+# This code is licensed under MIT license (see LICENSE for details)
+
+"""
+The **proj_flow.plugins.store** provides ``"StoreTests"`` step.
+"""
+
+from proj_flow.api import env, step
+
+
+@step.register
+class StoreTests(step.Step):
+    """Stores test results gathered during tests for ``preset`` config value."""
+
+    name = "StoreTests"
+    runs_after = ["Test"]
+
+    def run(self, config: env.Config, rt: env.Runtime) -> int:
+        return rt.cp(
+            f"build/{config.preset}/test-results", "build/artifacts/test-results"
+        )

proj_flow/template/layers/base/.clang-format

@@ -0,0 +1,27 @@
+---
+Language:             Cpp
+BasedOnStyle:         Chromium
+AccessModifierOffset: -4
+AllowShortIfStatementsOnASingleLine: true
+AllowShortEnumsOnASingleLine: true
+AllowShortFunctionsOnASingleLine: All
+AllowShortLambdasOnASingleLine: All
+BreakConstructorInitializersBeforeComma: true
+IndentWidth:          4
+NamespaceIndentation: All
+TabWidth:             4
+UseTab:               ForIndentation
+...
+Language:             JavaScript
+BasedOnStyle:         Chromium
+AccessModifierOffset: -4
+AllowShortIfStatementsOnASingleLine: true
+AllowShortEnumsOnASingleLine: true
+AllowShortFunctionsOnASingleLine: All
+AllowShortLambdasOnASingleLine: All
+BreakConstructorInitializersBeforeComma: true
+IndentWidth:          4
+NamespaceIndentation: All
+TabWidth:             4
+UseTab:               ForIndentation
+...

proj_flow/template/layers/base/.flow/config.yml

@@ -0,0 +1,38 @@
+entry:
+  config: [ Conan, CMake ]
+  build: [ Build ]
+  test: [ Build, Test ]
+  verify:
+    - Build
+    - Test
+    - Sign
+    - Pack
+    - SignPackages
+    - Store
+    - BinInst
+    - DevInst
+
+compiler:
+  names:
+    clang: [ clang, clang++ ]
+    gcc: [ gcc, g++ ]
+  os-default: { ubuntu: gcc, windows: msvc }
+
+lts:
+  ubuntu:
+    - ubuntu-20.04
+    - ubuntu-22.04
+    - ubuntu-24.04
+
+postproc:
+  exclude:
+    - { github_os: ubuntu-20.04, sanitizer: true }
+    - { github_os: ubuntu-24.04, sanitizer: true }
+    - { github_os: ubuntu-20.04, compiler: clang }
+
+
+shortcuts:
+  dbg: { build_type: Debug, sanitizer: false }
+  rel: { build_type: Release, sanitizer: false }
+  both: { build_type: [ Debug, Release ], sanitizer: false }
+  sane: { build_type: Debug, sanitizer: true }