undersort 0.1.1__tar.gz → 0.1.3__tar.gz

{undersort-0.1.1 → undersort-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: undersort
-Version: 0.1.1
+Version: 0.1.3
 Summary: A tool to sort class methods by visibility (public, protected, private)
 Project-URL: Homepage, https://github.com/kivicode/undersort
 Project-URL: Repository, https://github.com/kivicode/undersort
@@ -43,10 +43,15 @@ A Python tool that automatically sorts class methods by visibility (public, prot
 
 ```bash
 # Using uv (recommended)
-uv pip install -e .
+uv add undersort
 
 # Using pip
-pip install -e .
+pip install undersort
+
+# For development
+git clone https://github.com/kivicode/undersort
+cd undersort
+uv sync
 ```
 
 ## Configuration
@@ -61,8 +66,8 @@ order = ["public", "protected", "private"]
 
 # Method type ordering within each visibility level (secondary sort, optional)
 # Options: "class" (classmethod), "static" (staticmethod), "instance" (regular methods)
-# Default: ["class", "static", "instance"]
-method_type_order = ["class", "static", "instance"]
+# Default: ["instance", "class", "static"]
+method_type_order = ["instance", "class", "static"]
 ```
 
 ### Method Visibility Rules
@@ -82,19 +87,25 @@ method_type_order = ["class", "static", "instance"]
 Methods are sorted in two levels:
 
 1. **Primary**: By visibility (public → protected → private)
-2. **Secondary**: Within each visibility level, by method type (class → static → instance by default)
+2. **Secondary**: Within each visibility level, by method type (instance → class → static by default)
+
+The sorting algorithm **minimizes movement** to preserve the original order as much as possible:
 
-Example: With default configuration, the order would be:
+- Methods that need to move DOWN (to a later section) are placed at the **beginning** of their target section
+- Methods that need to move UP (to an earlier section) are placed at the **end** of their target section
+- Methods already in the correct section maintain their relative order
 
-1. Public class methods
-2. Public static methods
-3. Public instance methods
-4. Protected class methods
-5. Protected static methods
-6. Protected instance methods
-7. Private class methods
-8. Private static methods
-9. Private instance methods
+Example order with default configuration:
+
+1. Public instance methods
+2. Public class methods
+3. Public static methods
+4. Protected instance methods
+5. Protected class methods
+6. Protected static methods
+7. Private instance methods
+8. Private class methods
+9. Private static methods
 
 ## Usage
 
@@ -143,9 +154,10 @@ repos:
     hooks:
       - id: undersort
         name: undersort
-        entry: uv run undersort
-        language: system
+        entry: undersort
+        language: python
         types: [python]
+        additional_dependencies: ["undersort"]
 ```
 
 Then install the hook:
@@ -190,6 +202,12 @@ class Example:
 
 ```python
 class Example:
+    def __init__(self):
+        pass
+
+    def public_instance(self):
+        pass
+
     @classmethod
     def public_class(cls):
         pass
@@ -198,19 +216,13 @@ class Example:
     def public_static():
         pass
 
-    def __init__(self):
-        pass
-
-    def public_instance(self):
+    def _protected_instance(self):
         pass
 
     @classmethod
     def _protected_class(cls):
         pass
 
-    def _protected_instance(self):
-        pass
-
     def __private_method(self):
         pass
 ```
@@ -218,7 +230,7 @@ class Example:
 The methods are now organized by:
 
 1. **Visibility**: public (including `__init__`) → protected → private
-2. **Type** (within each visibility): class → static → instance
+2. **Type** (within each visibility): instance → class → static
 
 ## Development
 

{undersort-0.1.1 → undersort-0.1.3}/README.md

@@ -16,10 +16,15 @@ A Python tool that automatically sorts class methods by visibility (public, prot
 
 ```bash
 # Using uv (recommended)
-uv pip install -e .
+uv add undersort
 
 # Using pip
-pip install -e .
+pip install undersort
+
+# For development
+git clone https://github.com/kivicode/undersort
+cd undersort
+uv sync
 ```
 
 ## Configuration
@@ -34,8 +39,8 @@ order = ["public", "protected", "private"]
 
 # Method type ordering within each visibility level (secondary sort, optional)
 # Options: "class" (classmethod), "static" (staticmethod), "instance" (regular methods)
-# Default: ["class", "static", "instance"]
-method_type_order = ["class", "static", "instance"]
+# Default: ["instance", "class", "static"]
+method_type_order = ["instance", "class", "static"]
 ```
 
 ### Method Visibility Rules
@@ -55,19 +60,25 @@ method_type_order = ["class", "static", "instance"]
 Methods are sorted in two levels:
 
 1. **Primary**: By visibility (public → protected → private)
-2. **Secondary**: Within each visibility level, by method type (class → static → instance by default)
+2. **Secondary**: Within each visibility level, by method type (instance → class → static by default)
+
+The sorting algorithm **minimizes movement** to preserve the original order as much as possible:
 
-Example: With default configuration, the order would be:
+- Methods that need to move DOWN (to a later section) are placed at the **beginning** of their target section
+- Methods that need to move UP (to an earlier section) are placed at the **end** of their target section
+- Methods already in the correct section maintain their relative order
 
-1. Public class methods
-2. Public static methods
-3. Public instance methods
-4. Protected class methods
-5. Protected static methods
-6. Protected instance methods
-7. Private class methods
-8. Private static methods
-9. Private instance methods
+Example order with default configuration:
+
+1. Public instance methods
+2. Public class methods
+3. Public static methods
+4. Protected instance methods
+5. Protected class methods
+6. Protected static methods
+7. Private instance methods
+8. Private class methods
+9. Private static methods
 
 ## Usage
 
@@ -116,9 +127,10 @@ repos:
     hooks:
       - id: undersort
         name: undersort
-        entry: uv run undersort
-        language: system
+        entry: undersort
+        language: python
         types: [python]
+        additional_dependencies: ["undersort"]
 ```
 
 Then install the hook:
@@ -163,6 +175,12 @@ class Example:
 
 ```python
 class Example:
+    def __init__(self):
+        pass
+
+    def public_instance(self):
+        pass
+
     @classmethod
     def public_class(cls):
         pass
@@ -171,19 +189,13 @@ class Example:
     def public_static():
         pass
 
-    def __init__(self):
-        pass
-
-    def public_instance(self):
+    def _protected_instance(self):
         pass
 
     @classmethod
     def _protected_class(cls):
         pass
 
-    def _protected_instance(self):
-        pass
-
     def __private_method(self):
         pass
 ```
@@ -191,7 +203,7 @@ class Example:
 The methods are now organized by:
 
 1. **Visibility**: public (including `__init__`) → protected → private
-2. **Type** (within each visibility): class → static → instance
+2. **Type** (within each visibility): instance → class → static
 
 ## Development
 

{undersort-0.1.1 → undersort-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "undersort"
-version = "0.1.1"
+version = "0.1.3"
 description = "A tool to sort class methods by visibility (public, protected, private)"
 authors = [{ name = "KiviCode", email = "kivicode.dev@gmail.com" }]
 readme = "README.md"
@@ -47,8 +47,8 @@ order = ["public", "protected", "private"]
 
 # Method type ordering within each visibility level (optional)
 # Options: "class" (classmethod), "static" (staticmethod), "instance" (regular methods)
-# Default order if not specified: ["class", "static", "instance"]
-method_type_order = ["class", "static", "instance"]
+# Default order if not specified: ["instance", "class", "static"]
+method_type_order = ["instance", "class", "static"]
 
 [tool.ruff]
 unsafe-fixes = true

{undersort-0.1.1 → undersort-0.1.3}/tests/test_sorter.py

@@ -382,7 +382,7 @@ class Example:
 
         try:
             order = ["public", "protected", "private"]
-            method_type_order = ["class", "static", "instance"]
+            method_type_order = ["instance", "class", "static"]
             was_modified = sort_file(temp_path, order, method_type_order)
 
             assert was_modified is True
@@ -390,19 +390,21 @@ class Example:
             with open(temp_path) as f:
                 result = f.read()
 
-            # Check order: class -> static -> instance
+            instance_idx = result.find("def instance_method")
             class_idx = result.find("def class_method")
             static_idx = result.find("def static_method")
-            instance_idx = result.find("def instance_method")
 
-            assert class_idx < static_idx < instance_idx
+            assert instance_idx < class_idx < static_idx
         finally:
             temp_path.unlink()
 
     def test_method_type_sorting_custom_order(self) -> None:
-        """Test custom method type ordering (instance first)."""
+        """Test custom method type ordering (class first)."""
         source = """
 class Example:
+    def instance_method(self):
+        pass
+
     @classmethod
     def class_method(cls):
         pass
@@ -410,9 +412,6 @@ class Example:
     @staticmethod
     def static_method():
         pass
-
-    def instance_method(self):
-        pass
 """
         with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
             f.write(source)
@@ -420,7 +419,7 @@ class Example:
 
         try:
             order = ["public", "protected", "private"]
-            method_type_order = ["instance", "static", "class"]
+            method_type_order = ["class", "static", "instance"]
             was_modified = sort_file(temp_path, order, method_type_order)
 
             assert was_modified is True
@@ -428,12 +427,11 @@ class Example:
             with open(temp_path) as f:
                 result = f.read()
 
-            # Check order: instance -> static -> class
-            instance_idx = result.find("def instance_method")
-            static_idx = result.find("def static_method")
             class_idx = result.find("def class_method")
+            static_idx = result.find("def static_method")
+            instance_idx = result.find("def instance_method")
 
-            assert instance_idx < static_idx < class_idx
+            assert class_idx < static_idx < instance_idx
         finally:
             temp_path.unlink()
 
@@ -465,7 +463,7 @@ class Example:
 
         try:
             order = ["public", "protected", "private"]
-            method_type_order = ["class", "static", "instance"]
+            method_type_order = ["instance", "class", "static"]
             was_modified = sort_file(temp_path, order, method_type_order)
 
             assert was_modified is True
@@ -473,23 +471,18 @@ class Example:
             with open(temp_path) as f:
                 result = f.read()
 
-            # Public methods should come first
-            public_class_idx = result.find("def public_class")
             public_instance_idx = result.find("def public_instance")
+            public_class_idx = result.find("def public_class")
 
-            # Protected methods should come after public
+            protected_instance_idx = result.find("def _protected_instance")
             protected_class_idx = result.find("def _protected_class")
             protected_static_idx = result.find("def _protected_static")
-            protected_instance_idx = result.find("def _protected_instance")
 
-            # Check visibility ordering
-            assert public_class_idx < protected_class_idx
             assert public_instance_idx < protected_instance_idx
+            assert public_class_idx < protected_class_idx
 
-            # Within public: class -> static -> instance
-            assert public_class_idx < public_instance_idx
+            assert public_instance_idx < public_class_idx
 
-            # Within protected: class -> static -> instance
-            assert protected_class_idx < protected_static_idx < protected_instance_idx
+            assert protected_instance_idx < protected_class_idx < protected_static_idx
         finally:
             temp_path.unlink()

{undersort-0.1.1 → undersort-0.1.3}/undersort/__init__.py

@@ -1,3 +1,3 @@
 """undersort - Sort class methods by visibility."""
 
-__version__ = "0.1.0"
+__version__ = "0.1.3"

{undersort-0.1.1 → undersort-0.1.3}/undersort/sorter.py

@@ -2,13 +2,14 @@
 
 import difflib
 from pathlib import Path
+from typing import Literal
 
 import libcst as cst
 
 from undersort import logger
 
 
-def get_method_visibility(method_name: str) -> str:
+def get_method_visibility(method_name: str) -> Literal["public", "private", "protected"]:
     """Determine method visibility based on naming convention.
 
     Args:
@@ -63,13 +64,15 @@ class MethodSorter(cst.CSTTransformer):
                    (e.g., ["public", "protected", "private"])
             method_type_order: Optional list specifying the order of method types
                               within each visibility level
-                              (e.g., ["class", "static", "instance"])
+                              (e.g., ["instance", "class", "static"])
         """
         self.order = order
-        self.method_type_order = method_type_order or ["class", "static", "instance"]
+        self.method_type_order = method_type_order or ["instance", "class", "static"]
         self.modified = False
 
-    def leave_ClassDef(self, original_node: cst.ClassDef, updated_node: cst.ClassDef) -> cst.ClassDef:
+    def leave_ClassDef(  # noqa: PLR0912, PLR0915
+        self, original_node: cst.ClassDef, updated_node: cst.ClassDef
+    ) -> cst.ClassDef:
         """Sort methods within a class definition.
 
         Args:
@@ -91,21 +94,56 @@ class MethodSorter(cst.CSTTransformer):
         if not methods:
             return updated_node
 
-        method_groups: dict[str, dict[str, list[cst.FunctionDef]]] = {
+        method_with_index = [(i, method) for i, method in enumerate(methods)]
+
+        method_groups: dict[str, dict[str, list[tuple[int, cst.FunctionDef]]]] = {
             "public": {"class": [], "static": [], "instance": []},
             "protected": {"class": [], "static": [], "instance": []},
             "private": {"class": [], "static": [], "instance": []},
         }
 
-        for method in methods:
+        for idx, method in method_with_index:
             visibility = get_method_visibility(method.name.value)
             method_type = get_method_type(method)
-            method_groups[visibility][method_type].append(method)
+            method_groups[visibility][method_type].append((idx, method))
 
-        sorted_methods = []
+        group_order = []
         for visibility in self.order:
             for method_type in self.method_type_order:
-                sorted_methods.extend(method_groups[visibility][method_type])
+                group_order.append((visibility, method_type))
+
+        sorted_methods = []
+        current_position = 0
+
+        for visibility, method_type in group_order:
+            group = method_groups[visibility][method_type]
+            if not group:
+                continue
+
+            group_indices = [idx for idx, _ in group]
+            min_original_idx = min(group_indices)
+            max_original_idx = max(group_indices)
+
+            moved_down = []
+            in_place = []
+            moved_up = []
+
+            for idx, method in group:
+                if idx < min_original_idx or (idx < current_position and current_position > 0):
+                    moved_down.append((idx, method))
+                elif idx > max_original_idx:
+                    moved_up.append((idx, method))
+                else:
+                    in_place.append((idx, method))
+
+            moved_down.sort(key=lambda x: x[0])
+            in_place.sort(key=lambda x: x[0])
+            moved_up.sort(key=lambda x: x[0])
+
+            group_sorted = moved_down + in_place + moved_up
+            sorted_methods.extend([method for _, method in group_sorted])
+
+            current_position += len(group)
 
         if methods != sorted_methods:
             self.modified = True

{undersort-0.1.1 → undersort-0.1.3}/uv.lock

@@ -905,7 +905,7 @@ wheels = [
 
 [[package]]
 name = "undersort"
-version = "0.1.1"
+version = "0.1.3"
 source = { editable = "." }
 dependencies = [
     { name = "libcst", version = "1.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.9'" },