Redo sorting of files to ensure most interesting files come first

Author: ewjoachim

coverage_comment/template.py

@@ -108,14 +108,6 @@ class FileInfo:
     diff: coverage_module.FileDiffCoverage | None
     previous: coverage_module.FileCoverage | None
 
-    @property
-    def new_missing_lines(self) -> list[int]:
-        missing_lines = set(self.coverage.missing_lines)
-        if self.previous:
-            missing_lines -= set(self.previous.missing_lines)
-
-        return sorted(missing_lines)
-
 
 def get_comment_markdown(
     *,
@@ -220,12 +212,31 @@ def select_files(
             files.append(file_info)
 
     count_files = len(files)
-    files = sorted(files, key=lambda x: len(x.new_missing_lines), reverse=True)
+    files = sorted(files, key=sort_order, reverse=True)
     if max_files is not None:
         files = files[:max_files]
     return sorted(files, key=lambda x: x.path), count_files
 
 
+def sort_order(file_info: FileInfo) -> tuple[int, int, int]:
+    """
+    Sort order for files:
+    1. Files with the most new missing lines
+    2. Files with the most added lines (from the diff)
+    3. Files with the most new executed lines (including not in the diff)
+    """
+    new_missing_lines = len(file_info.coverage.missing_lines)
+    if file_info.previous:
+        new_missing_lines -= len(file_info.previous.missing_lines)
+
+    added_statements = len(file_info.diff.added_statements) if file_info.diff else 0
+    new_covered_lines = len(file_info.coverage.executed_lines)
+    if file_info.previous:
+        new_covered_lines -= len(file_info.previous.executed_lines)
+
+    return abs(new_missing_lines), added_statements, abs(new_covered_lines)
+
+
 def get_readme_markdown(
     is_public: bool,
     readme_url: str,

tests/unit/test_template.py

@@ -639,6 +639,30 @@ def test_get_marker(marker_id, result):
             3,
             id="truncated_and_ordered",
         ),
+        pytest.param(
+            """
+            # file: a.py
+            1 covered
+            # file: c.py
+            1 covered
+            # file: b.py
+            1 covered
+            """,
+            """
+            # file: a.py
+            1
+            2 covered
+            # file: c.py
+            + 1 covered
+            # file: b.py
+            1 covered
+            1 covered
+            """,
+            2,
+            ["b.py", "c.py"],
+            2,
+            id="truncated_and_ordered_sort_order_advanced",
+        ),
         pytest.param(
             """
             # file: a.py
@@ -703,6 +727,90 @@ def test_select_files__no_previous(
     assert total == 1
 
 
+@pytest.mark.parametrize(
+    "previous_code, current_code_and_diff, expected_new_missing, expected_added, expected_new_covered",
+    [
+        pytest.param(
+            """
+            # file: a.py
+            1 covered
+            2 missing
+            """,
+            """
+            # file: a.py
+            + 1
+            2 covered
+            + 3 missing
+            + 4 missing
+            + 5 covered
+            """,
+            1,
+            3,
+            1,
+            id="added_code",
+        ),
+        pytest.param(
+            """
+            # file: a.py
+            1 covered
+            2 missing
+            3 covered
+            4 missing
+            """,
+            """
+            # file: a.py
+            + 1 missing
+            """,
+            1,
+            1,
+            2,
+            id="removed_code",
+        ),
+    ],
+)
+def test_sort_order(
+    make_coverage_and_diff,
+    make_coverage,
+    previous_code,
+    current_code_and_diff,
+    expected_new_missing,
+    expected_added,
+    expected_new_covered,
+):
+    previous_cov = make_coverage(previous_code)
+    cov, diff_cov = make_coverage_and_diff(current_code_and_diff)
+    path = pathlib.Path("a.py")
+    file_info = template.FileInfo(
+        path=path,
+        coverage=cov.files[path],
+        diff=diff_cov.files[path],
+        previous=previous_cov.files[path],
+    )
+    new_missing, added, new_covered = template.sort_order(file_info=file_info)
+    assert new_missing == expected_new_missing
+    assert added == expected_added
+    assert new_covered == expected_new_covered
+
+
+def test_sort_order__none(make_coverage):
+    cov = make_coverage(
+        """
+        # file: a.py
+        1 covered
+        """
+    )
+    file_info = template.FileInfo(
+        path=pathlib.Path("a.py"),
+        coverage=cov.files[pathlib.Path("a.py")],
+        diff=None,
+        previous=None,
+    )
+    new_missing, added, new_covered = template.sort_order(file_info=file_info)
+    assert new_missing == 0
+    assert added == 0
+    assert new_covered == 1
+
+
 def test_get_readme_markdown():
     result = template.get_readme_markdown(
         is_public=True,