Added watch slicing tests, rewritten slice function.

cista/watching.py

@@ -50,37 +50,42 @@ class State:
         begin, end = 0, len(self._listing)
         level = 0
         isfile = 0
-        while level < len(relpath.parts):
+
-            # Enter a subdirectory
+        # Special case for root
+        if not relpath.parts:
+            return slice(begin, end)
+
+        begin += 1
+        for part in relpath.parts:
             level += 1
-            begin += 1
+            found = False
-            if level == len(relpath.parts):
+
-                isfile = relfile
+            while begin < end:
-            name = relpath.parts[level - 1]
+                entry = self._listing[begin]
-            namesort = sortkey(name)
+
-            r = self._listing[begin]
+                if entry.level < level:
-            assert r.level == level
+                    break
-            # Iterate over items at this level
+
-            while (
+                if entry.level == level:
-                begin < end
+                    if entry.name == part:
-                and r.name != name
+                        found = True
-                and r.isfile <= isfile
+                        if level == len(relpath.parts):
-                and sortkey(r.name) < namesort
+                            isfile = relfile
-            ):
+                        else:
-                # Skip contents
+                            begin += 1
+                        break
+                    cmp = entry.isfile - isfile or sortkey(entry.name) > sortkey(part)
+                    if cmp > 0:
+                        break
+
                 begin += 1
-                while begin < end and self._listing[begin].level > level:
+
-                    begin += 1
+            if not found:
-                # Not found?
-                if begin == end or self._listing[begin].level < level:
-                    return slice(begin, begin)
-                r = self._listing[begin]
-            # Not found?
-            if begin == end or r.name != name:
                 return slice(begin, begin)
-        # Found an item, now find its end
+
-        for end in range(begin + 1, len(self._listing)):
+        # Found the starting point, now find the end of the slice
-            if self._listing[end].level <= level:
+        for end in range(begin + 1, len(self._listing) + 1):
+            if end == len(self._listing) or self._listing[end].level <= level:
                 break
         return slice(begin, end)
 

tests/test_watching.py

@@ -1,7 +1,10 @@
+from pathlib import PurePosixPath
+
 import msgspec
+import pytest
 
 from cista.protocol import FileEntry, UpdateMessage, UpdDel, UpdIns, UpdKeep
-from cista.watching import format_update
+from cista.watching import State, format_update
 
 
 def decode(data: str):
@@ -75,3 +78,59 @@ def test_longer_lists():
         UpdIns(f(2, 7)),
     ]
     assert decode(format_update(old_list, new_list)) == expected
+
+
+def sortkey(name):
+    # Define the sorting key for names here
+    return name.lower()
+
+
+@pytest.fixture()
+def state():
+    entries = [
+        FileEntry(0, "", "root", 0, 0, 0),
+        FileEntry(1, "bar", "bar", 0, 0, 0),
+        FileEntry(2, "baz", "bar/baz", 0, 0, 0),
+        FileEntry(1, "foo", "foo", 0, 0, 0),
+        FileEntry(1, "xxx", "xxx", 0, 0, 0),
+        FileEntry(2, "yyy", "xxx/yyy", 0, 0, 1),
+    ]
+    s = State()
+    s._listing = entries
+    return s
+
+
+def test_existing_directory(state):
+    path = PurePosixPath("bar")
+    expected_slice = slice(1, 3)  # Includes 'bar' and 'baz'
+    assert state._slice(path) == expected_slice
+
+
+def test_existing_file(state):
+    path = PurePosixPath("xxx/yyy")
+    expected_slice = slice(5, 6)  # Only includes 'yyy'
+    assert state._slice(path) == expected_slice
+
+
+def test_nonexistent_directory(state):
+    path = PurePosixPath("zzz")
+    expected_slice = slice(6, 6)  # 'zzz' would be inserted at end
+    assert state._slice(path) == expected_slice
+
+
+def test_nonexistent_file(state):
+    path = (PurePosixPath("bar/mmm"), 1)
+    expected_slice = slice(3, 3)  # A file would be inserted after 'baz' under 'bar'
+    assert state._slice(path) == expected_slice
+
+
+def test_root_directory(state):
+    path = PurePosixPath()
+    expected_slice = slice(0, 6)  # Entire tree
+    assert state._slice(path) == expected_slice
+
+
+def test_directory_with_subdirs_and_files(state):
+    path = PurePosixPath("xxx")
+    expected_slice = slice(4, 6)  # Includes 'xxx' and 'yyy'
+    assert state._slice(path) == expected_slice