ZedScripts 0.0.2__py3-none-any.whl

ZedScripts/scripts/version.py

@@ -0,0 +1,75 @@
+from typing import TYPE_CHECKING, Self
+if TYPE_CHECKING:
+    from ..environment.config import ReleaseModel
+
+
+class GameVersion:
+    _cache: dict[str, 'GameVersion'] = {}
+    def __init__(self, version: str):
+        self.version = version
+        split_version = version.split(".")
+        assert len(split_version) >= 3, "Version must have major, minor, and patch components"
+        self.major = int(split_version[0])
+        self.minor = int(split_version[1])
+        self.patch = int(split_version[2])
+
+        # cache
+        GameVersion._cache[version] = self
+
+    def __hash__(self):
+        return hash((self.major, self.minor, self.patch))
+
+    def __str__(self) -> str:
+        return self.version
+
+    def to_data_version(self, build: int) -> "DataVersion":
+        return DataVersion(f"{self.major}.{self.minor}.{self.patch}.{build}")
+
+    @staticmethod
+    def find_or_make(version: str) -> "GameVersion":
+        return GameVersion._cache.get(version, GameVersion(version))
+
+    @staticmethod
+    def from_values(major: int, minor: int, patch: int) -> "GameVersion":
+        return GameVersion.find_or_make(f"{major}.{minor}.{patch}")
+
+    def __ge__(self, other):
+        if not isinstance(other, GameVersion): return NotImplemented
+        return (self.major, self.minor, self.patch) >= (other.major, other.minor, other.patch)
+
+    def __gt__(self, other):
+        if not isinstance(other, GameVersion): return NotImplemented
+        return (self.major, self.minor, self.patch) > (other.major, other.minor, other.patch)
+
+    def __lt__(self, other):
+        if not isinstance(other, GameVersion): return NotImplemented
+        return (self.major, self.minor, self.patch) < (other.major, other.minor, other.patch)
+
+    def __le__(self, other):
+        if not isinstance(other, GameVersion): return NotImplemented
+        return (self.major, self.minor, self.patch) <= (other.major, other.minor, other.patch)
+
+    def __eq__(self, other):
+        if not isinstance(other, GameVersion): return NotImplemented
+        return (self.major, self.minor, self.patch) == (other.major, other.minor, other.patch)
+
+class DataVersion(GameVersion):
+    _data_cache: dict[str, 'DataVersion'] = {}
+    def __init__(self, version: str):
+        super().__init__(version)
+        split_version = version.split(".")
+        assert len(split_version) >= 4, "Data version must have major, minor, patch, and build components"
+        self.build = int(split_version[3])
+
+        # cache
+        DataVersion._data_cache[version] = self
+
+    def __hash__(self):
+        return hash((self.major, self.minor, self.patch, self.build))
+
+    def to_game_version(self) -> GameVersion:
+        return GameVersion.find_or_make(f"{self.major}.{self.minor}.{self.patch}")
+
+    @staticmethod
+    def find_or_make(version: str) -> "DataVersion":
+        return DataVersion._data_cache.get(version, DataVersion(version))

ZedScripts/server.py

@@ -0,0 +1,288 @@
+import os
+import logging
+from pathlib import Path
+
+from lsprotocol import types
+from pygls.lsp.server import LanguageServer
+from pygls.protocol.language_server import LanguageServerProtocol
+
+from .__about__ import __version__
+from .utils import uri_to_path
+from .environment import WorkspaceType
+from .environment.workspace import Workspace
+from .environment.document import Document
+from .providers.diagnostics import DiagnosticReport
+from .providers.semantic_tokens import get_tokens
+from .providers.locale import zedlocalizer
+from .providers import capabilities
+from .providers.notifications import ZedNotification, NotificationParams
+
+
+
+# for future implementation of custom protocol features
+class ZedLanguageProtocole(LanguageServerProtocol): ...
+
+
+
+class ZedServer(LanguageServer):
+    instance: 'ZedServer | None' = None
+    def __init__(self):
+        super().__init__(name="zedserver", version=__version__, protocol_cls=ZedLanguageProtocole)
+        self.documents: dict[Path, Document] = {}
+        zedlocalizer.load_locale_files()
+        ZedServer.instance = self
+
+    def send_notification(self, method: ZedNotification, params: NotificationParams | None = None) -> None:
+        logging.debug("Sending notification: %s with params: %s", method, params)
+        self.protocol.notify(
+            method,
+            params
+        )
+
+    # def send_request(self, method: str, )
+
+
+    def wait_for_debug_client(self) -> None:
+        import time
+        from .providers.debug import wait_for_port_available, force_close_port
+        try:
+            import debugpy
+        except ImportError:
+            logging.error("debugpy is not installed. Debugging will not be available.")
+            return
+
+        debug_port = 5678
+        debug_host = "localhost"
+        
+        # ensure the debug port is available
+        if not wait_for_port_available(debug_port, debug_host):
+            logging.error(f"Debug port {debug_port} is still in use after waiting. Attempting to bind anyway...")
+
+            # probably a bad idea to do that
+            # but realistically, we should only be the ones using that port
+            force_close_port(debug_port)
+            time.sleep(0.2)
+
+
+        debugpy.listen((debug_host, debug_port))
+        logging.debug(f"Waiting for debug client to attach on {debug_host}:{debug_port}...")
+        debugpy.wait_for_client()  # blocks until the "Python: Attach" launch config connects
+        logging.debug("Debug client attached.")
+
+
+    def startup(self) -> None:
+        logging.info(f"ZedServer {__version__} starting up.")
+
+        logging.debug("ZEDSCRIPTS_DEBUG_WAIT=%s", os.environ.get("ZEDSCRIPTS_DEBUG_WAIT"))
+        if os.environ.get("ZEDSCRIPTS_DEBUG_WAIT") == "1":
+            self.wait_for_debug_client()
+
+        self.start_io()
+
+
+
+    def on_document_changed(self, path: Path, text: str) -> None:
+        # skip if it's a configuration file
+        if Workspace.update_configuration_file(path, text):
+            return
+
+        # first check if the file is a zedscripts file
+        document = Workspace.find_or_make(path)
+        if document is None:
+            return
+        
+        logging.debug("Document changed: %s\n%s", path, text)
+
+        # update it
+        document.on_document_changed(text)
+
+    def on_document_deleted(self, path: Path) -> None:
+        Document.delete(path)
+
+    def on_document_renamed(self, old_file: Path, new_file: Path) -> None:
+        Document.rename(old_file, new_file)
+
+    def on_did_change_watched_files(self, params: types.DidChangeWatchedFilesParams) -> None:
+        # we are only interested in handling the global configuration file changes
+        for change in params.changes:
+            path = uri_to_path(change.uri)
+            if not Workspace.is_global_configuration_file(path):
+                continue
+
+            logging.debug(f"Global configuration file changed. ({change.type})")
+
+            # update the global configuration
+            Workspace.update_global_configuration()
+
+
+    def on_document_diagnostics(self, path: Path, previous_result_id: str | None) -> DiagnosticReport | None:
+        document = Workspace.find_or_make(path)
+        if document is None:
+            return None
+        return document.on_document_diagnostics(previous_result_id)
+
+    def on_semantic_tokens(self, path: Path) -> types.SemanticTokens | None:
+        document = Document.find(path)
+        if document is None:
+            return None
+        return document.on_semantic_tokens()
+
+    def on_document_hover(self, path: Path, position: types.Position) -> types.Hover | None:
+        document = Document.find(path)
+        if document is None:
+            return None
+        return document.on_hover(position)
+
+    def on_linked_editing_range(self, path: Path, position: types.Position) -> types.LinkedEditingRanges | None:
+        document = Document.find(path)
+        if document is None:
+            return None
+        return document.on_linked_editing_range(position)
+
+    def on_definition(self, path: Path, position: types.Position) -> types.DefinitionResult:
+        document = Document.find(path)
+        if document is None: 
+            return None
+        return document.on_definition(position)
+
+zedserver = ZedServer()
+
+
+
+## EVENT HANDLERS
+
+@zedserver.feature(types.INITIALIZE)
+def initialize(server: ZedServer, params: types.InitializeParams):
+    """
+    In here we handle the initialization of the server. For that we provide
+    a set of rules and capabilities that the server supports.
+
+    ### Diagnostics
+    Our diagnostics depend on other files so we prefer to diagnostic 
+    the whole workspace. They could take a while for large workspaces
+    (i.e. the game files) so we want to provide feedback when it takes
+    a while.
+    """
+    # this will store what the server can currently do
+    capabilities.register_client_capabilities(params)
+
+    # from the above, we determine what the server capabilities should be
+    return types.InitializeResult(
+        capabilities=capabilities.get_server_capabilities(),
+        server_info=types.ServerInfo(
+            name="ZedScripts Language Server",
+            version=__version__,
+        )
+    )
+
+
+@zedserver.feature(types.INITIALIZED)
+def initialized(server: ZedServer, params: types.InitializedParams) -> None:
+    """
+    Called after the client sends the 'initialized' notification.
+    At this point, the client is ready to receive notifications.
+    This is the proper place to load workspaces and send progress notifications.
+    """
+    # load the global dataset
+    Workspace.global_dataset.load()
+
+    logging.debug("Server workspace folders")
+    logging.debug(server.workspace.folders)
+    for workspace_folder in server.workspace.folders.values():
+        ws = Workspace(uri_to_path(workspace_folder.uri), WorkspaceType.PROJECT)
+        ws.load()
+    Workspace.load_libraries()
+    server.send_notification(
+        ZedNotification.LOADING_DOCUMENTS_DONE
+    )
+
+
+@zedserver.feature(types.TEXT_DOCUMENT_DID_OPEN)
+def did_open(server: ZedServer, params: types.DidOpenTextDocumentParams) -> None:
+    server.on_document_changed(uri_to_path(params.text_document.uri), params.text_document.text)
+    
+@zedserver.feature(types.TEXT_DOCUMENT_DID_CHANGE)
+def did_change(server: ZedServer, params: types.DidChangeTextDocumentParams) -> None:
+    document = server.workspace.get_text_document(params.text_document.uri)
+    server.on_document_changed(uri_to_path(document.uri), str.join("", document.lines))
+
+@zedserver.feature(types.WORKSPACE_DID_DELETE_FILES)
+def workspace_did_delete_files(server: ZedServer, params: types.DeleteFilesParams) -> None:
+    for file in params.files:
+        path = uri_to_path(file.uri)
+        server.on_document_deleted(path)
+
+@zedserver.feature(types.WORKSPACE_DID_RENAME_FILES)
+def workspace_did_rename_files(server: ZedServer, params: types.RenameFilesParams) -> None:
+    for file in params.files:
+        old_path = uri_to_path(file.old_uri)
+        new_path = uri_to_path(file.new_uri)
+        server.on_document_renamed(old_path, new_path)
+
+
+
+@zedserver.feature(types.TEXT_DOCUMENT_DIAGNOSTIC)
+def diagnostic(server: ZedServer, params: types.DocumentDiagnosticParams) -> DiagnosticReport | None:
+    path = uri_to_path(params.text_document.uri)
+    return server.on_document_diagnostics(path, params.previous_result_id)
+
+
+
+# sadly I'm not sure that implementation works as expected because the client constantly
+# asks again and again for workspace diagnostics
+# it also doesn't ask for diagnostics of non-opened documents
+# 
+# # also see when implementing the configuration file:
+# # https://microsoft.github.io/language-server-protocol/specifications/lsp/3.18/specification/#diagnostic_refresh
+# @zedserver.feature(types.WORKSPACE_DIAGNOSTIC)
+# def workspace_diagnostic(server: ZedServer, params: types.WorkspaceDiagnosticParams):
+#     """
+#     Provides diagnostics for all documents in the workspace.
+#     This is called when the client requests workspace-wide diagnostics.
+#     """
+#     logging.info("Workspace diagnostic requested.")
+
+#     # map of previous result IDs by document URI
+#     previous_result_ids = {item.uri: item.value for item in params.previous_result_ids}
+#     logging.debug(pformat(previous_result_ids))
+
+#     items: list[types.WorkspaceDocumentDiagnosticReport] = []
+#     for document in Document.get_documents():
+#         uri = document.get_uri()
+#         previous_result_id = previous_result_ids.get(uri)
+#         items.append(document.get_lsp_workspace_diagnostics(previous_result_id))
+
+#     return types.WorkspaceDiagnosticReport(items=items)
+
+
+token_types, token_modifiers = get_tokens()
+@zedserver.feature(
+        types.TEXT_DOCUMENT_SEMANTIC_TOKENS_FULL,
+        types.SemanticTokensLegend(
+            token_types=token_types,
+            token_modifiers=token_modifiers,
+        )
+    )
+def semantic_tokens(server: ZedServer, params: types.SemanticTokensParams):
+    path = uri_to_path(params.text_document.uri)
+    return server.on_semantic_tokens(path)
+
+
+@zedserver.feature(types.TEXT_DOCUMENT_HOVER)
+def hover(server: ZedServer, params: types.HoverParams) -> types.Hover | None:
+    path = uri_to_path(params.text_document.uri)
+    return server.on_document_hover(path, params.position)
+
+@zedserver.feature(types.TEXT_DOCUMENT_LINKED_EDITING_RANGE)
+def linked_editing_range(server: ZedServer, params: types.LinkedEditingRangeParams) -> types.LinkedEditingRanges | None:
+    path = uri_to_path(params.text_document.uri)
+    return server.on_linked_editing_range(path, params.position)
+
+@zedserver.feature(types.TEXT_DOCUMENT_DEFINITION)
+def definition(server: ZedServer, params: types.DefinitionParams) -> types.DefinitionResult:
+    path = uri_to_path(params.text_document.uri)
+    return server.on_definition(path, params.position)
+
+@zedserver.feature(types.WORKSPACE_DID_CHANGE_WATCHED_FILES)
+def did_change_watched_files(server: ZedServer, params: types.DidChangeWatchedFilesParams) -> None:
+    return server.on_did_change_watched_files(params)

ZedScripts/structure/ast.py

@@ -0,0 +1,143 @@
+from typing import TYPE_CHECKING, Optional
+
+from .lexer import Token, TokenCollection
+
+if TYPE_CHECKING:
+    from .lexer import TextPosition
+
+class BlockBody:
+    def __init__(self) -> None:
+        super().__init__()
+        self.children: list[Node] = []
+        """Child nodes."""
+
+
+class Node:
+    """Base class for Zedscript AST nodes."""
+    def __init__(self, *, comments: Optional[list[Token]] = None) -> None:
+        super().__init__()
+        if comments is None:
+            comments = []
+        self.comments: list[Token] = comments
+        """
+        Comments for the node.
+        For blocks, all comments before the opening bracket are included.
+        For values, all comments in the range of the value are included.
+        A TokenCollection is not used because the tokens might not be contiguous.
+        """
+
+
+class BlockNode(Node, BlockBody):
+    """
+    Zedscript block.
+    """
+    def __init__(
+            self, type: TokenCollection | None, id: TokenCollection | None,
+            open_bracket: Token, close_bracket: Token | None,
+            *, comments: Optional[list[Token]] = None
+    ) -> None:
+        super().__init__(comments=comments)
+        self.type: TokenCollection | None = type
+        """
+        Tokens representing the type of the block.
+        This never has any whitespace, but a collection is used because comments can appear anywhere.
+        This will never be None in well formed Zedscript. 
+        """
+        self.id: TokenCollection | None = id
+        """
+        Tokens representing the id of the block.
+        This never has any whitespace, but a collection is used because comments can appear anywhere.
+        """
+        self.open_bracket: Token = open_bracket
+        """
+        Opening bracket token. (``{``)
+        """
+        self.close_bracket: Token | None = close_bracket
+        """
+        Closing bracket token. (``}``)
+        This will never be None in well formed Zedscript.
+        """
+
+    @property
+    def tokens(self) -> TokenCollection:
+        result = TokenCollection()
+        if self.type is not None:
+            result.extend(self.type)
+        if self.id is not None:
+            result.extend(self.id)
+        result.append(self.open_bracket)
+        if self.close_bracket is not None:
+            result.append(self.close_bracket)
+        return result
+
+    def well_formed(self) -> bool:
+        return self.type is not None and self.close_bracket is not None
+
+    def contains_position(self, text_position: 'TextPosition') -> bool:
+        return self.tokens.to_range() == text_position
+
+
+class ValueNode(Node):
+    """
+    Zedscript value.
+    """
+    def __init__(self, tokens: TokenCollection, comma: Token, *, comments: Optional[list[Token]] = None) -> None:
+        super().__init__(comments=comments)
+        self.tokens: TokenCollection = tokens
+        """Tokens comprising the value."""
+        self.comma: Token = comma
+        """
+        Comma token following the value.
+        """
+
+    def is_key_value(self) -> bool:
+        return "=" in str(self.tokens)
+
+    def value(self) -> TokenCollection:
+        if not self.is_key_value():
+            return self.tokens.strip()
+        value = TokenCollection()
+
+        # for token in reversed(self.tokens):
+        found_equal = False
+        for token in self.tokens:
+            if not found_equal:
+                if token.text == "=":
+                    found_equal = True
+                continue
+            # if token.text == "=":
+            #     found_equal = True
+            #     break
+            value.append(token)
+
+        # since we looped backwards, they've been inserted backwards
+        # value.reverse()
+        return value.strip()
+
+    def key(self) -> TokenCollection:
+        assert self.is_key_value()
+        key = TokenCollection()
+
+        for token in self.tokens:
+            if token.text == "=":
+                break
+            key.append(token)
+
+        return key.strip()
+
+    def equals(self) -> Token:
+        assert self.is_key_value()
+        for token in self.tokens:
+            if token.text == "=":
+                return token
+        raise RuntimeError("Couldn't find equals token")
+
+    def contains_position(self, text_position: 'TextPosition') -> bool:
+        return self.tokens.to_range() == text_position
+
+
+class Chunk(BlockBody):
+    """
+    Root of a Zedscript chunk.
+    A chunk is essentially a block body, but we use a separate class to avoid ambiguity.
+    """