proj-flow 0.17.2__py3-none-any.whl → 0.19.0__py3-none-any.whl

proj_flow/ext/webidl/cli/gen.py

@@ -0,0 +1,157 @@
+# Copyright (c) 2026 Marcin Zdun
+# This code is licensed under MIT license (see LICENSE for details)
+
+import json
+import sys
+import typing
+from dataclasses import asdict
+from pathlib import Path
+from pprint import pprint
+
+import chevron
+
+from proj_flow.api import arg, env
+from proj_flow.ext.webidl.base.config import (
+    CMakeDirs,
+    Output,
+    TemplateConfig,
+    templates_dir,
+)
+from proj_flow.ext.webidl.cli.updater import update_file_if_needed
+from proj_flow.ext.webidl.model.ast import Definitions
+from proj_flow.ext.webidl.registry import webidl_visitors
+
+
+def aslist(items: list):
+    return [asdict(item) for item in items]
+
+
+T = typing.TypeVar("T")
+P = typing.TypeVar("P")
+
+
+def conv(conv: typing.Callable[[T], P], maybe: T | None) -> P | None:
+    if maybe is None:
+        return None
+    return conv(maybe)
+
+
+@arg.command("webidl", "gen")
+def gen(
+    config_path: typing.Annotated[
+        str, arg.Argument(help="Input configuration", names=["--cfg"], meta="json-file")
+    ],
+    binary_dir: typing.Annotated[
+        str,
+        arg.Argument(
+            help="Project binary dir", names=["--binary-dir"], meta="project-binary-dir"
+        ),
+    ],
+    rt: env.Runtime,
+):
+    """Run mustache codegen on WebIDL definitions"""
+
+    config_filename = Path(config_path)
+    cmake_dirs = CMakeDirs.from_config_path(
+        config_filename, project_binary_dir=Path(binary_dir)
+    )
+
+    global_ctx = cmake_dirs.my_defines()
+    config_filename = Path(config_path).absolute()
+    config = TemplateConfig.load_config(
+        config_filename, global_ctx, cmake_dirs.project_source_dir
+    )
+
+    global_ctx["version"] = str(config.version)
+
+    pkg_partials: dict[str, str] = {}
+    partials_dir = templates_dir / "partials"
+    ext = ".mustache"
+    for root, _dirs, files in partials_dir.walk():
+        for path in [
+            root / filename for filename in files if filename[-len(ext) :] == ext
+        ]:
+            path_id = path.relative_to(partials_dir).with_name(path.stem)
+            lang_id = str(path_id.parents[0])
+            partial = path_id.as_posix()[len(lang_id) + 1 :]
+            partial = f"pkg-{lang_id}:{partial}"
+            pkg_partials[partial] = path.read_text(encoding="UTF-8")
+
+            if rt.verbose:
+                print(f"-- WebIDL: adding `{partial}' package partial")
+
+    for rule in config.rules:
+        names = list(map(lambda path: path.as_posix(), rule.inputs))
+        context = {
+            **global_ctx,
+            "input": Output.filename_context(names[0], cmake_dirs.project_source_dir),
+        }
+
+        try:
+            idl = Definitions.parse_and_merge(names, config.ext_attrs)
+        except FileNotFoundError as e:
+            p = Path(e.filename)
+            print(f"{e.strerror}: {p.as_posix()}")
+            sys.exit(1)
+        if isinstance(idl, list):
+            for error in idl:
+                print(f"{error.path}:{error.error}")
+            sys.exit(1)
+
+        for visitor in webidl_visitors.get():
+            visitor.on_definitions(idl)
+
+        for output in rule.outputs:
+            if not output.mustache_template:
+                continue
+            write_message: str | None = None
+            if not rt.silent:
+                fname = (
+                    output.output.relative_to(cmake_dirs.project_source_dir).as_posix()
+                    if output.output.is_relative_to(cmake_dirs.project_source_dir)
+                    else output.output.as_posix()
+                )
+                write_message = f"writing {fname}"
+
+            types = output.get_type_replacements()
+            interfaces, modules_or_includes = idl.order(types)
+            output_context = {
+                **output.initial_context,
+                **context,
+                "modules_or_includes": list(sorted(modules_or_includes)),
+                "interfaces": aslist(interfaces),
+                "enums": aslist(idl.enum),
+                "has_modules_or_includes": not not modules_or_includes,
+                "has_interfaces": not not interfaces,
+                "has_enums": not not idl.enum,
+                "output": Output.filename_context(
+                    str(output.output), cmake_dirs.project_binary_dir
+                ),
+            }
+
+            kwargs = {}
+            if output.partials:
+                kwargs["partials_path"] = output.partials.as_posix()
+            text = output.mustache_template.read_text(encoding="UTF-8")
+            try:
+                text = chevron.render(
+                    text, output_context, partials_dict=pkg_partials, **kwargs
+                )
+            except chevron.ChevronError as e:
+                filename = e.filename or output.mustache_template.as_posix()
+                line = conv(lambda num: f":{num}", e.lineno) or ""
+                col = (conv(lambda num: f":{num}", e.offset) or "") if e.lineno else ""
+                print(f"{filename}{line}{col}: {e.msg}")
+                if e.text:
+                    print(e.text)
+                    if e.offset:
+                        spaces = "".join(
+                            ["\t" if c == "\t" else " " for c in e.text[: e.offset]]
+                        )
+                        print(f"{spaces}^")
+                sys.exit(1)
+
+            update_file_if_needed(output.output, text, write_message)
+
+            dst = output.output.with_name(output.output.name + ".json")
+            update_file_if_needed(dst, json.dumps(output_context, indent=2))

proj_flow/ext/webidl/cli/init.py

@@ -0,0 +1,26 @@
+# Copyright (c) 2026 Marcin Zdun
+# This code is licensed under MIT license (see LICENSE for details)
+
+import typing
+from pathlib import Path
+
+from proj_flow.api import arg, env
+from proj_flow.ext.webidl.cli.updater import update_file_if_needed
+
+
+@arg.command("webidl", "init")
+def init(rt: env.Runtime):
+    """Copy the main WebIDL CMake config to .flow/cmake"""
+
+    out_dir_name = Path(".flow") / "cmake"
+    in_dir_name = Path(__file__).parent.parent / "data" / "init"
+
+    for root, _dirs, files in in_dir_name.walk():
+        for filename in files:
+            in_path = root / filename
+            out_path = out_dir_name / in_path.relative_to(in_dir_name)
+            update_file_if_needed(
+                out_path,
+                in_path.read_bytes().decode("utf-8"),
+                f"adding {out_path.as_posix()}",
+            )

proj_flow/ext/webidl/cli/root.py

@@ -0,0 +1,12 @@
+# Copyright (c) 2026 Marcin Zdun
+# This code is licensed under MIT license (see LICENSE for details)
+
+from typing import cast
+
+from proj_flow.api import arg
+from proj_flow.base import inspect as _inspect
+
+
+@arg.command("webidl")
+def webidl():
+    """Configure and generate WebIDL-based interfaces"""

proj_flow/ext/webidl/cli/updater.py

@@ -0,0 +1,20 @@
+# Copyright (c) 2026 Marcin Zdun
+# This file is licensed under MIT license (see LICENSE for details)
+
+from pathlib import Path
+
+
+def update_file_if_needed(dst: Path, contents: str, message: str | None = None):
+    prev = ""
+    if dst.exists():
+        prev = dst.read_bytes().decode("utf-8")
+    if prev == contents:
+        return False
+
+    if message:
+        print("-- WebIDL:", "\n-- WebIDL: ".join(message.split("\n")))
+
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    dst.write_bytes(contents.encode("utf-8"))
+
+    return True

proj_flow/ext/webidl/data/init/flow_webidl.cmake

@@ -0,0 +1,26 @@
+macro(__webidl_exec CONFIG EXT COMMAND)
+    cmake_path(ABSOLUTE_PATH CONFIG OUTPUT_VARIABLE __ABS_CONFIG)
+    cmake_path(RELATIVE_PATH __ABS_CONFIG OUTPUT_VARIABLE __CONFIG)
+
+    execute_process(
+        ECHO_OUTPUT_VARIABLE
+        ECHO_ERROR_VARIABLE
+        COMMAND_ERROR_IS_FATAL LAST
+        COMMAND "${Python3_EXECUTABLE}" "${PROJECT_SOURCE_DIR}/.flow/flow.py" webidl ${COMMAND}
+        --cfg "${__ABS_CONFIG}"
+        --binary-dir "${PROJECT_BINARY_DIR}"
+        ${ARGN}
+    )
+endmacro()
+
+function(add_webidl_generation TARGET CONFIG)
+    __webidl_exec("${CONFIG}" cmake cmake --target "${TARGET}")
+    __webidl_exec("${CONFIG}" deps depfile)
+
+    cmake_path(ABSOLUTE_PATH CONFIG)
+    cmake_path(RELATIVE_PATH CONFIG)
+
+    if(EXISTS "${CMAKE_CURRENT_BINARY_DIR}/${CONFIG}.cmake")
+        include("${CMAKE_CURRENT_BINARY_DIR}/${CONFIG}.cmake")
+    endif()
+endfunction()

proj_flow/ext/webidl/data/templates/cmake.mustache

@@ -0,0 +1,45 @@
+macro(__webidl_config EXT COMMAND)
+    add_custom_command(
+        OUTPUT "{{{config.binary}}}.${EXT}"
+        MAIN_DEPENDENCY "{{{config.source}}}"
+        COMMAND "${Python3_EXECUTABLE}"
+            "${PROJECT_SOURCE_DIR}/.flow/flow.py" webidl ${COMMAND}
+            --cfg "{{{config.source}}}"
+            --binary-dir "${PROJECT_BINARY_DIR}"
+             ${ARGN}
+    )
+    target_sources(__webidl_cmake PRIVATE "{{{config.binary}}}.${EXT}")
+endmacro()
+
+if(NOT TARGET __webidl_cmake)
+    add_custom_target(__webidl_cmake ALL)
+endif()
+
+__webidl_config(deps depfile)
+{{# target}}
+__webidl_config(cmake cmake --target "{{{.}}}")
+{{/ target}}
+{{^ target}}
+__webidl_config(cmake cmake)
+{{/ target}}
+
+SET(GEN_SRCS
+{{# output}}
+    "{{{.}}}"
+{{/ output}}
+)
+{{# target}}
+
+source_group(TREE ${CMAKE_CURRENT_BINARY_DIR} PREFIX gen FILES ${GEN_SRCS})
+target_sources("{{{.}}}" PRIVATE ${GEN_SRCS})
+{{/target}}
+
+add_custom_command(
+    OUTPUT ${GEN_SRCS}
+    DEPFILE "{{{depfile}}}"
+    COMMAND "${Python3_EXECUTABLE}"
+        "${PROJECT_SOURCE_DIR}/.flow/flow.py" webidl gen
+        --cfg "{{{config.source}}}"
+        --binary-dir "${PROJECT_BINARY_DIR}"
+    COMMENT "Generating code for {{{config.basename}}}"
+)

proj_flow/ext/webidl/data/templates/depfile.mustache

@@ -0,0 +1,6 @@
+{{# rule}}
+{{#target}}{{sep}}{{pathname}}{{/target}}:{{#dependency}} \
+    {{.}}{{/dependency}}
+
+
+{{/rule}}

proj_flow/ext/webidl/data/templates/partials/cxx/attribute-decl.mustache

@@ -0,0 +1 @@
+{{# static}}static {{/static}}{{# readonly}}const {{/readonly}}{{#type}}{{> pkg-cxx:type}}{{/type}} {{name}}{{default}};

proj_flow/ext/webidl/data/templates/partials/cxx/in-out.mustache

@@ -0,0 +1,2 @@
+{{#ext_attrs.out}}&{{/ext_attrs.out}}{{!
+}}{{^ext_attrs.out}}{{#ext_attrs.in}} const&{{/ext_attrs.in}}{{/ext_attrs.out}}

proj_flow/ext/webidl/data/templates/partials/cxx/includes.mustache

@@ -0,0 +1,6 @@
+{{# modules_or_includes}}
+#include {{{.}}}
+{{/ modules_or_includes}}
+{{# has_modules_or_includes}}
+
+{{/ has_modules_or_includes}}

proj_flow/ext/webidl/data/templates/partials/cxx/operation-decl.mustache

@@ -0,0 +1,12 @@
+{{# static}}static {{/static}}{{#type}}{{> pkg-cxx:type}}{{/type}}{{> pkg-cxx:in-out}} {{!
+}}{{name}}({{#arguments}}{{!
+	}}{{^ first}}, {{/first}}{{#type}}{{> pkg-cxx:type}}{{/type}}{{> pkg-cxx:in-out}}{{!
+	}} {{name}}{{#ext_attrs}}{{!
+		}}{{#default}} = {{{.}}}{{/default}}{{!
+		}}{{^default}}{{#defaulted}} = {}{{/defaulted}}{{/default}}{{!
+	}}{{/ext_attrs}}{{!
+}}{{/arguments}}){{!
+}}{{^ext_attrs.mutable}}{{^ static}} const{{/static}}{{/ext_attrs.mutable}}{{!
+}}{{^ext_attrs.throws}} noexcept{{/ext_attrs.throws}}{{!
+}}{{#ext_attrs.defaulted}} = default{{/ext_attrs.defaulted}}{{!
+}};

proj_flow/ext/webidl/data/templates/partials/cxx/type.mustache

@@ -0,0 +1,6 @@
+{{# nullable}}std::optional<{{/nullable}}{{!
+    }}{{{name}}}{{!
+    }}{{# generic}}<{{#arguments}}{{!
+        }}{{^first}}, {{/first}}{{#arg_type}}{{> pkg-cxx:type}}{{/arg_type}}{{!
+    }}{{/arguments}}>{{/generic}}{{!
+}}{{# nullable}}>{{/nullable}}

proj_flow/ext/webidl/data/types/cxx.json

@@ -0,0 +1,47 @@
+{
+    "void": null,
+    "int": null,
+    "signed": null,
+    "unsigned": null,
+    "uint": "unsigned",
+    "short": null,
+    "signed short": null,
+    "unsigned short": null,
+    "long": null,
+    "signed long": null,
+    "unsigned long": null,
+    "ulong": "unsigned long",
+    "long long": null,
+    "signed long long": null,
+    "unsigned long long": null,
+    "char": null,
+    "wchar_t": null,
+    "char8_t": null,
+    "char16_t": null,
+    "char32_t": null,
+    "bool": null,
+    "float": null,
+    "double": null,
+    "long double": null,
+    "record": [ "<map>", "std::map" ],
+    "optional": [ "<optional>", "std::optional" ],
+    "array": [ "<vector>", "std::vector" ],
+    "sequence": [ "<vector>", "std::vector" ],
+    "span": [ "<span>", "std::span" ],
+    "set": [ "<set>", "std::set" ],
+    "union": [ "<variant>", "std::variant" ],
+    "DOMString": [ "<string>", "std::string" ],
+    "string": [ "<string>", "std::string" ],
+    "string_view": [ "<string_view>", "std::string_view" ],
+    "path": [ "<filesystem>", "std::filesystem::path" ],
+    "size_t": [ "<cstddef>", "std::size_t" ],
+    "nullptr_t": [ "<cstddef>", "std::nullptr_t" ],
+    "int8_t": [ "<cstdint>", "std::int8_t" ],
+    "int16_t": [ "<cstdint>", "std::int16_t" ],
+    "int32_t": [ "<cstdint>", "std::int32_t" ],
+    "int64_t": [ "<cstdint>", "std::int64_t" ],
+    "uint8_t": [ "<cstdint>", "std::uint8_t" ],
+    "uint16_t": [ "<cstdint>", "std::uint16_t" ],
+    "uint32_t": [ "<cstdint>", "std::uint32_t" ],
+    "uint64_t": [ "<cstdint>", "std::uint64_t" ]
+}

proj_flow/ext/webidl/model/__init__.py

@@ -0,0 +1,2 @@
+# Copyright (c) 2026 Marcin Zdun
+# This code is licensed under MIT license (see LICENSE for details)