execsql2 2.26.0__py3-none-any.whl → 2.27.0__py3-none-any.whl

execsql/lsp/server.py

@@ -0,0 +1,358 @@
+"""The pygls server behind ``execsql lsp``."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from lsprotocol import types
+from pygls.lsp.server import LanguageServer
+from pygls.uris import to_fs_path
+
+from execsql import __version__
+from execsql.lsp.code_actions import code_actions
+from execsql.lsp.completion import completions
+from execsql.lsp.diagnostics import diagnostics, too_deep_diagnostic
+from execsql.lsp.document import ScriptIndex, index_script, read_included, same_file_key
+from execsql.lsp.folding import folding_ranges
+from execsql.lsp.formatting import format_document
+from execsql.lsp.hover import hover
+from execsql.lsp.rename import RenameError, prepare_rename, rename
+from execsql.lsp.navigation import definition, document_links, document_symbols, references
+
+__all__ = ["ExecsqlLanguageServer", "create_server"]
+
+# Pause after the last keystroke before linting, so a burst of typing lints once.
+LINT_DELAY_SECONDS = 0.2
+
+# Files whose change can alter an open script's findings or index: the config
+# file (its [lint] and [format] sections) and any script it may INCLUDE.
+WATCHED_FILES = ("**/execsql.conf", "**/*.sql")
+
+
+class _DropLateCancels(logging.Filter):
+    """Drops pygls's warning about a cancel for a request already answered.
+
+    Editors cancel requests they no longer need (a hover after the cursor
+    moves); the handlers answer in milliseconds, so the cancel usually
+    arrives late.  That is normal, but the warning reaches the editor's
+    output as an error.
+    """
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        return not record.getMessage().startswith("Cancel notification for unknown message id")
+
+
+@dataclass
+class Settings:
+    """What the configuration sets for one workspace folder: lint rule selection and format options."""
+
+    select: tuple[str, ...] = ()
+    ignore: tuple[str, ...] = ()
+    format_options: dict[str, Any] = field(default_factory=dict)  # format_document keywords, from [format]
+
+
+class ExecsqlLanguageServer(LanguageServer):
+    """Holds what the handlers share: each workspace folder's settings and pending lint tasks."""
+
+    def __init__(self) -> None:
+        super().__init__("execsql", __version__)
+        self.settings: dict[str, Settings] = {}  # by same_file_key of each workspace folder
+        self.fallback = Settings()  # for a file in no workspace folder
+        self.pending: dict[str, asyncio.Task[Any]] = {}
+
+    def load_settings(self) -> None:
+        """Read ``[lint]`` and ``[format]`` for each workspace folder, as ``execsql lint`` / ``execsql format`` run there would.
+
+        execsql reads config files from the working directory, so each
+        folder's settings are read from inside it.  The server itself works
+        from the workspace root: a file in no folder gets the settings read
+        there, and an unsaved script's relative ``INCLUDE`` resolves there.
+        """
+        root = self.workspace.root_path
+        if root and os.path.isdir(root):
+            os.chdir(root)
+        self.fallback = self._read_settings(None)
+        self.settings = {}
+        for folder in self.workspace.folders.values():
+            path = to_fs_path(folder.uri)
+            if path and os.path.isdir(path):
+                self.settings[same_file_key(path)] = self._read_settings(path)
+
+    def _read_settings(self, folder: str | None) -> Settings:
+        """The settings ``execsql lint`` run from *folder* (the working directory if ``None``) reads.
+
+        A config error is shown to the user and leaves every rule on.
+        """
+        from execsql.cli.lint import resolve_selectors
+        from execsql.cli.run import _tool_config
+
+        here = os.getcwd()
+        try:
+            if folder is not None:
+                os.chdir(folder)
+            conf = _tool_config(None)
+            return Settings(
+                select=resolve_selectors([conf.lint_select]) if conf.lint_select else (),
+                ignore=resolve_selectors([conf.lint_ignore]) if conf.lint_ignore else (),
+                format_options={
+                    "indent": conf.format_indent,
+                    "use_sql": conf.format_sql,
+                    "leading_comma": conf.format_leading_comma,
+                    "rewrite_sql": conf.format_rewrite_sql,
+                },
+            )
+        except Exception as exc:  # a bad config must not take the server down
+            self.window_show_message(
+                types.ShowMessageParams(type=types.MessageType.Warning, message=f"execsql config: {exc}"),
+            )
+            return Settings()
+        finally:
+            os.chdir(here)
+
+    def settings_for(self, uri: str) -> Settings:
+        """The settings of the innermost workspace folder holding *uri*'s file, else :attr:`fallback`."""
+        path = to_fs_path(uri)
+        if path is None:
+            return self.fallback
+        key = same_file_key(path)
+        holding = [f for f in self.settings if key == f or key.startswith(f.rstrip(os.sep) + os.sep)]
+        return self.settings[max(holding, key=len)] if holding else self.fallback
+
+    def index(self, uri: str) -> ScriptIndex:
+        """The current document's index (rebuilt per request: a few milliseconds).
+
+        A script the parser cannot handle (nesting past Python's recursion
+        limit) gets an empty index, so features fall back to what needs none.
+        """
+        document = self.workspace.get_text_document(uri)
+        path = to_fs_path(uri)
+        try:
+            index = index_script(document.source, path, self.read_included)
+        except RecursionError:
+            index = ScriptIndex(path=path)
+        index.open_uris = self.open_uris()
+        return index
+
+    def open_uris(self) -> dict[str, str]:
+        """The open documents' URIs as the client spelled them, by :func:`same_file_key` of their paths.
+
+        A location in another open file is reported under this URI: one
+        rebuilt from the path can differ (``file:///c:/``, ``file:///C:/`` on
+        Windows), and a client may not match the two.
+        """
+        found: dict[str, str] = {}
+        for uri in self.workspace.text_documents:
+            fs_path = to_fs_path(uri)
+            if fs_path is not None:
+                found.setdefault(same_file_key(fs_path), uri)
+        return found
+
+    def read_included(self, path: Path) -> str | None:
+        """An ``INCLUDE``d file's text: the editor's copy if it is open (saved or not), else the file's.
+
+        Open documents are matched by path, not URI: clients spell the same
+        file differently (``file:///c%3A/``, ``file:///C:/`` on Windows).
+        """
+        uri = self.open_uris().get(same_file_key(str(path)))
+        if uri is not None:
+            return self.workspace.get_text_document(uri).source
+        return read_included(path)
+
+    def supports_snippets(self) -> bool:
+        caps = self.client_capabilities.text_document
+        item = caps.completion.completion_item if caps and caps.completion else None
+        return bool(item and item.snippet_support)
+
+    def publish(self, uri: str) -> None:
+        """Lint the document's current text and publish the result."""
+        document = self.workspace.get_text_document(uri)
+        settings = self.settings_for(uri)
+        try:
+            found = diagnostics(document.source, to_fs_path(uri), settings.select, settings.ignore)
+        except RecursionError:
+            found = [too_deep_diagnostic()]
+        self.text_document_publish_diagnostics(
+            types.PublishDiagnosticsParams(uri=uri, version=document.version, diagnostics=found),
+        )
+
+    def publish_all(self) -> None:
+        """Lint every open document again: a file one of them includes, or the config, changed."""
+        for uri in list(self.workspace.text_documents):
+            self.publish(uri)
+
+    def watch_files(self) -> None:
+        """Ask the client to report changes to :data:`WATCHED_FILES`, if it can."""
+        caps = self.client_capabilities.workspace
+        watched = caps.did_change_watched_files if caps else None
+        if not (watched and watched.dynamic_registration):
+            return
+        self.client_register_capability(
+            types.RegistrationParams(
+                registrations=[
+                    types.Registration(
+                        id="execsql-watched-files",
+                        method=types.WORKSPACE_DID_CHANGE_WATCHED_FILES,
+                        register_options=types.DidChangeWatchedFilesRegistrationOptions(
+                            watchers=[types.FileSystemWatcher(glob_pattern=g) for g in WATCHED_FILES],
+                        ),
+                    ),
+                ],
+            ),
+        )
+
+    def publish_later(self, uri: str) -> None:
+        """Lint after :data:`LINT_DELAY_SECONDS` without another change."""
+        previous = self.pending.pop(uri, None)
+        if previous is not None:
+            previous.cancel()
+
+        async def run() -> None:
+            await asyncio.sleep(LINT_DELAY_SECONDS)
+            self.pending.pop(uri, None)
+            self.publish(uri)
+
+        self.pending[uri] = asyncio.ensure_future(run())
+
+
+def create_server() -> ExecsqlLanguageServer:
+    """A server with every feature registered."""
+    server = ExecsqlLanguageServer()
+    rpc_logger = logging.getLogger("pygls.protocol.json_rpc")
+    if not any(isinstance(f, _DropLateCancels) for f in rpc_logger.filters):
+        rpc_logger.addFilter(_DropLateCancels())
+
+    @server.feature(types.INITIALIZED)
+    def initialized(ls: ExecsqlLanguageServer, params: types.InitializedParams) -> None:
+        ls.load_settings()
+        ls.watch_files()
+
+    @server.feature(types.TEXT_DOCUMENT_DID_OPEN)
+    def did_open(ls: ExecsqlLanguageServer, params: types.DidOpenTextDocumentParams) -> None:
+        ls.publish(params.text_document.uri)
+
+    @server.feature(types.TEXT_DOCUMENT_DID_CHANGE)
+    def did_change(ls: ExecsqlLanguageServer, params: types.DidChangeTextDocumentParams) -> None:
+        ls.publish_later(params.text_document.uri)
+
+    @server.feature(types.TEXT_DOCUMENT_DID_SAVE)
+    def did_save(ls: ExecsqlLanguageServer, params: types.DidSaveTextDocumentParams) -> None:
+        # Another open script may INCLUDE this one; a client that cannot watch files reports nothing else.
+        ls.publish_all()
+
+    @server.feature(types.WORKSPACE_DID_CHANGE_WATCHED_FILES)
+    def did_change_watched_files(ls: ExecsqlLanguageServer, params: types.DidChangeWatchedFilesParams) -> None:
+        if any(Path(to_fs_path(change.uri) or "").name.lower() == "execsql.conf" for change in params.changes):
+            ls.load_settings()
+        ls.publish_all()
+
+    @server.feature(types.WORKSPACE_DID_CHANGE_WORKSPACE_FOLDERS)
+    def did_change_folders(ls: ExecsqlLanguageServer, params: types.DidChangeWorkspaceFoldersParams) -> None:
+        # pygls has already updated ls.workspace.folders.
+        ls.load_settings()
+        ls.publish_all()
+
+    @server.feature(types.TEXT_DOCUMENT_DID_CLOSE)
+    def did_close(ls: ExecsqlLanguageServer, params: types.DidCloseTextDocumentParams) -> None:
+        uri = params.text_document.uri
+        pending = ls.pending.pop(uri, None)
+        if pending is not None:
+            pending.cancel()
+        ls.text_document_publish_diagnostics(types.PublishDiagnosticsParams(uri=uri, diagnostics=[]))
+
+    @server.feature(
+        types.TEXT_DOCUMENT_COMPLETION,
+        types.CompletionOptions(trigger_characters=["!", "(", "{", "$", " "]),
+    )
+    def completion(ls: ExecsqlLanguageServer, params: types.CompletionParams) -> types.CompletionList:
+        uri = params.text_document.uri
+        source = ls.workspace.get_text_document(uri).source
+        return completions(
+            ls.index(uri),
+            source,
+            params.position.line,
+            params.position.character,
+            snippets=ls.supports_snippets(),
+        )
+
+    @server.feature(types.TEXT_DOCUMENT_HOVER)
+    def on_hover(ls: ExecsqlLanguageServer, params: types.HoverParams) -> types.Hover | None:
+        uri = params.text_document.uri
+        source = ls.workspace.get_text_document(uri).source
+        return hover(ls.index(uri), source, params.position.line, params.position.character)
+
+    @server.feature(types.TEXT_DOCUMENT_DEFINITION)
+    def on_definition(ls: ExecsqlLanguageServer, params: types.DefinitionParams) -> list[types.Location]:
+        uri = params.text_document.uri
+        return definition(ls.index(uri), uri, params.position.line, params.position.character)
+
+    @server.feature(types.TEXT_DOCUMENT_REFERENCES)
+    def on_references(ls: ExecsqlLanguageServer, params: types.ReferenceParams) -> list[types.Location]:
+        uri = params.text_document.uri
+        return references(
+            ls.index(uri),
+            uri,
+            params.position.line,
+            params.position.character,
+            include_declaration=params.context.include_declaration,
+        )
+
+    @server.feature(types.TEXT_DOCUMENT_DOCUMENT_SYMBOL)
+    def on_symbols(ls: ExecsqlLanguageServer, params: types.DocumentSymbolParams) -> list[types.DocumentSymbol]:
+        uri = params.text_document.uri
+        try:
+            return document_symbols(ls.index(uri), ls.workspace.get_text_document(uri).source)
+        except RecursionError:  # nesting deeper than the outline can walk: no outline
+            return []
+
+    @server.feature(
+        types.TEXT_DOCUMENT_CODE_ACTION,
+        types.CodeActionOptions(code_action_kinds=[types.CodeActionKind.QuickFix]),
+    )
+    def on_code_action(ls: ExecsqlLanguageServer, params: types.CodeActionParams) -> list[types.CodeAction]:
+        uri = params.text_document.uri
+        source = ls.workspace.get_text_document(uri).source
+        return code_actions(ls.index(uri), uri, source, params.context.diagnostics)
+
+    @server.feature(types.TEXT_DOCUMENT_FORMATTING)
+    def on_format(ls: ExecsqlLanguageServer, params: types.DocumentFormattingParams) -> list[types.TextEdit] | None:
+        uri = params.text_document.uri
+        source = ls.workspace.get_text_document(uri).source
+        try:
+            return format_document(source, **ls.settings_for(uri).format_options)
+        except Exception as exc:  # e.g. the formatter extra missing: say so, change nothing
+            ls.window_show_message(
+                types.ShowMessageParams(type=types.MessageType.Error, message=f"execsql format: {exc}"),
+            )
+            return None
+
+    @server.feature(types.TEXT_DOCUMENT_PREPARE_RENAME)
+    def on_prepare_rename(ls: ExecsqlLanguageServer, params: types.PrepareRenameParams) -> types.Range | None:
+        return prepare_rename(ls.index(params.text_document.uri), params.position.line, params.position.character)
+
+    @server.feature(types.TEXT_DOCUMENT_RENAME, types.RenameOptions(prepare_provider=True))
+    def on_rename(ls: ExecsqlLanguageServer, params: types.RenameParams) -> types.WorkspaceEdit | None:
+        uri = params.text_document.uri
+        try:
+            return rename(ls.index(uri), uri, params.position.line, params.position.character, params.new_name)
+        except RenameError as exc:
+            ls.window_show_message(types.ShowMessageParams(type=types.MessageType.Warning, message=str(exc)))
+            return None
+
+    @server.feature(types.TEXT_DOCUMENT_FOLDING_RANGE)
+    def on_folding(ls: ExecsqlLanguageServer, params: types.FoldingRangeParams) -> list[types.FoldingRange]:
+        uri = params.text_document.uri
+        try:
+            return folding_ranges(ls.workspace.get_text_document(uri).source, to_fs_path(uri))
+        except RecursionError:  # nesting deeper than the parser can walk: no folding
+            return []
+
+    @server.feature(types.TEXT_DOCUMENT_DOCUMENT_LINK)
+    def on_links(ls: ExecsqlLanguageServer, params: types.DocumentLinkParams) -> list[types.DocumentLink]:
+        return document_links(ls.index(params.text_document.uri))
+
+    return server

execsql/metacommands/dispatch.py

@@ -705,6 +705,13 @@ def build_dispatch_table() -> MetaCommandList:
         description="QUOTE_ALL_TEXT",
         category="config_option",
     )
+    # The documented form; upstream accepted only bare MAX_INT, which stays.
+    mcl.add(
+        r"^\s*CONFIG\s+MAX_INT\s+(?P<maxint>[0-9]+)\s*$",
+        x_max_int,
+        description="MAX_INT",
+        category="config_option",
+    )
     mcl.add(
         r"^\s*CONFIG\s+IMPORT_ROW_BUFFER\s+(?P<rows>[1-9][0-9]*)\s*$",
         x_import_row_buffer,