proj-flow 0.14.1__py3-none-any.whl → 0.15.1__py3-none-any.whl

proj_flow/__init__.py

@@ -6,4 +6,4 @@ The **proj_flow** contains only ``__version__`` to be updated, nothing more.
 This is in an attempt to make this module easy to load initially.
 """
 
-__version__ = "0.14.1"
+__version__ = "0.15.1"

proj_flow/api/arg.py

@@ -26,6 +26,15 @@ class _Completable(typing.Protocol):
     completer: _inspect.Function
 
 
+@dataclass
+class ExclusiveArgumentGroup:
+    opt: bool = False
+
+    def visit(self, parser: argparse._ActionsContainer) -> argparse._ActionsContainer:
+        self.opt
+        return parser.add_mutually_exclusive_group(required=not self.opt)
+
+
 @dataclass
 class Argument:
     help: LazyArgument[str] = ""
@@ -38,8 +47,9 @@ class Argument:
     default: LazyArgument[typing.Optional[typing.Any]] = None
     choices: LazyArgument[typing.Optional[typing.List[str]]] = None
     completer: typing.Optional[_inspect.Function] = None
+    group: typing.Optional[ExclusiveArgumentGroup] = None
 
-    def visit(self, parser: argparse.ArgumentParser, name: str):
+    def visit(self, parser: argparse._ActionsContainer, name: str):
         kwargs = {}
 
         self_help = _eval(self.help)
@@ -82,9 +92,19 @@ class Argument:
 
 
 class FlagArgument(Argument):
-    def __init__(self, help: str = "", names: typing.List[str] = []):
+    def __init__(
+        self,
+        help: str = "",
+        names: typing.List[str] = [],
+        group: typing.Optional[ExclusiveArgumentGroup] = None,
+    ):
         super().__init__(
-            help=help, names=names, opt=True, action="store_true", default=False
+            help=help,
+            names=names,
+            group=group,
+            opt=True,
+            action="store_true",
+            default=False,
         )
 
 

proj_flow/base/__init__.py

@@ -6,6 +6,33 @@ The **proj_flow.base** contains low-level tools for higher-level parts of the
 library.
 """
 
+import typing
+
 from . import cmd, matrix, plugins, registry, uname
 
 __all__ = ["cmd", "matrix", "plugins", "registry", "uname"]
+
+
+def path_get(
+    structure: typing.Union[dict, list], dotted_path: str, default: typing.Any = None
+):
+    ctx: typing.Any = structure
+    for name in dotted_path.split("."):
+        if isinstance(ctx, dict):
+            try:
+                ctx = ctx[name]
+                continue
+            except KeyError:
+                return default
+
+        if isinstance(ctx, (list, tuple)):
+            try:
+                index = int(name)
+            except ValueError:
+                return default
+            except IndexError:
+                return default
+
+        return default
+
+    return ctx

proj_flow/cli/argument.py

@@ -135,7 +135,11 @@ class AnnotatedArgument:
     name: str
     argument: arg.Argument
 
-    def argparse_visit(self, parser: argparse.ArgumentParser):
+    @property
+    def group(self):
+        return self.argument.group
+
+    def argparse_visit(self, parser: argparse._ActionsContainer):
         return self.argument.visit(parser, self.name)
 
 
@@ -186,8 +190,21 @@ class Command:
         if has_config:
             _argparse_config_visit(parser)
 
-        for arg in self.annotated:
-            arg.argparse_visit(parser)
+        groups: typing.Set[int] = set()
+        for arg_index in range(len(self.annotated)):
+            annotated = self.annotated[arg_index]
+            group = annotated.group
+            if group is not None:
+                if id(group) in groups:
+                    continue
+                groups.add(id(group))
+                group_container = group.visit(parser)
+                for sub_index in range(arg_index, len(self.annotated)):
+                    sub = self.annotated[sub_index]
+                    if sub.group is group:
+                        sub.argparse_visit(group_container)
+                continue
+            annotated.argparse_visit(parser)
 
         if len(self.children):
             subparsers = parser.add_subparsers(
@@ -257,7 +274,7 @@ def _argparse_visit_all(
         dest="command", metavar="command", help="Known command name, see below"
     )
 
-    subparsers.parent = parser  # type: ignore
+    subparsers.parent = parser
 
     run: typing.Optional[Command] = None
     for entry in menu:

proj_flow/ext/github/cli.py

@@ -88,7 +88,9 @@ def release_cmd(
     ],
     changelog: typing.Annotated[
         bool,
-        arg.FlagArgument(help="Even with --dry-run, write changes in project files, changelog, etc."),
+        arg.FlagArgument(
+            help="Even with --dry-run, write changes in project files, changelog, etc."
+        ),
     ],
 ):
     """
@@ -107,7 +109,7 @@ def release_cmd(
     released = False
 
     released = False
-    next_tag = ''
+    next_tag = ""
     try:
         next_tag = log.release.add_release(
             rt=rt,

proj_flow/ext/github/switches.py

@@ -7,7 +7,20 @@ projects.
 
 from proj_flow.api import ctx
 
-ctx.register_common_switch("with_github_actions", "Use Github Actions", True)
+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
+    "with.github.auto-release",
+    "Make a GitHub release automatically on each closed PR",
+    False,
+)
+ctx.register_common_switch(
+    "with.github.social", "Use Github ISSUE_TEMPLATE, CONTRIBUTING.md, etc.", True
+)
+
+ctx.register_common_init_setting(
+    ctx.Setting(
+        "with.github.no-auto-release",
+        value=lambda settings: not settings.get("with.github.auto-release"),
+    ),
+    is_hidden=True,
 )

proj_flow/flow/layer.py

@@ -14,6 +14,7 @@ from typing import List, Optional, cast
 import chevron
 
 from proj_flow.api import ctx, env
+from proj_flow.base import path_get
 
 
 @dataclass
@@ -42,8 +43,8 @@ class FileInfo:
         open_mstch = "{{"
         close_mstch = "}}"
         if self.when:
-            return f"{open_mstch}#{self.when}{close_mstch}\n{self.dst}\n{open_mstch}/{self.when}{close_mstch}\n"
-        return f"{self.dst}\n"
+            return f"{open_mstch}#{self.when}{close_mstch}\n{self.src}\n{open_mstch}/{self.when}{close_mstch}\n"
+        return f"{self.src}\n"
 
     def run(self, root: str, rt: env.Runtime, context: ctx.SettingsType):
         if not rt.silent:
@@ -81,7 +82,7 @@ class LayerInfo:
     def from_fs(cls, layer_dir: str, context: ctx.SettingsType):
         with open(f"{layer_dir}.json", encoding="UTF-8") as f:
             layer_info: dict = json.load(f)
-        when = cast(Optional[bool], layer_info.get("when"))
+        when = cast(Optional[str], layer_info.get("when"))
         filelist = cast(dict, layer_info.get("filelist", {}))
 
         sources: List[str] = []
@@ -110,7 +111,7 @@ class LayerInfo:
                 chevron.render(result.template(), context).split("\n"),
             )
         )
-        result.files = list(filter(lambda file: file.dst in allowed_files, files))
+        result.files = list(filter(lambda file: file.src in allowed_files, files))
 
         return result
 
@@ -150,7 +151,7 @@ class LayerInfo:
 
 
 def copy_license(rt: env.Runtime, context: ctx.SettingsType):
-    license = context.get("COPY", {}).get("LICENSE")
+    license = path_get(context, "COPY.LICENSE")
     if not license:
         return
 

proj_flow/log/commit.py

@@ -144,6 +144,7 @@ def _get_commit(hash: str, short_hash: str, message: str) -> Optional[Commit]:
         breaking_change = [
             re.sub(r"\s+", " ", para.strip()) for para in body.split("\n\n")
         ]
+        is_breaking = True
 
     return Commit(
         type_scope[0].strip(),

proj_flow/minimal/init.py

@@ -29,6 +29,9 @@ def _project_help():
     )
 
 
+_output_group = arg.ExclusiveArgumentGroup(opt=True)
+
+
 @arg.command("init")
 def main(
     project: Annotated[
@@ -52,25 +55,58 @@ def main(
     ],
     non_interactive: Annotated[
         bool,
-        arg.FlagArgument(help="Selects all the default answers", names=["-y", "--yes"]),
+        arg.FlagArgument(
+            help="Selects all the default answers.",
+            names=["-y", "--yes"],
+            group=_output_group,
+        ),
+    ],
+    store: Annotated[
+        Optional[str],
+        arg.Argument(
+            help="Do not create project, store the context in given file.",
+            meta="context-file",
+            group=_output_group,
+        ),
+    ],
+    answers: Annotated[
+        Optional[str],
+        arg.Argument(
+            help="Take all the answers from the answer sheet.",
+            meta="context-file",
+            group=_output_group,
+        ),
     ],
     save_context: Annotated[
         bool,
-        arg.FlagArgument(help="Save the mustache context as JSON", names=["--ctx"]),
+        arg.FlagArgument(help="Save the mustache context as YAML.", names=["--ctx"]),
     ],
     rt: env.Runtime,
 ):
     """Initialize new project"""
 
+    setup = interact.ContextSetup(
+        dest_path=path,
+        interactive=not non_interactive and answers is None,
+        simple=store is not None,
+        load=answers,
+    )
+
+    context_file = store or ".context.yaml"
+    save_context = save_context or store is not None
+    if path is not None and os.path.basename(path) == "":
+        setup.dest_path = os.path.dirname(path)
+
     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:
+    if path is not None and store is None:
         os.makedirs(path, exist_ok=True)
         os.chdir(path)
+        setup.dest_path = None
 
     errors = dependency.verify(dependency.gather(init.__steps))
     if len(errors) > 0:
@@ -79,7 +115,7 @@ def main(
                 print(f"proj-flow: {error}", file=sys.stderr)
         return 1
 
-    context = current_project.get_context(not non_interactive, rt)
+    context = current_project.get_context(setup, rt)
     if not non_interactive and not rt.silent:
         print()
 
@@ -89,8 +125,14 @@ def main(
             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)
+        with open(context_file, "w", encoding="UTF-8") as jsonf:
+            if os.path.splitext(context_file)[1] == ".json":
+                json.dump(context, jsonf, indent=4)
+            else:
+                yaml.dump(context, jsonf, indent=4)
+
+    if store is not None:
+        return 0
 
     flow.layer.copy_license(rt, context)
     if not rt.silent:

proj_flow/project/api.py

@@ -30,8 +30,8 @@ class ProjectType(ABC):
     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, rt: env.Runtime):
-        return interact.get_context(interactive, self.id, rt)
+    def get_context(self, setup: interact.ContextSetup, rt: env.Runtime):
+        return interact.get_context(setup, self.id, rt)
 
     def append_extensions(self, context: dict):
         extensions = self.get_extension_list(context)

proj_flow/project/cplusplus/cmake_context.py

@@ -17,13 +17,13 @@ from proj_flow.project import data
 from proj_flow.project.cplusplus import project
 
 config_json_mustache = """
-{{#with_cmake}}
+{{#with.cmake}}
 cmake:
   vars:
     {{NAME_PREFIX}}_COVERAGE: "?config:coverage"
     {{NAME_PREFIX}}_SANITIZE: "?config:sanitizer"
     {{NAME_PREFIX}}_CUTDOWN_OS: "?runtime:cutdown_os"
-{{/with_cmake}}
+{{/with.cmake}}
 """
 
 
@@ -64,7 +64,7 @@ project.cxx.register_init_setting(
     api.ctx.Setting("PROJECT.WIX.UPGRADE_GUID", value=lambda: str(uuid.uuid4())),
     is_hidden=True,
 )
-project.cxx.register_switch("with_cmake", "Use CMake", True)
+project.cxx.register_switch("with.cmake", "Use CMake", True)
 project.cxx.register_internal(
     "cmake",
     {

proj_flow/project/cplusplus/conan_context.py

@@ -7,4 +7,4 @@ The **proj_flow.ext.cplusplus.conan** provides the ``"Conan"`` step.
 
 from proj_flow.project.cplusplus import project
 
-project.cxx.register_switch("with_conan", "Use Conan for dependency manager", True)
+project.cxx.register_switch("with.conan", "Use Conan for dependency manager", True)

proj_flow/project/cplusplus/project.py

@@ -5,6 +5,7 @@
 The **proj_flow.project.cplusplus** registers a ``"C++"`` projects support.
 """
 
+from proj_flow.base import path_get
 from proj_flow.project import api
 
 CPP_EXTENSIONS = [
@@ -20,7 +21,7 @@ class CPlusPlus(api.ProjectType):
         super().__init__("C++ plus CMake plus Conan", "cxx")
 
     def get_extension_list(self, context: dict):
-        with_github_actions = not not context.get("with_github_actions")
+        with_github_actions = not not path_get(context, "with.github.actions")
         if with_github_actions:
             return [*CPP_EXTENSIONS, "proj_flow.ext.github"]
         return CPP_EXTENSIONS

proj_flow/project/interact.py

@@ -6,8 +6,9 @@ The **proj_flow.project.interact** provides initialization context through
 user prompts.
 """
 
+import os
 from dataclasses import dataclass
-from typing import Callable, List, Optional, Union
+from typing import Any, Callable, List, Optional, Union, cast
 
 from prompt_toolkit import prompt as tk_prompt
 from prompt_toolkit.completion import WordCompleter
@@ -16,6 +17,7 @@ from prompt_toolkit.shortcuts import CompleteStyle
 from prompt_toolkit.validation import Validator
 
 from proj_flow.api import ctx, env
+from proj_flow.base import plugins
 
 
 @dataclass
@@ -51,31 +53,31 @@ class _Question:
         return self.prompt or f'"{self.key}"'
 
     def _ps(self, default: ctx.Values, counter: int, size: int) -> AnyFormattedText:
-        if default:
-            if isinstance(default, str):
-                return [
-                    ("", f"[{counter}/{size}] {self.ps} ["),
-                    ("bold", default),
-                    ("", f"]: "),
-                ]
-            if isinstance(default, bool):
-                b = "bold"
-                n = ""
-                on_true = (b if default else n, "yes")
-                on_false = (b if not default else n, "no")
-                return [
-                    ("", f"[{counter}/{size}] {self.ps} ["),
-                    on_true,
-                    ("", " / "),
-                    on_false,
-                    ("", f"]: "),
-                ]
+        if isinstance(default, str):
+            if default == "":
+                return f"[{counter}/{size}] {self.ps}: "
             return [
                 ("", f"[{counter}/{size}] {self.ps} ["),
-                ("bold", default[0]),
-                ("", f"{''.join(f' / {x}' for x in default[1:])}]: "),
+                ("bold", default),
+                ("", f"]: "),
             ]
-        return f"[{counter}/{size}] {self.ps}: "
+        if isinstance(default, bool):
+            b = "bold"
+            n = ""
+            on_true = (b if default else n, "yes")
+            on_false = (b if not default else n, "no")
+            return [
+                ("", f"[{counter}/{size}] {self.ps} ["),
+                on_true,
+                ("", " / "),
+                on_false,
+                ("", f"]: "),
+            ]
+        return [
+            ("", f"[{counter}/{size}] {self.ps} ["),
+            ("bold", default[0]),
+            ("", f"{''.join(f' / {x}' for x in default[1:])}]: "),
+        ]
 
     def _get_str(self, default: str, counter: int, size: int):
         value = tk_prompt(self._ps(default, counter, size))
@@ -214,6 +216,10 @@ def _fixup_context(settings: ctx.SettingsType, wanted: Callable[[ctx.Setting], b
     except KeyError:
         pass
 
+    return _split_keys(settings)
+
+
+def _split_keys(settings: dict):
     result = {}
     for key in settings:
         path = key.split(".")
@@ -226,14 +232,54 @@ def _fixup_context(settings: ctx.SettingsType, wanted: Callable[[ctx.Setting], b
     return result
 
 
-def get_context(interactive: bool, project: Optional[str], rt: env.Runtime):
+def _flatten_keys(settings: Any, prefix=""):
+    if not isinstance(settings, dict):
+        yield (prefix, settings)
+        return
+
+    for key in settings:
+        next = f"{prefix}{key}."
+        for name, value in _flatten_keys(settings[key], next):
+            yield (cast(str, name), cast(Any, value))
+
+
+def _flatten_dict(settings: dict):
+    result = {}
+    for name, value in _flatten_keys(settings):
+        result[name[:-1]] = value
+    return result
+
+
+@dataclass
+class ContextSetup:
+    """
+    Holds the setup for current context gathering.
+    """
+
+    #: Provides path name for project, in case it should differ from current
+    #: directory.
+    dest_path: Optional[str]
+
+    #: Selects, if the initialization process is done through prompts, or not.
+    interactive: bool
+
+    #: Do no post-processing and key expanding of the resulting context
+    simple: bool
+
+    #: If this setup is non-interactive, use contents of this file for
+    #: answers. If any given answer is missing, the default answer would be
+    #: taken.
+    load: Optional[str]
+
+
+def get_context(setup: ContextSetup, project: Optional[str], rt: env.Runtime):
     """
     Prompts user to provide details of newly-crated project. If `interactive`
     is true, however, this functions skips the prompts and chooses all the
     default answers.
 
-    :param interactive: Selects, if the initialization process is done through
-        prompts, or not.
+    :param setup: Selects, if the initialization process is done through
+        prompts, or not and how to answer any given question.
 
     :param project: Alows to select questions for any given language.
 
@@ -243,13 +289,24 @@ def get_context(interactive: bool, project: Optional[str], rt: env.Runtime):
     """
 
     overrides = rt._cfg.get("defaults", {})
+    if setup.dest_path is not None:
+        overrides["PROJECT.NAME"] = os.path.basename(setup.dest_path)
+
+    if setup.load is not None:
+        data = plugins.load_data(setup.load)
+        data = _flatten_dict(_split_keys(data))
+        for key, value in data.items():
+            overrides[key] = value
 
     wanted = _project_filter(project)
-    return _fixup_context(
-        (
-            _all_default(wanted, overrides)
-            if not interactive
-            else _prompt(wanted, overrides)
-        ),
-        wanted,
+    result = (
+        _all_default(wanted, overrides)
+        if not setup.interactive
+        else _prompt(wanted, overrides)
     )
+    if "COPY.YEAR" in result:
+        fast = cast(dict, result)
+        fast["COPY.YEAR"] = int(fast["COPY.YEAR"])
+    if setup.simple:
+        return _split_keys(result)
+    return _fixup_context(result, wanted)

proj_flow/template/layers/cmake/CMakeLists.txt.mustache

@@ -24,16 +24,16 @@ set(CMAKE_CXX_EXTENSIONS OFF)
 
 set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 
-{{#with_conan}}
+{{#with.conan}}
 list(APPEND CMAKE_MODULE_PATH "${PROJECT_BINARY_DIR}/conan" "${PROJECT_SOURCE_DIR}/.flow/cmake")
 list(APPEND CMAKE_PREFIX_PATH "${PROJECT_BINARY_DIR}/conan")
-{{/with_conan}}
-{{^with_conan}}
+{{/with.conan}}
+{{^with.conan}}
 list(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/.flow/cmake")
-{{/with_conan}}
+{{/with.conan}}
 
 include(common)
-{{#with_conan}}
+{{#with.conan}}
 include(output_dirs_setup)
 
 set(CONAN_CMAKE_SILENT_OUTPUT ON)
@@ -41,14 +41,14 @@ find_package(Python3 COMPONENTS Interpreter REQUIRED)
 find_package(fmt REQUIRED)
 find_package(GTest REQUIRED)
 find_package(mbits-args REQUIRED)
-{{/with_conan}}
+{{/with.conan}}
 
 if ({{NAME_PREFIX}}_TESTING)
   enable_testing()
 
-{{#with_conan}}
+{{#with.conan}}
   find_package(GTest REQUIRED)
-{{/with_conan}}
+{{/with.conan}}
 
   set(TEST_REPORT_DIR "${PROJECT_BINARY_DIR}/test-results")
   set(TEST_SANITIZER_TAG "")
@@ -58,10 +58,10 @@ if ({{NAME_PREFIX}}_TESTING)
   set(TEST_REPORT_FILE "${CMAKE_SYSTEM_NAME}-${CMAKE_CXX_COMPILER_ID}-${CMAKE_BUILD_TYPE}${TEST_SANITIZER_TAG}.xml")
 endif()
 
-{{#with_conan}}
+{{#with.conan}}
 include(output_dirs_setup)
 old_conan_output_dirs_setup()
-{{/with_conan}}
+{{/with.conan}}
 
 # See <https://github.com/lefticus/cppbestpractices/blob/v1.0.0/02-Use_the_Tools_Available.md#compilers>
 
@@ -177,7 +177,7 @@ target_include_directories(${PROJECT_NAME}
     ${CMAKE_CURRENT_SOURCE_DIR}/src
     ${CMAKE_CURRENT_BINARY_DIR}/src
 )
-target_link_libraries(${PROJECT_NAME}{{#with_conan}} fmt::fmt mbits::args{{/with_conan}})
+target_link_libraries(${PROJECT_NAME}{{#with.conan}} fmt::fmt mbits::args{{/with.conan}})
 set_target_properties(${PROJECT_NAME} PROPERTIES
   VERSION ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}
 {{#cmake.dynamic-library}}

proj_flow/template/layers/cmake/src/main.cc.mustache

@@ -1,10 +1,10 @@
 // Copyright (c) {{COPY.YEAR}} {{COPY.HOLDER}}
 // This code is licensed under {{COPY.LICENSE}} license (see LICENSE for details)
 
-{{#with_conan}}
+{{#with.conan}}
 #include <fmt/format.h>
 #include <args/parser.hpp>
-{{/with_conan}}
+{{/with.conan}}
 #include <{{INCLUDE_PREFIX}}/version{{EXT.hxx}}>
 
 int main(int argc, char* argv[]) {
@@ -23,15 +23,15 @@ int main(int argc, char* argv[]) {
 	    "sets the argument for the plural string");
 	parser.parse();
 
-{{#with_conan}}
+{{#with.conan}}
 	auto msg = std::string_view{counter == 1 ? "you have one foobar"
 	                                         : "you have {0} foobars"};
 	fmt::print(fmt::runtime(msg), counter);
-{{/with_conan}}
-{{^with_conan}}
+{{/with.conan}}
+{{^with.conan}}
 	auto msg = std::string_view{counter == 1 ? "you have one foobar"
 	                                         : "you have %ld foobars"};
 	printf(msg.data(), counter);
-{{/with_conan}}
+{{/with.conan}}
 	fputc('\n', stdout);
 }