jaclang 0.8.1__py3-none-any.whl → 0.8.2__py3-none-any.whl

jaclang/langserve/tests/server_test/test_lang_serve.py

@@ -1,4 +1,5 @@
 """Test for Jac language server[VSCE] features"""
+
 import os
 import pytest
 
@@ -16,19 +17,18 @@ from jaclang.langserve.tests.server_test.utils import (
     create_temp_jac_file,
     get_code,
     get_jac_file_path,
+    get_simple_code,
     create_ls_with_workspace,  # new helper
 )
 from jaclang.vendor.pygls.uris import from_fs_path
 from jaclang.vendor.pygls.workspace import Workspace
 from jaclang import JacMachineInterface as _
-
-JacLangServer = _.py_jac_import(
-    "....langserve.engine", __file__, items={"JacLangServer": None}
-)[0]
-(did_open, did_save, did_change, formatting) = _.py_jac_import(    "....langserve.server", __file__, items={"did_open": None, "did_save": None, "did_change": None, "formatting": None})
+from jaclang.langserve.engine import JacLangServer
+from jaclang.langserve.server import did_open, did_save, did_change, formatting
 
 JAC_FILE = get_jac_file_path()
 
+
 class TestLangServe:
     """Test class for Jac language server features."""
 
@@ -95,7 +95,7 @@ class TestLangServe:
         temp_file_path = create_temp_jac_file(code)
         uri = from_fs_path(temp_file_path)
         ls.lsp._workspace = Workspace(os.path.dirname(temp_file_path), ls)
-    
+
         params = DidOpenTextDocumentParams(
             text_document=TextDocumentItem(
                 uri=uri,
@@ -130,7 +130,9 @@ class TestLangServe:
         ls.shutdown()
         assert hasattr(sem_tokens, "data")
         assert isinstance(sem_tokens.data, list)
-        assert len(sem_tokens.data) == 0 # TODO: we should retain the sem tokens, will be fixed in next PR 
+        assert (
+            len(sem_tokens.data) == 0
+        )  # TODO: we should retain the sem tokens, will be fixed in next PR
 
         os.remove(temp_file_path)
 
@@ -141,14 +143,17 @@ class TestLangServe:
         temp_file_path = create_temp_jac_file(code)
         uri, ls = create_ls_with_workspace(temp_file_path)
 
-        await did_open(ls, DidOpenTextDocumentParams(
-            text_document=TextDocumentItem(
-                uri=uri,
-                language_id="jac",
-                version=1,
-                text=code,
-            )
-        ))
+        await did_open(
+            ls,
+            DidOpenTextDocumentParams(
+                text_document=TextDocumentItem(
+                    uri=uri,
+                    language_id="jac",
+                    version=1,
+                    text=code,
+                )
+            ),
+        )
 
         params = DidSaveTextDocumentParams(
             text_document=TextDocumentItem(
@@ -166,12 +171,14 @@ class TestLangServe:
 
         # Now simulate a syntax error by updating the workspace and saving
         broken_code = get_code("error")
-        ls.workspace.put_text_document(TextDocumentItem(
-            uri=uri,
-            language_id="jac",
-            version=3,
-            text=broken_code,
-        ))
+        ls.workspace.put_text_document(
+            TextDocumentItem(
+                uri=uri,
+                language_id="jac",
+                version=3,
+                text=broken_code,
+            )
+        )
         params = DidSaveTextDocumentParams(
             text_document=TextDocumentItem(
                 uri=uri,
@@ -181,6 +188,9 @@ class TestLangServe:
             )
         )
         await did_save(ls, params)
+        sem_tokens = ls.get_semantic_tokens(uri)
+        # semantic tokens should still be present even if there is a syntax error
+        assert len(sem_tokens.data) == 300
         diagnostics = ls.diagnostics.get(uri, [])
         assert isinstance(diagnostics, list)
         assert len(diagnostics) == 1
@@ -196,26 +206,31 @@ class TestLangServe:
         temp_file_path = create_temp_jac_file(code)
         uri, ls = create_ls_with_workspace(temp_file_path)
 
-        await did_open(ls, DidOpenTextDocumentParams(
-            text_document=TextDocumentItem(
-                uri=uri,
-                language_id="jac",
-                version=1,
-                text=code,
-            )
-        ))
+        await did_open(
+            ls,
+            DidOpenTextDocumentParams(
+                text_document=TextDocumentItem(
+                    uri=uri,
+                    language_id="jac",
+                    version=1,
+                    text=code,
+                )
+            ),
+        )
 
         # No error, should be no diagnostics
         params = DidChangeTextDocumentParams(
             text_document=VersionedTextDocumentIdentifier(uri=uri, version=2),
-            content_changes=[{"text": "\n" + code}]
+            content_changes=[{"text": "\n" + code}],
+        )
+        ls.workspace.put_text_document(
+            TextDocumentItem(
+                uri=uri,
+                language_id="jac",
+                version=2,
+                text="\n" + code,
+            )
         )
-        ls.workspace.put_text_document(TextDocumentItem(
-            uri=uri,
-            language_id="jac",
-            version=2,
-            text="\n" + code,
-        ))
         await did_change(ls, params)
         diagnostics = ls.diagnostics.get(uri, [])
         assert isinstance(diagnostics, list)
@@ -226,15 +241,20 @@ class TestLangServe:
         error_code = "\nerror"
         params = DidChangeTextDocumentParams(
             text_document=VersionedTextDocumentIdentifier(uri=uri, version=3),
-            content_changes=[{"text": error_code + code}]
+            content_changes=[{"text": error_code + code}],
+        )
+        ls.workspace.put_text_document(
+            TextDocumentItem(
+                uri=uri,
+                language_id="jac",
+                version=3,
+                text=error_code + code,
+            )
         )
-        ls.workspace.put_text_document(TextDocumentItem(
-            uri=uri,
-            language_id="jac",
-            version=3,
-            text=error_code + code,
-        ))
         await did_change(ls, params)
+        sem_tokens = ls.get_semantic_tokens(uri)
+        # semantic tokens should still be present even if there is a syntax error
+        assert len(sem_tokens.data) == 300
         diagnostics = ls.diagnostics.get(uri, [])
         assert isinstance(diagnostics, list)
         assert len(diagnostics) == 1
@@ -250,12 +270,84 @@ class TestLangServe:
         uri, ls = create_ls_with_workspace(temp_file_path)
         params = DocumentFormattingParams(
             text_document=TextDocumentIdentifier(uri=uri),
-            options={"tabSize": 4, "insertSpaces": True}
+            options={"tabSize": 4, "insertSpaces": True},
         )
         edits = formatting(ls, params)
         assert isinstance(edits, list)
         assert isinstance(edits[0], TextEdit)
-        assert len(edits[0].new_text) > 100  # it is a random number to check if the text is changed
+        assert (
+            len(edits[0].new_text) > 100
+        )  # it is a random number to check if the text is changed
         print(edits[0].new_text)
         ls.shutdown()
-        os.remove(temp_file_path)
+        os.remove(temp_file_path)
+
+    @pytest.mark.asyncio
+    async def test_multifile_workspace(self):
+        """Test opening multiple Jac files in a workspace."""
+        code1 = get_simple_code("")
+        code2 = get_simple_code("error")
+        temp_file_path1 = create_temp_jac_file(code1)
+        temp_file_path2 = create_temp_jac_file(code2)
+
+        uri1, ls = create_ls_with_workspace(temp_file_path1)
+        uri2 = from_fs_path(temp_file_path2)
+
+        await did_open(
+            ls,
+            DidOpenTextDocumentParams(
+                text_document=TextDocumentItem(
+                    uri=uri1,
+                    language_id="jac",
+                    version=1,
+                    text=code1,
+                )
+            ),
+        )
+        await did_open(
+            ls,
+            DidOpenTextDocumentParams(
+                text_document=TextDocumentItem(
+                    uri=uri2,
+                    language_id="jac",
+                    version=1,
+                    text=code2,
+                )
+            ),
+        )
+
+        diagnostics1 = ls.diagnostics.get(uri1, [])
+        diagnostics2 = ls.diagnostics.get(uri2, [])
+        assert len(diagnostics1) == 0
+        assert len(diagnostics2) == 1
+        assert diagnostics2[0].message == "Syntax Error"
+
+        before_sem_tokens_1 = ls.get_semantic_tokens(uri1)
+        before_sem_tokens_2 = ls.get_semantic_tokens(uri2)
+        assert len(before_sem_tokens_1.data) == 15
+        assert len(before_sem_tokens_2.data) == 0
+
+        changed_code = get_simple_code("glob x = 90;")
+        ls.workspace.put_text_document(
+            TextDocumentItem(
+                uri=uri1,
+                language_id="jac",
+                version=2,
+                text=changed_code,
+            )
+        )
+        params = DidChangeTextDocumentParams(
+            text_document=VersionedTextDocumentIdentifier(uri=uri1, version=2),
+            content_changes=[{"text": changed_code}],
+        )
+        await did_change(ls, params)
+
+        after_sem_tokens_1 = ls.get_semantic_tokens(uri1)
+        after_sem_tokens_2 = ls.get_semantic_tokens(uri2)
+
+        assert len(after_sem_tokens_1.data) == 20
+        assert len(after_sem_tokens_2.data) == 0
+
+        ls.shutdown()
+        os.remove(temp_file_path1)
+        os.remove(temp_file_path2)

jaclang/langserve/tests/server_test/utils.py

@@ -1,4 +1,5 @@
 """Unit test utilities for JacLangServer."""
+
 import os
 import tempfile
 
@@ -6,27 +7,31 @@ from jaclang.vendor.pygls.uris import from_fs_path
 from jaclang.vendor.pygls.workspace import Workspace
 
 from textwrap import dedent
-from jaclang import JacMachineInterface as _
-JacLangServer = _.py_jac_import(
-    "....langserve.engine", __file__, items={"JacLangServer": None}
-)[0]
+
 
 def get_jac_file_path():
     """Return the absolute path to the sample Jac file used for testing."""
     return os.path.abspath(
-        os.path.join(os.path.dirname(__file__), "../../../../examples/manual_code/circle.jac")
+        os.path.join(
+            os.path.dirname(__file__), "../../../../examples/manual_code/circle.jac"
+        )
     )
 
+
 def create_temp_jac_file(initial_content: str = "") -> str:
     """Create a temporary Jac file with optional initial content and return its path."""
-    temp = tempfile.NamedTemporaryFile(delete=False, suffix=".jac", mode="w", encoding="utf-8")
+    temp = tempfile.NamedTemporaryFile(
+        delete=False, suffix=".jac", mode="w", encoding="utf-8"
+    )
     temp.write(initial_content)
     temp.close()
     return temp.name
 
+
 def get_code(code: str) -> str:
     """Generate a sample Jac code snippet with optional test code injected."""
-    jac_code = dedent(f'''
+    jac_code = dedent(
+        f'''
     """
     This module demonstrates a simple circle class and a function to calculate
     the area of a circle in all of Jac's glory.
@@ -107,12 +112,33 @@ def get_code(code: str) -> str:
         c = Circle(RAD);
         check c.shape_type == ShapeType.CIRCLE;
     }}
-''')
+'''
+    )
     return jac_code
 
+
+def get_simple_code(code: str) -> str:
+    """Generate a sample Jac code snippet with optional test code injected."""
+    jac_code = dedent(
+        f"""
+    
+    # Unit Tests!
+    glob expected_area0 = 78.53981633974483;
+    glob expected_area1 = 78.53981633974483;
+    {code}
+    glob expected_area2 = 78.53981633974483;
+
+
+"""
+    )
+    return jac_code
+
+
 def create_ls_with_workspace(file_path: str):
     """Create JacLangServer and workspace for a given file path, return (uri, ls)."""
+    from jaclang.langserve.engine import JacLangServer
+
     ls = JacLangServer()
     uri = from_fs_path(file_path)
     ls.lsp._workspace = Workspace(os.path.dirname(file_path), ls)
-    return uri, ls
+    return uri, ls

jaclang/langserve/tests/test_sem_tokens.py

@@ -4,10 +4,10 @@ import copy
 import lsprotocol.types as lspt
 from jaclang import JacMachineInterface as _
 from jaclang.utils.test import TestCase
+from jaclang.langserve.sem_manager import SemTokManager
 
 from typing import Tuple
 
-SemTokManager = _.py_jac_import("..sem_manager", __file__, items={"SemTokManager": None})[0]
 
 class TestUpdateSemTokens(TestCase):
     """Test update semantic tokens"""

jaclang/langserve/tests/test_server.py

@@ -5,13 +5,9 @@ from jaclang.vendor.pygls.workspace import Workspace
 import lsprotocol.types as lspt
 import pytest
 from jaclang import JacMachineInterface as _
+from jaclang.langserve.engine import JacLangServer
+from .session import LspSession
 
-JacLangServer = _.py_jac_import(
-    "...langserve.engine", __file__, items={"JacLangServer": None}
-)[0]
-LspSession = _.py_jac_import(
-    "session", __file__, items={"LspSession": None}
-)[0]
 
 class TestJacLangServer(TestCase):
 
@@ -143,7 +139,7 @@ class TestJacLangServer(TestCase):
         lsp.deep_check(guess_game_file)
         self.assertIn(
             "guess_game4.jac:16:8-16:21",
-            str(lsp.get_definition(guess_game_file, lspt.Position(14, 45))),
+            str(lsp.get_definition(guess_game_file, lspt.Position(15, 45))),
         )
 
     def test_go_to_definition_method_manual_impl(self) -> None:

jaclang/runtimelib/archetype.py

@@ -2,21 +2,24 @@
 
 from __future__ import annotations
 
-import inspect
 from dataclasses import asdict, dataclass, field, fields, is_dataclass
 from enum import IntEnum
 from functools import cached_property
+from inspect import _empty, signature
 from logging import getLogger
 from pickle import dumps
 from types import UnionType
-from typing import Any, Callable, ClassVar, Optional, TypeVar
+from typing import Any, Callable, ClassVar, Optional, TypeAlias, TypeVar
 from uuid import UUID, uuid4
 
+from ..compiler.constant import EdgeDir
+
 
 logger = getLogger(__name__)
 
 TARCH = TypeVar("TARCH", bound="Archetype")
 TANCH = TypeVar("TANCH", bound="Anchor")
+T = TypeVar("T")
 
 
 class AccessLevel(IntEnum):
@@ -66,6 +69,125 @@ class AnchorReport:
     context: dict[str, Any]
 
 
+DataSpatialFilter: TypeAlias = (
+    Callable[["Archetype"], bool] | "Archetype" | list["Archetype"] | None
+)
+
+
+@dataclass(eq=False, repr=False)
+class DataSpatialDestination:
+    """Object-Spatial Destination."""
+
+    direction: EdgeDir
+    edge: Callable[["Archetype"], bool] | None = None
+    node: Callable[["Archetype"], bool] | None = None
+
+    def edge_filter(self, arch: Archetype) -> bool:
+        """Filter edge."""
+        return not self.edge or self.edge(arch)
+
+    def node_filter(self, arch: Archetype) -> bool:
+        """Filter node."""
+        return not self.node or self.node(arch)
+
+
+@dataclass(eq=False, repr=False)
+class DataSpatialPath:
+    """Object-Spatial Path."""
+
+    origin: list[NodeArchetype]
+    destinations: list[DataSpatialDestination]
+    edge_only: bool
+    from_visit: bool
+
+    def __init__(
+        self,
+        origin: NodeArchetype | list[NodeArchetype],
+        destinations: list[DataSpatialDestination] | None = None,
+    ) -> None:
+        """Override Init."""
+        if not isinstance(origin, list):
+            origin = [origin]
+        self.origin = origin
+        self.destinations = [] if destinations is None else destinations
+        self.edge_only = False
+        self.from_visit = False
+
+    def convert(
+        self,
+        filter: DataSpatialFilter,
+    ) -> Callable[["Archetype"], bool] | None:
+        """Convert filter."""
+        if not filter:
+            return None
+        if callable(filter):
+            return filter
+        elif isinstance(filter, list):
+            return lambda i: i in filter
+        return lambda i: i == filter
+
+    def append(
+        self,
+        direction: EdgeDir,
+        edge: DataSpatialFilter,
+        node: DataSpatialFilter,
+    ) -> DataSpatialPath:
+        """Append destination."""
+        self.destinations.append(
+            DataSpatialDestination(direction, self.convert(edge), self.convert(node))
+        )
+        return self
+
+    def _out(
+        self, edge: DataSpatialFilter = None, node: DataSpatialFilter = None
+    ) -> DataSpatialPath:
+        """Override greater than function."""
+        return self.append(EdgeDir.OUT, edge, node)
+
+    def _in(
+        self, edge: DataSpatialFilter = None, node: DataSpatialFilter = None
+    ) -> DataSpatialPath:
+        """Override greater than function."""
+        return self.append(EdgeDir.IN, edge, node)
+
+    def _any(
+        self, edge: DataSpatialFilter = None, node: DataSpatialFilter = None
+    ) -> DataSpatialPath:
+        """Override greater than function."""
+        return self.append(EdgeDir.ANY, edge, node)
+
+    def edge(self) -> DataSpatialPath:
+        """Set edge only."""
+        self.edge_only = True
+        return self
+
+    def visit(self) -> DataSpatialPath:
+        """Set from visit."""
+        self.from_visit = True
+        return self
+
+    def repr_builder(self, repr: str, dest: DataSpatialDestination, mark: str) -> str:
+        """Repr builder."""
+        repr += mark
+        repr += f' (edge{" filter" if dest.edge else ""}) '
+        repr += mark
+        repr += f' (node{" filter" if dest.node else ""}) '
+        return repr
+
+    def __repr__(self) -> str:
+        """Override repr."""
+        repr = "nodes "
+        for dest in self.destinations:
+            match dest.direction:
+                case EdgeDir.IN:
+                    repr = self.repr_builder(repr, dest, "<<")
+                case EdgeDir.OUT:
+                    repr = self.repr_builder(repr, dest, ">>")
+                case _:
+                    repr = self.repr_builder(repr, dest, "--")
+        return repr.strip()
+
+
 @dataclass(eq=False, repr=False, kw_only=True)
 class Anchor:
     """Object Anchor."""
@@ -329,7 +451,7 @@ class Root(NodeArchetype):
 
 @dataclass(eq=False)
 class DataSpatialFunction:
-    """Data Spatial Function."""
+    """Object-Spatial Function."""
 
     name: str
     func: Callable[[Any, Any], Any]
@@ -337,9 +459,9 @@ class DataSpatialFunction:
     @cached_property
     def trigger(self) -> type | UnionType | tuple[type | UnionType, ...] | None:
         """Get function parameter annotations."""
-        parameters = inspect.signature(self.func, eval_str=True).parameters
+        parameters = signature(self.func, eval_str=True).parameters
         if len(parameters) >= 2:
             second_param = list(parameters.values())[1]
             ty = second_param.annotation
-            return ty if ty != inspect._empty else None
+            return ty if ty != _empty else None
         return None