refactor(changelog): better typing, yield

bearomorphism · Lee-W · commit baee83e2bdca · 2025-06-08T16:23:13.000+08:00
diff --git a/commitizen/changelog.py b/commitizen/changelog.py
@@ -29,10 +29,10 @@
 
 import re
 from collections import OrderedDict, defaultdict
-from collections.abc import Iterable
+from collections.abc import Generator, Iterable, Mapping
 from dataclasses import dataclass
 from datetime import date
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 from jinja2 import (
     BaseLoader,
@@ -84,7 +84,7 @@ def generate_tree_from_commits(
     changelog_message_builder_hook: MessageBuilderHook | None = None,
     changelog_release_hook: ChangelogReleaseHook | None = None,
     rules: TagRules | None = None,
-) -> Iterable[dict]:
+) -> Generator[dict[str, Any], None, None]:
     pat = re.compile(changelog_pattern)
     map_pat = re.compile(commit_parser, re.MULTILINE)
     body_map_pat = re.compile(commit_parser, re.MULTILINE | re.DOTALL)
@@ -187,24 +187,27 @@ def process_commit_message(
             changes[change_type].append(msg)
 
 
-def order_changelog_tree(tree: Iterable, change_type_order: list[str]) -> Iterable:
+def generate_ordered_changelog_tree(
+    tree: Iterable[Mapping[str, Any]], change_type_order: list[str]
+) -> Generator[dict[str, Any], None, None]:
     if len(set(change_type_order)) != len(change_type_order):
         raise InvalidConfigurationError(
             f"Change types contain duplicated types ({change_type_order})"
         )
 
-    sorted_tree = []
     for entry in tree:
-        ordered_change_types = change_type_order + sorted(
-            set(entry["changes"].keys()) - set(change_type_order)
-        )
-        changes = [
-            (ct, entry["changes"][ct])
-            for ct in ordered_change_types
-            if ct in entry["changes"]
-        ]
-        sorted_tree.append({**entry, **{"changes": OrderedDict(changes)}})
-    return sorted_tree
+        yield {
+            **entry,
+            "changes": _calculate_sorted_changes(change_type_order, entry["changes"]),
+        }
+
+
+def _calculate_sorted_changes(
+    change_type_order: list[str], changes: Mapping[str, Any]
+) -> OrderedDict[str, Any]:
+    remaining_change_types = set(changes.keys()) - set(change_type_order)
+    sorted_change_types = change_type_order + sorted(remaining_change_types)
+    return OrderedDict((ct, changes[ct]) for ct in sorted_change_types if ct in changes)
 
 
 def get_changelog_template(loader: BaseLoader, template: str) -> Template:
diff --git a/commitizen/commands/changelog.py b/commitizen/commands/changelog.py
@@ -215,7 +215,9 @@ def __call__(self):
             rules=self.tag_rules,
         )
         if self.change_type_order:
-            tree = changelog.order_changelog_tree(tree, self.change_type_order)
+            tree = changelog.generate_ordered_changelog_tree(
+                tree, self.change_type_order
+            )
 
         extras = self.cz.template_extras.copy()
         extras.update(self.config.settings["extras"])
diff --git a/tests/test_changelog.py b/tests/test_changelog.py
@@ -1215,26 +1215,26 @@ def test_generate_tree_from_commits_with_no_commits(tags):
         ),
     ),
 )
-def test_order_changelog_tree(change_type_order, expected_reordering):
-    tree = changelog.order_changelog_tree(COMMITS_TREE, change_type_order)
+def test_generate_ordered_changelog_tree(change_type_order, expected_reordering):
+    tree = changelog.generate_ordered_changelog_tree(COMMITS_TREE, change_type_order)
 
     for index, entry in enumerate(tuple(tree)):
-        version = tree[index]["version"]
+        version = entry["version"]
         if version in expected_reordering:
             # Verify that all keys are present
-            assert [*tree[index].keys()] == [*COMMITS_TREE[index].keys()]
+            assert [*entry.keys()] == [*COMMITS_TREE[index].keys()]
             # Verify that the reorder only impacted the returned dict and not the original
             expected = expected_reordering[version]
-            assert [*tree[index]["changes"].keys()] == expected["sorted"]
+            assert [*entry["changes"].keys()] == expected["sorted"]
             assert [*COMMITS_TREE[index]["changes"].keys()] == expected["original"]
         else:
-            assert [*entry["changes"].keys()] == [*tree[index]["changes"].keys()]
+            assert [*entry["changes"].keys()] == [*entry["changes"].keys()]
 
 
-def test_order_changelog_tree_raises():
+def test_generate_ordered_changelog_tree_raises():
     change_type_order = ["BREAKING CHANGE", "feat", "refactor", "feat"]
     with pytest.raises(InvalidConfigurationError) as excinfo:
-        changelog.order_changelog_tree(COMMITS_TREE, change_type_order)
+        list(changelog.generate_ordered_changelog_tree(COMMITS_TREE, change_type_order))
 
     assert "Change types contain duplicated types" in str(excinfo)
 
