codesorter 0.2.3__tar.gz → 0.2.5__tar.gz

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

@@ -5,18 +5,31 @@
 codesorter follows `semantic versioning <https://semver.org/>`_.
 
 ********************
- 0.2.3 (2026/06/14)
+ 0.2.5 (2026/06/14)
 ********************
 
+**Changed**
+
+- Depend on ``ruff`` directly so the formatter is always installed alongside
+  ``codesorter``. The CLI shells out to ``ruff format``, which previously only worked
+  when ``ruff`` happened to be on ``PATH`` from another source; it is now a runtime
+  dependency, so ``codesorter`` is self-contained in a clean environment and in the
+  isolated pre-commit hook.
+
 ********************
- 0.2.2 (2026/06/14)
+ 0.2.4 (2026/06/14)
 ********************
 
-**Changed**
+**Fixed**
 
-- 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.
+- Never reorder a definition across a side-effecting statement. A bare statement such as
+  ``sys.path.insert(0, str(REPO_ROOT))`` is now a barrier, and sorting happens only
+  within each segment between barriers, so a constant the statement uses is no longer
+  hoisted after it (which raised ``NameError``).
+
+********************
+ 0.2.3 (2026/06/14)
+********************
 
 **Fixed**
 
@@ -27,6 +40,16 @@ codesorter follows `semantic versioning <https://semver.org/>`_.
   getter/setter/deleter groups, which carry no assignment, are still ordered by their
   sort key.
 
+********************
+ 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)
 ********************

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codesorter
-Version: 0.2.3
+Version: 0.2.5
 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/
@@ -51,6 +51,7 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Requires-Dist: libcst<2.0.0,>=1.8.6
 Requires-Dist: pathspec>=1.1.1
+Requires-Dist: ruff>=0.1.2
 Description-Content-Type: text/x-rst
 
 ############

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

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

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

@@ -488,6 +488,44 @@ class SortCodeCommand(VisitorBasedCodemodCommand, m.MatcherDecoratableTransforme
             property_type,
         )
 
+    def _reorder_segment(
+        self,
+        body: Sequence[cst.BaseStatement],
+        new_body: list[cst.BaseStatement],
+        *,
+        anchor_indexes: list[int],
+        trailers_of: dict[int, list[int]],
+    ) -> None:
+        """Reorder one barrier-free segment of sortable members in place within ``new_body``."""
+        if not anchor_indexes:
+            return
+        positions: list[int] = []
+        anchor_nodes: list[_Sortable] = []
+        trailers_by_anchor: dict[int, list[cst.BaseStatement]] = {}
+        for index in anchor_indexes:
+            trailer_indexes = sorted(trailers_of.get(index, []))
+            positions.append(index)
+            positions.extend(trailer_indexes)
+            anchor = cast("_Sortable", body[index])
+            anchor_nodes.append(anchor)
+            trailers_by_anchor[id(anchor)] = [body[trailer] for trailer in trailer_indexes]
+        # Blank-line separators are positional: the n-th anchor in the segment keeps the
+        # n-th separator. Trailers are excluded so they stay tight to their anchor.
+        anchor_separators = [_split_leading_lines(node)[0] for node in anchor_nodes]
+        trailer_ids = {id(trailer) for trailers in trailers_by_anchor.values() for trailer in trailers}
+        flattened: list[cst.BaseStatement] = []
+        for anchor in self._sorted_items(anchor_nodes):
+            flattened.append(anchor)
+            flattened.extend(trailers_by_anchor[id(anchor)])
+        anchor_index = 0
+        for position, member in zip(sorted(positions), flattened, strict=True):
+            if id(member) in trailer_ids:
+                new_body[position] = member
+                continue
+            _, attached = _split_leading_lines(member)
+            new_body[position] = member.with_changes(leading_lines=[*anchor_separators[anchor_index], *attached])
+            anchor_index += 1
+
     def _resolve_dependents(self, node: _Sortable) -> None:
         dependencies, _ = self._get_dependencies(node)
         name = _sortable_name(node)
@@ -513,40 +551,27 @@ class SortCodeCommand(VisitorBasedCodemodCommand, m.MatcherDecoratableTransforme
         Blank-line spacing stays with each slot while comment lines travel with their
         statement, so reordering never shifts a blank line onto a different statement.
 
+        Sortable members are only reordered within a segment of consecutive sortable
+        members; any other statement (an import, a bare expression such as
+        ``sys.path.insert(...)``, an ``if`` block) is a barrier that no definition may
+        cross, since the barrier may depend on a definition beside it.
+
         """
         anchors = self._anchor_trailers(body, sort_constants=sort_constants)
         trailers_of: defaultdict[int, list[int]] = defaultdict(list)
         for trailer_index, anchor_index in anchors.items():
             trailers_of[anchor_index].append(trailer_index)
-        positions: list[int] = []
-        anchor_nodes: list[_Sortable] = []
-        trailers_by_anchor: dict[int, list[cst.BaseStatement]] = {}
-        for index, member in enumerate(body):
-            if index in anchors or not self._is_sortable(member, sort_constants=sort_constants):
-                continue
-            trailer_indexes = sorted(trailers_of.get(index, []))
-            positions.append(index)
-            positions.extend(trailer_indexes)
-            anchor = cast("_Sortable", member)
-            anchor_nodes.append(anchor)
-            trailers_by_anchor[id(anchor)] = [body[trailer] for trailer in trailer_indexes]
-        # Blank-line separators are positional: the n-th anchor in the body keeps the
-        # n-th separator. Trailers are excluded so they stay tight to their anchor.
-        anchor_separators = [_split_leading_lines(node)[0] for node in anchor_nodes]
-        trailer_ids = {id(trailer) for trailers in trailers_by_anchor.values() for trailer in trailers}
-        flattened: list[cst.BaseStatement] = []
-        for anchor in self._sorted_items(anchor_nodes):
-            flattened.append(anchor)
-            flattened.extend(trailers_by_anchor[id(anchor)])
         new_body = list(body)
-        anchor_index = 0
-        for position, member in zip(sorted(positions), flattened, strict=True):
-            if id(member) in trailer_ids:
-                new_body[position] = member
+        segment: list[int] = []
+        for index, member in enumerate(body):
+            if index in anchors:
+                continue  # a trailer, reordered together with its anchor
+            if self._is_sortable(member, sort_constants=sort_constants):
+                segment.append(index)
                 continue
-            _, attached = _split_leading_lines(member)
-            new_body[position] = member.with_changes(leading_lines=[*anchor_separators[anchor_index], *attached])
-            anchor_index += 1
+            self._reorder_segment(body, new_body, anchor_indexes=segment, trailers_of=trailers_of)
+            segment = []
+        self._reorder_segment(body, new_body, anchor_indexes=segment, trailers_of=trailers_of)
         return new_body
 
     def _sorted_items(

{codesorter-0.2.3 → codesorter-0.2.5}/docs/contributing/pre_commit.rst

@@ -21,9 +21,9 @@ hook so the repository is always sorted by the code on the current branch:
 ***************************
 
 Because the hook uses ``language: system``, it runs the ``codesorter`` executable from
-your environment instead of an isolated one pre-commit manages. CodeSorter then invokes
-``ruff format`` as its formatter (configured in ``.libcst.codemod.yaml``). Both
-``codesorter`` and ``ruff`` must therefore be on ``PATH`` when the hook runs.
+your environment instead of an isolated one pre-commit manages. CodeSorter always
+invokes ``ruff format`` as its formatter, so both ``codesorter`` and ``ruff`` must be on
+``PATH`` when the hook runs.
 
 Install the development environment and the git hook:
 

{codesorter-0.2.3 → codesorter-0.2.5}/pyproject.toml

@@ -16,8 +16,7 @@ docs = [
   "sphinx-autodoc-typehints>=2.5.0"
 ]
 lint = [
-  "pre-commit>=4.6.0",
-  "ruff>=0.15.17"
+  "pre-commit>=4.6.0"
 ]
 test = [
   "coverage>=7.14.1",
@@ -50,7 +49,8 @@ classifiers = [
 ]
 dependencies = [
   "libcst>=1.8.6,<2.0.0",
-  "pathspec>=1.1.1"
+  "pathspec>=1.1.1",
+  "ruff>=0.1.2"
 ]
 description = "A Python codemod that sorts and organizes code in your files."
 dynamic = ["version"]

codesorter-0.2.5/tests/test_files/barrier_input.py

@@ -0,0 +1,11 @@
+"""Definitions never cross a side-effecting statement that may depend on them."""
+
+import sys
+from pathlib import Path
+
+ZEBRA = 1
+REPO_ROOT = Path(__file__).resolve().parent
+sys.path.insert(0, str(REPO_ROOT))
+
+BANANA = 3
+APPLE = 2

codesorter-0.2.5/tests/test_files/barrier_output.py

@@ -0,0 +1,11 @@
+"""Definitions never cross a side-effecting statement that may depend on them."""
+
+import sys
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parent
+ZEBRA = 1
+sys.path.insert(0, str(REPO_ROOT))
+
+APPLE = 2
+BANANA = 3

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

@@ -48,6 +48,22 @@ class TestSortCodeCommand:
 
         assert expected_code == result.code
 
+    def test_barrier(self, test_files):
+        """Test that definitions are not reordered across a side-effecting statement.
+
+        A bare statement such as ``sys.path.insert(0, str(REPO_ROOT))`` is a barrier:
+        the constants before it (which it may use) must stay before it, so sorting
+        happens only within each segment between barriers rather than across the whole
+        module.
+
+        """
+        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_basic_function(self, test_files):
         """Test that functions are sorted correctly."""
         input_code, expected_code = test_files

{codesorter-0.2.3 → codesorter-0.2.5}/uv.lock

@@ -190,6 +190,7 @@ source = { editable = "." }
 dependencies = [
     { name = "libcst" },
     { name = "pathspec" },
+    { name = "ruff" },
 ]
 
 [package.dev-dependencies]
@@ -199,7 +200,6 @@ dev = [
     { name = "pre-commit" },
     { name = "pyright" },
     { name = "pytest" },
-    { name = "ruff" },
     { name = "sphinx", version = "8.1.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
     { name = "sphinx", version = "9.0.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*'" },
     { name = "sphinx", version = "9.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
@@ -219,7 +219,6 @@ docs = [
 ]
 lint = [
     { name = "pre-commit" },
-    { name = "ruff" },
 ]
 test = [
     { name = "coverage" },
@@ -235,6 +234,7 @@ type = [
 requires-dist = [
     { name = "libcst", specifier = ">=1.8.6,<2.0.0" },
     { name = "pathspec", specifier = ">=1.1.1" },
+    { name = "ruff", specifier = ">=0.1.2" },
 ]
 
 [package.metadata.requires-dev]
@@ -244,7 +244,6 @@ dev = [
     { name = "pre-commit", specifier = ">=4.6.0" },
     { name = "pyright", specifier = ">=1.1.410" },
     { name = "pytest", specifier = ">=9.0.3" },
-    { name = "ruff", specifier = ">=0.15.17" },
     { name = "sphinx", specifier = ">=8.1.3" },
     { name = "sphinx-autodoc-typehints", specifier = ">=2.5.0" },
     { name = "tox-uv", specifier = ">=1.35.2" },
@@ -254,10 +253,7 @@ docs = [
     { name = "sphinx", specifier = ">=8.1.3" },
     { name = "sphinx-autodoc-typehints", specifier = ">=2.5.0" },
 ]
-lint = [
-    { name = "pre-commit", specifier = ">=4.6.0" },
-    { name = "ruff", specifier = ">=0.15.17" },
-]
+lint = [{ name = "pre-commit", specifier = ">=4.6.0" }]
 test = [
     { name = "coverage", specifier = ">=7.14.1" },
     { name = "pytest", specifier = ">=9.0.3" },

codesorter-0.2.3/.libcst.codemod.yaml

@@ -1,36 +0,0 @@
-# String that LibCST should look for in code which indicates that the
-# module is generated code.
-generated_code_marker: '@generated'
-# Command line and arguments for invoking a code formatter. Anything
-# specified here must be capable of taking code via stdin and returning
-# formatted code via stdout.
-formatter: ['ruff', 'format', '-']
-# List of regex patterns which LibCST will evaluate against filenames to
-# determine if the module should be touched.
-blacklist_patterns:
-- '.*/\.bzr/.*'
-- '.*/\.direnv/.*'
-- '.*/\.eggs/.*'
-- '.*/\.git/.*'
-- '.*/\.hg/.*'
-- '.*/\.mypy_cache/.*'
-- '.*/\.nox/.*'
-- '.*/\.pytest_cache/.*'
-- '.*/\.ruff_cache/.*'
-- '.*/\.svn/.*'
-- '.*/\.tox/.*'
-- '.*/\.venv/.*'
-- '.*/__pycache__/.*'
-- '.*/__pypackages__/.*'
-- '.*/build/.*'
-- '.*/dist/.*'
-- '.*/env/.*'
-- '.*/node_modules/.*'
-- '.*/venv/.*'
-# List of modules that contain codemods inside of them.
-modules:
-- 'codesorter'
-# Absolute or relative path of the repository root, used for providing
-# full-repo metadata. Relative paths should be specified with this file
-# location as the base.
-repo_root: '.'