refactor(git,init): code cleanup

Author: bearomorphism

commitizen/commands/init.py

@@ -2,7 +2,6 @@
 
 import os
 import shutil
-from typing import Any
 
 import questionary
 import yaml
@@ -14,7 +13,12 @@
 from commitizen.defaults import DEFAULT_SETTINGS, config_files
 from commitizen.exceptions import InitFailedError, NoAnswersError
 from commitizen.git import get_latest_tag_name, get_tag_names, smart_open
-from commitizen.version_schemes import KNOWN_SCHEMES, Version, get_version_scheme
+from commitizen.version_schemes import (
+    KNOWN_SCHEMES,
+    Version,
+    VersionScheme,
+    get_version_scheme,
+)
 
 
 class ProjectInfo:
@@ -63,16 +67,6 @@ def is_npm_package(self) -> bool:
     def is_php_composer(self) -> bool:
         return os.path.isfile("composer.json")
 
-    @property
-    def latest_tag(self) -> str | None:
-        return get_latest_tag_name()
-
-    def tags(self) -> list | None:
-        """Not a property, only use if necessary"""
-        if self.latest_tag is None:
-            return None
-        return get_tag_names()
-
     @property
     def is_pre_commit_installed(self) -> bool:
         return bool(shutil.which("pre-commit"))
@@ -113,98 +107,79 @@ def __call__(self):
         except KeyboardInterrupt:
             raise InitFailedError("Stopped by user")
 
-        # Initialize configuration
-        if "toml" in config_path:
-            self.config = TomlConfig(data="", path=config_path)
-        elif "json" in config_path:
-            self.config = JsonConfig(data="{}", path=config_path)
-        elif "yaml" in config_path:
-            self.config = YAMLConfig(data="", path=config_path)
-        values_to_add = {}
-        values_to_add["name"] = cz_name
-        values_to_add["tag_format"] = tag_format
-        values_to_add["version_scheme"] = version_scheme
-
-        if version_provider == "commitizen":
-            values_to_add["version"] = version.public
-        else:
-            values_to_add["version_provider"] = version_provider
+        self._init_config(config_path)
 
-        if update_changelog_on_bump:
-            values_to_add["update_changelog_on_bump"] = update_changelog_on_bump
+        self._init_pre_commit_hook()
 
-        if major_version_zero:
-            values_to_add["major_version_zero"] = major_version_zero
-
-        # Collect hook data
-        hook_types = questionary.checkbox(
-            "What types of pre-commit hook you want to install? (Leave blank if you don't want to install)",
-            choices=[
-                questionary.Choice("commit-msg", checked=False),
-                questionary.Choice("pre-push", checked=False),
-            ],
-        ).unsafe_ask()
-        if hook_types:
-            try:
-                self._install_pre_commit_hook(hook_types)
-            except InitFailedError as e:
-                raise InitFailedError(f"Failed to install pre-commit hook.\n{e}")
-
-        # Create and initialize config
         self.config.init_empty_config_content()
-        self._update_config_file(values_to_add)
+        self._update_config_file(
+            version_provider,
+            version,
+            name=cz_name,
+            tag_format=tag_format,
+            version_scheme=version_scheme,
+            update_changelog_on_bump=update_changelog_on_bump,
+            major_version_zero=major_version_zero,
+        )
 
         out.write("\nYou can bump the version running:\n")
         out.info("\tcz bump\n")
         out.success("Configuration complete 🚀")
 
     def _ask_config_path(self) -> str:
-        default_path = ".cz.toml"
-        if self.project_info.has_pyproject:
-            default_path = "pyproject.toml"
-
-        name: str = questionary.select(
-            "Please choose a supported config file: ",
-            choices=config_files,
-            default=default_path,
-            style=self.cz.style,
-        ).unsafe_ask()
-        return name
+        default_path = (
+            "pyproject.toml" if self.project_info.has_pyproject else ".cz.toml"
+        )
+
+        return str(
+            questionary.select(
+                "Please choose a supported config file: ",
+                choices=config_files,
+                default=default_path,
+                style=self.cz.style,
+            ).unsafe_ask()
+        )
 
     def _ask_name(self) -> str:
-        name: str = questionary.select(
-            "Please choose a cz (commit rule): (default: cz_conventional_commits)",
-            choices=list(registry.keys()),
-            default="cz_conventional_commits",
-            style=self.cz.style,
-        ).unsafe_ask()
-        return name
+        return str(
+            questionary.select(
+                "Please choose a cz (commit rule): (default: cz_conventional_commits)",
+                choices=list(registry.keys()),
+                default="cz_conventional_commits",
+                style=self.cz.style,
+            ).unsafe_ask()
+        )
 
     def _ask_tag(self) -> str:
-        latest_tag = self.project_info.latest_tag
+        latest_tag = get_latest_tag_name()
         if not latest_tag:
             out.error("No Existing Tag. Set tag to v0.0.1")
             return "0.0.1"
 
         is_correct_tag = questionary.confirm(
             f"Is {latest_tag} the latest tag?", style=self.cz.style, default=False
         ).unsafe_ask()
-        if not is_correct_tag:
-            tags = self.project_info.tags()
-            if not tags:
-                out.error("No Existing Tag. Set tag to v0.0.1")
-                return "0.0.1"
-
-            # the latest tag is most likely with the largest number. Thus list the tags in reverse order makes more sense
-            sorted_tags = sorted(tags, reverse=True)
-            latest_tag = questionary.select(
+        if is_correct_tag:
+            return latest_tag
+
+        tags = get_tag_names()
+        if not tags:
+            out.error("No Existing Tag. Set tag to v0.0.1")
+            return "0.0.1"
+
+        # Tags are sorted in reverse order to get the most recent tag first,
+        # which is typically the one we want to use as a reference.
+        latest_tag = str(
+            questionary.select(
                 "Please choose the latest tag: ",
-                choices=sorted_tags,
+                choices=sorted(tags, reverse=True),
                 style=self.cz.style,
             ).unsafe_ask()
+        )
+
+        if not latest_tag:
+            raise NoAnswersError("Tag is required!")
 
-            if not latest_tag:
-                raise NoAnswersError("Tag is required!")
         return latest_tag
 
     def _ask_tag_format(self, latest_tag) -> str:
@@ -215,16 +190,16 @@ def _ask_tag_format(self, latest_tag) -> str:
                 f'Is "{tag_format}" the correct tag format?', style=self.cz.style
             ).unsafe_ask()
 
+        if is_correct_format:
+            return tag_format
+
         default_format = DEFAULT_SETTINGS["tag_format"]
-        if not is_correct_format:
-            tag_format = questionary.text(
-                f'Please enter the correct version format: (default: "{default_format}")',
-                style=self.cz.style,
-            ).unsafe_ask()
+        tag_format = questionary.text(
+            f'Please enter the correct version format: (default: "{default_format}")',
+            style=self.cz.style,
+        ).unsafe_ask()
 
-            if not tag_format:
-                tag_format = default_format
-        return tag_format
+        return tag_format or default_format
 
     def _ask_version_provider(self) -> str:
         """Ask for setting: version_provider"""
@@ -323,7 +298,31 @@ def _gen_pre_commit_cmd(self, hook_types: list[str]) -> str:
         )
         return cmd_str
 
-    def _install_pre_commit_hook(self, hook_types: list[str] | None = None):
+    def _init_config(self, config_path: str):
+        if "toml" in config_path:
+            self.config = TomlConfig(data="", path=config_path)
+        elif "json" in config_path:
+            self.config = JsonConfig(data="{}", path=config_path)
+        elif "yaml" in config_path:
+            self.config = YAMLConfig(data="", path=config_path)
+
+    def _init_pre_commit_hook(self):
+        hook_types = questionary.checkbox(
+            "What types of pre-commit hook you want to install? (Leave blank if you don't want to install)",
+            choices=[
+                questionary.Choice("commit-msg", checked=False),
+                questionary.Choice("pre-push", checked=False),
+            ],
+        ).unsafe_ask()
+        try:
+            self._install_pre_commit_hook(hook_types)
+        except InitFailedError as e:
+            raise InitFailedError(f"Failed to install pre-commit hook.\n{e}")
+
+    def _install_pre_commit_hook(self, hook_types: list[str] | None):
+        if not hook_types:
+            return
+
         pre_commit_config_filename = ".pre-commit-config.yaml"
         cz_hook_config = {
             "repo": "https://github.com/commitizen-tools/commitizen",
@@ -364,11 +363,18 @@ def _install_pre_commit_hook(self, hook_types: list[str] | None = None):
 
         if not self.project_info.is_pre_commit_installed:
             raise InitFailedError("pre-commit is not installed in current environment.")
-        if hook_types is None:
-            hook_types = ["commit-msg", "pre-push"]
+
         self._exec_install_pre_commit_hook(hook_types)
         out.write("commitizen pre-commit hook is now installed in your '.git'\n")
 
-    def _update_config_file(self, values: dict[str, Any]):
-        for key, value in values.items():
-            self.config.set_key(key, value)
+    def _update_config_file(
+        self, version_provider: str, version: VersionScheme, **kwargs
+    ):
+        for key, value in kwargs.items():
+            if value:
+                self.config.set_key(key, value)
+
+        if version_provider == "commitizen":
+            self.config.set_key("version", version.public)
+        else:
+            self.config.set_key("version_provider", version_provider)