refactor(BaseConfig): update docstring, extract factory method and remove unnecessary variable assignment

Author: bearomorphism

commitizen/commands/init.py

@@ -2,14 +2,18 @@
 
 import os
 import shutil
+from pathlib import Path
 from typing import Any, NamedTuple
 
 import questionary
 import yaml
 
 from commitizen import cmd, factory, out
 from commitizen.__version__ import __version__
-from commitizen.config import BaseConfig, JsonConfig, TomlConfig, YAMLConfig
+from commitizen.config import (
+    BaseConfig,
+    create_config,
+)
 from commitizen.cz import registry
 from commitizen.defaults import CONFIG_FILES, DEFAULT_SETTINGS
 from commitizen.exceptions import InitFailedError, NoAnswersError
@@ -153,14 +157,6 @@ def __call__(self) -> None:
         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)
-
         # 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)",
@@ -175,37 +171,33 @@ def __call__(self) -> None:
             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.config.set_key("name", cz_name)
-        self.config.set_key("tag_format", tag_format)
-        self.config.set_key("version_scheme", version_scheme)
-        if version_provider == "commitizen":
-            self.config.set_key("version", version.public)
-        else:
-            self.config.set_key("version_provider", version_provider)
-        if update_changelog_on_bump:
-            self.config.set_key("update_changelog_on_bump", update_changelog_on_bump)
-        if major_version_zero:
-            self.config.set_key("major_version_zero", major_version_zero)
+        _write_config_to_file(
+            path=config_path,
+            cz_name=cz_name,
+            version_provider=version_provider,
+            version_scheme=version_scheme,
+            version=version,
+            tag_format=tag_format,
+            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:
+    def _ask_config_path(self) -> Path:
         default_path = (
             "pyproject.toml" if self.project_info.has_pyproject else ".cz.toml"
         )
 
-        name: str = questionary.select(
+        filename: str = questionary.select(
             "Please choose a supported config file: ",
             choices=CONFIG_FILES,
             default=default_path,
             style=self.cz.style,
         ).unsafe_ask()
-        return name
+        return Path(filename)
 
     def _ask_name(self) -> str:
         name: str = questionary.select(
@@ -383,3 +375,30 @@ def _install_pre_commit_hook(self, hook_types: list[str] | None = None) -> 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 _write_config_to_file(
+    *,
+    path: Path,
+    cz_name: str,
+    version_provider: str,
+    version_scheme: str,
+    version: Version,
+    tag_format: str,
+    update_changelog_on_bump: bool,
+    major_version_zero: bool,
+) -> None:
+    out_config = create_config(path=path)
+    out_config.init_empty_config_content()
+
+    out_config.set_key("name", cz_name)
+    out_config.set_key("tag_format", tag_format)
+    out_config.set_key("version_scheme", version_scheme)
+    if version_provider == "commitizen":
+        out_config.set_key("version", version.public)
+    else:
+        out_config.set_key("version_provider", version_provider)
+    if update_changelog_on_bump:
+        out_config.set_key("update_changelog_on_bump", update_changelog_on_bump)
+    if major_version_zero:
+        out_config.set_key("major_version_zero", major_version_zero)

commitizen/config/__init__.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from collections.abc import Generator
 from pathlib import Path
 
 from commitizen import defaults, git
@@ -11,48 +12,55 @@
 from .yaml_config import YAMLConfig
 
 
-def read_cfg(filepath: str | None = None) -> BaseConfig:
-    conf = BaseConfig()
-
+def _resolve_config_paths(filepath: str | None = None) -> Generator[Path, None, None]:
     if filepath is not None:
-        if not Path(filepath).exists():
+        out_path = Path(filepath)
+        if not out_path.exists():
             raise ConfigFileNotFound()
 
-        cfg_paths = (path for path in (Path(filepath),))
-    else:
-        git_project_root = git.find_git_project_root()
-        cfg_search_paths = [Path(".")]
-        if git_project_root:
-            cfg_search_paths.append(git_project_root)
+        yield out_path
+        return
+
+    git_project_root = git.find_git_project_root()
+    cfg_search_paths = [Path(".")]
+    if git_project_root:
+        cfg_search_paths.append(git_project_root)
 
-        cfg_paths = (
-            path / Path(filename)
-            for path in cfg_search_paths
-            for filename in defaults.CONFIG_FILES
-        )
+    for path in cfg_search_paths:
+        for filename in defaults.CONFIG_FILES:
+            yield path / Path(filename)
+    return
 
-    for filename in cfg_paths:
+
+def read_cfg(filepath: str | None = None) -> BaseConfig:
+    for filename in _resolve_config_paths(filepath):
         if not filename.exists():
             continue
 
-        _conf: TomlConfig | JsonConfig | YAMLConfig
-
         with open(filename, "rb") as f:
             data: bytes = f.read()
 
-        if "toml" in filename.suffix:
-            _conf = TomlConfig(data=data, path=filename)
-        elif "json" in filename.suffix:
-            _conf = JsonConfig(data=data, path=filename)
-        elif "yaml" in filename.suffix:
-            _conf = YAMLConfig(data=data, path=filename)
+        conf = create_config(data=data, path=filename)
+        if not conf.is_empty_config:
+            return conf
 
-        if filepath is not None and _conf.is_empty_config:
+        if filepath is not None:
             raise ConfigFileIsEmpty()
-        elif _conf.is_empty_config:
-            continue
-        else:
-            conf = _conf
-            break
 
-    return conf
+    return BaseConfig()
+
+
+# TODO: consider moving this to some factory class?
+def create_config(*, data: bytes | str | None = None, path: Path) -> BaseConfig:
+    if "toml" in path.suffix:
+        return TomlConfig(data=data or "", path=path)
+    if "json" in path.suffix:
+        return JsonConfig(data=data or "{}", path=path)
+    if "yaml" in path.suffix:
+        return YAMLConfig(data=data or "", path=path)
+
+    # TODO: adjust the exception type
+    # Should be unreachable. See the constant CONFIG_FILES.
+    raise ValueError(
+        f"Unsupported config file: {path.name} due to unknown file extension"
+    )

commitizen/config/base_config.py

@@ -17,8 +17,8 @@
 
 class BaseConfig:
     def __init__(self) -> None:
+        self.is_empty_config = False
         self._settings: Settings = DEFAULT_SETTINGS.copy()
-        self.encoding = self.settings["encoding"]
         self._path: Path | None = None
 
     @property
@@ -48,4 +48,8 @@ def _parse_setting(self, data: bytes | str) -> None:
         raise NotImplementedError()
 
     def init_empty_config_content(self) -> None:
+        """Create a config file with the empty config content.
+
+        The implementation is different for each config file type.
+        """
         raise NotImplementedError()

commitizen/config/json_config.py

@@ -22,12 +22,13 @@
 class JsonConfig(BaseConfig):
     def __init__(self, *, data: bytes | str, path: Path | str) -> None:
         super().__init__()
-        self.is_empty_config = False
         self.path = path
         self._parse_setting(data)
 
     def init_empty_config_content(self) -> None:
-        with smart_open(self.path, "a", encoding=self.encoding) as json_file:
+        with smart_open(
+            self.path, "a", encoding=self._settings["encoding"]
+        ) as json_file:
             json.dump({"commitizen": {}}, json_file)
 
     def set_key(self, key: str, value: Any) -> Self:
@@ -40,7 +41,7 @@ def set_key(self, key: str, value: Any) -> Self:
             parser = json.load(f)
 
         parser["commitizen"][key] = value
-        with smart_open(self.path, "w", encoding=self.encoding) as f:
+        with smart_open(self.path, "w", encoding=self._settings["encoding"]) as f:
             json.dump(parser, f, indent=2)
         return self
 

commitizen/config/toml_config.py

@@ -23,7 +23,6 @@
 class TomlConfig(BaseConfig):
     def __init__(self, *, data: bytes | str, path: Path | str) -> None:
         super().__init__()
-        self.is_empty_config = False
         self.path = path
         self._parse_setting(data)
 
@@ -38,7 +37,9 @@ def init_empty_config_content(self) -> None:
             if parser.get("tool") is None:
                 parser["tool"] = table()
             parser["tool"]["commitizen"] = table()  # type: ignore[index]
-            output_toml_file.write(parser.as_string().encode(self.encoding))
+            output_toml_file.write(
+                parser.as_string().encode(self._settings["encoding"])
+            )
 
     def set_key(self, key: str, value: Any) -> Self:
         """Set or update a key in the conf.
@@ -51,7 +52,7 @@ def set_key(self, key: str, value: Any) -> Self:
 
         parser["tool"]["commitizen"][key] = value  # type: ignore[index]
         with open(self.path, "wb") as f:
-            f.write(parser.as_string().encode(self.encoding))
+            f.write(parser.as_string().encode(self._settings["encoding"]))
         return self
 
     def _parse_setting(self, data: bytes | str) -> None:

commitizen/config/yaml_config.py

@@ -23,12 +23,13 @@
 class YAMLConfig(BaseConfig):
     def __init__(self, *, data: bytes | str, path: Path | str) -> None:
         super().__init__()
-        self.is_empty_config = False
         self.path = path
         self._parse_setting(data)
 
     def init_empty_config_content(self) -> None:
-        with smart_open(self.path, "a", encoding=self.encoding) as json_file:
+        with smart_open(
+            self.path, "a", encoding=self._settings["encoding"]
+        ) as json_file:
             yaml.dump({"commitizen": {}}, json_file, explicit_start=True)
 
     def _parse_setting(self, data: bytes | str) -> None:
@@ -61,7 +62,9 @@ def set_key(self, key: str, value: Any) -> Self:
             parser = yaml.load(yaml_file, Loader=yaml.FullLoader)
 
         parser["commitizen"][key] = value
-        with smart_open(self.path, "w", encoding=self.encoding) as yaml_file:
+        with smart_open(
+            self.path, "w", encoding=self._settings["encoding"]
+        ) as yaml_file:
             yaml.dump(parser, yaml_file, explicit_start=True)
 
         return self