[sdk/kde-builder] /: refactor: Unwrap _compare_build_order_depends() function

Git commit e87d07bd8509e24460d74b2fa482615a4a66461d by Andrew Shark.
Committed on 31/07/2026 at 23:12.
Pushed by ashark into branch 'master'.

refactor: Unwrap _compare_build_order_depends() function

M  +35   -38   kde_builder_lib/dependency_resolver.py
M  +17   -17   tests/unit/dependency-resolver/test_compare-build-order.py

https://invent.kde.org/sdk/kde-builder/-/commit/e87d07bd8509e24460d74b2fa482615a4a66461d

diff --git a/kde_builder_lib/dependency_resolver.py b/kde_builder_lib/dependency_resolver.py
index 02da7650..efa5fca7 100644
--- a/kde_builder_lib/dependency_resolver.py
+++ b/kde_builder_lib/dependency_resolver.py
@@ -622,62 +622,59 @@ class DependencyResolver:
             self._descend_module_graph(mode, info, context)
             item_index += 1
 
-    def make_comparison_func(self) -> Callable:
+    def _compare_build_order_depends(self, a, b):
         module_graph = self.dependency_graph
 
-        def _compare_build_order_depends(a, b):
-            # comparison results uses:
-            # -1 if a < b
-            # 0 if a == b
-            # 1 if a > b
+        # comparison results uses:
+        # -1 if a < b
+        # 0 if a == b
+        # 1 if a > b
 
-            a_votes = module_graph[a]["votes"]
-            b_votes = module_graph[b]["votes"]
+        a_votes = module_graph[a]["votes"]
+        b_votes = module_graph[b]["votes"]
 
-            # Enforce a strict dependency ordering.
-            # The case where both are true should never happen, since that would
-            # amount to a cycle, and cycle detection is supposed to have been
-            # performed beforehand.
+        # Enforce a strict dependency ordering.
+        # The case where both are true should never happen, since that would
+        # amount to a cycle, and cycle detection is supposed to have been
+        # performed beforehand.
 
-            b_depends_on_a = a_votes.get(b, 0)
-            a_depends_on_b = b_votes.get(a, 0)
-            order = -1 if b_depends_on_a else (1 if a_depends_on_b else 0)
+        b_depends_on_a = a_votes.get(b, 0)
+        a_depends_on_b = b_votes.get(a, 0)
+        order = -1 if b_depends_on_a else (1 if a_depends_on_b else 0)
 
-            if order:
-                return order
+        if order:
+            return order
 
-            # Assuming no dependency relation, next sort by "popularity":
-            # the item with the most votes (back edges) is depended on the most
-            # so it is probably a good idea to build that one earlier to help
-            # maximise the duration of time for which builds can be run in parallel
+        # Assuming no dependency relation, next sort by "popularity":
+        # the item with the most votes (back edges) is depended on the most
+        # so it is probably a good idea to build that one earlier to help
+        # maximise the duration of time for which builds can be run in parallel
 
-            votes = len(b_votes) - len(a_votes)
+        votes = len(b_votes) - len(a_votes)
 
-            if votes:
-                return votes
+        if votes:
+            return votes
 
-            # If there is no good reason to prefer one module over another,
-            # simply sort by the order contained within the configuration file (if
-            # present), which would be setup as the rc-file is read.
+        # If there is no good reason to prefer one module over another,
+        # simply sort by the order contained within the configuration file (if
+        # present), which would be setup as the rc-file is read.
 
-            a_rc_order: int = module_graph[a]["module"].create_id
-            b_rc_order: int = module_graph[b]["module"].create_id
-            config_order = (a_rc_order > b_rc_order) - (a_rc_order < b_rc_order)
+        a_rc_order: int = module_graph[a]["module"].create_id
+        b_rc_order: int = module_graph[b]["module"].create_id
+        config_order = (a_rc_order > b_rc_order) - (a_rc_order < b_rc_order)
 
-            if config_order:
-                return config_order
+        if config_order:
+            return config_order
 
-            # If the rc-file is not present then sort by name to ensure a reproducible
-            # build order that isn't influenced by randomization of the runtime.
-            return (a > b) - (a < b)
-
-        return _compare_build_order_depends
+        # If the rc-file is not present then sort by name to ensure a reproducible
+        # build order that isn't influenced by randomization of the runtime.
+        return (a > b) - (a < b)
 
     def sort_modules_into_build_order(self) -> list[Module]:
         module_graph = self.dependency_graph
         resolved = list(module_graph.keys())
         built = [el for el in resolved if module_graph[el]["build"] and module_graph[el]["module"]]
-        prioritised = sorted(built, key=cmp_to_key(self.make_comparison_func()))
+        prioritised = sorted(built, key=cmp_to_key(self._compare_build_order_depends))
         modules = [module_graph[key]["module"] for key in prioritised]
         return modules
 
diff --git a/tests/unit/dependency-resolver/test_compare-build-order.py b/tests/unit/dependency-resolver/test_compare-build-order.py
index a9483176..ddf505f9 100644
--- a/tests/unit/dependency-resolver/test_compare-build-order.py
+++ b/tests/unit/dependency-resolver/test_compare-build-order.py
@@ -69,30 +69,30 @@ def test_comparison(mock_module_from_attrs):
     # test one pair of these tests now that the test matrix is growing.
     for left in ["a", "b", "c", "d", "e", "f"]:
         for right in ["a", "b", "c", "d", "e", "f"]:
-            res = dr.make_comparison_func()(left, right)
+            res = dr._compare_build_order_depends(left, right)
 
             if left == right:
                 assert res == 0, f"\"{left}\" should be sorted at the same position as itself"
             else:
                 assert abs(res) == 1, f"Different module items (\"{left}\" and \"{right}\") compare to 1 or -1 (but not 0)"
-                assert dr.make_comparison_func()(right, left) == -res, f"Swapping order of operands should negate the result (\"{right}\" vs \"{left}\")"
+                assert dr._compare_build_order_depends(right, left) == -res, f"Swapping order of operands should negate the result (\"{right}\" vs \"{left}\")"
 
-    assert dr.make_comparison_func()("a", "b") == -1, "\"a\" should be sorted before \"b\" by dependency ordering"
-    assert dr.make_comparison_func()("a", "c") == -1, "\"a\" should be sorted before \"c\" by vote ordering"
-    assert dr.make_comparison_func()("a", "d") == -1, "\"a\" should be sorted before \"d\" by dependency ordering"
-    assert dr.make_comparison_func()("a", "e") == -1, "\"a\" should be sorted before \"e\" by lexicographic ordering"
-    assert dr.make_comparison_func()("a", "f") == -1, "\"a\" should be sorted before \"f\" by lexicographic ordering"
+    assert dr._compare_build_order_depends("a", "b") == -1, "\"a\" should be sorted before \"b\" by dependency ordering"
+    assert dr._compare_build_order_depends("a", "c") == -1, "\"a\" should be sorted before \"c\" by vote ordering"
+    assert dr._compare_build_order_depends("a", "d") == -1, "\"a\" should be sorted before \"d\" by dependency ordering"
+    assert dr._compare_build_order_depends("a", "e") == -1, "\"a\" should be sorted before \"e\" by lexicographic ordering"
+    assert dr._compare_build_order_depends("a", "f") == -1, "\"a\" should be sorted before \"f\" by lexicographic ordering"
 
-    assert dr.make_comparison_func()("b", "c") == 1, "\"b\" should be sorted after \"c\" by vote ordering"
-    assert dr.make_comparison_func()("b", "d") == -1, "\"b\" should be sorted before \"d\" by lexicographic ordering"
-    assert dr.make_comparison_func()("b", "e") == 1, "\"b\" should be sorted after \"e\" by dependency ordering"
-    assert dr.make_comparison_func()("b", "f") == 1, "\"b\" should be sorted after \"f\" by dependency ordering"
+    assert dr._compare_build_order_depends("b", "c") == 1, "\"b\" should be sorted after \"c\" by vote ordering"
+    assert dr._compare_build_order_depends("b", "d") == -1, "\"b\" should be sorted before \"d\" by lexicographic ordering"
+    assert dr._compare_build_order_depends("b", "e") == 1, "\"b\" should be sorted after \"e\" by dependency ordering"
+    assert dr._compare_build_order_depends("b", "f") == 1, "\"b\" should be sorted after \"f\" by dependency ordering"
 
-    assert dr.make_comparison_func()("c", "d") == -1, "\"c\" should be sorted before \"d\" by dependency ordering"
-    assert dr.make_comparison_func()("c", "e") == 1, "\"c\" should be sorted after \"e\" by vote ordering"
-    assert dr.make_comparison_func()("c", "f") == 1, "\"c\" should be sorted after \"f\" by vote ordering"
+    assert dr._compare_build_order_depends("c", "d") == -1, "\"c\" should be sorted before \"d\" by dependency ordering"
+    assert dr._compare_build_order_depends("c", "e") == 1, "\"c\" should be sorted after \"e\" by vote ordering"
+    assert dr._compare_build_order_depends("c", "f") == 1, "\"c\" should be sorted after \"f\" by vote ordering"
 
-    assert dr.make_comparison_func()("d", "e") == 1, "\"d\" should be sorted after \"e\" by dependency ordering"
-    assert dr.make_comparison_func()("d", "f") == 1, "\"d\" should be sorted after \"f\" by dependency ordering"
+    assert dr._compare_build_order_depends("d", "e") == 1, "\"d\" should be sorted after \"e\" by dependency ordering"
+    assert dr._compare_build_order_depends("d", "f") == 1, "\"d\" should be sorted after \"f\" by dependency ordering"
 
-    assert dr.make_comparison_func()("e", "f") == 1, "\"e\" should be sorted after \"f\" by rc-file ordering"
+    assert dr._compare_build_order_depends("e", "f") == 1, "\"e\" should be sorted after \"f\" by rc-file ordering"