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

jaclang/runtimelib/tests/fixtures/client_app.jac

@@ -0,0 +1,18 @@
+"""Sample Jac module containing client-side declarations."""
+
+cl let API_LABEL: str = "Runtime Test";
+
+cl obj ButtonProps {
+    has label: str = "Tap Me";
+    has color: str = "primary";
+}
+
+cl def client_page() {
+    let props = ButtonProps(label="Tap Me", color="primary");
+    return <div class="app">
+        <h1>{API_LABEL}</h1>
+        <button class={props.color} data-id="button">
+            {props.label}
+        </button>
+    </div>;
+}

jaclang/runtimelib/tests/fixtures/custom_access_validation.jac

@@ -27,7 +27,7 @@ node A {
 walker create_other_root {
     can enter with `root entry {
         other_root = `root().__jac__;
-        _jl.save(other_root);
+        save(other_root);
         print(other_root.id);
     }
 }

jaclang/runtimelib/tests/fixtures/savable_object.jac

@@ -43,10 +43,8 @@ walker create_custom_object {
     }
 
     can exit1 with `root exit {
-        # get directly from shelf
-        o = _jl.get_context().mem.__shelf__.get(str(self.obj.__jac__.id)).archetype;
-        print(jid(o));
-        print(o);
+        print(jid(self.obj));
+        print(self.obj);
     }
 }
 
@@ -87,6 +85,7 @@ walker delete_custom_object {
     has object_id: str;
 
     can enter1 with `root entry {
-        _jl.destroy([&(self.object_id)]);
+        savable_object = &(self.object_id);
+        del savable_object;
     }
 }

jaclang/runtimelib/tests/fixtures/serve_api.jac

@@ -0,0 +1,75 @@
+"""Example Jac program for REST API server."""
+
+# Define some nodes
+node Task {
+    has title: str;
+    has completed: bool = False;
+    has priority: int = 0;
+}
+
+node User {
+    has name: str;
+    has email: str;
+}
+
+# Define a walker to create tasks
+walker CreateTask {
+    has title: str;
+    has priority: int = 1;
+
+    can create with `root entry {
+        task_list = here ++> Task(title=self.title, priority=self.priority);
+        task = task_list[0] if task_list else None;
+        if task {
+            print("Created task: " + task.title);
+        }
+    }
+}
+
+# Define a walker to list all tasks
+walker ListTasks {
+    has tasks: list = [];
+
+    can collect with `root entry {
+        visit [-->];
+    }
+
+    can gather with Task entry {
+        print("Found task: " + here.title);
+    }
+}
+
+# Define a walker to mark tasks as complete
+walker CompleteTask {
+    has title: str;
+
+    can search with `root entry {
+        visit [-->];
+    }
+
+    can mark_complete with Task entry {
+        if here.title == self.title {
+            here.completed = True;
+            print("Completed task: " + here.title);
+        }
+    }
+}
+
+"""Function to add two numbers together."""
+def add_numbers(a: int, b: int) -> int {
+    return a + b;
+}
+
+"""Function to generate a greeting message."""
+def greet(name: str = "World") -> str {
+    return "Hello, " + name + "!";
+}
+
+cl let WELCOME_TITLE: str = "Runtime Test";
+
+cl def client_page() {
+    return <section class="welcome">
+        <h1>{WELCOME_TITLE}</h1>
+        <p>{greet()}</p>
+    </section>;
+}

jaclang/runtimelib/tests/test_client_bundle.py

@@ -0,0 +1,55 @@
+"""Tests for client bundle generation."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from jaclang.runtimelib.client_bundle import ClientBundleBuilder
+from jaclang.runtimelib.machine import JacMachine as Jac
+from jaclang.utils.test import TestCase
+
+
+class ClientBundleBuilderTests(TestCase):
+    """Validate client bundle compilation."""
+
+    def setUp(self) -> None:
+        Jac.reset_machine()
+        return super().setUp()
+
+    def tearDown(self) -> None:
+        Jac.reset_machine()
+        return super().tearDown()
+
+    def test_build_bundle_for_module(self) -> None:
+        """Compile a Jac module and ensure client bundle metadata is emitted."""
+        fixtures_dir = Path(__file__).parent / "fixtures"
+        (module,) = Jac.jac_import("client_app", str(fixtures_dir))
+
+        builder = ClientBundleBuilder()
+        bundle = builder.build(module)
+
+        self.assertIn("function __jacJsx", bundle.code)
+        # Check that registration mechanism is present
+        self.assertIn('moduleFunctions[funcName] = funcRef;', bundle.code)
+        self.assertIn('scope[funcName] = funcRef;', bundle.code)
+        self.assertIn('moduleGlobals[gName] = existing;', bundle.code)
+        self.assertIn('scope[gName] = defaultValue;', bundle.code)
+        # Check that actual client functions and globals are defined
+        self.assertIn('function client_page()', bundle.code)
+        self.assertIn('class ButtonProps', bundle.code)
+        self.assertIn('const API_LABEL = "Runtime Test";', bundle.code)
+        # Check hydration logic is present
+        self.assertIn("__jacHydrateFromDom", bundle.code)
+        self.assertIn("__jacEnsureHydration", bundle.code)
+        self.assertIn('getElementById("__jac_init__")', bundle.code)
+        self.assertIn('getElementById("__jac_root")', bundle.code)
+        # Check globals iteration logic
+        self.assertIn("for (const gName of __objectKeys(payloadGlobals))", bundle.code)
+        self.assertIn("client_page", bundle.client_functions)
+        self.assertIn("ButtonProps", bundle.client_functions)
+        self.assertIn("API_LABEL", bundle.client_globals)
+        self.assertGreater(len(bundle.hash), 10)
+
+        cached = builder.build(module)
+        self.assertEqual(bundle.hash, cached.hash)
+        self.assertEqual(bundle.code, cached.code)

jaclang/runtimelib/tests/test_client_render.py

@@ -0,0 +1,63 @@
+"""Offline tests for client page rendering without sockets."""
+
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+
+from jaclang.runtimelib.machine import JacMachine as Jac
+from jaclang.runtimelib.server import JacAPIServer
+from jaclang.utils.test import TestCase
+
+
+class ClientRenderTests(TestCase):
+    """Validate client bundle helpers without opening sockets."""
+
+    def setUp(self) -> None:
+        Jac.reset_machine()
+        super().setUp()
+
+    def tearDown(self) -> None:
+        Jac.reset_machine()
+        super().tearDown()
+
+    def _make_server(self) -> JacAPIServer:
+        fixtures_dir = Path(__file__).parent / "fixtures"
+        Jac.jac_import("client_app", str(fixtures_dir))
+        server = JacAPIServer(
+            module_name="client_app", session_path=str(self.fixture_abs_path("client.session"))
+        )
+        server.load_module()
+        return server
+
+    def test_render_client_page_returns_html(self) -> None:
+        server = self._make_server()
+        server.user_manager.create_user("tester", "pass")
+        html_bundle = server.render_client_page("client_page", {}, "tester")
+
+        self.assertIn("<!DOCTYPE html>", html_bundle["html"])
+        self.assertIn('<div id="__jac_root"></div>', html_bundle["html"])
+        self.assertIn("/static/client.js?hash=", html_bundle["html"])
+
+        init_match = re.search(
+            r'<script id="__jac_init__" type="application/json">([^<]*)</script>',
+            html_bundle["html"],
+        )
+        self.assertIsNotNone(init_match)
+        payload = json.loads(init_match.group(1)) if init_match else {}
+        self.assertEqual(payload.get("module"), "client_app")
+        self.assertEqual(payload.get("function"), "client_page")
+        self.assertEqual(payload.get("globals", {}).get("API_LABEL"), "Runtime Test")
+        self.assertEqual(payload.get("argOrder"), [])
+
+        bundle_code = server.get_client_bundle_code()
+        self.assertIn("function __jacJsx", bundle_code)
+        self.assertEqual(bundle_code, html_bundle["bundle_code"])
+
+    def test_render_unknown_page_raises(self) -> None:
+        server = self._make_server()
+        server.user_manager.create_user("tester", "pass")
+
+        with self.assertRaises(ValueError):
+            server.render_client_page("missing", {}, "tester")