codesorter 0.2.0__tar.gz → 0.2.2__tar.gz

{codesorter-0.2.0 → codesorter-0.2.2}/CHANGES.rst

@@ -4,6 +4,28 @@
 
 codesorter follows `semantic versioning <https://semver.org/>`_.
 
+********************
+ 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.
+
+********************
+ 0.2.1 (2026/06/14)
+********************
+
+**Fixed**
+
+- Treat a name used inside a module- or class-level comprehension as a real dependency.
+  Such a comprehension runs eagerly when the definition executes, so an assignment like
+  ``values = {key: build(key) for key in keys}`` now sorts after the ``build`` function
+  it calls instead of ahead of it (which raised ``NameError``). A comprehension inside a
+  function body stays deferred and still imposes no ordering.
+
 ********************
  0.2.0 (2026/06/14)
 ********************

{codesorter-0.2.0 → codesorter-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codesorter
-Version: 0.2.0
+Version: 0.2.2
 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.0 → codesorter-0.2.2}/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.0 → codesorter-0.2.2}/codesorter/const.py

@@ -39,4 +39,4 @@ PLAIN_DECORATOR_PARTS = 1
 
 PROPERTY_DECORATOR_PARTS = 2
 
-__version__ = "0.2.0"
+__version__ = "0.2.2"

{codesorter-0.2.0 → codesorter-0.2.2}/codesorter/sort_code.py

@@ -294,9 +294,14 @@ class SortCodeCommand(VisitorBasedCodemodCommand, m.MatcherDecoratableTransforme
         if isinstance(meta, (md.ClassScope, md.GlobalScope)):
 
             def _outer_scope(scope: object) -> bool:
-                return isinstance(scope, (md.ClassScope, md.GlobalScope)) or (
-                    isinstance(scope, md.ClassScope) and scope.parent != meta
-                )
+                # A comprehension at module or class level runs eagerly when the
+                # definition executes, so a name used inside it is a real dependency.
+                # Walk out through any comprehension scopes; a function scope in the
+                # chain means the reference is deferred (a lambda or method body) and is
+                # not a definition-time dependency.
+                while isinstance(scope, md.ComprehensionScope):
+                    scope = scope.parent
+                return isinstance(scope, (md.ClassScope, md.GlobalScope))
 
             for found in self.extractall(
                 node,

codesorter-0.2.2/tests/test_files/comprehension_dependency_input.py

@@ -0,0 +1,13 @@
+"""A module-level comprehension references a function eagerly, so it depends on it."""
+
+placeholders = {name: build(name) for name in ["a", "b"]}
+
+
+def build(name):
+    """Used eagerly by the module-level comprehension above."""
+    return f"value-{name}"
+
+
+def lazy():
+    """A comprehension here is deferred, so it imposes no ordering."""
+    return [build(name) for name in ["c", "d"]]

codesorter-0.2.2/tests/test_files/comprehension_dependency_output.py

@@ -0,0 +1,13 @@
+"""A module-level comprehension references a function eagerly, so it depends on it."""
+
+def build(name):
+    """Used eagerly by the module-level comprehension above."""
+    return f"value-{name}"
+
+
+placeholders = {name: build(name) for name in ["a", "b"]}
+
+
+def lazy():
+    """A comprehension here is deferred, so it imposes no ordering."""
+    return [build(name) for name in ["c", "d"]]

{codesorter-0.2.0 → codesorter-0.2.2}/tests/test_sort_code.py

@@ -116,6 +116,22 @@ class MyClass:
         except SyntaxError as e:
             pytest.fail(f"Codemod produced invalid Python syntax: {e}")
 
+    def test_comprehension_dependency(self, test_files):
+        """Test that a name used in a module-level comprehension is a real dependency.
+
+        A module-level comprehension runs eagerly when the module executes, so an
+        assignment built from one must follow the function it calls (the reference lives
+        in a comprehension scope, which previously hid the dependency). A comprehension
+        inside a function body stays deferred and imposes no ordering.
+
+        """
+        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_comprehensive(self, test_files):
         """Test comprehensive scenario with pytest fixtures, custom decorators, inheritance, and global dependencies."""
         input_code, expected_code = test_files