refactor(SemVerIncrement): use IntEnum

Author: bearomorphism

commitizen/bump_rule.py

@@ -1,41 +1,41 @@
 from __future__ import annotations
 
 import re
-from collections.abc import Iterable
-from enum import Enum, auto
+from collections.abc import Iterable, Mapping
+from enum import IntEnum, auto
 from functools import cached_property
-from typing import Any, Callable, Protocol
+from typing import Callable, Protocol
 
 from commitizen.exceptions import NoPatternMapError
 
 
-class SemVerIncrement(Enum):
+class SemVerIncrement(IntEnum):
     """An enumeration representing semantic versioning increments.
 
     This class defines the three types of version increments according to semantic versioning:
-    - MAJOR: For incompatible API changes
-    - MINOR: For backwards-compatible functionality additions
     - PATCH: For backwards-compatible bug fixes
+    - MINOR: For backwards-compatible functionality additions
+    - MAJOR: For incompatible API changes
     """
 
-    MAJOR = auto()
-    MINOR = auto()
     PATCH = auto()
+    MINOR = auto()
+    MAJOR = auto()
 
     def __str__(self) -> str:
         return self.name
 
     @classmethod
-    def safe_cast(cls, value: Any) -> SemVerIncrement | None:
-        if value is None:
+    def safe_cast(cls, value: object) -> SemVerIncrement | None:
+        if not isinstance(value, str):
             return None
         try:
             return cls[value]
         except KeyError:
             return None
 
     @classmethod
-    def safe_cast_dict(cls, d: dict[str, Any]) -> dict[str, SemVerIncrement]:
+    def safe_cast_dict(cls, d: Mapping[str, object]) -> dict[str, SemVerIncrement]:
         return {
             k: v
             for k, v in ((k, SemVerIncrement.safe_cast(v)) for k, v in d.items())
@@ -68,25 +68,17 @@ def get_highest_by_messages(
             >>> SemVerIncrement.get_highest_by_messages(commit_messages, lambda x: rule.get_increment(x, False))
             'MINOR'
         """
-        return _find_highest_increment(
+        return SemVerIncrement.get_highest(
             get_increment(line)
             for message in commit_messages
             for line in message.split("\n")
         )
 
-
-_VERSION_ORDERING = dict(
-    zip(
-        (None, SemVerIncrement.PATCH, SemVerIncrement.MINOR, SemVerIncrement.MAJOR),
-        range(4),
-    )
-)
-
-
-def _find_highest_increment(
-    increments: Iterable[SemVerIncrement | None],
-) -> SemVerIncrement | None:
-    return max(increments, key=lambda x: _VERSION_ORDERING[x], default=None)
+    @staticmethod
+    def get_highest(
+        increments: Iterable[SemVerIncrement | None],
+    ) -> SemVerIncrement | None:
+        return max(filter(None, increments), default=None)
 
 
 class BumpRule(Protocol):
@@ -193,8 +185,8 @@ def get_increment(
         )
 
         try:
-            if ret := _find_highest_increment(
-                (increment for name, increment in bump_map.items() if m.group(name))
+            if ret := SemVerIncrement.get_highest(
+                (increment for name, increment in bump_map.items() if m.group(name)),
             ):
                 return ret
         except IndexError:

tests/test_bump_rule.py

@@ -4,7 +4,6 @@
     ConventionalCommitBumpRule,
     CustomBumpRule,
     SemVerIncrement,
-    _find_highest_increment,
 )
 from commitizen.defaults import (
     BUMP_MAP,
@@ -589,104 +588,39 @@ def test_with_find_increment_by_callable(self, custom_bump_rule):
         )
 
 
-def test_find_highest_increment():
-    """Test the _find_highest_increment function."""
-    # Test with single increment
-    assert _find_highest_increment([SemVerIncrement.MAJOR]) == SemVerIncrement.MAJOR
-    assert _find_highest_increment([SemVerIncrement.MINOR]) == SemVerIncrement.MINOR
-    assert _find_highest_increment([SemVerIncrement.PATCH]) == SemVerIncrement.PATCH
-
-    # Test with multiple increments
-    assert (
-        _find_highest_increment(
-            [SemVerIncrement.PATCH, SemVerIncrement.MINOR, SemVerIncrement.MAJOR]
-        )
-        == SemVerIncrement.MAJOR
-    )
-    assert (
-        _find_highest_increment([SemVerIncrement.PATCH, SemVerIncrement.MINOR])
-        == SemVerIncrement.MINOR
-    )
-    assert (
-        _find_highest_increment([SemVerIncrement.PATCH, SemVerIncrement.PATCH])
-        == SemVerIncrement.PATCH
-    )
-
-    # Test with None values
-    assert (
-        _find_highest_increment([None, SemVerIncrement.PATCH]) == SemVerIncrement.PATCH
-    )
-    assert _find_highest_increment([None, None]) is None
-    assert _find_highest_increment([]) is None
-
-    # Test with mixed values
-    assert (
-        _find_highest_increment(
-            [None, SemVerIncrement.PATCH, SemVerIncrement.MINOR, SemVerIncrement.MAJOR]
-        )
-        == SemVerIncrement.MAJOR
-    )
-    assert (
-        _find_highest_increment([None, SemVerIncrement.PATCH, SemVerIncrement.MINOR])
-        == SemVerIncrement.MINOR
-    )
-    assert (
-        _find_highest_increment([None, SemVerIncrement.PATCH]) == SemVerIncrement.PATCH
-    )
-
-    # Test with empty iterator
-    assert _find_highest_increment(iter([])) is None
-
-    # Test with generator expression
-    assert (
-        _find_highest_increment(
-            x
-            for x in [
-                SemVerIncrement.PATCH,
-                SemVerIncrement.MINOR,
-                SemVerIncrement.MAJOR,
-            ]
-        )
-        == SemVerIncrement.MAJOR
-    )
-    assert (
-        _find_highest_increment(
-            x for x in [None, SemVerIncrement.PATCH, SemVerIncrement.MINOR]
-        )
-        == SemVerIncrement.MINOR
-    )
-
-
-class TestSemVerIncrementSafeCast:
-    def test_safe_cast_valid_values(self):
-        """Test safe_cast with valid enum values."""
-        assert SemVerIncrement.safe_cast("MAJOR") == SemVerIncrement.MAJOR
-        assert SemVerIncrement.safe_cast("MINOR") == SemVerIncrement.MINOR
-        assert SemVerIncrement.safe_cast("PATCH") == SemVerIncrement.PATCH
-
-    def test_safe_cast_invalid_values(self):
-        """Test safe_cast with invalid values."""
-        assert SemVerIncrement.safe_cast("INVALID") is None
-        assert SemVerIncrement.safe_cast("") is None
-        assert SemVerIncrement.safe_cast(123) is None
-        assert SemVerIncrement.safe_cast(None) is None
-
-    def test_safe_cast_dict(self):
-        """Test safe_cast_dict method."""
-        test_dict = {
-            "MAJOR": "MAJOR",
-            "MINOR": "MINOR",
-            "PATCH": "PATCH",
-            "INVALID": "INVALID",
-            "empty": "",
-            "number": 123,
-            "none": None,
-        }
+class TestGetHighest:
+    def test_get_highest_with_major(self):
+        increments = [
+            SemVerIncrement.PATCH,
+            SemVerIncrement.MINOR,
+            SemVerIncrement.MAJOR,
+        ]
+        assert SemVerIncrement.get_highest(increments) == SemVerIncrement.MAJOR
 
-        expected_dict = {
-            "MAJOR": SemVerIncrement.MAJOR,
-            "MINOR": SemVerIncrement.MINOR,
-            "PATCH": SemVerIncrement.PATCH,
-        }
+    def test_get_highest_with_minor(self):
+        increments = [SemVerIncrement.PATCH, SemVerIncrement.MINOR, None]
+        assert SemVerIncrement.get_highest(increments) == SemVerIncrement.MINOR
+
+    def test_get_highest_with_patch(self):
+        increments = [SemVerIncrement.PATCH, None, None]
+        assert SemVerIncrement.get_highest(increments) == SemVerIncrement.PATCH
+
+    def test_get_highest_with_none(self):
+        increments = [None, None, None]
+        assert SemVerIncrement.get_highest(increments) is None
+
+    def test_get_highest_empty(self):
+        increments = []
+        assert SemVerIncrement.get_highest(increments) is None
+
+    def test_get_highest_mixed_order(self):
+        increments = [
+            SemVerIncrement.MAJOR,
+            SemVerIncrement.PATCH,
+            SemVerIncrement.MINOR,
+        ]
+        assert SemVerIncrement.get_highest(increments) == SemVerIncrement.MAJOR
 
-        assert SemVerIncrement.safe_cast_dict(test_dict) == expected_dict
+    def test_get_highest_with_none_values(self):
+        increments = [None, SemVerIncrement.MINOR, None, SemVerIncrement.PATCH]
+        assert SemVerIncrement.get_highest(increments) == SemVerIncrement.MINOR