update

Author: observerw

python/src/lsap/locate.py

@@ -1,6 +1,6 @@
 import re
 from pathlib import Path
-from typing import Protocol
+from typing import NamedTuple, Protocol
 
 from attrs import define
 from lsap_schema.locate import (
@@ -43,51 +43,54 @@ def _to_regex(text: str) -> str:
     if not tokens:
         return ""
 
-    result: list[str] = []
-    for i, token in enumerate(tokens):
-        if token[0].isspace():
-            result.append(r"\s+")
-        else:
-            result.append(re.escape(token))
-            if i < len(tokens) - 1 and not tokens[i + 1][0].isspace():
-                result.append(r"\s*")
-    return "".join(result)
+    def parts():
+        for i, token in enumerate(tokens):
+            if token[0].isspace():
+                yield r"\s+"
+            else:
+                yield re.escape(token)
+                if i < len(tokens) - 1 and not tokens[i + 1][0].isspace():
+                    yield r"\s*"
+
+    return "".join(parts())
+
+
+class ScopeInfo(NamedTuple):
+    range: LSPRange
+    selection_start: LSPPosition | None
 
 
 async def _get_scope_info(
     client: LocateClient,
     file_path: Path,
     scope: LineScope | SymbolScope | None,
     reader: DocumentReader,
-) -> tuple[LSPRange, LSPPosition | None]:
+) -> ScopeInfo:
     match scope:
         case None:
-            return reader.full_range, None
+            return ScopeInfo(reader.full_range, None)
 
         case LineScope(line=line):
-            if isinstance(line, int):
-                start, end = line - 1, line - 1
-            else:
-                start, end = line[0] - 1, line[1] - 1
+            match line:
+                case int():
+                    start, end = line - 1, line - 1
+                case (s, e):
+                    start, end = s - 1, e - 1
 
-            return (
+            return ScopeInfo(
                 LSPRange(
                     start=LSPPosition(line=start, character=0),
                     end=LSPPosition(line=end + 1, character=0),
                 ),
                 None,
             )
-
         case SymbolScope(symbol_path=path):
             symbols = await client.request_document_symbol_list(file_path)
             for s_path, symbol in iter_symbols(symbols or []):
                 if s_path == path:
-                    return symbol.range, symbol.selection_range.start
+                    return ScopeInfo(symbol.range, symbol.selection_range.start)
             raise NotFoundError(f"Symbol {path} not found in {file_path}")
 
-        case _:
-            return reader.full_range, None
-
 
 @define
 class LocateCapability(Capability[LocateClient, LocateRequest, LocateResponse]):
@@ -96,21 +99,18 @@ async def __call__(self, req: LocateRequest) -> LocateResponse | None:
         document = await self.client.read_file(locate.file_path)
         reader = DocumentReader(document)
 
-        scope_range, selection_start = await _get_scope_info(
+        info = await _get_scope_info(
             self.client, locate.file_path, locate.scope, reader
         )
 
-        snippet = reader.read(scope_range)
+        snippet = reader.read(info.range)
         if not snippet:
             return None
 
         pos: LSPPosition | None = None
 
         if locate.find:
-            # Auto-detect marker in the find text
-            marker_info = detect_marker(locate.find)
-
-            if marker_info:
+            if marker_info := detect_marker(locate.find):
                 marker, _, _ = marker_info
                 before, _, after = locate.find.partition(marker)
                 re_before, re_after = _to_regex(before), _to_regex(after)
@@ -129,11 +129,17 @@ async def __call__(self, req: LocateRequest) -> LocateResponse | None:
                 return None
 
             pos = reader.offset_to_position(snippet.range.start, offset)
-        elif isinstance(locate.scope, SymbolScope):
-            pos = selection_start
-        elif isinstance(locate.scope, LineScope):
-            m = re.search(r"\S", snippet.exact_content)
-            pos = reader.offset_to_position(snippet.range.start, m.start() if m else 0)
+        else:
+            match locate.scope:
+                case SymbolScope():
+                    pos = info.selection_start
+                case LineScope():
+                    m = re.search(r"\S", snippet.exact_content)
+                    pos = reader.offset_to_position(
+                        snippet.range.start, m.start() if m else 0
+                    )
+                case _:
+                    pos = info.range.start
 
         if pos:
             return LocateResponse(
@@ -152,20 +158,20 @@ async def __call__(self, req: LocateRangeRequest) -> LocateRangeResponse | None:
         document = await self.client.read_file(locate.file_path)
         reader = DocumentReader(document)
 
-        scope_range, _ = await _get_scope_info(
+        info = await _get_scope_info(
             self.client, locate.file_path, locate.scope, reader
         )
 
         final_range: LSPRange | None = None
 
         if locate.find:
-            snippet = reader.read(scope_range)
+            snippet = reader.read(info.range)
             if not snippet:
                 return None
 
             re_find = _to_regex(locate.find)
             if not re_find:
-                final_range = scope_range
+                final_range = info.range
             elif m := re.search(re_find, snippet.exact_content):
                 final_range = LSPRange(
                     start=reader.offset_to_position(snippet.range.start, m.start()),
@@ -174,7 +180,7 @@ async def __call__(self, req: LocateRangeRequest) -> LocateRangeResponse | None:
             else:
                 return None
         else:
-            final_range = scope_range
+            final_range = info.range
 
         if final_range:
             return LocateRangeResponse(
@@ -184,3 +190,4 @@ async def __call__(self, req: LocateRangeRequest) -> LocateRangeResponse | None:
                     end=Position.from_lsp(final_range.end),
                 ),
             )
+        return None