proj-flow 0.8.1__py3-none-any.whl → 0.9.0__py3-none-any.whl

proj_flow/log/hosting/github.py

@@ -11,7 +11,7 @@ from typing import Any, List, NamedTuple, Optional, Tuple, cast
 
 from proj_flow.api import env
 from proj_flow.base import cmd
-from proj_flow.log import commit, release
+from proj_flow.log import commit, msg
 
 
 class _GitHub(NamedTuple):
@@ -122,21 +122,25 @@ class GitHub(commit.Hosting):
 
         return json.loads(proc.stdout)
 
-    def draft_a_release(
-        self, log: commit.ChangeLog, setup: commit.LogSetup, git: commit.Git
+    def add_release(
+        self,
+        log: commit.ChangeLog,
+        setup: commit.LogSetup,
+        git: commit.Git,
+        draft: bool,
     ) -> commit.ReleaseInfo:
         if setup.curr_tag is None:
             git.rt.fatal(f"New tag is needed.")
 
         git.push_with_refs(self.remote, "main")
 
-        body = release.ReleaseMessage(setup).format_changelog(log)
+        body = msg.ReleaseMessage(setup).format_changelog(log)
 
         rel = {
             "tag_name": setup.curr_tag,
             "name": setup.curr_tag,
             "body": body,
-            "draft": True,
+            "draft": draft,
             "prerelease": len(setup.curr_tag.split("-", 1)) > 1,
         }
 
@@ -157,7 +161,7 @@ class GitHub(commit.Hosting):
     def from_repo(git: commit.Git, remote: Optional[str] = None):
         info = _find_github(git, remote)
         if info == _NO_GITHUB:
-            return commit.NoHosting()
+            return None
         return GitHub(info, git.rt)
 
 

proj_flow/log/msg.py

@@ -185,6 +185,29 @@ class CommitMessage(ChangelogMessage):
         return result
 
 
+class ReleaseMessage(ChangelogMessage):
+    setup: commit.LogSetup
+
+    def __init__(self, setup: commit.LogSetup):
+        self.setup = setup
+
+    def scope_text(self, scope: str):
+        if len(scope):
+            scope = f"**{scope}**: "
+        return scope
+
+    def short_hash_link(self, link: commit.Link):
+        url = self.setup.single_commit_link(link)
+        if not url:
+            return link.short_hash
+        return f"[{link.short_hash}]({url})"
+
+    def outro_lines(self, lines: List[str]) -> None:
+        url = self.setup.commit_listing_link()
+        if url:
+            lines.append(f"**Full Changelog**: {url}")
+
+
 def _find_breaking_notes(links: List[commit.Link]) -> List[str]:
     breaking: List[str] = []
     for link in links:

proj_flow/log/release.py

@@ -2,33 +2,124 @@
 # This code is licensed under MIT license (see LICENSE for details)
 
 """
-The **proj_flow.log.release** builds a changelog message for hosting
-service release.
+The **proj_flow.log.release** performs a relase on the hosting service.
 """
 
-from typing import List
+import typing
+from abc import ABC, abstractmethod
+from typing import Iterable, Union
 
-from proj_flow.log import commit, msg
+from proj_flow import api
+from proj_flow.api import env
+from proj_flow.base import registry
+from proj_flow.log import commit, fmt, rich_text
+from proj_flow.log.error import NoProjectError, VersionNotAdvancing
 
+OneOrMoreStrings = Union[str, Iterable[str]]
 
-class ReleaseMessage(msg.ChangelogMessage):
-    setup: commit.LogSetup
 
-    def __init__(self, setup: commit.LogSetup):
-        self.setup = setup
+class VersionUpdater(ABC):
+    @abstractmethod
+    def on_version_change(self, new_version: str) -> OneOrMoreStrings: ...
 
-    def scope_text(self, scope: str):
-        if len(scope):
-            scope = f"**{scope}**: "
-        return scope
 
-    def short_hash_link(self, link: commit.Link):
-        url = self.setup.single_commit_link(link)
-        if not url:
-            return link.short_hash
-        return f"[{link.short_hash}]({url})"
+version_updaters = registry.Registry[VersionUpdater]("VersionUpdater")
 
-    def outro_lines(self, lines: List[str]) -> None:
-        url = self.setup.commit_listing_link()
-        if url:
-            lines.append(f"**Full Changelog**: {url}")
+
+def _bump_version(ver: str, level: commit.Level):
+    split = ver.split("-", 1)
+    if len(split) == 2:
+        stability = f"-{split[1]}"
+    else:
+        stability = ""
+
+    semver = [int(s) for s in split[0].split(".")]
+    while len(semver) < 3:
+        semver.append(0)
+    semver = semver[:3]
+
+    if level.value > commit.Level.BENIGN.value:
+        # This turns [1, 2, 3] through 4 - x into [3, 2, 1]
+        lvl = commit.Level.BREAKING.value - level.value
+        semver[lvl] += 1
+        for index in range(lvl + 1, len(semver)):
+            semver[index] = 0
+
+    return ".".join(str(v) for v in semver) + stability
+
+
+def _get_project(rt: env.Runtime):
+    def wrap(suite: api.release.ProjectSuite):
+        return suite.get_project(rt)
+
+    return wrap
+
+
+def add_release(
+    rt: env.Runtime,
+    forced_level: typing.Optional[commit.Level],
+    take_all: bool,
+    draft: bool,
+    generator: rich_text.api.ChangelogGenerator,
+    git: commit.Git,
+    hosting: commit.Hosting,
+):
+    """
+    Bumps the project version based on current git logs, creates a "chore"
+    commit for the change, attaches an annotated tag with the version number
+    and pushes it all to hosting.
+    """
+
+    suite, project = api.release.project_suites.find(_get_project(rt))
+
+    if not project or not suite:
+        raise NoProjectError()
+
+    tags = git.tag_list(silent=True)
+
+    prev_tag = tags[-1] if len(tags) > 0 else None
+
+    setup = commit.LogSetup(hosting, prev_tag, None, take_all=take_all)
+    changelog, log_level = git.get_log(setup)
+
+    project_version = f"{project.version}"
+    next_version = _bump_version(project_version, forced_level or log_level)
+    setup.curr_tag = f"v{next_version}"
+
+    if next_version == project_version:
+        raise VersionNotAdvancing(next_version)
+
+    if setup.curr_tag in tags:
+        rt.fatal(f"Tag {setup.curr_tag} already exists.")
+
+    files_to_commit: typing.List[str] = []
+    if not rt.dry_run:
+        generator.update_changelog(changelog, setup, rt)
+        files_to_commit.append(generator.filename)
+
+        suite.set_version(rt, next_version)
+        version_path = suite.get_version_file_path(rt)
+        if version_path:
+            files_to_commit.append(version_path)
+
+        for updater in version_updaters.get():
+            modified = updater.on_version_change(next_version)
+            if isinstance(modified, str):
+                files_to_commit.append(modified)
+            else:
+                files_to_commit.extend(modified)
+    else:
+        files_to_commit.append(generator.filename)
+        version_path = suite.get_version_file_path(rt)
+        if version_path:
+            files_to_commit.append(version_path)
+
+    commit_message = f"release {next_version}"
+    git.add_files(*files_to_commit)
+    git.commit(f"chore: {commit_message}{fmt.format_commit_message(changelog)}")
+    git.annotated_tag(setup.curr_tag, commit_message)
+
+    if hosting.is_active:
+        draft_url = hosting.add_release(changelog, setup, git, draft).draft_url
+        if draft_url:
+            rt.message("-- Visit draft at", draft_url, level=env.Msg.ALWAYS)

proj_flow/log/rich_text/__init__.py

@@ -8,15 +8,3 @@ The **proj_flow.log.rich_text** allows to operate on CHANGELOG.md.
 from . import api, markdown, re_structured_text
 
 __all__ = ["api", "markdown", "re_structured_text"]
-
-
-def select_generator(rst: bool = False) -> api.ChangelogGenerator:
-    """
-    Selects proper generator/formatter for Changelog messages.
-
-    :param rst: Generator selector. When true, returns reStructuredText
-        generator, Markdown otherwise.
-    """
-    if rst:
-        return re_structured_text.ChangelogGenerator()
-    return markdown.ChangelogGenerator()

proj_flow/log/rich_text/api.py

@@ -11,11 +11,12 @@ import os
 import re
 from typing import Dict, List, Type
 
+from proj_flow import base
 from proj_flow.api import env
-from proj_flow.log import commit, release
+from proj_flow.log import commit, msg
 
 
-class FileUpdate(release.ReleaseMessage):
+class FileUpdate(msg.ReleaseMessage):
     commit_date: str
 
     def __init__(self, setup: commit.LogSetup, commit_date: str):
@@ -24,6 +25,10 @@ class FileUpdate(release.ReleaseMessage):
 
 
 class ChangelogGenerator(abc.ABC):
+    @property
+    def filename(self) -> str:
+        return f"CHANGELOG{self.ext}"
+
     @property
     @abc.abstractmethod
     def formatter(self) -> Type[FileUpdate]: ...
@@ -101,7 +106,7 @@ class ChangelogGenerator(abc.ABC):
             setup, commit.read_tag_date(setup.curr_tag or "HEAD", rt)
         )
         text = formatter.format_changelog(log)
-        filename = f"CHANGELOG{self.ext}"
+        filename = self.filename
         path = os.path.join(rt.root, filename)
 
         try:
@@ -123,4 +128,5 @@ class ChangelogGenerator(abc.ABC):
         with open(filename, "wb") as f:
             f.write(new_text.encode("UTF-8"))
 
-        return [filename]
+
+changelog_generators = base.registry.Registry[ChangelogGenerator]("ChangelogGenerator")

proj_flow/minimal/__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.minimal** defines minimal extension package: ``bootstrap``
+and ``run`` commands, with basic set of steps.
+"""
+
+from . import bootstrap, list, run, system
+
+__all__ = ["bootstrap", "list", "run", "system"]

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

@@ -2,12 +2,12 @@
 # This code is licensed under MIT license (see LICENSE for details)
 
 """
-The **proj_flow.plugins.commands.bootstrap** implements ``./flow bootstrap`` command.
+The **proj_flow.minimal.bootstrap** implements ``./flow bootstrap`` command.
 """
 
 import os
 
-from proj_flow.api import arg, env
+from proj_flow.api import arg
 
 
 @arg.command("bootstrap")

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

@@ -2,13 +2,13 @@
 # This code is licensed under MIT license (see LICENSE for details)
 
 """
-The **proj_flow.plugins.commands.list** implements ``./flow list`` command.
+The **proj_flow.minimal.list** implements ``./flow list`` command.
 """
 
 import os
-from typing import Annotated, Dict, List, Optional, Set, cast
+from typing import Annotated, Dict, List, Set, cast
 
-from proj_flow import flow
+from proj_flow import cli
 from proj_flow.api import arg, env, step
 from proj_flow.base import matrix
 
@@ -24,6 +24,7 @@ def main(
     ],
     pipe: Annotated[bool, arg.FlagArgument(help="Do not show additional information")],
     rt: env.Runtime,
+    menu: cli.argument.Command,
 ):
     """List all the commands and/or steps for proj-flow"""
 
@@ -38,9 +39,10 @@ def main(
         configs = True
 
     if builtin:
-        builtin_entries = list(
-            sorted((entry.name, entry.doc) for entry in flow.cli.cmds.command_list)
-        )
+        root = menu
+        while root.parent is not None:
+            root = root.parent
+        builtin_entries = list(sorted((cmd.name, cmd.doc) for cmd in root.children))
         if not pipe and len(builtin_entries) > 0:
             print("Builtin commands")
             print("----------------")
@@ -68,13 +70,13 @@ def main(
             print("Known aliases")
             print("-------------")
 
-        for alias in aliases:
+        for run_alias in aliases:
             if pipe:
-                print(alias.name)
+                print(run_alias.name)
                 continue
 
-            name = f"{bold}{alias.name}{reset}"
-            print(f"- {name}: {', '.join(alias.steps)}")
+            name = f"{bold}{run_alias.name}{reset}"
+            print(f"- {name}: {', '.join(run_alias.steps)}")
 
         printed_something = True
 

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

@@ -2,7 +2,7 @@
 # This code is licensed under MIT license (see LICENSE for details)
 
 """
-The **proj_flow.plugins.commands.run** implements ``./flow run`` command.
+The **proj_flow.minimal.run** implements ``./flow run`` command.
 """
 
 import os
@@ -19,6 +19,8 @@ from proj_flow.flow.configs import Configs
 
 @api.arg.command("run")
 def main(
+    configs: Configs,
+    rt: api.env.Runtime,
     cli_steps: Annotated[
         Optional[List[str]],
         api.arg.Argument(
@@ -31,8 +33,6 @@ def main(
             completer=api.completers.step_completer,
         ),
     ],
-    configs: Configs,
-    rt: api.env.Runtime,
 ):
     """Run automation steps for current project"""
 
@@ -117,6 +117,7 @@ def run_steps(
     configs: Configs, rt: api.env.Runtime, program: List[api.step.Step], printed: bool
 ) -> int:
     config_count = len(configs.usable)
+    steps_ran = 0
     for config_index in range(config_count):
         config = configs.usable[config_index]
         steps = [step for step in program if step.is_active(config, rt)]
@@ -128,20 +129,28 @@ def run_steps(
             print(file=sys.stderr)
         printed = True
 
-        if config_count < 2:
-            print(f"- {config.build_name}", file=sys.stderr)
-        else:
-            print(
-                f"- {config_index + 1}/{config_count}: {config.build_name}",
-                file=sys.stderr,
-            )
+        build_name: Optional[str] = getattr(config, "build_name")
+
+        if build_name:
+            if config_count < 2:
+                print(f"- {build_name}", file=sys.stderr)
+            else:
+                print(
+                    f"- {config_index + 1}/{config_count}: {build_name}",
+                    file=sys.stderr,
+                )
 
-        with compilers_env_setup(config.compiler, rt):
+        compilers: List[str] = getattr(config, "compiler", [])
+        with compilers_env_setup(compilers, rt):
             for index in range(step_count):
                 step = steps[index]
                 print(f"-- step {index + 1}/{step_count}: {step.name}", file=sys.stderr)
+                steps_ran += 1
                 ret = step.run(config, rt)
                 if ret:
                     return 1
 
+    if steps_ran == 0:
+        print("Nothing to do.")
+
     return 0

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

@@ -2,14 +2,14 @@
 # This code is licensed under MIT license (see LICENSE for details)
 
 """
-The **proj_flow.plugins.commands.system** implements ``./flow system`` command.
+The **proj_flow.minimal.system** implements ``./flow system`` command.
 """
 
 import platform
 import sys
 from typing import Annotated
 
-from proj_flow.api import arg, env
+from proj_flow.api import arg
 from proj_flow.base import uname
 
 

proj_flow/plugins/__init__.py

@@ -2,7 +2,7 @@
 # This code is licensed under MIT license (see LICENSE for details)
 
 """
-The **proj_flow.plugins** provides the runtime comnponents of the *C++ flow*:
+The **proj_flow.plugins** provides the runtime comnponents of the *Project Flow*:
 the :class:`initialization helpers <proj_flow.api.init.InitStep>` and
 :class:`run steps <proj_flow.api.step.Step>`.
 """

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

@@ -53,7 +53,7 @@ include:
   - os: ubuntu
     build_type: Release
     sanitizer: false
-  
+
   - os: windows
     build_type: Release
     conan_settings: [ compiler.runtime=MD ]

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

@@ -135,7 +135,7 @@ else()
     list(APPEND {{NAME_PREFIX}}_ADDITIONAL_COMPILE_FLAGS
       -fsanitize=address
       -fsanitize=undefined
-      
+
     )
     list(APPEND {{NAME_PREFIX}}_ADDITIONAL_LINK_FLAGS
       -fsanitize=address

proj_flow/template/layers/github_actions/.github/workflows/build.yml

@@ -236,6 +236,6 @@ jobs:
       with:
         name: Packages
         path: ${{github.workspace}}/build/download/packages
-    
+
     - name: Upload to release
       run: python ./.flow/flow.py ci upload --ref "${{github.action_ref}}" "${{github.workspace}}/build/download/packages"

proj_flow/template/layers/github_social/.github/ISSUE_TEMPLATE/feature_request.md.mustache

@@ -25,4 +25,4 @@ _A clear and concise description of the alternative solutions you've considered.
 
 ## Additional context
 
-_Add any other context or screenshots about the feature request here._ 
+_Add any other context or screenshots about the feature request here._

{proj_flow-0.8.1.dist-info → proj_flow-0.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: proj-flow
-Version: 0.8.1
+Version: 0.9.0
 Summary: C++ project maintenance, automated
 Project-URL: Documentation, https://proj-flow.readthedocs.io/en/latest/
 Project-URL: Homepage, https://pypi.org/project/proj-flow/
@@ -20,15 +20,16 @@ Requires-Dist: argcomplete
 Requires-Dist: chevron2021
 Requires-Dist: prompt-toolkit
 Requires-Dist: pyyaml
+Requires-Dist: toml
 Description-Content-Type: text/markdown
 
-# C++ flow
+# Project Flow
 
 [![Python package workflow badge](https://github.com/mzdun/proj-flow/actions/workflows/python-publish.yml/badge.svg)](https://github.com/mzdun/proj-flow/actions)
 [![PyPI version badge](https://img.shields.io/pypi/v/proj-flow.svg)](https://pypi.python.org/pypi/proj-flow)
 [![PyPI License: MIT](https://img.shields.io/pypi/l/proj-flow.svg)](https://pypi.python.org/pypi/proj-flow)
 
-**C++ flow** aims at being a one-stop tool for C++ projects, from creating new
+**Project Flow** aims at being a one-stop tool for C++ projects, from creating new
 project, though building and verifying, all the way to publishing releases to
 the repository. It will run a set of known steps and will happily consult your
 project what do you want to call any subset of those steps.
@@ -38,13 +39,13 @@ for config and build and GitHub CLI for releases.
 
 ## Installation
 
-To create a new project with _C++ flow_, first install it using pip:
+To create a new project with _Project Flow_, first install it using pip:
 
 ```sh
 (.venv) $ pip install proj-flow
 ```
 
-Every project created with _C++ flow_ has a self-bootstrapping helper script,
+Every project created with _Project Flow_ has a self-bootstrapping helper script,
 which will install `proj-flow` if it is needed, using either current virtual
 environment or switching to a private virtual environment (created inside
 `.flow/.venv` directory). This is used by the GitHub workflow in the generated