ZedScripts 1.1.0__tar.gz → 1.2.0__tar.gz

{zedscripts-1.1.0/src/ZedScripts.egg-info → zedscripts-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ZedScripts
-Version: 1.1.0
+Version: 1.2.0
 Author: SimKDT
 License: MIT License
         
@@ -38,6 +38,8 @@ Provides-Extra: debug
 Requires-Dist: debugpy; extra == "debug"
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
+Provides-Extra: pygments
+Requires-Dist: pygments; extra == "pygments"
 Dynamic: license-file
 
 # ZedScripts LSP
@@ -244,5 +246,24 @@ 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.
 
+## Pygments
+
+The ZedScripts LSP provides a Pygments lexer for syntax highlighting of ZedScripts code. It is available in the `ZedScripts.structure.pygments_lexer` module. You can notably use the command-line wrapper to highlight any file's content as ZedScripts:
+
+```bash
+uv pip install ZedScripts[pygments]
+highlight-zedscripts path/to/file.txt
+```
+
+![Screenshot of the output of highlight-zedscripts command on an example script file](assets/pygments_implementation.png)
+
+To use the lexer in Sphinx docs, you can add the following to your `conf.py`:
+
+```python
+from ZedScripts.structure.pygments_lexer import ZedScriptsLexer
+from sphinx.highlighting import lexers
+lexers['zedscripts'] = ZedScriptsLexer()
+```
+
 ## License and contribution
 This project is licensed under a [MIT license](LICENSE). Before contributing to the project, please see [CONTRIBUTING](CONTRIBUTING.md).

{zedscripts-1.1.0 → zedscripts-1.2.0}/README.md

@@ -202,5 +202,24 @@ 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.
 
+## Pygments
+
+The ZedScripts LSP provides a Pygments lexer for syntax highlighting of ZedScripts code. It is available in the `ZedScripts.structure.pygments_lexer` module. You can notably use the command-line wrapper to highlight any file's content as ZedScripts:
+
+```bash
+uv pip install ZedScripts[pygments]
+highlight-zedscripts path/to/file.txt
+```
+
+![Screenshot of the output of highlight-zedscripts command on an example script file](assets/pygments_implementation.png)
+
+To use the lexer in Sphinx docs, you can add the following to your `conf.py`:
+
+```python
+from ZedScripts.structure.pygments_lexer import ZedScriptsLexer
+from sphinx.highlighting import lexers
+lexers['zedscripts'] = ZedScriptsLexer()
+```
+
 ## License and contribution
 This project is licensed under a [MIT license](LICENSE). Before contributing to the project, please see [CONTRIBUTING](CONTRIBUTING.md).

{zedscripts-1.1.0 → zedscripts-1.2.0}/pyproject.toml

@@ -3,7 +3,7 @@ name = "ZedScripts"
 description = ""
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.12.3"
-version = "1.1.0"
+version = "1.2.0"
 license = {file = "LICENSE"}
 authors = [
   { name = "SimKDT" },
@@ -26,12 +26,18 @@ debug = [
 test = [
     "pytest"
 ]
+pygments = [
+    "pygments"
+]
 
 # used to load locale JSON files
 [build-system]
 requires = ["setuptools>=61"]
 build-backend = "setuptools.build_meta"
 
+[project.scripts]
+highlight-zedscripts = "ZedScripts.structure.pygments_lexer:main"
+
 [tool.setuptools.package-data]
 ZedScripts = [
     "locale/*.json"

{zedscripts-1.1.0 → zedscripts-1.2.0}/src/ZedScripts/__about__.py

@@ -1,4 +1,4 @@
-__version__ = "1.1.0"
+__version__ = "1.2.0"
 
 def main():
     print(__version__)

{zedscripts-1.1.0 → zedscripts-1.2.0}/src/ZedScripts/enums/Diagnostic.py

@@ -52,6 +52,9 @@ class DiagnosticType(enum.StrEnum):
     VALUE_UNMATCHED_BLOCK_REF =              enum.auto()
     VALUE_MULTIPLE_BLOCK_REFS =              enum.auto()
 
+    # debug
+    DEBUG_MISSING_PARAMETER_DESCRIPTION =    enum.auto()
+
 
 # syntax diagnostics
 DiagnosticDefinition(DiagnosticType.PARSER_TOO_MANY_CLOSING_BRACKETS,
@@ -155,6 +158,10 @@ DiagnosticDefinition(DiagnosticType.VALUE_MULTIPLE_BLOCK_REFS,
                      DiagnosticSeverity.Error,
                      args={"value": str, "parameter": str, "expected_block": str})
 
+DiagnosticDefinition(DiagnosticType.DEBUG_MISSING_PARAMETER_DESCRIPTION,
+                     DiagnosticSeverity.Information,
+                     args={"type": str, "key": str})
+
 
 # ensure that all diagnostic types have a corresponding definition
 for diagnostic_type in DiagnosticType:

{zedscripts-1.1.0 → zedscripts-1.2.0}/src/ZedScripts/locale/en.json

@@ -33,6 +33,8 @@
         "VALUE_CANNOT_PROVIDE_MODULE": "Value '{value}' cannot contain a module '{module}' reference, only direct block references are allowed.",
         "VALUE_BLOCK_REF_CANNOT_BE_EMPTY": "Value '{value}' has an empty block reference, which is not allowed.",
         "VALUE_UNMATCHED_BLOCK_REF": "Value '{value}' for parameter '{parameter}' does not match any existing block (expects '{expected_block}' block). Make sure the referenced block exists.",
-        "VALUE_MULTIPLE_BLOCK_REFS": "Multiple block references found for '{value}' for parameter '{parameter}' (expects '{expected_block}' block). Make sure duplicate block references are not present."
+        "VALUE_MULTIPLE_BLOCK_REFS": "Multiple block references found for '{value}' for parameter '{parameter}' (expects '{expected_block}' block). Make sure duplicate block references are not present.",
+
+        "DEBUG_MISSING_PARAMETER_DESCRIPTION": "DEBUG: Parameter '{key}' in block '{type}' is missing a description."
     }
 }

{zedscripts-1.1.0 → zedscripts-1.2.0}/src/ZedScripts/scripts/value.py

@@ -240,7 +240,7 @@ class Value(Element["ValueNode"]):
         if not dataset.can_block_have_parameter(parent_type, key):
             return ''
         param_data = dataset.get_parameter_data(parent_type, key)
-        return param_data.get('description', '') if param_data else ''
+        return param_data.get('description', '')
 
     def get_scriptsdocs_url(self, tree: list[str]) -> str | None:
         return self.parent.get_scriptsdocs_url(tree) + f"#scripts-{self.parent.type}-{self.key()}".replace(' ', '-').lower()
@@ -413,6 +413,14 @@ class Value(Element["ValueNode"]):
 
         param_data = dataset.get_parameter_data(parent_type, key)
 
+        # DEBUG: add information diagnostic if there is not description for the parameter
+        if not param_data.get('description', ''):
+            self.parent.add_diagnostic(
+                type=DiagnosticType.DEBUG_MISSING_PARAMETER_DESCRIPTION,
+                location=key_node.to_range(),
+                args={"type": parent_type, "key": key}
+            )
+
         # do the type highlight before anything else
         # so we highlight by type even if the value is otherwise invalid
         type_data = param_data.get('type')
@@ -652,8 +660,6 @@ class Value(Element["ValueNode"]):
             )
             return False
 
-        # TODO: look for the source block
-
         root = self.parent.get_root()
 
         # retrieve imports

{zedscripts-1.1.0 → zedscripts-1.2.0}/src/ZedScripts/server.py

@@ -47,7 +47,7 @@ class ZedServer(LanguageServer):
         try:
             import debugpy
         except ImportError:
-            logging.error("debugpy is not installed. Debugging will not be available.")
+            logging.error("debugpy is not installed. Debugging will not be available. Install the `debug` group dependencies (`pip install ZedScripts[debug]`).")
             return
 
         debug_port = 5678

zedscripts-1.2.0/src/ZedScripts/structure/pygments_lexer.py

@@ -0,0 +1,79 @@
+try:
+    from pygments.lexer import RegexLexer, bygroups
+    from pygments import token
+    from pygments.formatter import Formatter
+except ImportError:
+    raise ImportError("Pygments is required to use this module, install the `pygments` group dependencies (`pip install ZedScripts[pygments]`).")
+
+
+class ZedScriptsLexer(RegexLexer):
+    name = "ZedScripts"
+    aliases = ["zedscripts"]
+
+    tokens = {
+        "root": [
+            (r'/\*', token.Comment.Multiline, 'comment'),
+
+            (r"[,;:|!={}\[\]]", token.Operator),
+            (r"(\S+[\S\/ ]*?)(\s*)(=)(\s*)",
+             bygroups(
+                 token.Name.Attribute,
+                 token.Whitespace,
+                 token.Operator,
+                 token.Whitespace,
+             )),
+            (r"^(\s*)(\w+)(\s+)(|[\w !*.:\/]+?)(\s*)({)(\s*)$",
+             bygroups(
+                 token.Whitespace,
+                 token.Keyword.Declaration,
+                 token.Whitespace,
+                 token.Name.Class,
+                 token.Whitespace,
+                 token.Operator,
+                 token.Whitespace)),
+            (r"(?<!\w)-?\d+\.\d+", token.Number.Float),
+            (r"(?<!\w)-?\d+", token.Number.Integer),
+            (r"\w+\.\w+", token.String.Double),
+            # (r"\s+", token.Text),
+            (r"[^\S\n]+", token.Whitespace),
+            (r"\n", token.Whitespace),
+            (r"[^\s,;:|!={}/]+", token.Text),
+            (r"/(?!\*)", token.Text),
+        ],
+        'comment': [
+            (r'[^*]+', token.Comment.Multiline),
+            (r'\*/', token.Comment.Multiline, '#pop'),
+            (r'\*', token.Comment.Multiline),
+        ],
+    }
+
+def highlight_zedscripts(code: str, formatter: Formatter) -> str:
+    from pygments import highlight
+
+    return highlight(code, ZedScriptsLexer(), formatter)
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser(description="Highlight ZedScripts code using Pygments.")
+    parser.add_argument("file", 
+                        help="Path to the ZedScripts file to highlight.")
+    parser.add_argument("-x", "--xterm", action="store_true", 
+                        help="Use Terminal256Formatter for pygments output.")
+    parser.add_argument("-t", "--tokens", action="store_true",
+                        help="Show the tokens instead of the highlighted code.")
+    args = parser.parse_args()
+
+    from pygments.formatters import TerminalFormatter, Terminal256Formatter
+
+    with open(args.file, "r") as f:
+        code = f.read()
+
+    if args.tokens:
+        for ttype, value in ZedScriptsLexer().get_tokens(code):
+            print(ttype, value)
+    else:
+        formatter = Terminal256Formatter() if args.xterm else TerminalFormatter()
+        print(highlight_zedscripts(code, formatter))
+
+if __name__ == "__main__":
+    main()

{zedscripts-1.1.0 → zedscripts-1.2.0}/src/ZedScripts/tests/parser/test_lexer.py

@@ -1,8 +1,9 @@
 
-from ZedScripts.structure.lexer import Lexer, TextPosition, TokenType, Token, TokenCollection
+import argparse
 
+from ZedScripts.structure.lexer import Lexer, TextPosition, TokenType, Token, TokenCollection
 
-def parse_example_content() -> TokenCollection:
+def get_example() -> str:
     EXAMPLE_SCRIPT_CONTENT = r"""
 module Base {
     item ItemTest {
@@ -48,7 +49,10 @@ module Base {
     }
 }
     """.strip()
-    return Lexer.tokenize(EXAMPLE_SCRIPT_CONTENT)
+    return EXAMPLE_SCRIPT_CONTENT
+
+def parse_example_content() -> TokenCollection:
+    return Lexer.tokenize(get_example())
 
 
 def get_theorical_tokens():
@@ -224,7 +228,16 @@ def get_theorical_tokens():
 
 
 
-def test_lexer():
+def generate_theorical_tokens(*args):
+    """
+    Assuming the tokens currently being parsed are already the right ones, generate the comparison list of theorical tokens
+    we are supposed to compare against.
+    """
+    lexical_tokens = parse_example_content()
+    for token in lexical_tokens:
+        print(f"Token({token.type}, TextPosition({token.pos.line}, {token.pos.offset}), TextPosition({token.end.line}, {token.end.offset}), {token.text!r}),")
+
+def test_lexer(*args):
     """Test the lexer by comparing its output against the theorical tokens."""
     lexical_tokens = parse_example_content()
     theorical_tokens = get_theorical_tokens()
@@ -233,28 +246,72 @@ def test_lexer():
         print(repr(theorical_token).ljust(80), repr(token).ljust(80))
         assert token == theorical_token, f"Theorical token: {theorical_token!r}, Actual token: {token!r}"
 
-def generate_theorical_tokens():
-    """
-    Assuming the tokens currently being parsed are already the right ones, generate the comparison list of theorical tokens
-    we are supposed to compare against.
-    """
-    lexical_tokens = parse_example_content()
-    for token in lexical_tokens:
-        print(f"Token({token.type}, TextPosition({token.pos.line}, {token.pos.offset}), TextPosition({token.end.line}, {token.end.offset}), {token.text!r}),")
+
+def test_pygments(args: argparse.Namespace | None = None):
+    try:
+        from ZedScripts.structure.pygments_lexer import highlight_zedscripts
+        from pygments import highlight
+        from pygments.formatters import TerminalFormatter, Terminal256Formatter
+
+    # if pygments is not installed, then don't run this test
+    except ImportError:
+        print("Pygments is not installed, skipping the test.")
+        return
+
+    xterm = True if args is not None and args.xterm else False
+
+    print(
+        highlight_zedscripts(
+            get_example(), 
+            Terminal256Formatter() if xterm else TerminalFormatter()))
+
+
+def test_pygments_comments(*args):
+    try:
+        from ZedScripts.structure.pygments_lexer import ZedScriptsLexer
+        from pygments.token import Comment, Error, Name
+    except ImportError:
+        print("Pygments is not installed, skipping the test.")
+        return
+
+    tokens = list(ZedScriptsLexer().get_tokens(get_example()))
+    comment_text = "".join(value for token_type, value in tokens if token_type in Comment.Multiline)
+    assert "/* values */" in comment_text
+    assert "/* comment, different syntax block under\n    hello world */" in comment_text
+    assert "/* comment continued */" in comment_text
+    assert not [value for token_type, value in tokens if token_type in Error]
+    assert (Name.Class, "ItemTest") in tokens
+
+
+
 
 def main():
     import argparse
 
-    parser = argparse.ArgumentParser(description="Lexer test.")
-    parser.add_argument("--run", action="store_true", help="Run the lexer test.")
-    parser.add_argument("--generate", action="store_true", help="Generate the theorical tokens.") 
-    args = parser.parse_args()
-    if args.run:
-        test_lexer()
-    elif args.generate:
-        generate_theorical_tokens()
-    else:
-        parser.print_help()
+    main_parser = argparse.ArgumentParser(description="Lexer test.")
+    subparser = main_parser.add_subparsers(
+        dest="command",
+        required=True,
+    )
+
+    test_lexer_parser = subparser.add_parser("test_lexer", 
+                                             help="Run the lexer test.")
+    test_lexer_parser.set_defaults(func=test_lexer)
+
+    test_pygments_parser = subparser.add_parser("test_pygments", 
+                                                help="Run the pygments test.")
+    test_pygments_parser.set_defaults(func=test_pygments)
+    test_pygments_parser.add_argument('-x', '--xterm', action='store_true', 
+                                      help='Use Terminal256Formatter for pygments output.')
+
+    generate_parser = subparser.add_parser("generate", 
+                                           help="Generate the theorical tokens.")
+    generate_parser.set_defaults(func=generate_theorical_tokens)
+
+    args = main_parser.parse_args()
+
+
+    args.func(args)
 
 
 if __name__ == "__main__":

{zedscripts-1.1.0 → zedscripts-1.2.0/src/ZedScripts.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ZedScripts
-Version: 1.1.0
+Version: 1.2.0
 Author: SimKDT
 License: MIT License
         
@@ -38,6 +38,8 @@ Provides-Extra: debug
 Requires-Dist: debugpy; extra == "debug"
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
+Provides-Extra: pygments
+Requires-Dist: pygments; extra == "pygments"
 Dynamic: license-file
 
 # ZedScripts LSP
@@ -244,5 +246,24 @@ 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.
 
+## Pygments
+
+The ZedScripts LSP provides a Pygments lexer for syntax highlighting of ZedScripts code. It is available in the `ZedScripts.structure.pygments_lexer` module. You can notably use the command-line wrapper to highlight any file's content as ZedScripts:
+
+```bash
+uv pip install ZedScripts[pygments]
+highlight-zedscripts path/to/file.txt
+```
+
+![Screenshot of the output of highlight-zedscripts command on an example script file](assets/pygments_implementation.png)
+
+To use the lexer in Sphinx docs, you can add the following to your `conf.py`:
+
+```python
+from ZedScripts.structure.pygments_lexer import ZedScriptsLexer
+from sphinx.highlighting import lexers
+lexers['zedscripts'] = ZedScriptsLexer()
+```
+
 ## License and contribution
 This project is licensed under a [MIT license](LICENSE). Before contributing to the project, please see [CONTRIBUTING](CONTRIBUTING.md).

{zedscripts-1.1.0 → zedscripts-1.2.0}/src/ZedScripts.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ src/ZedScripts/utils.py
 src/ZedScripts.egg-info/PKG-INFO
 src/ZedScripts.egg-info/SOURCES.txt
 src/ZedScripts.egg-info/dependency_links.txt
+src/ZedScripts.egg-info/entry_points.txt
 src/ZedScripts.egg-info/requires.txt
 src/ZedScripts.egg-info/top_level.txt
 src/ZedScripts/enums/Diagnostic.py
@@ -37,5 +38,6 @@ src/ZedScripts/scripts/version.py
 src/ZedScripts/structure/ast.py
 src/ZedScripts/structure/lexer.py
 src/ZedScripts/structure/parser.py
+src/ZedScripts/structure/pygments_lexer.py
 src/ZedScripts/tests/parser/test_lexer.py
 tests/test_config_cli.py

zedscripts-1.2.0/src/ZedScripts.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+highlight-zedscripts = ZedScripts.structure.pygments_lexer:main

{zedscripts-1.1.0 → zedscripts-1.2.0}/src/ZedScripts.egg-info/requires.txt

@@ -10,5 +10,8 @@ pyinstaller
 [debug]
 debugpy
 
+[pygments]
+pygments
+
 [test]
 pytest