ZedScripts 0.0.2__py3-none-any.whl

ZedScripts/structure/parser.py

@@ -0,0 +1,243 @@
+import re
+from typing import TYPE_CHECKING
+
+from ..enums.SyntaxErrorType import SyntaxErrorType
+from .lexer import (
+    Lexer, 
+    TokenType, Token, TokenCollection, 
+    TextRange, TextPosition, 
+    ELEMENTS_DELIMITERS
+)
+from .ast import Node, Chunk, BlockNode, ValueNode
+from ..scripts.block import Block, ScriptBlock, Root
+from ..scripts.value import Value
+
+if TYPE_CHECKING:
+    from ..environment.document import Document
+
+class SyntaxError:
+    def __init__(self, type: SyntaxErrorType, location: TextRange) -> None:
+        self.type: SyntaxErrorType = type
+        self.location: TextRange = location
+
+
+class ParseResult:
+    def __init__(self, chunk: Chunk) -> None:
+        self.chunk: Chunk = chunk
+        self.errors: list[SyntaxError] = []
+
+
+class Parser:
+    def __init__(self) -> None:
+        self.chunk: Chunk = Chunk()
+        """Root of the chunk being parsed."""
+        self.block_stack: list[BlockNode] = []
+        """Stack of the currently parsing blocks."""
+
+    def add_block(self, block: BlockNode) -> None:
+        """
+        Adds a block to the top of the stack.
+        :return: The block that was added.
+        """
+        if len(self.block_stack) > 0:
+            self.block_stack[-1].children.append(block)
+        else:
+            self.chunk.children.append(block)
+        self.block_stack.append(block)
+
+    def add_value(self, value: ValueNode) -> None:
+        """
+        Adds a value to the block at the top of the stack, or the root if the stack is empty.
+        :param value: The value to push.
+        :return:
+        """
+        if len(self.block_stack) > 0:
+            self.block_stack[-1].children.append(value)
+        else:
+            self.chunk.children.append(value)
+
+    def pop_block(self) -> BlockNode:
+        """
+        Removes the block at the top of the stack.
+        :return: The block that was at the top of the stack.
+        """
+        assert len(self.block_stack) > 0, "Attempted to pop from empty stack"
+        return self.block_stack.pop()
+
+
+def parse_type_id(tokens: list[Token]) -> tuple[TokenCollection | None, TokenCollection | None]:
+    type_token = TokenCollection()
+    id_token = TokenCollection()
+    hit_whitespace = False
+    for unparsed_token in tokens:
+        if unparsed_token.type is TokenType.TEXT:
+            # all tokens before the first whitespace are the type
+            if not hit_whitespace:
+                type_token.append(unparsed_token)
+                # all tokens between the first and second are the id
+            else:
+                id_token.append(unparsed_token)
+        elif len(type_token) > 0 and unparsed_token.type is TokenType.WHITESPACE:
+            if not hit_whitespace:
+                hit_whitespace = True
+            else:
+                # after we hit whitespace for a second time, break
+                # FIXME: whitespace -> comment -> whitespace should not break
+                break
+
+    if len(type_token) < 1:
+        type_token = None
+    if len(id_token) < 1:
+        id_token = None
+
+    return type_token, id_token
+
+
+def parse(text: str) -> ParseResult:
+    return parse_tokens(Lexer.tokenize(text))
+
+
+def parse_tokens(tokens: TokenCollection) -> ParseResult:
+    parser = Parser()
+    unparsed_tokens: list[Token] = []
+    result: ParseResult = ParseResult(parser.chunk)
+    unassigned_comments: list[Token] = []
+
+    for token in tokens:
+        match token.type:
+            case TokenType.ELEMENT_DELIMITER:
+                match token.text:
+                    case "}":
+                        if len(parser.block_stack) == 0:
+                            result.errors.append(
+                                SyntaxError(SyntaxErrorType.TOO_MANY_CLOSING_BRACKETS,
+                                            TextRange(token.pos, token.end))
+                            )
+                            break
+                        if len(unparsed_tokens) > 1:
+                            # necessary when when writing between two block end }
+                            # should be -1 when after a key-value def
+                            start = 1
+                            end = -2 if len(unparsed_tokens) > 2 else -1
+                            result.errors.append(
+                                SyntaxError(SyntaxErrorType.UNPARSED_TOKENS,
+                                            TextRange(unparsed_tokens[start].pos, unparsed_tokens[end].end))
+                            )
+                        top_block = parser.pop_block()
+                        top_block.close_bracket = token
+                    case "{":
+                        type_token, id_token = parse_type_id(unparsed_tokens)
+
+                        if type_token is None:
+                            result.errors.append(
+                                SyntaxError(SyntaxErrorType.BLOCK_MISSING_TYPE,
+                                            TextRange(token.pos, token.end))
+                            )
+
+                        parser.add_block(
+                            BlockNode(
+                                type_token, id_token, token, None,
+                                comments=unassigned_comments
+                            )
+                        )
+                    case ",":
+                        value = ValueNode(
+                            TokenCollection(unparsed_tokens),
+                            token, # comma token
+                            comments=unassigned_comments
+                        )
+                        parser.add_value(value)
+                    case _:
+                        raise RuntimeError("Unknown punctuator " + token.text)
+                unparsed_tokens = []
+                unassigned_comments = []
+            case TokenType.COMMENT:
+                unassigned_comments.append(token)
+            case _:
+                unparsed_tokens.append(token)
+
+    if len(parser.block_stack) > 0:
+        result.errors.append(
+            SyntaxError(SyntaxErrorType.BLOCK_NOT_CLOSED,
+                        TextRange(parser.block_stack[0].open_bracket.pos, tokens[-1].end))
+        )
+
+    return result
+
+
+def ast_to_comment(node: Node, start: TextPosition) -> str:
+    """
+    Parses comment tokens from a node into a single string.
+    :param node: The node to parse comments from.
+    :param start: The start position of the actual object represented by the node.
+    :return: The comments merged into a string.
+    """
+    comment: str = ""
+
+    # we loop backwards to easily ignore comment tokens separated by a non-comment line
+    for token in reversed(node.comments):
+        if token.end.line < start.line - 1:
+            continue
+
+        comment = str(token)[2:-2] + comment
+
+        if token.pos < start:
+            start = token.pos
+
+    # remove leading whitespace from each line
+    comment = re.sub(r'\n\s+', '\n', comment)
+    # remove leading/trailing newlines
+    comment = re.sub(r'^\n+', '', comment)
+    comment = re.sub(r'\n+$', '', comment)
+
+    return comment
+
+
+def ast_to_value(node: ValueNode, parent: Block) -> Value:
+    tokens = node.tokens.strip()
+    if len(tokens) > 0:
+        comment = ast_to_comment(node, tokens[0].pos)
+    else:
+        comment = ""
+
+    value = Value(
+        str(node.tokens).strip(),
+        node,
+        parent,
+        comment
+    )
+
+    return value
+
+def ast_to_block(document: 'Document', node: BlockNode, parent: Block) -> ScriptBlock:
+    if node.type is None:
+        type = ""
+    else:
+        type = str(node.type)
+    
+    if node.id is None:
+        id = None
+    else:
+        id = str(node.id)
+
+    comment = ast_to_comment(node, node.open_bracket.pos)
+    block = ScriptBlock(document, type, id, node, parent, comment)
+    ast_to_any(document, block)
+
+    return block
+
+
+def ast_to_any(document, parent: ScriptBlock | Root):
+    if parent.node is None:
+        raise RuntimeError("Parent block has no associated AST node.")
+    for child in parent.node.children:
+        if isinstance(child, ValueNode):
+            parent.values.append(ast_to_value(child, parent))
+        elif isinstance(child, BlockNode):
+            parent.children.append(ast_to_block(document, child, parent))
+
+
+def chunk_to_root(document: 'Document', chunk: Chunk, rootType: str) -> Root:
+    root = Root(document, rootType, chunk, "")
+    ast_to_any(document, root)
+    return root

ZedScripts/utils.py

@@ -0,0 +1,85 @@
+from pathlib import Path
+from typing import Iterable, TypeVar
+from pydantic import BaseModel
+from deepmerge import always_merger
+
+from lsprotocol import types
+from pygls.uris import from_fs_path, to_fs_path
+
+from .structure.lexer import TextRange, TextPosition
+
+
+def textrange_to_lsp(range: TextRange) -> types.Range:
+    return types.Range(
+        types.Position(range.start.line, range.start.offset),
+        types.Position(range.end.line, range.end.offset)
+    )
+def position_to_texposition(position: types.Position) -> TextPosition:
+    return TextPosition(position.line, position.character)
+
+def uri_to_path(uri: str) -> Path:
+    fs_path = to_fs_path(uri)
+    if fs_path is None:
+        raise ValueError(f"Cannot convert URI to file path: {uri}")
+    return Path(fs_path)
+
+def path_to_uri(path: Path | str) -> str:
+    uri = from_fs_path(str(path))
+    if uri is None:
+        raise ValueError(f"Cannot convert file path to URI: {path}")
+    return uri
+
+
+
+def sort_by_load_order(files: Iterable[Path]) -> Iterable[Path]:
+    """
+    Sorts an iterable of script paths into the order that the game would load them.
+    :param files: List of script filepaths.
+    :return: Sorted list of filepaths.
+    """
+    templates: list[Path] = []
+    other: list[Path] = []
+
+    for path in files:
+        if path.name.startswith("template_"):
+            templates.append(path)
+        else:
+            other.append(path)
+
+    templates.sort()
+    other.sort()
+
+    return templates + other
+
+
+
+def glob_files_by_extensions(folder: Path, extensions: set[str]) -> Iterable[Path]:
+    """
+    Glob all files in the given folder and its subfolders 
+    that have one of the specified extensions.
+    https://stackoverflow.com/a/57054058/33113221
+    """
+    files = (p.resolve() for p in Path(folder).rglob("*") if p.suffix in extensions)
+    return files
+
+
+T = TypeVar("T", bound=BaseModel)
+
+def merge_pydantic_models(base: T, *models: T) -> T:
+    """Merge multiple Pydantic model instances.
+
+    The attributes of 'base' and all subsequent models that weren't explicitly set are dumped into dicts
+    using '.model_dump(exclude_unset=True)', which are then merged using 'deepmerge',
+    and the merged result is turned into a model instance using '.model_validate'.
+
+    For attributes set on both 'base' and the subsequent models, the value from the last model in the arguments will be used in
+    the output result.
+
+    Modified from:
+    @source: https://github.com/pydantic/pydantic/discussions/3416#discussioncomment-12267413
+    """
+    base_dict = base.model_dump(exclude_unset=True)
+    for nxt in models:
+        nxt_dict = nxt.model_dump(exclude_unset=True)
+        base_dict = always_merger.merge(base_dict, nxt_dict)
+    return base.model_validate(base_dict)

zedscripts-0.0.2.dist-info/METADATA

@@ -0,0 +1,105 @@
+Metadata-Version: 2.4
+Name: ZedScripts
+Version: 0.0.2
+Author: SimKDT
+License-Expression: MIT
+Requires-Python: >=3.12.3
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: lsprotocol
+Requires-Dist: pygls
+Requires-Dist: requests-cache
+Requires-Dist: pydantic
+Requires-Dist: deepmerge
+Provides-Extra: build
+Requires-Dist: pyinstaller; extra == "build"
+Provides-Extra: debug
+Requires-Dist: debugpy; extra == "debug"
+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/)
+
+> [!IMPORTANT]
+> Work In Progress, this is a BETA release
+
+ZedScripts LSP is a language server protocol implementation in Python for the [scripting format]() of Project Zomboid. Previously a VSCode extension, it is now reimplemented as a standalone LSP.
+
+## Installation
+### Releases
+
+### Python package
+
+<!-- <details open>
+<summary>PyPi</summary>
+
+```bash
+pip install ZedScripts-LSP
+```
+</details> -->
+
+<details>
+<summary>Git</summary>
+
+```bash
+pip install git+https://github.com/PZ-Wiki-Modding/ZedScripts-LSP.git
+```
+</details>
+
+<details>
+<summary>Local</summary>
+
+```bash
+pip install .
+```
+</details>
+
+## Usage
+
+You can either launch the LSP from Python or you can launch the software as is.
+
+### LSP cache directory
+
+The LSP uses a cache directory on your system to store temporary files and logs as well as configuration files. You can find it here: 
+
+<details>
+<summary>Linux</summary>
+
+```bash
+~/.zedscripts
+```
+</details>
+
+<details>
+<summary>Windows</summary>
+
+```bash
+%USERPROFILE%\.zedscripts
+```
+</details>
+
+### Configuration
+
+The LSP uses configurations files which provide information to the LSP about various settings. You have access to a global configuration file
+
+Example configuration:
+```json
+{
+    "dataset": {
+        "latest": true
+    },
+    "libraries": [
+        "/home/simon/.steam/debian-installation/steamapps/common/ProjectZomboid/projectzomboid/media",
+    ]
+}
+```
+
+WIP: proper documentation will come soon
+
+## License
+See [LICENSE](LICENSE) for details.

zedscripts-0.0.2.dist-info/RECORD

@@ -0,0 +1,37 @@
+ZedScripts/__about__.py,sha256=ry5O5SW74ugwOUMKSV2_LbWjYa8B0IEvUm7S-lHPA2c,23
+ZedScripts/__init__.py,sha256=FhE0ANZpYH8YyjZXQGzplZ9VrqEXFsD8S0wx9Q-E-As,1282
+ZedScripts/main.py,sha256=hoa-oRPmUy0mmIkUyoAWLh8wCwo1jCgvtEQOKw-HSf8,124
+ZedScripts/server.py,sha256=4b4C5hLG5Dw2tdcptd2uo655dI0QFw3H5wvWdGPM0xk,11047
+ZedScripts/utils.py,sha256=eQFqgWKMO0riKeb_IzHTY6tj2lPUT3NATqW5Pk6_EVA,2852
+ZedScripts/enums/Diagnostic.py,sha256=a2PANTKDy1PZd1flAVQXJy1L5QpTTbwAHwbK_PgR7Qo,8075
+ZedScripts/enums/SyntaxErrorType.py,sha256=MC9VWpoxfwPaPGRGwi-jpKISiHJaO63DFvUg_nBsPQ4,196
+ZedScripts/environment/__init__.py,sha256=uv-ez4lW8KkpvZMNZlq5npKJVzAO72YF6Vot4Dz6MZU,1107
+ZedScripts/environment/config.py,sha256=7YsQHkUvPfbySShRIHoZJtnUdstHk1gC5693KqQwtco,2896
+ZedScripts/environment/document.py,sha256=2Mx1ZSin6fiBoKaww15YSDbRrcfAu80GzJ5UZHyTObU,14552
+ZedScripts/environment/mod.py,sha256=wlfnIU5LmTesrFsD5Ynh64qRRms6ua6y5Si0cxMp1Yg,2434
+ZedScripts/environment/version.py,sha256=0gmsqIyWIO1Ctk0FTddAR2SrMacUdlFjzUn2VyqAANw,7441
+ZedScripts/environment/workspace.py,sha256=ghrNQ0Um93-vvpsZAOIVDOhD1YX8ss9057BuvwP1L3I,12877
+ZedScripts/locale/en.json,sha256=82CWRO9_G2y5-fr-3aM-6laEI67FI7YNQUW0EXSukqk,3580
+ZedScripts/providers/actions.py,sha256=WyWOtlw_YOO4J-Hn0OkTA9NZFFeaB4wyXpKPPBFi02o,411
+ZedScripts/providers/capabilities.py,sha256=_cMMuFTucqa-UDobOcTQ-6bkiGE23K8cQ-fFAetBq7s,3485
+ZedScripts/providers/configuration.py,sha256=dCr1EwuHjvqOKZVMpl7P-JVyMkSMHYyG3Blkzn3Z0SQ,564
+ZedScripts/providers/debug.py,sha256=_uAA-78y4k4Qe1yvsIHSPVhZNOVHnP6vZ_iEepwfCBU,2204
+ZedScripts/providers/diagnostics.py,sha256=DHkG4WOjaFQlK5wa4DAHSxqCkgdGK4_EFKS5VtQ7hno,3739
+ZedScripts/providers/hover.py,sha256=Mju1hfdKODThE_DH7BXc6Bfkiel5HM5czX5LGCjW-Us,1051
+ZedScripts/providers/http.py,sha256=DwQ1qMPJSOB2tUAOcQXy5WU3Yd2uvoejG2g7pWeS-Wo,1648
+ZedScripts/providers/locale.py,sha256=eEOdPZ8FKYPdmshB7kvpCFLD5AjNrZIO3DeT45Jukyo,3042
+ZedScripts/providers/notifications.py,sha256=xfUb4HDs5LoR0by_l4PQs9xIQmr7h0CsD77LugKtkPk,1090
+ZedScripts/providers/semantic_tokens.py,sha256=6HI3ixWz8uahjSBehD00c3K9RmEXR5FZoSKXET3lERw,6431
+ZedScripts/scripts/__init__.py,sha256=3En0FJDKn1gR49T0NzV6rhie-ZvU3s59v47t8paH0Xc,4638
+ZedScripts/scripts/block.py,sha256=TEtSiGjXASIRKT6g0S_Dk5lvCRWtpM-ObsqmQd31KYI,18947
+ZedScripts/scripts/dataset.py,sha256=YnsMHfxE75cQC4dBgFAPN9eqcaOfpWqX0KTjhMXs0Xs,13062
+ZedScripts/scripts/value.py,sha256=HTgoae5dCUCCwPFO6oOEyOH1B3JXW_IqesMVPfzOlKs,28001
+ZedScripts/scripts/version.py,sha256=-R7VofQyJrOqqq86JnmukWTv2P6RmqDX6O4vDIXmJbw,2897
+ZedScripts/structure/ast.py,sha256=ukRATCVenrKjwsUHKUYR4wP9LBOwFhV3enjwBNNmtB4,4624
+ZedScripts/structure/lexer.py,sha256=2cp5eYIyGPond1W-41ALlut8wDitxHDJcpjdSSPEv7c,16339
+ZedScripts/structure/parser.py,sha256=bK4taAONQOpoEW6fZ222GSd-EDOpsBFtHIRmmZXOJW0,8577
+zedscripts-0.0.2.dist-info/licenses/LICENSE,sha256=U4VZ5OLZttGqVxQfLdbpLIvMEDpj5KRXLqltyHwWxsA,1072
+zedscripts-0.0.2.dist-info/METADATA,sha256=dPXVBMQS35QFRzhuerYjQlOfIpNAX32ID1TECHmT4PI,2474
+zedscripts-0.0.2.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+zedscripts-0.0.2.dist-info/top_level.txt,sha256=FkHjeVoFW1B97gPjIPEMXwVDyWr_9RoNYnOlWfDnYTg,11
+zedscripts-0.0.2.dist-info/RECORD,,

zedscripts-0.0.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

zedscripts-0.0.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 PZ Wiki Modding
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

zedscripts-0.0.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+ZedScripts