proj-flow 0.8.1__py3-none-any.whl

proj_flow/template/layers/base/.flow/flow.py.mustache

@@ -0,0 +1,172 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2025 Marcin Zdun
+# This code is licensed under MIT license (see LICENSE for details)
+
+import os
+import re
+import shutil
+import subprocess
+import sys
+from contextlib import contextmanager
+from dataclasses import dataclass
+from typing import List, Optional, cast
+
+CXX_FLOW_VERSION = "{{__flow_version__}}"
+PROJECT_ROOT = os.path.dirname(os.path.dirname(__file__))
+VER_REGEX = re.compile(r"((?:0|[1-9][0-9]*)\.(?:0|[1-9][0-9]*)\.(?:0|[1-9][0-9]*))")
+
+
+@dataclass
+class Version:
+    major: int
+    minor: int
+    patch: int
+
+    def compatible_with(self: "Version", runtime: Optional["Version"]):
+        if runtime is None:
+            return False
+        return self.major == runtime.major and self.minor <= runtime.minor
+
+    @staticmethod
+    def parse(value: str):
+        chunks = value.split("-")[0].split("+")[0].split(".")
+        try:
+            int_chunks = list(map(int, chunks))[0:3]
+            while len(int_chunks) < 3:
+                int_chunks.append(0)
+            return Version(*int_chunks)
+        except ValueError:
+            return None
+
+    @staticmethod
+    def proc_parse(process: subprocess.CompletedProcess):
+        value = cast(str, process.stdout).strip() if process.returncode == 0 else ""
+        m = VER_REGEX.search(value)
+        return Version.parse(m.group(0)) if m is not None else None
+
+
+proj_flow = Version.parse(CXX_FLOW_VERSION)
+
+PYTHON_EXECUTABLE = sys.executable
+
+
+def python(
+    *args: List[str],
+    module: Optional[str] = None,
+    capture_output: bool = True,
+) -> subprocess.CompletedProcess:
+    if module is not None:
+        return subprocess.run(
+            [PYTHON_EXECUTABLE, "-m", module, *args],
+            shell=False,
+            capture_output=capture_output,
+        )
+    return subprocess.run(
+        [PYTHON_EXECUTABLE, *args], shell=False, capture_output=capture_output
+    )
+
+
+def pip(*args: List[str], capture_output: bool = False):
+    return python(*args, module="pip", capture_output=capture_output)
+
+
+def venv(*args: List[str], capture_output: bool = False):
+    return python(*args, module="venv", capture_output=capture_output)
+
+
+def cxx_flow_version(print_output=False):
+    proc = subprocess.run(
+        "proj-flow --version", shell=True, encoding="UTF-8", capture_output=True
+    )
+    result = Version.proc_parse(proc)
+    if result is None and print_output:
+        if proc.stdout:
+            print(proc.stdout)
+        if proc.stderr:
+            print(proc.stderr, file=sys.stderr)
+    return result
+
+
+@contextmanager
+def cd(path: str):
+    prev = os.getcwd()
+    os.chdir(path)
+    try:
+        yield
+    finally:
+        os.chdir(prev)
+
+
+def get_venv_path():
+    bindir = os.path.join(".venv", "bin")
+    scripts = os.path.join(".venv", "Scripts")
+
+    if os.path.isdir(bindir):
+        return bindir
+
+    if os.path.isdir(scripts):
+        return scripts
+
+    return None
+
+
+def activate_virtual_env():
+    global PYTHON_EXECUTABLE
+
+    with cd(os.path.dirname(__file__)):
+        exec_ext = ".exe" if sys.platform == "win32" else ""
+        python_exec = f"python{exec_ext}"
+        bindir = get_venv_path()
+        has_venv = bindir is not None and os.path.isfile(
+            os.path.join(bindir, python_exec)
+        )
+
+        if not has_venv:
+            venv(".venv")
+            bindir = get_venv_path()
+
+        os.environ["PATH"] = (
+            f"{os.path.abspath(bindir)}{os.pathsep}{os.environ['PATH']}"
+        )
+        PYTHON_EXECUTABLE = shutil.which("python") or sys.executable
+
+
+def bootstrap_cxx_flow():
+    if proj_flow.compatible_with(cxx_flow_version()):
+        return True
+
+    if sys.prefix == sys.base_prefix:
+        activate_virtual_env()
+
+        if proj_flow.compatible_with(cxx_flow_version()):
+            return True
+
+    if pip("--version", capture_output=True).returncode != 0:
+        print("Cannot call pip as a module. Exiting.\n", file=sys.stderr)
+        sys.exit(1)
+
+    version_major = proj_flow.major
+    version_minor = proj_flow.minor
+    version_range = f">={version_major}.{version_minor},<{version_major + 1}"
+
+    if pip("install", f"proj-flow{version_range}").returncode != 0:
+        print("Cannot install proj-flow with current pip. Exiting.\n", file=sys.stderr)
+        sys.exit(1)
+
+    return proj_flow.compatible_with(cxx_flow_version(print_output=True))
+
+
+def main():
+    if not bootstrap_cxx_flow():
+        print("Cannot find a working copy of proj-flow", file=sys.stderr)
+        return 1
+
+    with cd(PROJECT_ROOT):
+        return subprocess.run(
+            [shutil.which("proj-flow"), *sys.argv[1:]], shell=False
+        ).returncode
+
+
+if __name__ == "__main__":
+    sys.exit(main())

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

@@ -0,0 +1,63 @@
+matrix:
+  compiler: [ gcc, clang, msvc ]
+  build_type: [ Release, Debug ]
+  sanitizer: [ true, false ]
+  os: [ ubuntu, windows ]
+
+exclude:
+  - { os: windows, compiler: clang }
+  - { os: windows, compiler: gcc }
+  - { os: ubuntu, compiler: msvc }
+  - { build_type: Release, sanitizer: true }
+
+include:
+  - build_type: Debug
+    preset: debug
+    coverage: true
+
+  - build_type: Release
+    preset: release
+
+  - os: ubuntu
+    conan_settings: [ compiler.libcxx=libstdc++11 ]
+    build_generator: ninja
+    cpack_generator: [ TGZ, DEB ]
+    ubuntu: true
+    home: /home/runner
+
+  - os: windows
+    conan2_settings:
+      - compiler.cppstd=23
+      - compiler.runtime=dynamic
+    build_generator: msbuild
+    report_os: Windows
+    cpack_generator: [ ZIP, WIX ]
+    windows: true
+    home: C:/Users/runneradmin
+
+  - os: ubuntu
+    report_os: Linux
+
+  - compiler: gcc
+    report_compiler: GNU
+    gcc: true
+
+  - compiler: clang
+    report_compiler: Clang
+    clang: true
+
+  - compiler: msvc
+    report_compiler: MSVC
+    msvc: true
+
+  - os: ubuntu
+    build_type: Release
+    sanitizer: false
+  
+  - os: windows
+    build_type: Release
+    conan_settings: [ compiler.runtime=MD ]
+
+  - os: windows
+    build_type: Debug
+    conan_settings: [ compiler.runtime=MDd ]

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

@@ -0,0 +1,4 @@
+exclude:
+  - compiler: clang
+  - build_type: Debug
+  - sanitizer: true

proj_flow/template/layers/base/.gitignore

@@ -0,0 +1,39 @@
+# Prerequisites
+*.d
+
+# Compiled Object files
+*.slo
+*.lo
+*.o
+*.obj
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Compiled Dynamic libraries
+*.so
+*.dylib
+*.dll
+
+# Fortran module files
+*.mod
+*.smod
+
+# Compiled Static libraries
+*.lai
+*.la
+*.a
+*.lib
+
+# Executables
+*.exe
+*.out
+*.app
+
+build/
+*.aps
+*.pyc
+web.log
+super-linter.log
+*.profraw

proj_flow/template/layers/base/README.md.mustache

@@ -0,0 +1,2 @@
+# {{PROJECT.NAME}}
+{{PROJECT.DESCRIPTION}}

proj_flow/template/layers/base/flow

@@ -0,0 +1,7 @@
+#!/bin/sh
+
+# Copyright (c) 2025 Marcin Zdun
+# This code is licensed under MIT license (see LICENSE for details)
+
+PROJECT_DIR=$(dirname "$(realpath $0)")
+python "${PROJECT_DIR}/.flow/flow.py" "$@"

proj_flow/template/layers/base/flow.cmd

@@ -0,0 +1,9 @@
+@rem Copyright (c) 2025 Marcin Zdun
+@rem This code is licensed under MIT license (see LICENSE for details)
+
+@echo off
+if "%OS%"=="Windows_NT" setlocal
+set DIRNAME=%~dp0
+if "%DIRNAME%"=="" set DIRNAME=.
+
+python "%DIRNAME%/.flow/flow.py" %*

proj_flow/template/layers/base.json

@@ -0,0 +1,2 @@
+{
+}

proj_flow/template/layers/cmake/.flow/cmake/common.cmake.mustache

@@ -0,0 +1,27 @@
+function(add_project_test TARGET)
+  cmake_parse_arguments(PARSE_ARGV 1 TST "" "" "")
+  add_executable(${TARGET}-test ${TST_UNPARSED_ARGUMENTS})
+  set_target_properties(${TARGET}-test PROPERTIES FOLDER tests)
+  target_compile_options(${TARGET}-test PRIVATE {{${}}{{NAME_PREFIX}}_ADDITIONAL_COMPILE_FLAGS})
+  target_link_options(${TARGET}-test PRIVATE {{${}}{{NAME_PREFIX}}_ADDITIONAL_LINK_FLAGS})
+  target_include_directories(${TARGET}-test
+    PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests
+    ${CMAKE_CURRENT_BINARY_DIR})
+endfunction()
+
+function(add_win32_icon TARGET NAME)
+  set(RESNAME "${PROJECT_SOURCE_DIR}/data/assets/${NAME}")
+  set(RC "${CMAKE_CURRENT_BINARY_DIR}/${TARGET}.dir/icon.rc")
+  set(__content "// Copyright (c) {{COPY.YEAR}} {{COPY.HOLDER}}
+// This code is licensed under {{COPY.LICENSE}} license (see LICENSE for details)
+// This file was autogenerated. Do not edit.
+
+LANGUAGE 9, 1
+
+100 ICON \"${RESNAME}\"
+")
+
+  file(GENERATE OUTPUT ${RC} CONTENT ${__content})
+  target_sources(${TARGET} PRIVATE "${RC}" "${RESNAME}")
+endfunction()

proj_flow/template/layers/cmake/.flow/extensions/wall/__init__.py.mustache

@@ -0,0 +1,2 @@
+# Copyright (c) {{COPY.YEAR}} {{COPY.HOLDER}}
+# This code is licensed under {{COPY.LICENSE}} license (see LICENSE for details)

proj_flow/template/layers/cmake/.flow/extensions/wall/icons/__init__.py.mustache

@@ -0,0 +1,54 @@
+# Copyright (c) {{COPY.YEAR}} {{COPY.HOLDER}}
+# This code is licensed under {{COPY.LICENSE}} license (see LICENSE for details)
+
+import os
+
+from proj_flow.api import env, step
+from proj_flow.api.makefile import Makefile
+
+from . import magick
+
+ICONS = os.path.join("data", "icons")
+ASSETS = os.path.join("data", "assets")
+ICONS_PNG = os.path.join(ICONS, "png")
+STENCIL = os.path.join(ICONS_PNG, "appicon.png")
+SIZES = ["16", "24", "32", "48", "256"]
+
+makefile = Makefile(
+    [
+        magick.svg_to_png(
+            output=STENCIL,
+            image=os.path.join(ICONS, "appicon.svg"),
+            mask=os.path.join(ICONS, "appicon-mask.svg"),
+        ),
+        *(
+            magick.resize(
+                output=os.path.join(ICONS_PNG, f"appicon-{size}.png"),
+                stencil=STENCIL,
+                size=size,
+            )
+            for size in SIZES
+        ),
+        magick.merge(
+            os.path.join(ASSETS, "appicon.ico"),
+            [os.path.join(ICONS_PNG, f"appicon-{size}.png") for size in SIZES],
+        ),
+        magick.mkdirs(ICONS_PNG),
+        magick.copy(
+            os.path.join(ICONS_PNG, f"appicon-256.png"),
+            os.path.join(ASSETS, f"appicon.png"),
+        ),
+    ]
+)
+
+
+@step.register
+class IconsStep:
+    name = "Icons"
+    runs_before = ["Build"]
+
+    def platform_dependencies(self):
+        return [f"{magick.tool}>=6"]
+
+    def run(self, config: env.Config, rt: env.Runtime) -> int:
+        return makefile.run(rt)

proj_flow/template/layers/cmake/.flow/extensions/wall/icons/magick.py.mustache

@@ -0,0 +1,97 @@
+# Copyright (c) {{COPY.YEAR}} {{COPY.HOLDER}}
+# This code is licensed under {{COPY.LICENSE}} license (see LICENSE for details)
+
+import os
+import sys
+from typing import List
+
+from proj_flow.api.env import Runtime
+from proj_flow.api.makefile import Rule, Statement
+
+tool = "magick" if sys.platform == "win32" else "convert"
+
+
+class MkDirs(Rule):
+    def command(self, _: Statement):
+        return []
+
+    def run(self, st: Statement, rt: Runtime):
+        for output in st.outputs:
+            result = rt.mkdirs(output)
+            if result:
+                return result
+        return 0
+
+
+class Copy(Rule):
+    def command(self, _: Statement):
+        return []
+
+    def run(self, st: Statement, rt: Runtime):
+        return rt.cp(st.inputs[0], st.outputs[0])
+
+
+class Magick:
+    class SvgToPng(Rule):
+        def command(self, st: Statement):
+            return [
+                tool,
+                "-background",
+                "none",
+                *st.inputs,
+                "-alpha",
+                "Off",
+                "-compose",
+                "CopyOpacity",
+                "-composite",
+                st.outputs[0],
+            ]
+
+    class Resize(Rule):
+        size: str
+
+        def __init__(self, size: str):
+            self.size = size
+
+        def command(self, st: Statement):
+            return [
+                tool,
+                "-background",
+                "none",
+                st.inputs[0],
+                "-resize",
+                f"{self.size}x{self.size}",
+                "-depth",
+                "32",
+                st.outputs[0],
+            ]
+
+    class Merge(Rule):
+        def command(self, st: Statement):
+            return [
+                tool,
+                *st.inputs,
+                st.outputs[0],
+            ]
+
+
+def mkdirs(dirname: str):
+    return MkDirs.statement([dirname], [])
+
+
+def copy(src: str, dst: str):
+    return Copy.statement([dst], [src])
+
+
+def svg_to_png(output: str, image: str, mask: str):
+    return Magick.SvgToPng.statement([output], [image, mask], [os.path.dirname(output)])
+
+
+def resize(output: str, stencil: str, size: str):
+    return Statement(
+        Magick.Resize(size), [output], [stencil], [os.path.dirname(output)]
+    )
+
+
+def merge(output: str, layers: List[str]):
+    return Magick.Merge.statement([output], layers, [os.path.dirname(output)])

proj_flow/template/layers/cmake/.flow/packages/base.cmake.mustache

@@ -0,0 +1,33 @@
+execute_process(COMMAND ${Python3_EXECUTABLE}
+    "${PROJECT_SOURCE_DIR}/.flow/flow.py" system --format=platform
+    OUTPUT_VARIABLE ___PACKAGE_NAME
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+)
+
+set(CPACK_PACKAGE_NAME "${PROJECT_NAME}")
+set(CPACK_PACKAGE_VENDOR "{{COPY.HOLDER}}")
+set(CPACK_PACKAGE_CONTACT "{{COPY.HOLDER}} <{{PROJECT.EMAIL}}>")
+set(CPACK_PACKAGE_VERSION "${PROJECT_VERSION}")
+set(CPACK_PACKAGE_VERSION_MAJOR "${PROJECT_VERSION_MAJOR}")
+set(CPACK_PACKAGE_VERSION_MINOR "${PROJECT_VERSION_MINOR}")
+set(CPACK_PACKAGE_VERSION_PATCH "${PROJECT_VERSION_PATCH}")
+set(CPACK_PACKAGE_DESCRIPTION "${PROJECT_DESCRIPTION}")
+set(CPACK_PACKAGE_INSTALL_DIRECTORY "{{PROJECT.NAME}}")
+set(CPACK_PACKAGE_INSTALL_REGISTRY_KEY "{{COPY.HOLDER}}/{{PROJECT.NAME}}")
+set(CPACK_PACKAGE_ICON "${PROJECT_SOURCE_DIR}/data/assets/appicon-256.png")
+set(CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}${PROJECT_VERSION_STABILITY}-${___PACKAGE_NAME}")
+
+if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND NOT APPLE)
+    string(REPLACE "." ";" _COMPILER_CHUNKS ${CMAKE_CXX_COMPILER_VERSION})
+    list(GET _COMPILER_CHUNKS 0 CMAKE_CXX_COMPILER_VERSION_MAJOR)
+    set(CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_FILE_NAME}-clang${CMAKE_CXX_COMPILER_VERSION_MAJOR}")
+endif()
+
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    set(CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_FILE_NAME}-dbg")
+endif()
+
+set(CPACK_PACKAGE_DIRECTORY "${PROJECT_BINARY_DIR}/packages")
+set(CPACK_RESOURCE_FILE_LICENSE "${PROJECT_BINARY_DIR}/packages/_CPack_Packages/LICENSE.txt")
+file(MAKE_DIRECTORY "${PROJECT_BINARY_DIR}/packages/_CPack_Packages")
+file(COPY_FILE "${PROJECT_SOURCE_DIR}/LICENSE" "${PROJECT_BINARY_DIR}/packages/_CPack_Packages/LICENSE.txt")

proj_flow/template/layers/cmake/.flow/packages/config.cmake

@@ -0,0 +1,12 @@
+set(CPACK_PROJECT_CONFIG_FILE "${CMAKE_CURRENT_LIST_DIR}/cpack.cmake")
+
+include(${CMAKE_CURRENT_LIST_DIR}/base.cmake)
+include(${CMAKE_CURRENT_LIST_DIR}/wix.cmake)
+
+set(CPACK_NSIS_MODIFY_PATH ON)
+
+set(CPACK_DEB_COMPONENT_INSTALL ON)
+set(CPACK_DEBIAN_APPS_PACKAGE_DEPENDS libgcc-s1)
+set(CPACK_DEBIAN_DEVEL_PACKAGE_DEPENDS)
+
+set(CPACK_ARCHIVE_COMPONENT_INSTALL ON)

proj_flow/template/layers/cmake/.flow/packages/cpack.cmake

@@ -0,0 +1,3 @@
+if (CPACK_GENERATOR STREQUAL "WIX")
+    include(${CMAKE_CURRENT_LIST_DIR}/wix/cpack.cmake)
+endif()

proj_flow/template/layers/cmake/.flow/packages/wix/cpack.cmake.mustache

@@ -0,0 +1 @@
+set(CPACK_PACKAGE_NAME "{{PROJECT.NAME}}")

proj_flow/template/layers/cmake/.flow/packages/wix/patches.in.wix

@@ -0,0 +1,10 @@
+<CPackWiXPatch>
+    <CPackWiXFragment Id="@PROJECT_WIX_BIN_DIR_COMP@">
+        <RegistryKey Root="HKLM" Key="Software\@PROJECT_REGISTRY_KEY@">
+            <RegistryValue Type="string" Name="Version" Value="@PROJECT_VERSION@@PROJECT_VERSION_STABILITY@" />
+            <RegistryValue Type="string" Value="[@PROJECT_WIX_BIN_DIR@]" />
+        </RegistryKey>
+        <Environment Id="@WIX_PATH_ID@" Name="PATH" Action="set" System="yes" Permanent="no" Part="last" Value="[@PROJECT_WIX_BIN_DIR@]" />
+    </CPackWiXFragment>
+    <CPackWiXFragment Id="#PRODUCTFEATURE" AllowAdvertise="no" />
+</CPackWiXPatch>

proj_flow/template/layers/cmake/.flow/packages/wix.cmake.mustache

@@ -0,0 +1,13 @@
+set(CPACK_WIX_UPGRADE_GUID "{{PROJECT.WIX.UPGRADE_GUID}}")
+set(CPACK_WIX_PRODUCT_ICON "${PROJECT_SOURCE_DIR}/data/assets/appicon.ico")
+set(CPACK_WIX_UI_BANNER "${PROJECT_SOURCE_DIR}/data/assets/wix_banner.bmp")
+set(CPACK_WIX_UI_DIALOG "${PROJECT_SOURCE_DIR}/data/assets/wix_dialog.bmp")
+set(CPACK_WIX_ROOT_FEATURE_TITLE "{{PROJECT.NAME}} ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}")
+set(CPACK_WIX_PATCH_FILE "${CMAKE_CURRENT_BINARY_DIR}/packages/_CPack_Packages/patches.wix")
+set(PROJECT_WIX_BIN_DIR "CM_DP_bin")
+set(PROJECT_WIX_BIN_DIR_COMP "CM_CP_bin.${CMAKE_PROJECT_NAME}.exe")
+set(WIX_PATH_ID "{{NAME_PREFIX}}_PATH")
+set(CPACK_WIX_VERSION 4)
+
+string(REPLACE "/" "\\" PROJECT_REGISTRY_KEY ${CPACK_PACKAGE_INSTALL_REGISTRY_KEY})
+configure_file(${CMAKE_CURRENT_LIST_DIR}/wix/patches.in.wix ${CMAKE_CURRENT_BINARY_DIR}/packages/_CPack_Packages/patches.wix @ONLY)

proj_flow/template/layers/cmake/CMakeGraphVizOptions.cmake

@@ -0,0 +1,8 @@
+set(GRAPHVIZ_GRAPH_HEADER "graph [\n  fontname = \"Montserrat SemiBold\";\n];\nnode [\n  fontsize = \"12\";\n  fontname = \"Montserrat\";\n];\nedge [\n  fontname = \"Montserrat Light\";\n];")
+set(GRAPHVIZ_GENERATE_PER_TARGET FALSE)
+set(GRAPHVIZ_GENERATE_DEPENDERS FALSE)
+set(GRAPHVIZ_IGNORE_TARGETS "CONAN_LIB::.*"
+    "GTest::.*"
+    ".*_DEPS_TARGET"
+    ".*-test"
+)