codesorter 0.2.1__tar.gz → 0.2.3__tar.gz

{codesorter-0.2.1 → codesorter-0.2.3}/CHANGES.rst

@@ -4,6 +4,29 @@
 
 codesorter follows `semantic versioning <https://semver.org/>`_.
 
+********************
+ 0.2.3 (2026/06/14)
+********************
+
+********************
+ 0.2.2 (2026/06/14)
+********************
+
+**Changed**
+
+- Format reordered files with ``ruff`` by default instead of ``black``, so a downstream
+  project no longer needs a ``.libcst.codemod.yaml`` to use the ``codesorter`` CLI or
+  pre-commit hook. ``ruff`` must be importable on the ``PATH`` when sorting.
+
+**Fixed**
+
+- Keep an assignment that rebinds a name also bound by a sibling in its original
+  position relative to that sibling. For example ``ten = cachedproperty(ten, ...)``
+  following ``def ten`` now stays after the method it wraps instead of being hoisted
+  ahead of it (which raised ``NameError`` and changed which binding wins). Property
+  getter/setter/deleter groups, which carry no assignment, are still ordered by their
+  sort key.
+
 ********************
  0.2.1 (2026/06/14)
 ********************

{codesorter-0.2.1 → codesorter-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codesorter
-Version: 0.2.1
+Version: 0.2.3
 Summary: A Python codemod that sorts and organizes code in your files.
 Project-URL: Change Log, https://codesorter.readthedocs.io/en/latest/package_info/change_log.html
 Project-URL: Documentation, https://codesorter.readthedocs.io/

{codesorter-0.2.1 → codesorter-0.2.3}/codesorter/cli.py

@@ -8,9 +8,8 @@ from pathlib import Path
 from typing import TYPE_CHECKING
 
 import libcst as cst
-import libcst.tool
 import pathspec
-from libcst.codemod import CodemodContext
+from libcst.codemod import CodemodContext, parallel_exec_transform_with_prettyprint
 
 from codesorter.const import DEFAULT_EXCLUDES
 from codesorter.sort_code import SortCodeCommand
@@ -208,20 +207,20 @@ def main(*, argv: list[str] | None = None) -> None:
     if args.check:
         sys.exit(_check_files(files=files))
 
-    cst_argv = [
-        "codemod",
-        "-x",
-        "codesorter.sort_code.SortCodeCommand",
-        *files,
-    ]
-
-    if args.unified_diff:
-        cst_argv.append("--unified-diff")
-
-    if args.show_successes:
-        cst_argv.append("--show-successes")
-
-    if args.jobs is not None:
-        cst_argv.extend(["--jobs", str(args.jobs)])
-
-    sys.exit(libcst.tool.main("codesorter", cst_argv))
+    # Format with ruff so downstream projects need no ``.libcst.codemod.yaml`` (the
+    # libcst codemod tool would otherwise default to black).
+    result = parallel_exec_transform_with_prettyprint(
+        SortCodeCommand,
+        files,
+        format_code=True,
+        formatter_args=["ruff", "format", "-"],
+        jobs=args.jobs,
+        repo_root=".",
+        show_successes=args.show_successes,
+        unified_diff=5 if args.unified_diff else None,
+    )
+    sys.stderr.write(f"Finished codemodding {result.successes + result.skips + result.failures} files!\n")
+    sys.stderr.write(f" - Transformed {result.successes} files successfully.\n")
+    sys.stderr.write(f" - Skipped {result.skips} files.\n")
+    sys.stderr.write(f" - Failed to codemod {result.failures} files.\n")
+    sys.exit(1 if result.failures > 0 else 0)

{codesorter-0.2.1 → codesorter-0.2.3}/codesorter/const.py

@@ -39,4 +39,4 @@ PLAIN_DECORATOR_PARTS = 1
 
 PROPERTY_DECORATOR_PARTS = 2
 
-__version__ = "0.2.1"
+__version__ = "0.2.3"

{codesorter-0.2.1 → codesorter-0.2.3}/codesorter/sort_code.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import enum
 import heapq
+import itertools
 from collections import defaultdict
 from enum import auto
 from typing import TYPE_CHECKING, Protocol, TypeAlias, TypeVar, cast
@@ -272,12 +273,27 @@ class SortCodeCommand(VisitorBasedCodemodCommand, m.MatcherDecoratableTransforme
             name_to_indexes[_sortable_name(item)].append(index)
         dependents: list[set[int]] = [set() for _ in items]
         indegree = [0] * len(items)
+
+        def _add_edge(earlier: int, later: int) -> None:
+            if earlier != later and later not in dependents[earlier]:
+                dependents[earlier].add(later)
+                indegree[later] += 1
+
         for index, item in enumerate(items):
             for dependency in self.dependencies.get(_sortable_name(item), ()):
                 for dependency_index in name_to_indexes.get(dependency, ()):
-                    if dependency_index != index and index not in dependents[dependency_index]:
-                        dependents[dependency_index].add(index)
-                        indegree[index] += 1
+                    _add_edge(dependency_index, index)
+        # An assignment that rebinds a name also bound by a sibling (for example
+        # ``def x`` followed by ``x = wraps(x)``) must keep its original position, since
+        # the later binding wins at runtime and may reference the earlier one. Groups of
+        # same-named methods (property getter/setter/deleter) are excluded — they carry
+        # no assignment and are ordered safely by their sort key.
+        for indexes in name_to_indexes.values():
+            for earlier, later in itertools.pairwise(indexes):
+                if isinstance(items[earlier], cst.SimpleStatementLine) or isinstance(
+                    items[later], cst.SimpleStatementLine
+                ):
+                    _add_edge(earlier, later)
         return dependents, indegree
 
     def _get_dependencies(  # noqa: C901

codesorter-0.2.3/tests/test_files/name_rebinding_input.py

@@ -0,0 +1,16 @@
+"""An assignment that rebinds a method name stays after the method it wraps."""
+
+
+class Klass:
+    def ten(self):
+        return 10
+
+    ten = cachedproperty(ten, doc="Return 10.")
+
+    def alpha(self):
+        """A method that sorts first alphabetically."""
+        return 1
+
+    def beta(self):
+        """A plain method."""
+        return 2

codesorter-0.2.3/tests/test_files/name_rebinding_output.py

@@ -0,0 +1,16 @@
+"""An assignment that rebinds a method name stays after the method it wraps."""
+
+
+class Klass:
+    def alpha(self):
+        """A method that sorts first alphabetically."""
+        return 1
+
+    def beta(self):
+        """A plain method."""
+        return 2
+
+    def ten(self):
+        return 10
+
+    ten = cachedproperty(ten, doc="Return 10.")

{codesorter-0.2.1 → codesorter-0.2.3}/tests/test_sort_code.py

@@ -217,6 +217,23 @@ from pathlib import Path
         assert "import sys" in result.code
         assert "from pathlib import Path" in result.code
 
+    def test_name_rebinding(self, test_files):
+        """Test that an assignment rebinding a method name stays after that method.
+
+        ``ten = cachedproperty(ten, ...)`` binds the same name as the ``def ten`` above
+        it and wraps that method, so the assignment must keep its position after the
+        method (moving it ahead would raise ``NameError`` and change which binding
+        wins). Property getter/setter/deleter groups are unaffected — they carry no
+        assignment.
+
+        """
+        input_code, expected_code = test_files
+        context = CodemodContext()
+        command = SortCodeCommand(context)
+        result = command.transform_module(cst.parse_module(input_code))
+
+        assert expected_code == result.code
+
     def test_order_sensitive(self, test_files):
         """Test that enum, dataclass, and named-tuple member order is preserved."""
         input_code, expected_code = test_files