jaclang 0.8.7__py3-none-any.whl → 0.8.9__py3-none-any.whl

jaclang/langserve/tests/server_test/utils.py

@@ -2,21 +2,19 @@
 
 import os
 import tempfile
-
+from typing import Optional
+from dataclasses import dataclass
+
+from lsprotocol.types import (
+    DidOpenTextDocumentParams,
+    TextDocumentItem,
+    DidSaveTextDocumentParams,
+    DidChangeTextDocumentParams,
+    VersionedTextDocumentIdentifier,
+)
 from jaclang.vendor.pygls.uris import from_fs_path
 from jaclang.vendor.pygls.workspace import Workspace
 
-from textwrap import dedent
-
-
-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"
-        )
-    )
-
 
 def create_temp_jac_file(initial_content: str = "") -> str:
     """Create a temporary Jac file with optional initial content and return its path."""
@@ -28,110 +26,11 @@ def create_temp_jac_file(initial_content: str = "") -> str:
     return temp.name
 
 
-def get_code(code: str) -> str:
-    """Generate a sample Jac code snippet with optional test code injected."""
-    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.
-    """
-
-    import math;
-
-    # Module-level global variable
-    glob RAD = 5;
-
-    """Function to calculate the area of a circle."""
-    def calculate_area(radius: float) -> float {{
-        return math.pi * radius * radius;
-    }}
-
-    #* (This is a multiline comment in Jac)
-    Above we have the demonstration of a function to calculate the area of a circle.
-    Below we have the demonstration of a class to calculate the area of a circle.
-    *#
-
-    """Enum for shape types"""
-    enum ShapeType {{
-        CIRCLE = "Circle",
-        UNKNOWN = "Unknown"
-    }}
-
-    """Base class for a shape."""
-    obj Shape {{
-        has shape_type: ShapeType;
-
-        """Abstract method to calculate the area of a shape."""
-        def area -> float abs;
-    }}
-
-    """Circle class inherits from Shape."""
-    obj Circle(Shape) {{
-        def init(radius: float) {{
-            super.init(ShapeType.CIRCLE);
-            self.radius = radius;
-        }}
-
-        """Overridden method to calculate the area of the circle."""
-        override def area -> float {{
-            return math.pi * self.radius * self.radius;
-        }}
-    }}
-
-    with entry {{
-        c = Circle(RAD);
-    }}
-
-    # Global also works here
-
-    with entry:__main__ {{
-        # To run the program functionality
-        print(
-            f"Area of a circle with radius {{RAD}} using function: {{calculate_area(RAD)}}"
-        );
-        print(
-            f"Area of a {{c.shape_type.value}} with radius {{RAD}} using class: {{c.area()}}"
-        );
-    }}
-
-    # Unit Tests!
-    glob expected_area = 78.53981633974483;
-    {code}
-
-    test calc_area {{
-        check almostEqual(calculate_area(RAD), expected_area);
-    }}
-
-    test circle_area {{
-        c = Circle(RAD);
-        check almostEqual(c.area(), expected_area);
-    }}
-
-    test circle_type {{
-        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 load_jac_template(template_file: str, code: str = "") -> str:
+    """Load a Jac template file and inject code into placeholder."""
+    with open(template_file, "r") as f:
+        jac_template = f.read()
+    return jac_template.replace("#{{INJECT_CODE}}", code)
 
 
 def create_ls_with_workspace(file_path: str):
@@ -142,3 +41,141 @@ def create_ls_with_workspace(file_path: str):
     uri = from_fs_path(file_path)
     ls.lsp._workspace = Workspace(os.path.dirname(file_path), ls)
     return uri, ls
+
+
+@dataclass
+class TestFile:
+    """Encapsulates test file information and operations."""
+    
+    path: str
+    uri: str
+    code: str
+    version: int = 1
+    
+    @classmethod
+    def from_template(cls, template_name: str, content: str = "") -> "TestFile":
+        """Create a test file from a template."""
+        code = load_jac_template(cls._get_template_path(template_name), content)
+        temp_path = create_temp_jac_file(code)
+        uri = from_fs_path(temp_path)
+        return cls(
+            path=temp_path,
+            uri=uri or "",
+            code=code,
+        )
+    
+    @staticmethod
+    def _get_template_path(file_name: str) -> str:
+        """Get absolute path to test template file."""
+        return os.path.abspath(
+            os.path.join(os.path.dirname(__file__), file_name)
+        )
+    
+    def cleanup(self):
+        """Remove temporary test file."""
+        if os.path.exists(self.path):
+            os.remove(self.path)
+    
+    def increment_version(self) -> int:
+        """Increment and return the version number."""
+        self.version += 1
+        return self.version
+
+
+class LanguageServerTestHelper:
+    """Helper class for language server testing operations."""
+    
+    def __init__(self, ls, test_file: TestFile):
+        self.ls = ls
+        self.test_file = test_file
+    
+    async def open_document(self) -> None:
+        """Open a document in the language server."""
+        from jaclang.langserve.server import did_open
+        
+        params = DidOpenTextDocumentParams(
+            text_document=TextDocumentItem(
+                uri=self.test_file.uri,
+                language_id="jac",
+                version=self.test_file.version,
+                text=self.test_file.code,
+            )
+        )
+        await did_open(self.ls, params)
+    
+    async def save_document(self, code: Optional[str] = None) -> None:
+        """Save a document in the language server."""
+        from jaclang.langserve.server import did_save
+        
+        content = code if code is not None else self.test_file.code
+        version = self.test_file.increment_version()
+        
+        if code:
+            self._update_workspace(code, version)
+        
+        from lsprotocol.types import TextDocumentIdentifier
+        
+        params = DidSaveTextDocumentParams(
+            text_document=TextDocumentIdentifier(uri=self.test_file.uri),
+            text=content
+        )
+        await did_save(self.ls, params)
+    
+    async def change_document(self, code: str) -> None:
+        """Change document content in the language server."""
+        from jaclang.langserve.server import did_change
+        
+        version = self.test_file.increment_version()
+        self._update_workspace(code, version)
+        
+        params = DidChangeTextDocumentParams(
+            text_document=VersionedTextDocumentIdentifier(
+                uri=self.test_file.uri,
+                version=version
+            ),
+            content_changes=[{"text": code}],  # type: ignore
+        )
+        await did_change(self.ls, params)
+    
+    def _update_workspace(self, code: str, version: int) -> None:
+        """Update workspace with new document content."""
+        self.ls.workspace.put_text_document(
+            TextDocumentItem(
+                uri=self.test_file.uri,
+                language_id="jac",
+                version=version,
+                text=code,
+            )
+        )
+    
+    def get_diagnostics(self) -> list:
+        """Get diagnostics for the current document."""
+        return self.ls.diagnostics.get(self.test_file.uri, [])
+    
+    def get_semantic_tokens(self):
+        """Get semantic tokens for the current document."""
+        return self.ls.get_semantic_tokens(self.test_file.uri)
+    
+    def assert_no_diagnostics(self) -> None:
+        """Assert that there are no diagnostics."""
+        diagnostics = self.get_diagnostics()
+        assert isinstance(diagnostics, list)
+        assert len(diagnostics) == 0, f"Expected no diagnostics, found {len(diagnostics)}"
+    
+    def assert_has_diagnostics(self, count: int = 1, message_contains: Optional[str] = None) -> None:
+        """Assert that diagnostics exist with optional message validation."""
+        diagnostics = self.get_diagnostics()
+        assert isinstance(diagnostics, list)
+        assert len(diagnostics) == count, f"Expected {count} diagnostic(s), found {len(diagnostics)}"
+        
+        if message_contains:
+            assert message_contains in diagnostics[0].message, \
+                f"Expected '{message_contains}' in diagnostic message"
+    
+    def assert_semantic_tokens_count(self, expected_count: int) -> None:
+        """Assert semantic tokens data has expected count."""
+        tokens = self.get_semantic_tokens()
+        assert hasattr(tokens, "data")
+        assert isinstance(tokens.data, list)
+        assert len(tokens.data) == expected_count, \
+            f"Expected {expected_count} tokens, found {len(tokens.data)}"

jaclang/langserve/tests/test_server.py

@@ -1,3 +1,4 @@
+from dataclasses import dataclass
 from jaclang.utils.test import TestCase
 from jaclang.vendor.pygls import uris
 from jaclang.vendor.pygls.workspace import Workspace
@@ -310,7 +311,6 @@ class TestJacLangServer(TestCase):
         for token_type, expected_count in expected_counts:
             self.assertEqual(str(sem_list).count(token_type), expected_count)
 
-    @pytest.mark.xfail(reason="TODO: Fix when we have the type checker")
     def test_completion(self) -> None:
         """Test that the completions are correct."""
         lsp = JacLangServer()
@@ -318,95 +318,28 @@ class TestJacLangServer(TestCase):
         workspace = Workspace(workspace_path, lsp)
         lsp.lsp._workspace = workspace
         base_module_file = uris.from_fs_path(
-            self.fixture_abs_path("base_module_structure.jac")
+            self.fixture_abs_path("completion_test_err.jac")
         )
         lsp.deep_check(base_module_file)
-        test_cases = [
-            (lspt.Position(38, 16), ["get_color1", "color1", "point1"], 3),
-            (lspt.Position(42, 22), ["RED", "GREEN", "BLUE"], 3),
-            (lspt.Position(42, 33), ["RED", "GREEN", "BLUE"], 3),
-            (lspt.Position(42, 45), ["RED", "GREEN", "BLUE"], 3),
-            (lspt.Position(46, 20), ["RED22", "GREEN22", "BLUE22"], 3),
-            (lspt.Position(46, 30), ["RED22", "GREEN22", "BLUE22"], 3),
-            (lspt.Position(46, 41), ["RED22", "GREEN22", "BLUE22"], 3),
-            (
-                lspt.Position(51, 32),
-                ["RED22", "GREEN22", "BLUE22"],
-                3,
-            ),
-            (
-                lspt.Position(65, 13),
-                [
-                    "get_color1",
-                    "color1",
-                    "point1",
-                    "base_colorred",
-                    "pointred",
-                    "inner_red",
-                    "doubleinner",
-                    "apply_red",
-                ],
-                11,
-            ),
-            (
-                lspt.Position(65, 23),
-                ["color22", "doublepoint22", "point22", "apply_inner_red", "enum_red"],
-                5,
-            ),
-            (
-                lspt.Position(65, 31),
-                ["RED22", "GREEN22", "BLUE22"],
-                3,
-            ),
-            (
-                lspt.Position(35, 28),
-                [],
-                0,
-            ),
-            (
-                lspt.Position(72, 12),
-                [
-                    "get_color1",
-                    "color1",
-                    "point1",
-                    "base_colorred",
-                    "pointred",
-                    "inner_red",
-                    "doubleinner",
-                    "apply_red",
-                ],
-                11,
-            ),
-            (
-                lspt.Position(73, 22),
-                ["color22", "doublepoint22", "apply_inner_red", "point22", "enum_red"],
-                5,
-            ),
-            (
-                lspt.Position(37, 12),
-                ["self", "add", "subtract", "x", "Colorenum", "Colour1", "red", "r"],
-                153,
-                None,
+
+        @dataclass
+        class Case:
+            pos: lspt.Position
+            expected: list[str]
+            trigger: str = "."
+
+        test_cases: list[Case] = [
+            Case(
+                lspt.Position(8, 8),
+                ["bar", "baz"],
             ),
         ]
-        default_trigger = "."
         for case in test_cases:
-            position, expected_completions, expected_length = case[:3]
-            completion_trigger = case[3] if len(case) > 3 else default_trigger
             completions = lsp.get_completion(
-                base_module_file, position, completion_trigger=completion_trigger
+                base_module_file, case.pos, completion_trigger=case.trigger
             ).items
-            for completion in expected_completions:
+            for completion in case.expected:
                 self.assertIn(completion, str(completions))
-            self.assertEqual(expected_length, len(completions))
-
-            if position == lspt.Position(73, 12):
-                self.assertEqual(
-                    2, str(completions).count("kind=<CompletionItemKind.Function: 3>")
-                )
-                self.assertEqual(
-                    4, str(completions).count("kind=<CompletionItemKind.Field: 5>")
-                )
 
     def test_go_to_reference(self) -> None:
         """Test that the go to reference is correct."""
@@ -419,8 +352,8 @@ class TestJacLangServer(TestCase):
         lsp.deep_check(circle_file)
         test_cases = [
             (47, 12, ["circle.jac:47:8-47:14", "69:8-69:14", "74:8-74:14"]),
-            (54, 66, ["54:62-54:76", "65:22-65:36"]),
-            (62, 14, ["65:43-65:56", "70:32-70:45"]),
+            (54, 66, ["54:62-54:76", "65:23-65:37"]),
+            (62, 14, ["65:44-65:57", "70:33-70:46"]),
         ]
         for line, char, expected_refs in test_cases:
             references = str(lsp.get_references(circle_file, lspt.Position(line, char)))
@@ -608,3 +541,7 @@ class TestJacLangServer(TestCase):
             "/tests/fixtures/M1.jac:0:0-0:0",
             str(lsp.get_definition(guess_game_file, lspt.Position(29, 9))),
         )
+
+
+
+TestJacLangServer().test_completion()

jaclang/langserve/utils.jac

@@ -1,5 +1,6 @@
 """Utility functions for the language server."""
 
+
 import asyncio;
 import builtins;
 import re;
@@ -112,25 +113,21 @@ def find_deepest_symbol_node_at_pos(
 
 
 """Check if the position falls within the node's location."""
-def position_within_node(<>node: uni.UniNode, line: int, character: int) -> bool {
-    if <>node.loc.first_line < (line + 1) < <>node.loc.last_line {
+# All lines and columns are 1-Based
+def position_within_node(n: uni.UniNode, line: int, character: int) -> bool {
+    if n.loc.first_line < line < n.loc.last_line {
         return True;
     }
-    if <>node.loc.first_line == (line + 1)
-    and <>node.loc.col_start <= (character + 1)
-    and <>node.loc.last_line == (line + 1)
-    and <>node.loc.col_end >= (character + 1)
-
-    or <>node.loc.last_line > (line + 1)
-     {
-        return True;
+    if line < n.loc.first_line or line > n.loc.last_line {
+        return False;
     }
-    if <>node.loc.last_line == (line + 1)
-    and <>node.loc.col_start <= (character + 1) <= <>node.loc.col_end
-     {
-        return True;
+    if line == n.loc.first_line and character < n.loc.col_start {
+        return False;
+    }
+    if line == n.loc.last_line and character >= n.loc.col_end {
+        return False;
     }
-    return False;
+    return True;
 }
 
 

jaclang/lib.py

@@ -0,0 +1,17 @@
+"""Jac Library - User-friendly interface for library mode."""
+
+from jaclang.runtimelib.machine import JacMachineInterface
+
+# Automatically expose all public attributes from JacMachineInterface
+# This includes archetype classes (Obj, Node, Edge, Walker, Root, Path) and all methods
+_jac_interface_attrs = {
+    name: getattr(JacMachineInterface, name)
+    for name in dir(JacMachineInterface)
+    if not name.startswith("_")
+}
+
+# Add to module globals
+globals().update(_jac_interface_attrs)
+
+# Build __all__ with all JacMachineInterface exports
+__all__ = sorted(_jac_interface_attrs.keys())

jaclang/runtimelib/archetype.py

@@ -69,13 +69,13 @@ class AnchorReport:
     context: dict[str, Any]
 
 
-DataSpatialFilter: TypeAlias = (
+ObjectSpatialFilter: TypeAlias = (
     Callable[["Archetype"], bool] | "Archetype" | list["Archetype"] | None
 )
 
 
 @dataclass(eq=False, repr=False)
-class DataSpatialDestination:
+class ObjectSpatialDestination:
     """Object-Spatial Destination."""
 
     direction: EdgeDir
@@ -92,18 +92,18 @@ class DataSpatialDestination:
 
 
 @dataclass(eq=False, repr=False)
-class DataSpatialPath:
+class ObjectSpatialPath:
     """Object-Spatial Path."""
 
     origin: list[NodeArchetype]
-    destinations: list[DataSpatialDestination]
+    destinations: list[ObjectSpatialDestination]
     edge_only: bool
     from_visit: bool
 
     def __init__(
         self,
         origin: NodeArchetype | list[NodeArchetype],
-        destinations: list[DataSpatialDestination] | None = None,
+        destinations: list[ObjectSpatialDestination] | None = None,
     ) -> None:
         """Override Init."""
         if not isinstance(origin, list):
@@ -115,7 +115,7 @@ class DataSpatialPath:
 
     def convert(
         self,
-        filter: DataSpatialFilter,
+        filter: ObjectSpatialFilter,
     ) -> Callable[["Archetype"], bool] | None:
         """Convert filter."""
         if not filter:
@@ -129,44 +129,44 @@ class DataSpatialPath:
     def append(
         self,
         direction: EdgeDir,
-        edge: DataSpatialFilter,
-        node: DataSpatialFilter,
-    ) -> DataSpatialPath:
+        edge: ObjectSpatialFilter,
+        node: ObjectSpatialFilter,
+    ) -> ObjectSpatialPath:
         """Append destination."""
         self.destinations.append(
-            DataSpatialDestination(direction, self.convert(edge), self.convert(node))
+            ObjectSpatialDestination(direction, self.convert(edge), self.convert(node))
         )
         return self
 
-    def _out(
-        self, edge: DataSpatialFilter = None, node: DataSpatialFilter = None
-    ) -> DataSpatialPath:
+    def edge_out(
+        self, edge: ObjectSpatialFilter = None, node: ObjectSpatialFilter = None
+    ) -> ObjectSpatialPath:
         """Override greater than function."""
         return self.append(EdgeDir.OUT, edge, node)
 
-    def _in(
-        self, edge: DataSpatialFilter = None, node: DataSpatialFilter = None
-    ) -> DataSpatialPath:
+    def edge_in(
+        self, edge: ObjectSpatialFilter = None, node: ObjectSpatialFilter = None
+    ) -> ObjectSpatialPath:
         """Override greater than function."""
         return self.append(EdgeDir.IN, edge, node)
 
-    def _any(
-        self, edge: DataSpatialFilter = None, node: DataSpatialFilter = None
-    ) -> DataSpatialPath:
+    def edge_any(
+        self, edge: ObjectSpatialFilter = None, node: ObjectSpatialFilter = None
+    ) -> ObjectSpatialPath:
         """Override greater than function."""
         return self.append(EdgeDir.ANY, edge, node)
 
-    def edge(self) -> DataSpatialPath:
+    def edge(self) -> ObjectSpatialPath:
         """Set edge only."""
         self.edge_only = True
         return self
 
-    def visit(self) -> DataSpatialPath:
+    def visit(self) -> ObjectSpatialPath:
         """Set from visit."""
         self.from_visit = True
         return self
 
-    def repr_builder(self, repr: str, dest: DataSpatialDestination, mark: str) -> str:
+    def repr_builder(self, repr: str, dest: ObjectSpatialDestination, mark: str) -> str:
         """Repr builder."""
         repr += mark
         repr += f' (edge{" filter" if dest.edge else ""}) '
@@ -361,8 +361,8 @@ class ObjectAnchor(Anchor):
 class Archetype:
     """Archetype Protocol."""
 
-    _jac_entry_funcs_: ClassVar[list[DataSpatialFunction]] = []
-    _jac_exit_funcs_: ClassVar[list[DataSpatialFunction]] = []
+    _jac_entry_funcs_: ClassVar[list[ObjectSpatialFunction]] = []
+    _jac_exit_funcs_: ClassVar[list[ObjectSpatialFunction]] = []
 
     @cached_property
     def __jac__(self) -> Anchor:
@@ -454,7 +454,7 @@ class Root(NodeArchetype):
 
 
 @dataclass(eq=False)
-class DataSpatialFunction:
+class ObjectSpatialFunction:
     """Object-Spatial Function."""
 
     name: str

jaclang/runtimelib/constructs.py

@@ -7,12 +7,12 @@ from .archetype import (
     AccessLevel,
     Anchor,
     Archetype,
-    DataSpatialFunction,
     EdgeAnchor,
     EdgeArchetype,
     GenericEdge,
     NodeAnchor,
     NodeArchetype,
+    ObjectSpatialFunction,
     Root,
     WalkerAnchor,
     WalkerArchetype,
@@ -32,7 +32,7 @@ __all__ = [
     "WalkerArchetype",
     "GenericEdge",
     "Root",
-    "DataSpatialFunction",
+    "ObjectSpatialFunction",
     "Memory",
     "ShelfStorage",
     "JacTestResult",