Change: Rename pontos-release release CLI to pontos-release create

Create is a much better name for this functionality. Therefore adjust
the CLI sub command, classes, functions and modules.

The CLI still supports pontos-release release via an alias to create.

pontos/release/__init__.py

@@ -16,17 +16,17 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+from .create import CreateReleaseCommand, CreateReleaseReturnValue
 from .helper import ReleaseType, find_signing_key, get_git_repository_name
 from .main import main
-from .release import ReleaseCommand, ReleaseReturnValue
 from .sign import SignatureError, SignCommand, SignReturnValue
 
 __all__ = (
     "ReleaseType",
     "get_git_repository_name",
     "find_signing_key",
-    "ReleaseCommand",
-    "ReleaseReturnValue",
+    "CreateReleaseCommand",
+    "CreateReleaseReturnValue",
     "SignCommand",
     "SignatureError",
     "SignReturnValue",

pontos/release/release.py → pontos/release/create.py

@@ -56,7 +56,7 @@ def write_github_output(self):
             output.write("next-version", self.next_version)
 
 
-class ReleaseReturnValue(IntEnum):
+class CreateReleaseReturnValue(IntEnum):
     """
     Possible return values of ReleaseCommand
     """
@@ -72,7 +72,7 @@ class ReleaseReturnValue(IntEnum):
     UPDATE_VERSION_AFTER_RELEASE_ERROR = auto()
 
 
-class ReleaseCommand(AsyncCommand):
+class CreateReleaseCommand(AsyncCommand):
     """
     A CLI command for creating a release
 
@@ -179,7 +179,7 @@ async def async_run(
         local: Optional[bool] = False,
         release_series: Optional[str] = None,
         update_project: bool = True,
-    ) -> ReleaseReturnValue:
+    ) -> CreateReleaseReturnValue:
         """
         Create a release
 
@@ -239,7 +239,7 @@ async def async_run(
         if not last_release_version:
             if not release_version:
                 self.print_error("Unable to determine last release version.")
-                return ReleaseReturnValue.NO_LAST_RELEASE_VERSION
+                return CreateReleaseReturnValue.NO_LAST_RELEASE_VERSION
             else:
                 self.terminal.info(
                     f"Creating the initial release {release_version}"
@@ -259,22 +259,22 @@ async def async_run(
             )
         except VersionError as e:
             self.print_error(f"Unable to determine release version. {e}")
-            return ReleaseReturnValue.NO_RELEASE_VERSION
+            return CreateReleaseReturnValue.NO_RELEASE_VERSION
 
         self.terminal.info(f"Preparing the release {release_version}")
 
         git_version = f"{self.git_tag_prefix}{release_version}"
 
         if self._has_tag(git_version):
             self.print_error(f"Git tag {git_version} already exists.")
-            return ReleaseReturnValue.ALREADY_TAKEN
+            return CreateReleaseReturnValue.ALREADY_TAKEN
 
         if update_project:
             try:
                 project = Project(versioning_scheme)
             except PontosError as e:
                 self.print_error(f"Unable to determine project settings. {e}")
-                return ReleaseReturnValue.PROJECT_SETTINGS_NOT_FOUND
+                return CreateReleaseReturnValue.PROJECT_SETTINGS_NOT_FOUND
 
             try:
                 updated = project.update_version(release_version)
@@ -288,7 +288,7 @@ async def async_run(
                 self.terminal.error(
                     f"Unable to update version to {release_version}. {e}"
                 )
-                return ReleaseReturnValue.UPDATE_VERSION_ERROR
+                return CreateReleaseReturnValue.UPDATE_VERSION_ERROR
 
         if last_release_version:
             self.terminal.info(
@@ -332,7 +332,7 @@ async def async_run(
                 self.terminal.ok(f"Created release {release_version}")
             except httpx.HTTPStatusError as e:
                 self.print_error(str(e))
-                return ReleaseReturnValue.CREATE_RELEASE_ERROR
+                return CreateReleaseReturnValue.CREATE_RELEASE_ERROR
 
         if not next_version:
             next_version = calculator.next_dev_version(release_version)
@@ -347,7 +347,9 @@ async def async_run(
                 self.print_error(
                     f"Error while updating version after release. {e}"
                 )
-                return ReleaseReturnValue.UPDATE_VERSION_AFTER_RELEASE_ERROR
+                return (
+                    CreateReleaseReturnValue.UPDATE_VERSION_AFTER_RELEASE_ERROR
+                )
 
             for f in updated.changed_files:
                 self.terminal.info(f"Adding changes of {f}")
@@ -379,10 +381,10 @@ async def async_run(
         if ActionIO.has_output():
             self.release_information.write_github_output()
 
-        return ReleaseReturnValue.SUCCESS
+        return CreateReleaseReturnValue.SUCCESS
 
 
-def release(
+def create_release(
     args: Namespace,
     *,
     token: str,
@@ -395,9 +397,11 @@ def release(
             "Token is missing. The GitHub token is required to create a "
             "release."
         )
-        return ReleaseReturnValue.TOKEN_MISSING
+        return CreateReleaseReturnValue.TOKEN_MISSING
 
-    return ReleaseCommand(terminal=terminal, error_terminal=error_terminal).run(
+    return CreateReleaseCommand(
+        terminal=terminal, error_terminal=error_terminal
+    ).run(
         token=token,
         space=args.space,
         project=args.project,

pontos/release/parser.py

@@ -34,7 +34,7 @@
     versioning_scheme_argument_type,
 )
 
-from .release import release
+from .create import create_release
 from .sign import sign
 
 DEFAULT_SIGNING_KEY = "0ED1E580"
@@ -88,86 +88,86 @@ def parse_args(args) -> Tuple[str, str, Namespace]:
         required=True,
     )
 
-    release_parser = subparsers.add_parser(
-        "release", help="Create a new release"
+    create_parser = subparsers.add_parser(
+        "create", help="Create a new release", aliases=["release"]
     )
-    release_parser.set_defaults(func=release)
-    release_parser.add_argument(
+    create_parser.set_defaults(func=create_release)
+    create_parser.add_argument(
         "--versioning-scheme",
         help="Versioning scheme to use for parsing and handling version "
         f"information. Choices are {', '.join(VERSIONING_SCHEMES.keys())}. "
         "Default: %(default)s",
         default="pep440",
         type=versioning_scheme_argument_type,
     )
-    release_parser.add_argument(
+    create_parser.add_argument(
         "--release-type",
         help="Select the release type for calculating the release version. "
         f"Possible choices are: {to_choices(ReleaseType)}.",
         type=enum_type(ReleaseType),
     )
-    release_parser.add_argument(
+    create_parser.add_argument(
         "--release-version",
         help=(
             "Will release changelog as version. "
             "Default: lookup version in project definition."
         ),
         action=ReleaseVersionAction,
     )
-    release_parser.add_argument(
+    create_parser.add_argument(
         "--release-series",
         help="Create a release for a release series. Setting a release series "
         "is required if the latest tag version is newer then the to be "
         'released version. Examples: "1.2", "2", "22.4"',
     )
 
-    release_parser.add_argument(
+    create_parser.add_argument(
         "--next-version",
         help=(
             "Sets the next version in project definition "
             "after the release. Default: set to next dev version"
         ),
     )
 
-    release_parser.add_argument(
+    create_parser.add_argument(
         "--git-remote-name",
         help="The git remote name to push the commits and tag to",
     )
-    release_parser.add_argument(
+    create_parser.add_argument(
         "--git-tag-prefix",
         default="v",
         const="",
         nargs="?",
         help="Prefix for git tag versions. Default: %(default)s",
     )
-    release_parser.add_argument(
+    create_parser.add_argument(
         "--git-signing-key",
         help="The key to sign the commits and tag for a release",
         default=os.environ.get("GPG_SIGNING_KEY"),
     )
-    release_parser.add_argument(
+    create_parser.add_argument(
         "--project",
         help="The github project",
     )
-    release_parser.add_argument(
+    create_parser.add_argument(
         "--space",
         default="greenbone",
         help="User/Team name in github",
     )
-    release_parser.add_argument(
+    create_parser.add_argument(
         "--local",
         action="store_true",
         help="Only create release changes locally and do not upload them to a "
         "remote repository. Also do not create a GitHub release.",
     )
-    release_parser.add_argument(
+    create_parser.add_argument(
         "--conventional-commits-config",
         dest="cc_config",
         type=Path,
         help="Conventional commits config file (toml), including conventions."
         " If not set defaults are used.",
     )
-    release_parser.add_argument(
+    create_parser.add_argument(
         "--update-project",
         help="Update version in project files like pyproject.toml. By default "
         "project files are updated.",
@@ -233,7 +233,7 @@ def parse_args(args) -> Tuple[str, str, Namespace]:
 
     scheme: VersioningScheme = getattr(parsed_args, "versioning_scheme", None)
 
-    if parsed_args.func in (release,):
+    if parsed_args.func in (create_release,):
         # check for release-type
         if not getattr(parsed_args, "release_type", None):
             parser.error("--release-type is required.")