sqlakit-lsp 0.1.2__tar.gz → 0.2.0__tar.gz

{sqlakit_lsp-0.1.2 → sqlakit_lsp-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlakit-lsp
-Version: 0.1.2
+Version: 0.2.0
 Summary: The language server for SQLAKit templates.
 Keywords: sqlalchemy,sqlakit,lsp,language-server,sql
 Author: Anton Ruhlov

{sqlakit_lsp-0.1.2 → sqlakit_lsp-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sqlakit-lsp"
-version = "0.1.2"
+version = "0.2.0"
 description = "The language server for SQLAKit templates."
 readme = "README.md"
 license = "MIT"

{sqlakit_lsp-0.1.2 → sqlakit_lsp-0.2.0}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "sqlakit-lsp"
-version = "0.1.2"
+version = "0.2.0"
 description = "The language server for SQLAKit templates."
 readme = "README.md"
 license = "MIT"

{sqlakit_lsp-0.1.2 → sqlakit_lsp-0.2.0}/sqlakit_lsp/_server.py

@@ -23,6 +23,7 @@ import asyncio
 import bisect
 import difflib
 import inspect
+import os
 import re
 import tempfile
 import uuid
@@ -476,9 +477,27 @@ class _Assistant:
     def names(self) -> list[str]:
         """Every template's name, read once until `forget_files`."""
         if self._names is None:
-            self._names = self.project.templates.names()
+            self._names = sorted(self._on_disk())
         return self._names
 
+    def _on_disk(self) -> dict[str, Path]:
+        """Return each template's name and file, as `Templates.names` finds them.
+
+        One walk of the directories, in strings: a file made has the next
+        keystroke read them again, and paths cost more than the walk.
+        """
+        skipped = {str(path) for path in self._macro_files | self._macro_sql}
+        found: dict[str, Path] = {}
+        for root in self._template_roots:
+            start = len(str(root)) + 1
+            for directory, _, files in os.walk(root):
+                for file in files:
+                    written = os.path.join(directory, file)  # noqa: PTH118 - strings, for speed
+                    if file.endswith(".sql") and written not in skipped:
+                        name = written[start:].replace(os.sep, "/")
+                        found.setdefault(name, Path(written))
+        return found
+
     def defines_macros(self, path: Path) -> bool:
         """Whether a file defines a macro the project calls, its own or built in.
 
@@ -1031,7 +1050,7 @@ class _Assistant:
             return next(
                 (
                     (start, end)
-                    for start, end, _ in _template_names(source)
+                    for start, end, _ in self._files_named(source, path)
                     if start <= offset <= end
                 ),
                 defined,
@@ -1129,25 +1148,46 @@ class _Assistant:
     def python_definition(
         self, source: str, offset: int, path: Path | None = None
     ) -> Target | None:
-        """Return the template the name under the offset reads.
+        """Return the file the name under the offset reads.
 
-        On the name of a `def` that defines a macro, that is the name itself.
+        That is a template in `db.sql("...")`, or the SQL of a macro in
+        `@sql_macro("...")`. On the name of a `def` that defines a macro, it is
+        the name itself.
         """
-        for start, end, name in _template_names(source):
+        for start, end, found in self._files_named(source, path):
             if start <= offset <= end:
-                found = self.project.path_of(name)
-                return None if found is None else Target(found, 0)
+                return Target(found, 0)
         return None if path is None else self._itself(path, source, offset)
 
+    def _files_named(
+        self, source: str, path: Path | None
+    ) -> list[tuple[int, int, Path]]:
+        """Return each file the Python names, where the name is, and the file.
+
+        A template is looked for under the template directories, and the SQL of
+        `@sql_macro("...")` next to the module, as `sql_macro` reads it.
+        """
+        found = [
+            (start, end, target)
+            for start, end, name in _template_names(source)
+            if (target := self.project.path_of(name)) is not None
+        ]
+        if path is not None:
+            found.extend(
+                (start, end, target)
+                for start, end, name in _sql_macro_files(source)
+                if (target := path.parent / name).is_file()
+            )
+        return found
+
     def links(self, path: Path, source: str) -> list[tuple[int, int, Path]]:
-        """Return each template the text names, where the name is, and its file."""
-        if self.reads_python(path):
-            named = _template_names(source)
-        else:
-            named = [
-                (found.start(1), found.end(1), found.group(1))
-                for found in self._include_path.finditer(source)
-            ]
+        """Return each file the text names, where the name is, and the file."""
+        if path.suffix == ".py":
+            return self._files_named(source, path)
+        named = [
+            (found.start(1), found.end(1), found.group(1))
+            for found in self._include_path.finditer(source)
+        ]
         return [
             (start, end, target)
             for start, end, name in named
@@ -1397,12 +1437,9 @@ class _Assistant:
         The paths are resolved, as the editor's open files are keyed.
         """
         if self._files is None:
-            named = {}
-            for name in self.names():
-                for root in self._template_roots:
-                    if (root / name).is_file():
-                        named[root / name] = name
-                        break
+            templates = self._on_disk()
+            self._names = sorted(templates)
+            named = {path: name for name, path in templates.items()}
             sql_files = [
                 *named,
                 *(path.resolve() for path in self.project.macro_files()),
@@ -1644,6 +1681,46 @@ def _template_names(source: str) -> list[tuple[int, int, str]]:
     return found
 
 
+def _sql_macro_files(source: str) -> list[tuple[int, int, str]]:
+    """Return where `@sql_macro("file.sql")` names its SQL, the quotes left out."""
+    if "sql_macro" not in source:
+        return []
+    try:
+        tree = ast.parse(source)
+    except SyntaxError:
+        return []
+    starts = _line_starts(source)
+    found = []
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef):
+            continue
+        for decorator in node.decorator_list:
+            if not (isinstance(decorator, ast.Call) and decorator.args):
+                continue
+            func = decorator.func
+            called = (
+                func.attr
+                if isinstance(func, ast.Attribute)
+                else getattr(func, "id", "")
+            )
+            name = decorator.args[0]
+            if not (
+                called == "sql_macro"
+                and isinstance(name, ast.Constant)
+                and isinstance(name.value, str)
+                and name.value.endswith(".sql")
+                and name.end_lineno is not None
+                and name.end_col_offset is not None
+            ):
+                continue
+            start = _char_offset(source, starts, name.lineno, name.col_offset)
+            end = _char_offset(source, starts, name.end_lineno, name.end_col_offset)
+            quote = source.find(name.value, start, end)
+            if quote >= 0:
+                found.append((quote, quote + len(name.value), name.value))
+    return found
+
+
 def _char_offset(source: str, starts: list[int], line: int, column: int) -> int:
     """Return the offset of a position `ast` gives, its column in UTF-8 bytes."""
     begin = starts[line - 1]