refactor(cargo_provider): cleanup and get rid of potential type errors

Author: bearomorphism

commitizen/providers/cargo_provider.py

@@ -2,20 +2,16 @@
 
 import fnmatch
 import glob
+from collections.abc import Container
 from pathlib import Path
 
-import tomlkit
+from tomlkit import TOMLDocument, dumps, parse
+from tomlkit.exceptions import NonExistentKey
+from tomlkit.items import AoT
 
 from commitizen.providers.base_provider import TomlProvider
 
 
-def matches_exclude(path: str, exclude_patterns: list[str]) -> bool:
-    for pattern in exclude_patterns:
-        if fnmatch.fnmatch(path, pattern):
-            return True
-    return False
-
-
 class CargoProvider(TomlProvider):
     """
     Cargo version management
@@ -30,65 +26,71 @@ class CargoProvider(TomlProvider):
     def lock_file(self) -> Path:
         return Path() / self.lock_filename
 
-    def get(self, document: tomlkit.TOMLDocument) -> str:
-        # If there is a root package, change its version (but not the workspace version)
-        try:
-            return document["package"]["version"]  # type: ignore[index,return-value]
-        # Else, bump the workspace version
-        except tomlkit.exceptions.NonExistentKey:
-            ...
-        return document["workspace"]["package"]["version"]  # type: ignore[index,return-value]
+    def get(self, document: TOMLDocument) -> str:
+        out = _try_get_workspace(document)["package"]["version"]  # type: ignore[index]
+        assert isinstance(out, str)
+        return out
 
-    def set(self, document: tomlkit.TOMLDocument, version: str) -> None:
-        try:
-            document["workspace"]["package"]["version"] = version  # type: ignore[index]
-            return
-        except tomlkit.exceptions.NonExistentKey:
-            ...
-        document["package"]["version"] = version  # type: ignore[index]
+    def set(self, document: TOMLDocument, version: str) -> None:
+        _try_get_workspace(document)["package"]["version"] = version  # type: ignore[index]
 
     def set_version(self, version: str) -> None:
         super().set_version(version)
         if self.lock_file.exists():
             self.set_lock_version(version)
 
     def set_lock_version(self, version: str) -> None:
-        cargo_toml_content = tomlkit.parse(self.file.read_text())
-        cargo_lock_content = tomlkit.parse(self.lock_file.read_text())
-        packages: tomlkit.items.AoT = cargo_lock_content["package"]  # type: ignore[assignment]
+        cargo_toml_content = parse(self.file.read_text())
+        cargo_lock_content = parse(self.lock_file.read_text())
+        packages = cargo_lock_content["package"]
+
+        assert isinstance(packages, AoT)
+
         try:
-            package_name = cargo_toml_content["package"]["name"]  # type: ignore[index]
+            cargo_package_name = cargo_toml_content["package"]["name"]  # type: ignore[index]
+            assert isinstance(cargo_package_name, str)
             for i, package in enumerate(packages):
-                if package["name"] == package_name:
+                if package["name"] == cargo_package_name:
                     cargo_lock_content["package"][i]["version"] = version  # type: ignore[index]
                     break
-        except tomlkit.exceptions.NonExistentKey:
-            workspace_members = cargo_toml_content.get("workspace", {}).get(
-                "members", []
-            )
-            excluded_workspace_members = cargo_toml_content.get("workspace", {}).get(
-                "exclude", []
-            )
-            members_inheriting = []
+        except NonExistentKey:
+            workspace = cargo_toml_content.get("workspace", {})
+            assert isinstance(workspace, dict)
+            workspace_members = workspace.get("members", [])
+            excluded_workspace_members = workspace.get("exclude", [])
+            members_inheriting: list[str] = []
 
             for member in workspace_members:
                 for path in glob.glob(member, recursive=True):
-                    if matches_exclude(path, excluded_workspace_members):
+                    if any(
+                        fnmatch.fnmatch(path, pattern)
+                        for pattern in excluded_workspace_members
+                    ):
                         continue
+
                     cargo_file = Path(path) / "Cargo.toml"
-                    cargo_toml_content = tomlkit.parse(cargo_file.read_text())
+                    package_content = parse(cargo_file.read_text()).get("package", {})
+                    assert isinstance(package_content, dict)
                     try:
-                        version_workspace = cargo_toml_content["package"]["version"][  # type: ignore[index]
-                            "workspace"
-                        ]
+                        version_workspace = package_content["version"]["workspace"]
                         if version_workspace is True:
-                            package_name = cargo_toml_content["package"]["name"]  # type: ignore[index]
+                            package_name = package_content["name"]
+                            assert isinstance(package_name, str)
                             members_inheriting.append(package_name)
-                    except tomlkit.exceptions.NonExistentKey:
-                        continue
+                    except NonExistentKey:
+                        pass
 
             for i, package in enumerate(packages):
                 if package["name"] in members_inheriting:
                     cargo_lock_content["package"][i]["version"] = version  # type: ignore[index]
 
-        self.lock_file.write_text(tomlkit.dumps(cargo_lock_content))
+        self.lock_file.write_text(dumps(cargo_lock_content))
+
+
+def _try_get_workspace(document: TOMLDocument) -> Container:
+    try:
+        workspace = document["workspace"]
+        assert isinstance(workspace, Container)
+        return workspace
+    except NonExistentKey:
+        return document