ZedScripts 0.0.2__tar.gz → 0.0.3__tar.gz

{zedscripts-0.0.2/src/ZedScripts.egg-info → zedscripts-0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ZedScripts
-Version: 0.0.2
+Version: 0.0.3
 Author: SimKDT
 License-Expression: MIT
 Requires-Python: >=3.12.3
@@ -19,11 +19,11 @@ Dynamic: license-file
 
 # ZedScripts LSP
 
-![ZedScripts-LSP](https://img.shields.io/badge/Latest_version-0.0.2-blue)
-[![License](https://img.shields.io/github/license/PZ-Wiki-Modding/ZedScripts-LSP?label=License)](LICENSE)
-![Code Size](https://img.shields.io/github/languages/code-size/PZ-Wiki-Modding/ZedScripts-LSP?label=Code%20Size)
-[![PyPi Version](https://img.shields.io/pypi/v/ZedScripts-LSP)](https://pypi.org/project/ZedScripts-LSP/)
-[![PyPi Downloads](https://img.shields.io/pypi/dm/ZedScripts-LSP)](https://pypi.org/project/ZedScripts-LSP/)
+[![License](https://img.shields.io/github/license/PZ-Wiki-Modding/ZedScripts?label=License)](LICENSE)
+![Code Size](https://img.shields.io/github/languages/code-size/PZ-Wiki-Modding/ZedScripts?label=Code%20Size)
+[![PyPi Version](https://img.shields.io/pypi/v/ZedScripts)](https://pypi.org/project/ZedScripts/)
+[![PyPi Downloads](https://img.shields.io/pypi/dm/ZedScripts)](https://pypi.org/project/ZedScripts/)
+![PyPI Python Version](https://img.shields.io/pypi/pyversions/ZedScripts)
 
 > [!IMPORTANT]
 > Work In Progress, this is a BETA release
@@ -101,5 +101,32 @@ Example configuration:
 
 WIP: proper documentation will come soon
 
+## IDE configuration
+Based on the IDE you use, you may need to install the ZedScripts LSP application for your OS in the [releases](https://github.com/PZ-Wiki-Modding/ZedScripts-LSP/releases) (Linux, Windows).
+
+### Visual Studio Code
+
+Install the [ZedScripts extension](https://marketplace.visualstudio.com/items?itemName=SimKDT.ZedScripts) from the Visual Studio Code marketplace. The extension will handle the downloading and setup of the ZedScripts LSP server for you.
+
+### VIM
+
+Using [yegappan/lsp](https://github.com/yegappan/lsp), setup the ZedScripts LSP server as follows:
+
+```vim
+let lspServers = [
+      \ #{
+      \   name: 'zedscripts',
+      \   filetype: ['text', 'zedscripts'],
+      \   path: 'path/to/ZedScripts',
+      \   args: []
+      \ }
+      \ ]
+
+autocmd User LspSetup call LspAddServer(lspServers)
+```
+
+> [!NOTE]
+> You can see [this video](https://www.youtube.com/watch?v=-5lb_jLQmKc) which explains how to set up VIM, and notably setup a LSP server.
+
 ## License
 See [LICENSE](LICENSE) for details.

{zedscripts-0.0.2 → zedscripts-0.0.3}/README.md

@@ -1,10 +1,10 @@
 # ZedScripts LSP
 
-![ZedScripts-LSP](https://img.shields.io/badge/Latest_version-0.0.2-blue)
-[![License](https://img.shields.io/github/license/PZ-Wiki-Modding/ZedScripts-LSP?label=License)](LICENSE)
-![Code Size](https://img.shields.io/github/languages/code-size/PZ-Wiki-Modding/ZedScripts-LSP?label=Code%20Size)
-[![PyPi Version](https://img.shields.io/pypi/v/ZedScripts-LSP)](https://pypi.org/project/ZedScripts-LSP/)
-[![PyPi Downloads](https://img.shields.io/pypi/dm/ZedScripts-LSP)](https://pypi.org/project/ZedScripts-LSP/)
+[![License](https://img.shields.io/github/license/PZ-Wiki-Modding/ZedScripts?label=License)](LICENSE)
+![Code Size](https://img.shields.io/github/languages/code-size/PZ-Wiki-Modding/ZedScripts?label=Code%20Size)
+[![PyPi Version](https://img.shields.io/pypi/v/ZedScripts)](https://pypi.org/project/ZedScripts/)
+[![PyPi Downloads](https://img.shields.io/pypi/dm/ZedScripts)](https://pypi.org/project/ZedScripts/)
+![PyPI Python Version](https://img.shields.io/pypi/pyversions/ZedScripts)
 
 > [!IMPORTANT]
 > Work In Progress, this is a BETA release
@@ -82,5 +82,32 @@ Example configuration:
 
 WIP: proper documentation will come soon
 
+## IDE configuration
+Based on the IDE you use, you may need to install the ZedScripts LSP application for your OS in the [releases](https://github.com/PZ-Wiki-Modding/ZedScripts-LSP/releases) (Linux, Windows).
+
+### Visual Studio Code
+
+Install the [ZedScripts extension](https://marketplace.visualstudio.com/items?itemName=SimKDT.ZedScripts) from the Visual Studio Code marketplace. The extension will handle the downloading and setup of the ZedScripts LSP server for you.
+
+### VIM
+
+Using [yegappan/lsp](https://github.com/yegappan/lsp), setup the ZedScripts LSP server as follows:
+
+```vim
+let lspServers = [
+      \ #{
+      \   name: 'zedscripts',
+      \   filetype: ['text', 'zedscripts'],
+      \   path: 'path/to/ZedScripts',
+      \   args: []
+      \ }
+      \ ]
+
+autocmd User LspSetup call LspAddServer(lspServers)
+```
+
+> [!NOTE]
+> You can see [this video](https://www.youtube.com/watch?v=-5lb_jLQmKc) which explains how to set up VIM, and notably setup a LSP server.
+
 ## License
 See [LICENSE](LICENSE) for details.

{zedscripts-0.0.2 → zedscripts-0.0.3}/pyproject.toml

@@ -3,7 +3,7 @@ name = "ZedScripts"
 description = ""
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.12.3"
-version = "0.0.2"
+version = "0.0.3"
 license = "MIT"
 license-files = ["LICENSE"]
 authors = [
@@ -34,3 +34,10 @@ build-backend = "setuptools.build_meta"
 ZedScripts = [
     "locale/*.json"
 ]
+
+# uv configs
+[[tool.uv.index]]
+name = "testpypi"
+url = "https://test.pypi.org/simple/"
+publish-url = "https://test.pypi.org/legacy/"
+explicit = true

{zedscripts-0.0.2 → zedscripts-0.0.3}/src/ZedScripts/enums/Diagnostic.py

@@ -7,7 +7,7 @@ from ..enums.SyntaxErrorType import SyntaxErrorType
 from ..providers.diagnostics import DiagnosticDefinition
 
 
-class DiagnosticType(enum.Enum):
+class DiagnosticType(enum.StrEnum):
     @classmethod
     def _missing_(cls, value: Any) -> 'DiagnosticType | None':
         if isinstance(value, SyntaxErrorType):

zedscripts-0.0.3/src/ZedScripts/environment/config.py

@@ -0,0 +1,179 @@
+import logging
+import enum
+from pathlib import Path
+from typing import Annotated, Optional
+from pydantic import BaseModel, BeforeValidator, Field, WithJsonSchema
+
+from lsprotocol.types import DiagnosticSeverity, DiagnosticTag
+
+from ..scripts.version import DataVersion
+from ..enums.Diagnostic import DiagnosticType
+
+
+
+# the auto enum of DiagnosticType makes them lowercase, but we'll want to use
+# uppercase, that is the member's name
+
+def _parse_diagnostic_type_name(value: object) -> object:
+    if isinstance(value, DiagnosticType):
+        return value
+    if isinstance(value, str):
+        try:
+            return DiagnosticType[value]
+        except KeyError:
+            raise ValueError("type must be a DiagnosticType member name") from None
+    return value
+DiagnosticTypeName = Annotated[
+    DiagnosticType,
+    BeforeValidator(_parse_diagnostic_type_name),
+    WithJsonSchema({
+        "type": "string",
+        "enum": [member.name for member in DiagnosticType],
+    }),
+]
+
+def _parse_diagnostic_severity_name(value: object) -> object:
+    if isinstance(value, DiagnosticSeverity):
+        return value
+    if isinstance(value, str):
+        try:
+            return DiagnosticSeverity[value]
+        except KeyError:
+            raise ValueError("severity must be a DiagnosticSeverity member name") from None
+    return value
+DiagnosticSeverityName = Annotated[
+    DiagnosticSeverity,
+    BeforeValidator(_parse_diagnostic_severity_name),
+    WithJsonSchema({
+        "type": "string",
+        "enum": [member.name for member in DiagnosticSeverity],
+    }),
+]
+
+def _parse_diagnostic_tag_name(value: object) -> object:
+    if isinstance(value, DiagnosticTag):
+        return value
+    if isinstance(value, str):
+        try:
+            return DiagnosticTag[value]
+        except KeyError:
+            raise ValueError("tag must be a DiagnosticTag member name") from None
+    return value
+DiagnosticTagName = Annotated[
+    DiagnosticTag,
+    BeforeValidator(_parse_diagnostic_tag_name),
+    WithJsonSchema({
+        "type": "string",
+        "enum": [member.name for member in DiagnosticTag],
+    }),
+]
+
+
+
+# define the models
+
+class DatasetTag(enum.StrEnum):
+    LATEST = "latest"
+    STABLE = "stable"
+
+
+
+class ReleaseModel(BaseModel):
+    major: int = Field(
+        description="Build game version number.",
+        ge=42,
+    )
+    minor: int = Field(
+        description="Minor game version number.",
+        ge=0,
+    )
+    patch: int = Field(
+        description="Patch game version number.",
+        ge=0,
+    )
+    version: Optional[int] = Field(
+        description="Dataset version number for the provided Build release (major.minor.patch). This is incremented whenever the dataset for a specific version is updated.",
+        default=None,
+        ge=0,
+    )
+
+class DatasetModel(BaseModel):
+    release: Optional[ReleaseModel] = Field(
+        description="Provides a configuration for the dataset version to use for validation. This overrides the `latest` and `stable` fields if set.",
+        default=None,
+    )
+    latest: Optional[bool] = Field(
+        description="Indicates whether to use the latest dataset version for validation. This is ignored if `release` is set. Overrides the `stable` field if set.",
+        default=False,
+    )
+    stable: Optional[bool] = Field(
+        description="Provides a configuration for the stable dataset version to use for validation. Ignored if `release` or `latest` is set.",
+        default=True,
+    )
+
+    def to_data_version(self) -> DataVersion | DatasetTag:
+        if self.release is None:
+            if self.latest:
+                return DatasetTag.LATEST
+            if self.stable:
+                return DatasetTag.STABLE
+            logging.warning("No dataset version specified, defaulting to 'stable'.")
+            return DatasetTag.STABLE
+        from ..scripts.dataset import Manifest
+        try:
+            return Manifest.from_release_model(self.release)
+        except Exception as e:
+            logging.error(f"Failed to get data version from release model: {e}. Defaulting to 'stable'.")
+            return DatasetTag.STABLE
+
+class DiagnosticsModel(BaseModel):
+    """Represents the diagnostics configuration for the workspace environment."""
+    type: DiagnosticTypeName = Field(
+        description="Specifies the diagnostic member name to enable.",
+    )
+    enable: Optional[bool] = Field(
+        description="Indicates whether diagnostics are enabled.",
+        default=True,
+    )
+    severity: Optional[DiagnosticSeverityName] = Field(
+        description="Specifies the severity level of the diagnostics.",
+        default=None,
+    )
+    tags: Optional[list[DiagnosticTagName]] = Field(
+        description="Specifies the tags associated with the diagnostics.",
+        default=None,
+    )
+
+class ConfigurationModel(BaseModel):
+    """Represents the content of the configuration files for workspace environments."""
+    dataset: DatasetModel = Field(
+        description="Provides configuration for the dataset version to use for diagnostics.",
+        default_factory=DatasetModel,
+    )
+    libraries: set[Path] = Field(
+        description="Set of library folders to reference. Usually this should contain the base game folder.",
+        default_factory=set,
+    )
+    ignored: set[str] = Field(
+        description="Regex patterns for files and folders to ignore in the workspace.",
+        default=set([
+            r"tileGeometry\.txt",
+            r"tileDepthTextureAssignments\.txt",
+            r".+\.tiles\.txt"
+        ]),
+    )
+    diagnostics: list[DiagnosticsModel] = Field(
+        description="List of diagnostics configurations for the workspace environment.",
+        default_factory=list,
+    )
+
+    def find_diagnostic(self, type: DiagnosticType) -> DiagnosticsModel | None:
+        for diagnostic in self.diagnostics:
+            if diagnostic.type == type:
+                return diagnostic
+        return None
+
+if __name__ == "__main__":
+    import json
+    config = ConfigurationModel()
+    print(json.dumps(config.model_json_schema(), indent=4))

{zedscripts-0.0.2 → zedscripts-0.0.3}/src/ZedScripts/environment/document.py

@@ -10,8 +10,8 @@ from ..utils import path_to_uri, position_to_texposition
 from ..enums.Diagnostic import DiagnosticType
 from ..structure.lexer import Lexer, TokenCollection
 from ..structure.parser import parse_tokens, chunk_to_root
+from ..providers import notifications
 from ..providers.diagnostics import DiagnosticReport, WorkspaceDiagnosticReport, DiagnosticCollection
-from ..providers.notifications import ZedNotification, SetZedScriptsNotificationParams
 from ..providers.semantic_tokens import SemanticTokenCollection, build_syntactic_tokens
 from ..providers.actions import make_linked_editing_ranges
 
@@ -21,8 +21,7 @@ if TYPE_CHECKING:
 
     from .workspace import Workspace
     from .mod import Mod
-    from ..server import ZedServer
-    from ..scripts.block import Block, Root
+    from ..scripts.block import Root
     from ..scripts.dataset import Dataset
 
 class Document:
@@ -85,16 +84,10 @@ class Document:
         self.mod = mod
 
     def make_zedscripts(self) -> None:
-        # import here to avoid circular dependency
-        from ..server import ZedServer
-        server = ZedServer.instance
-        if server is not None:
-            server.send_notification(
-                ZedNotification.SET_ZEDSCRIPTS,
-                SetZedScriptsNotificationParams(
-                    uri=path_to_uri(self.path)
-                )
-            )
+        notifications.send_notification(
+            notifications.ZedNotification.SET_ZEDSCRIPTS,
+            uri=self.get_uri()
+        )
 
     def get_text(self) -> str:
         if self.text is None:
@@ -111,7 +104,8 @@ class Document:
         return path_to_uri(self.path)
     
     def get_lsp_diagnostics(self) -> list[types.Diagnostic]:
-        lsp_diagnostics = self.diagnostics.to_lsp() + self.syntactic_diagnostics.to_lsp()
+        config = self.workspace.get_configuration()
+        lsp_diagnostics = self.diagnostics.to_lsp(config) + self.syntactic_diagnostics.to_lsp(config)
         logging.debug(f"LSP Diagnostics for {self.get_uri()}: {len(lsp_diagnostics)}")
         return lsp_diagnostics
 
@@ -267,8 +261,10 @@ class Document:
         # set new syntactic diagnostics
         syntactic_diagnostics = self.syntactic_diagnostics
         syntactic_diagnostics.clear() # reset previous syntactic diagnostics
+        config = self.workspace.configuration
         for error in result.errors:
             syntactic_diagnostics.add(
+                config,
                 type=DiagnosticType(error.type),
                 location=error.location
             )

{zedscripts-0.0.2 → zedscripts-0.0.3}/src/ZedScripts/environment/workspace.py

@@ -12,8 +12,8 @@ from .document import Document
 from .mod import Mod, ModCollection
 from .version import Version
 from .config import ConfigurationModel
-from ..providers.notifications import ZedNotification, send_progress_notification
-from ..utils import merge_pydantic_models
+from ..providers import notifications
+from ..utils import merge_pydantic_models, path_to_uri
 from ..scripts.dataset import Dataset
 
 if TYPE_CHECKING:
@@ -43,19 +43,20 @@ class Workspace:
     def __repr__(self) -> str:
         return f"Workspace(type={self.workspace_type}, folder={self.folder})"
 
-    def load(self) -> None:
+    def load(self) -> tuple[int, int]:
         """
         Retrieve every script files and cache them as Document instances.
+
+        Returns:
+            tuple[int, int]: A tuple containing the number of loaded mods and the number of loaded documents.
         """
         logging.info(f"Loading workspace: {self.folder}")
-        self.load_mods()
+        loaded_mod_count = self.load_mods()
         # self.load_documents()
-        self.load_documents()
-
-    def load_documents(self) -> None:
-        send_progress_notification(ZedNotification.LOADING_DOCUMENTS, 
-                                   self.folder, 0.0, self.workspace_type)
+        loaded_document_count = self.load_documents()
+        return loaded_mod_count, loaded_document_count
 
+    def load_documents(self) -> int:
         # inside the workspace folder, find every txt files, and try to load them
         # as documents
         files = list(self.folder.rglob("*.txt"))
@@ -63,39 +64,51 @@ class Workspace:
         last_progress = 0
         step = 10
         step_count = step * total_files / 100
+        loaded_file_count = 0
         for progress, path in enumerate(files):
-            self.load_document(path)
+            document = self.load_document(path)
+            if document is not None:
+                loaded_file_count += 1
 
             # send update notification to client
             if progress - last_progress >= step_count:
                 logging.info(f"Loading progress: {progress}/{total_files}")
-                send_progress_notification(ZedNotification.LOADING_DOCUMENTS, 
-                                           self.folder, progress / total_files * 100, self.workspace_type)
+                notifications.send_notification(
+                    notifications.ZedNotification.SET_PROGRESS,
+                    progress=progress / total_files * 100,
+                )
                 last_progress = progress
 
         # send final progress notification
-        send_progress_notification(ZedNotification.LOADING_DOCUMENTS, 
-                                   self.folder, 100, self.workspace_type)
+        notifications.send_notification(
+            notifications.ZedNotification.SET_PROGRESS,
+            progress=100
+        )
+        return loaded_file_count
 
-    def load_mods(self) -> None:
+    def load_mods(self) -> int:
         logging.info(f"Loading mods for workspace: {self.folder}")
         # look for mod.info files
         # one or more of these files are associated to a specific mod
+        mod_count = 0
         for file in self.folder.rglob("mod.info"):
             # only consider versioning and common folders
             version = Version.find_or_make_version(file)
             if version.type in {VersionType.VERSIONING, VersionType.COMMON}:
-                mod_folder = file.parent.parent
+                mod_folder = file.parent.parent # the folder containing the 42 / common folders
                 mod = Mod.find_or_make_mod(mod_folder, self)
                 mod.add_mod_info_file(file, version)
                 self.mods[mod_folder] = mod
+                mod_count += 1
                 continue
 
             # if it's OTHER, then it's probably not a mod file
             # TODO: should we handle those ?
 
+        return mod_count
+
     @staticmethod
-    def load_libraries() -> None:
+    def load_libraries() -> int:
         logging.info("Loading libraries for all workspaces.")
 
         # gather libraries from configs
@@ -111,10 +124,25 @@ class Workspace:
         libraries = Workspace.filter_out_projects(libraries)
 
         Workspace.workspace_cache[WorkspaceType.LIBRARY] = {}
+        libraries_count = 0
         for library in libraries:
             Workspace.workspace_cache[WorkspaceType.LIBRARY][library] = Workspace(library, WorkspaceType.LIBRARY)
-        for library in Workspace.workspace_cache[WorkspaceType.LIBRARY].values():
+            libraries_count += 1
+
+        notifications.send_notification(
+            notifications.ZedNotification.SET_LIBRARIES_COUNT,
+            count=libraries_count
+        )
+
+        for i, library in enumerate(Workspace.workspace_cache[WorkspaceType.LIBRARY].values()):
+            notifications.send_notification(
+                notifications.ZedNotification.LOADING_DOCUMENTS,
+                uri=str(library.folder),
+                workspace_type=library.workspace_type,
+                index=i
+            )
             library.load()
+        return libraries_count
 
     def should_ignore(self, path: Path) -> bool:
         for pattern in self.ignored_patterns:

{zedscripts-0.0.2 → zedscripts-0.0.3}/src/ZedScripts/providers/diagnostics.py

@@ -1,20 +1,19 @@
 from __future__ import annotations
 
-from lsprotocol.types import DiagnosticSeverity, DiagnosticTag
+from lsprotocol import types
 
 import enum
 from typing import TYPE_CHECKING, ClassVar, Any
 from dataclasses import dataclass
 
-from lsprotocol import types
 
 import ZedScripts
 from ..utils import textrange_to_lsp
-from ..enums.SyntaxErrorType import SyntaxErrorType
 from ..structure.lexer import TextRange
 from ..providers.locale import zedlocalizer
 
 if TYPE_CHECKING:
+    from ..environment.config import ConfigurationModel
     from ..enums.Diagnostic import DiagnosticType
 
 type DiagnosticReport = (
@@ -37,19 +36,30 @@ class DiagnosticDefinition:
                  type: DiagnosticType, 
                  severity: types.DiagnosticSeverity, 
                  args: dict[str, Any] = {},
-                 tags: list[DiagnosticTag] = [],
+                 tags: list[types.DiagnosticTag] = [],
                 ) -> None:
         self.type: DiagnosticType = type
         self.severity: types.DiagnosticSeverity = severity
         self.args: dict[str, Any] = args
-        self.tags: list[DiagnosticTag] = tags
+        self.tags: list[types.DiagnosticTag] = tags
 
         DiagnosticDefinition.by_type[type] = self
 
+    @staticmethod
+    def get(type: DiagnosticType) -> DiagnosticDefinition:
+        assert type in DiagnosticDefinition.by_type, f"WEIRD: Diagnostic type '{type}' is not registered, but this is verified earlier"
+        return DiagnosticDefinition.by_type[type]
+
     def get_name(self) -> str:
         """Provides an identifier for the diagnostic type."""
         return self.type.name
 
+    def get_severity(self) -> types.DiagnosticSeverity:
+        return self.severity
+
+    def get_tags(self) -> list[types.DiagnosticTag]:
+        return self.tags
+
 
 @dataclass
 class DiagnosticInfo:
@@ -59,7 +69,7 @@ class DiagnosticInfo:
 
 
 class DiagnosticCollection(list[DiagnosticInfo]):
-    def to_lsp(self) -> list[types.Diagnostic]:
+    def to_lsp(self, config: ConfigurationModel) -> list[types.Diagnostic]:
         """
         Converts the different diagnostic information into LSP-compatible diagnostics.
 
@@ -67,8 +77,19 @@ class DiagnosticCollection(list[DiagnosticInfo]):
             list[types.Diagnostic]: A list of LSP-compatible diagnostic objects.
         """
         lsp_diagnostics: list[types.Diagnostic] = []
-        for diagnostic in self:
-            definition = DiagnosticDefinition.by_type[diagnostic.type]
+        for i, diagnostic in enumerate(reversed(self)):
+            definition = DiagnosticDefinition.get(diagnostic.type)
+            severity = definition.get_severity()
+            tags = definition.get_tags()
+
+            config_def = config.find_diagnostic(diagnostic.type)
+            if config_def is not None:
+                config_severity = config_def.severity
+                if config_severity is not None:
+                    severity = config_severity
+                config_tags = config_def.tags
+                if config_tags is not None:
+                    tags = config_tags
 
             # ensure that the correct arguments are always passed
             for name, arg_type in definition.args.items():
@@ -80,22 +101,28 @@ class DiagnosticCollection(list[DiagnosticInfo]):
                     range=textrange_to_lsp(diagnostic.location),
                     message=zedlocalizer.localize_string(definition.type, definition,
                                                                 args=diagnostic.args),
-                    severity=definition.severity,
+                    severity=severity,
                     source=ZedScripts.SOURCE,
                     code=definition.get_name(),
-                    tags=definition.tags
+                    tags=tags
                 )
             )
         return lsp_diagnostics
 
-    def add(self, type: DiagnosticType, location: TextRange, args: dict[str, Any] = {}) -> None:
+    def add(self, config: ConfigurationModel, type: DiagnosticType, location: TextRange, args: dict[str, Any] = {}) -> None:
         """
         Adds a new diagnostic to the collection.
 
         Args:
+            config (ConfigurationModel): The configuration model to use for the diagnostic.
             type (DiagnosticType): The type of the diagnostic.
             location (TextRange): The location in the text where the diagnostic applies.
             args (dict[str, Any], optional): Additional arguments for the diagnostic. Defaults to {}.
         """
+        config_def = config.find_diagnostic(type)
+        if config_def is not None:
+            enabled = config_def.enable
+            if not enabled:
+                return
         self.append(DiagnosticInfo(type=type, location=location, args=args))
 

zedscripts-0.0.3/src/ZedScripts/providers/notifications.py

@@ -0,0 +1,57 @@
+import enum
+
+from typing import TYPE_CHECKING, Literal, overload
+if TYPE_CHECKING:
+    from ..environment import WorkspaceType
+
+
+class ZedNotification(enum.StrEnum):
+    SET_ZEDSCRIPTS = "zedscripts/setZedScripts"
+
+    SET_PROGRESS = "zedscripts/setProgress"
+    SET_WORKSPACE_COUNT = "zedscripts/setWorkspaceCount"
+    SET_LIBRARIES_COUNT = "zedscripts/setLibrariesCount"
+
+    LOADING_DOCUMENTS = "zedscripts/loadingDocuments"
+    LOADING_DOCUMENTS_DONE = "zedscripts/loadingDocumentsDone"
+
+
+@overload
+def send_notification(
+    notification: Literal[ZedNotification.SET_ZEDSCRIPTS],
+    *, uri: str) -> None: ...
+
+
+@overload
+def send_notification(
+    notification: Literal[ZedNotification.SET_PROGRESS],
+    *, progress: float) -> None: ...
+@overload
+def send_notification(
+    notification: Literal[ZedNotification.SET_WORKSPACE_COUNT],
+    *, count: int) -> None: ...
+@overload
+def send_notification(
+    notification: Literal[ZedNotification.SET_LIBRARIES_COUNT],
+    *, count: int) -> None: ...
+
+
+@overload
+def send_notification(
+    notification: Literal[ZedNotification.LOADING_DOCUMENTS],
+    *, uri: str, workspace_type: 'WorkspaceType', index: int) -> None: ...
+
+
+def send_notification(notification: ZedNotification, **kargs) -> None:
+    """
+    Sends a notification to the Zed server.
+
+    Args:
+        notification (ZedNotification): The type of notification to send.
+        **kargs: Additional keyword arguments specific to the notification type.
+    """
+    from ..server import ZedServer
+    server = ZedServer.instance
+    if server is None:
+        return
+    server.send_notification(notification, kargs)

{zedscripts-0.0.2 → zedscripts-0.0.3}/src/ZedScripts/scripts/block.py

@@ -116,7 +116,8 @@ class Block:
         return duplicate_count > 1 # > 1 bcs there's itself in the list
 
     def add_diagnostic(self, type: DiagnosticType, location: TextRange, args: dict[str, Any] = {}) -> None:
-        self.document.diagnostics.add(type=type, location=location, args=args)
+        config = self.document.workspace.configuration
+        self.document.diagnostics.add(config, type=type, location=location, args=args)
 
     def add_semantic_token(self, type: SemanticTokenType, location: TextRange, modifiers: list[SemanticTokenModifier] = []) -> None:
         self.document.semantic_tokens.add(type=type, location=location, modifiers=modifiers)

{zedscripts-0.0.2 → zedscripts-0.0.3}/src/ZedScripts/scripts/value.py

@@ -280,7 +280,7 @@ class Value(Element["ValueNode"]):
 
             if IS_DEBUG:
                 txt += "(debug)\n\n"
-                txt += f"- Refs: {[str(ref) for ref in self.refs]}"
+                txt += f"- Refs: {[f"{ref.document.path}:{ref.get_ref_id_range()}" for ref in self.refs]}"
 
             return make_hover_information(txt, value_node.to_range())
 

{zedscripts-0.0.2 → zedscripts-0.0.3}/src/ZedScripts/server.py

@@ -7,15 +7,14 @@ from pygls.lsp.server import LanguageServer
 from pygls.protocol.language_server import LanguageServerProtocol
 
 from .__about__ import __version__
-from .utils import uri_to_path
+from .utils import uri_to_path, path_to_uri
 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
+from .providers import capabilities, notifications
 
 
 
@@ -32,7 +31,7 @@ class ZedServer(LanguageServer):
         zedlocalizer.load_locale_files()
         ZedServer.instance = self
 
-    def send_notification(self, method: ZedNotification, params: NotificationParams | None = None) -> None:
+    def send_notification(self, method: notifications.ZedNotification, params: dict | None = None) -> None:
         logging.debug("Sending notification: %s with params: %s", method, params)
         self.protocol.notify(
             method,
@@ -186,16 +185,37 @@ def initialized(server: ZedServer, params: types.InitializedParams) -> None:
     # load the global dataset
     Workspace.global_dataset.load()
 
+    # load workspaces
     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
+    should_load_libraries = False
+    folders = server.workspace.folders.values()
+    
+    notifications.send_notification(
+        notifications.ZedNotification.SET_WORKSPACE_COUNT,
+        count=len(folders)
     )
 
+    for i, workspace_folder in enumerate(folders):
+        ws = Workspace(uri_to_path(workspace_folder.uri), WorkspaceType.PROJECT)
+
+        notifications.send_notification(
+            notifications.ZedNotification.LOADING_DOCUMENTS,
+            uri=path_to_uri(ws.folder),
+            workspace_type=ws.workspace_type,
+            index=i+1
+        )
+
+        _, file_count = ws.load()
+        if file_count != 0:
+            should_load_libraries = True
+
+    # load libraries if any ZedScripts files were found
+    if should_load_libraries:
+        Workspace.load_libraries()
+
+    server.send_notification(notifications.ZedNotification.LOADING_DOCUMENTS_DONE)
+
 
 @zedserver.feature(types.TEXT_DOCUMENT_DID_OPEN)
 def did_open(server: ZedServer, params: types.DidOpenTextDocumentParams) -> None:

{zedscripts-0.0.2 → zedscripts-0.0.3/src/ZedScripts.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ZedScripts
-Version: 0.0.2
+Version: 0.0.3
 Author: SimKDT
 License-Expression: MIT
 Requires-Python: >=3.12.3
@@ -19,11 +19,11 @@ Dynamic: license-file
 
 # ZedScripts LSP
 
-![ZedScripts-LSP](https://img.shields.io/badge/Latest_version-0.0.2-blue)
-[![License](https://img.shields.io/github/license/PZ-Wiki-Modding/ZedScripts-LSP?label=License)](LICENSE)
-![Code Size](https://img.shields.io/github/languages/code-size/PZ-Wiki-Modding/ZedScripts-LSP?label=Code%20Size)
-[![PyPi Version](https://img.shields.io/pypi/v/ZedScripts-LSP)](https://pypi.org/project/ZedScripts-LSP/)
-[![PyPi Downloads](https://img.shields.io/pypi/dm/ZedScripts-LSP)](https://pypi.org/project/ZedScripts-LSP/)
+[![License](https://img.shields.io/github/license/PZ-Wiki-Modding/ZedScripts?label=License)](LICENSE)
+![Code Size](https://img.shields.io/github/languages/code-size/PZ-Wiki-Modding/ZedScripts?label=Code%20Size)
+[![PyPi Version](https://img.shields.io/pypi/v/ZedScripts)](https://pypi.org/project/ZedScripts/)
+[![PyPi Downloads](https://img.shields.io/pypi/dm/ZedScripts)](https://pypi.org/project/ZedScripts/)
+![PyPI Python Version](https://img.shields.io/pypi/pyversions/ZedScripts)
 
 > [!IMPORTANT]
 > Work In Progress, this is a BETA release
@@ -101,5 +101,32 @@ Example configuration:
 
 WIP: proper documentation will come soon
 
+## IDE configuration
+Based on the IDE you use, you may need to install the ZedScripts LSP application for your OS in the [releases](https://github.com/PZ-Wiki-Modding/ZedScripts-LSP/releases) (Linux, Windows).
+
+### Visual Studio Code
+
+Install the [ZedScripts extension](https://marketplace.visualstudio.com/items?itemName=SimKDT.ZedScripts) from the Visual Studio Code marketplace. The extension will handle the downloading and setup of the ZedScripts LSP server for you.
+
+### VIM
+
+Using [yegappan/lsp](https://github.com/yegappan/lsp), setup the ZedScripts LSP server as follows:
+
+```vim
+let lspServers = [
+      \ #{
+      \   name: 'zedscripts',
+      \   filetype: ['text', 'zedscripts'],
+      \   path: 'path/to/ZedScripts',
+      \   args: []
+      \ }
+      \ ]
+
+autocmd User LspSetup call LspAddServer(lspServers)
+```
+
+> [!NOTE]
+> You can see [this video](https://www.youtube.com/watch?v=-5lb_jLQmKc) which explains how to set up VIM, and notably setup a LSP server.
+
 ## License
 See [LICENSE](LICENSE) for details.

{zedscripts-0.0.2 → zedscripts-0.0.3}/src/ZedScripts.egg-info/SOURCES.txt

@@ -22,7 +22,6 @@ src/ZedScripts/environment/workspace.py
 src/ZedScripts/locale/en.json
 src/ZedScripts/providers/actions.py
 src/ZedScripts/providers/capabilities.py
-src/ZedScripts/providers/configuration.py
 src/ZedScripts/providers/debug.py
 src/ZedScripts/providers/diagnostics.py
 src/ZedScripts/providers/hover.py

zedscripts-0.0.2/src/ZedScripts/environment/config.py

@@ -1,82 +0,0 @@
-import logging
-import enum
-from pathlib import Path
-from typing import Optional
-from pydantic import BaseModel, Field
-
-from ..scripts.version import DataVersion
-
-
-class DatasetTag(enum.Enum):
-    LATEST = "latest"
-    STABLE = "stable"
-
-
-
-class ReleaseModel(BaseModel):
-    major: int = Field(
-        description="Build game version number.",
-        ge=42,
-    )
-    minor: int = Field(
-        description="Minor game version number.",
-        ge=0,
-    )
-    patch: int = Field(
-        description="Patch game version number.",
-        ge=0,
-    )
-    version: Optional[int] = Field(
-        description="Dataset version number for the provided Build release (major.minor.patch). This is incremented whenever the dataset for a specific version is updated.",
-        default=None,
-        ge=0,
-    )
-
-class DatasetModel(BaseModel):
-    release: Optional[ReleaseModel] = Field(
-        description="Provides a configuration for the dataset version to use for validation. This overrides the `latest` and `stable` fields if set.",
-        default=None,
-    )
-    latest: Optional[bool] = Field(
-        description="Indicates whether to use the latest dataset version for validation. This is ignored if `release` is set. Overrides the `stable` field if set.",
-        default=False,
-    )
-    stable: Optional[bool] = Field(
-        description="Provides a configuration for the stable dataset version to use for validation. Ignored if `release` or `latest` is set.",
-        default=True,
-    )
-
-    def to_data_version(self) -> DataVersion | DatasetTag:
-        if self.release is None:
-            if self.latest:
-                return DatasetTag.LATEST
-            if self.stable:
-                return DatasetTag.STABLE
-            logging.warning("No dataset version specified, defaulting to 'stable'.")
-            return DatasetTag.STABLE
-        from ..scripts.dataset import Manifest
-        try:
-            return Manifest.from_release_model(self.release)
-        except Exception as e:
-            logging.error(f"Failed to get data version from release model: {e}. Defaulting to 'stable'.")
-            return DatasetTag.STABLE
-
-
-class ConfigurationModel(BaseModel):
-    """Represents the content of the configuration files for workspace environments."""
-    dataset: DatasetModel = Field(
-        description="Provides configuration for the dataset version to use for diagnostics.",
-        default_factory=DatasetModel,
-    )
-    libraries: set[Path] = Field(
-        description="Set of library folders to reference. Usually this should contain the base game folder.",
-        default_factory=set,
-    )
-    ignored: set[str] = Field(
-        description="Regex patterns for files and folders to ignore in the workspace.",
-        default=set([
-            r"tileGeometry\.txt",
-            r"tileDepthTextureAssignments\.txt",
-            r".+\.tiles\.txt"
-        ]),
-    )

zedscripts-0.0.2/src/ZedScripts/providers/configuration.py

@@ -1,26 +0,0 @@
-import enum
-from typing import Any, TypedDict
-
-
-class ConfigurationType(enum.IntEnum):
-    DATA_SOURCE = enum.auto()
-
-# TODO: implement fixed configuration values
-
-
-default_configuration: dict[ConfigurationType, Any] = {
-    ConfigurationType.DATA_SOURCE: "latest"
-}
-
-
-
-class Configuration:
-    def __init__(self):
-        self.settings: dict[ConfigurationType, Any] = {}
-
-    def get(self, key: ConfigurationType, default=None):
-        return self.settings.get(key, default)
-
-    def set(self, key: ConfigurationType, value):
-        self.settings[key] = value
-

zedscripts-0.0.2/src/ZedScripts/providers/notifications.py

@@ -1,45 +0,0 @@
-import enum
-from typing import TypedDict
-from pathlib import Path
-
-from ..utils import path_to_uri
-
-from typing import TYPE_CHECKING
-if TYPE_CHECKING:
-    from ..environment import WorkspaceType
-
-
-class ZedNotification(enum.StrEnum):
-    SET_ZEDSCRIPTS = "zedscripts/setZedScripts"
-
-    LOADING_DOCUMENTS = "zedscripts/loadingDocuments"
-    LOADING_DOCUMENTS_DONE = "zedscripts/loadingDocumentsDone"
-
-
-
-class NotificationParams(TypedDict): ...
-
-class SetZedScriptsNotificationParams(NotificationParams):
-    uri: str
-
-class LoadingDocumentsNotificationParams(NotificationParams):
-    uri: str
-    progress: float
-    workspace_type: 'WorkspaceType'
-
-
-
-
-def send_progress_notification(type: ZedNotification, folder: Path, progress: float, workspace_type: 'WorkspaceType'):
-    from ..server import ZedServer
-    server = ZedServer.instance
-    if server is None:
-        return
-    server.send_notification(
-        type,
-        LoadingDocumentsNotificationParams(
-            uri=path_to_uri(folder),
-            progress=progress,
-            workspace_type=workspace_type
-        )
-    )