jaclang 0.7.14__py3-none-any.whl → 0.7.17__py3-none-any.whl

jaclang/tests/fixtures/err.jac

@@ -1,5 +1,7 @@
-"""Demo"""
+obj HasFault {
+    can init;
+}
 
 can speak {
-    "Hello" |> aprint;
+    HasFault();
 }

jaclang/tests/fixtures/err_runtime.jac

@@ -0,0 +1,15 @@
+
+can bar(some_list:list) {
+    invalid_index = 4;
+    print(some_list[invalid_index]);  # This should fail.
+}
+
+
+can foo() {
+    bar([0, 1, 2, 3]);
+}
+
+
+with entry {
+    foo();
+}

jaclang/tests/fixtures/foo.jac

@@ -0,0 +1,43 @@
+import:py from jaclang.plugin.feature, JacFeature as Jac;
+import:py from jaclang.runtimelib.machine, JacMachine;
+import:jac from bar, bar_walk;
+# Test runner to initialize the walker
+
+can test_run {
+    # Print the loaded modules
+    modules = JacMachine.get().list_modules();
+    "Loaded Modules:" |> print;
+    for mod_name in modules {
+        f"Module: {mod_name}" |> print;
+    }
+    # Print walkers
+    walkers = JacMachine.get().list_walkers(mod_name);
+    if walkers {
+        f"Walkers in {mod_name}:" |> print;
+        for walker in walkers {
+            f"  - Walker: {walker}" |> print;
+        }
+    }
+    # Print nodes
+    nodes = JacMachine.get().list_nodes(mod_name);
+    if nodes {
+        f"Nodes in {mod_name}:" |> print;
+        for node in nodes {
+            f"  - Node: {node}" |> print;
+        }
+    }
+    # Print edges
+    edges = JacMachine.get().list_edges(mod_name);
+    if edges {
+        f"Edges in {mod_name}:" |> print;
+        for edge in edges {
+            f"  - Edge: {edge}" |> print;
+        }
+    }
+    root spawn bar_walk();
+}
+# Define the entry point to run the test
+
+with entry {
+    test_run();
+}

jaclang/tests/fixtures/gendot_bubble_sort.jac

@@ -73,5 +73,5 @@ with entry {
     root spawn walker1();
     root spawn walker2();
     root spawn walker3();
-    print(root._jac_.gen_dot());
+    print(root.__jac__.gen_dot());
 }

jaclang/tests/fixtures/hello.jac

@@ -1,5 +1,9 @@
 """Hello World!"""
 
+can still_there {
+    print("im still here");
+}
+
 with entry {
     "Hello World!" |> print;
 }

jaclang/tests/fixtures/impl_grab.impl.jac

@@ -1,4 +1,5 @@
 import:py math;
+
 :can:test_grab {
     return math.sqrt(2);
-}
+}

jaclang/tests/fixtures/impl_grab.jac

@@ -1,2 +1,5 @@
 can test_grab;
-with entry {print(test_grab());}
+
+with entry {
+    print(test_grab());
+}

jaclang/tests/fixtures/import.jac

@@ -0,0 +1,9 @@
+import:py os;
+import:py sys;
+import:py pyfunc;
+import:py pygame_mock.inner;
+import:py pygame_mock.inner.inner_mod;
+import:py math;
+import:py argparse;
+import:py from pygame_mock { color, display }
+import:py pygame_mock;

jaclang/tests/fixtures/index_slice.jac

@@ -0,0 +1,30 @@
+obj fruit {
+    has name: str,
+        color: str;
+}
+
+glob a: list[fruit] = [
+    fruit(name="apple", color="red"),
+    fruit(name="banana", color="yellow"),
+    fruit(name="grape", color="purple")
+];
+
+glob b: dict[str, fruit] = {
+    "a": fruit(name="apple", color="red"),
+    "b": fruit(name="banana", color="yellow"),
+    "c": fruit(name="grape", color="purple")
+};
+
+can foo(a: list[fruit]) -> list[fruit] {
+    return a[0:2];
+}
+
+with entry {
+    fruit_1 = a[0];
+    clr_1 = a[0].color;
+    clr_1 = b["a"].color;
+    f_clr = foo(a);
+    f_clrw = foo(a)[0];
+    f_clrw2 = foo(a)[0:1][0].color;
+    # print(foo(a)[0].color);
+}

jaclang/tests/fixtures/jp_importer_auto.jac

@@ -0,0 +1,14 @@
+import from math { sin as s, cos, sqrt as sq }
+include random;
+import from ..test_cli, JacCliTests as Jac;
+import from deep.mycode, code as c;
+import hashcheck as h, assign_compr as a;
+import from jacsamp, my_print as m;
+
+with entry {
+    print(sq(4), s(30), cos(30));
+    print(randint(1, 10));
+    print(m("--->my_print<---"));
+    print(h.a, a.mvar);
+    print(c());
+}

jaclang/tests/fixtures/maxfail_run_test.jac

@@ -1,17 +1,17 @@
 glob x = 5, y = 2;
 
 test a {
-    check assertAlmostEqual(5, x);
+    check almostEqual(5, x);
 }
 
 test b {
-    check assertIn("l", "llm");
+    check "l" in "llm";
 }
 
 test c {
-    check assertEqual(x - y, 3);
+    check x - y == 3;
 }
 
 test d {
-    check assertEqual(1, 2);
+    check 1 == 2;
 }

jaclang/tests/fixtures/needs_import.jac

@@ -3,7 +3,7 @@
 import:py os;
 import:py pyfunc;
 import:py random;
-import:py from pyfunc, my_print;
+import:py from pyfunc { my_print }
 
 with entry {
     my_print(pyfunc);
@@ -11,7 +11,7 @@ with entry {
 }
 
 import:py circle_pysolo;
-import:py from circle_pysolo, calculate_area;
+import:py from circle_pysolo { calculate_area }
 
 with entry {
     print(f"are {calculate_area(2.0)}");

jaclang/tests/fixtures/pyfunc_1.py

@@ -79,7 +79,7 @@ for i in range(a):
         break
     print(b)
 else:
-    print("Loop completed normally{}".format(i))
+    print(f"Loop completed normally{i}")
 
 
 def fooo45() -> None:

jaclang/tests/fixtures/pyfunc_2.py

@@ -1,9 +1,9 @@
+from __future__ import annotations
+
 # flake8: noqa
 
 """Python function for testing py imports."""
 
-from __future__ import annotations
-
 
 def count_up_to(n: int):
     """Count up to n"""
@@ -277,3 +277,6 @@ def foo() -> None:
 
 
 foo()
+
+node = 90
+print(node)

jaclang/tests/fixtures/pygame_mock/__init__.py

@@ -0,0 +1,3 @@
+from .display import *
+from .color import *
+from .constants import *

jaclang/tests/fixtures/pygame_mock/color.py

@@ -0,0 +1,3 @@
+class Color:
+    def __init__(self, value: int | str) -> None:
+        pass

jaclang/tests/fixtures/pygame_mock/constants.py

@@ -0,0 +1,5 @@
+CONST_VALUE: int = 0
+
+
+class CL:
+    CONST_VALUE2: str = "h"

jaclang/tests/fixtures/pygame_mock/display.py

@@ -0,0 +1,2 @@
+def set_mode(a, b):
+    pass

jaclang/tests/fixtures/pygame_mock/inner/iner_mod.py

@@ -0,0 +1,2 @@
+def hello_world():
+    print("Hello")

jaclang/tests/fixtures/registry.jac

@@ -24,6 +24,15 @@ glob personality_examples: 'Personality Information of Famous People': dict[str,
 
 glob person_value : list[tuple[dict[str, Personality], int]] =(-90);
 
+can 'GenAI ability'
+genai_ability(x: 'Something': str) -> 'Something Else': str by llm();
+
+can 'Normal ability'
+normal_ability(x: 'Something': str) -> 'Something Else': str {
+    y = 10;
+    return x;
+}
+
 can foo() {
    person_value=22;
    can bar() {

jaclang/tests/fixtures/run_test.jac

@@ -1,17 +1,17 @@
 glob a = 5, b = 2;
 
 test t1 {
-    check assertAlmostEqual(a, 6);
+    check almostEqual(a, 6);
 }
 
 test t2 {
-    check assertTrue(a != b);
+    check a != b;
 }
 
 test t3 {
-    check assertIn("d", "abc");
+    check "d" in "abc";
 }
 
 test t4 {
-    check assertEqual(a - b, 3);
+    check a - b == 3;
 }

jaclang/tests/fixtures/semstr.jac

@@ -27,7 +27,4 @@ journal {
 can add() -> 'no of': int {}
 
 can 'update user mood'
-updateMood(* mood: 'Moo of the Person': str,  something:'Something':str, something_else: 'Something Else': int = 5, without_semstr: float) -> 'mood selection': str {}
-
-
- can get_personality (person: 'Person Object': list[Person]) -> 'Personality of the Person': dict[Personality, PersonalityIndex] by llm(reason=True, incl_info=(personality_examples, self.diary_entries));
+updateMood(* mood: 'Moo of the Person': str,  something:'Something':str, something_else: 'Something Else': int = 5, without_semstr: float) -> 'mood selection': str {}

jaclang/tests/fixtures/simple_archs.jac

@@ -15,7 +15,7 @@ class SimpleClass {
         var2: int,
         var3: int = 0;
 
-    can init {
+    can init(self: SimpleClass) {
         print(self.var3);
     }
 }

jaclang/tests/test_cli.py

@@ -5,6 +5,7 @@ import io
 import os
 import subprocess
 import sys
+import traceback
 
 from jaclang.cli import cli
 from jaclang.plugin.builtin import dotgen
@@ -38,7 +39,7 @@ class JacCliTests(TestCase):
         sys.stderr = captured_output
 
         try:
-            cli.enter(self.fixture_abs_path("err2.jac"), entrypoint="speak", args=[])  # type: ignore
+            cli.enter(self.fixture_abs_path("err2.jac"), entrypoint="speak", args=[])
         except Exception as e:
             print(f"Error: {e}")
 
@@ -46,7 +47,66 @@ class JacCliTests(TestCase):
         sys.stderr = sys.__stderr__
         stdout_value = captured_output.getvalue()
         # print(stdout_value)
-        self.assertIn("Syntax Error", stdout_value)
+        self.assertIn("Error", stdout_value)
+
+    def test_jac_cli_alert_based_runtime_err(self) -> None:
+        """Basic test for pass."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        sys.stderr = captured_output
+
+        try:
+            cli.run(self.fixture_abs_path("err_runtime.jac"))
+        except Exception as e:
+            print(f"Error: {e}")
+
+        sys.stdout = sys.__stdout__
+        sys.stderr = sys.__stderr__
+
+        expected_stdout_values = (
+            "Error: list index out of range",
+            "    print(some_list[invalid_index]);",
+            "          ^^^^^^^^^^^^^^^^^^^^^^^^",
+            "  at bar() ",
+            "  at foo() ",
+            "  at <module> ",
+        )
+
+        logger_capture = "\n".join([rec.message for rec in self.caplog.records])
+        for exp in expected_stdout_values:
+            self.assertIn(exp, logger_capture)
+
+    def test_jac_impl_err(self) -> None:
+        """Basic test for pass."""
+        if "jaclang.tests.fixtures.err" in sys.modules:
+            del sys.modules["jaclang.tests.fixtures.err"]
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        sys.stderr = captured_output
+
+        try:
+            cli.enter(self.fixture_abs_path("err.jac"), entrypoint="speak", args=[])
+        except Exception:
+            traceback.print_exc()
+
+        sys.stdout = sys.__stdout__
+        sys.stderr = sys.__stderr__
+        stdout_value = captured_output.getvalue()
+        # print(stdout_value)
+        path_to_file = self.fixture_abs_path("err.impl.jac")
+        self.assertIn(f'"{path_to_file}", line 2', stdout_value)
+
+    def test_jac_test_err(self) -> None:
+        """Basic test for pass."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+        sys.stderr = captured_output
+        cli.test(self.fixture_abs_path("baddy.jac"))
+        sys.stdout = sys.__stdout__
+        sys.stderr = sys.__stderr__
+        stdout_value = captured_output.getvalue()
+        path_to_file = self.fixture_abs_path("baddy.test.jac")
+        self.assertIn(f'"{path_to_file}", line 2,', stdout_value)
 
     def test_jac_ast_tool_pass_template(self) -> None:
         """Basic test for pass."""
@@ -84,6 +144,52 @@ class JacCliTests(TestCase):
         stdout_value = captured_output.getvalue()
         self.assertIn("+-- Token", stdout_value)
 
+    def test_import_mod_abs_path(self) -> None:
+        """Testing for print AstTool."""
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+
+        cli.tool("ir", ["ast", f"{self.fixture_abs_path('import.jac')}"])
+
+        sys.stdout = sys.__stdout__
+        stdout_value = captured_output.getvalue()
+        self.assertRegex(
+            stdout_value,
+            r"1\:11 \- 1\:13.*ModulePath - os - abs_path\:.*typeshed/stdlib/os/__init__.pyi",
+        )
+        self.assertRegex(
+            stdout_value,
+            r"2\:11 \- 2\:14.*ModulePath - sys - abs_path\:.*typeshed/stdlib/sys/__init__.pyi",
+        )
+        self.assertRegex(
+            stdout_value,
+            r"3\:11 \- 3\:17.*ModulePath - pyfunc - abs_path\:.*fixtures/pyfunc.py",
+        )
+        self.assertRegex(
+            stdout_value,
+            r"4\:11 \- 4\:28.*ModulePath - pygame_mock - abs_path\:.*fixtures/pygame_mock/inner/__init__.py",
+        )
+        self.assertRegex(
+            stdout_value,
+            r"6\:11 \- 6\:15.*ModulePath - math - abs_path\:.*typeshed/stdlib/math.pyi",
+        )
+        self.assertRegex(
+            stdout_value,
+            r"7\:11 \- 7\:19.*ModulePath - argparse - abs_path\:.*typeshed/stdlib/argparse.pyi",
+        )
+        self.assertRegex(
+            stdout_value,
+            r"8\:16 \- 8\:27.*ModulePath - pygame_mock - abs_path\:.*fixtures/pygame_mock/__init__.py",
+        )
+        self.assertRegex(
+            stdout_value,
+            r"8\:30 \- 8:35.*ModuleItem - color - abs_path\:.*fixtures/pygame_mock/color.py",
+        )
+        self.assertRegex(
+            stdout_value,
+            r"8\:37 \- 8:44.*ModuleItem - display - abs_path\:.*fixtures/pygame_mock/display.py",
+        )
+
     def test_ast_dotgen(self) -> None:
         """Testing for print AstTool."""
         captured_output = io.StringIO()
@@ -102,7 +208,7 @@ class JacCliTests(TestCase):
         cli.check(f"{self.fixture_abs_path('game1.jac')}")
         sys.stdout = sys.__stdout__
         stdout_value = captured_output.getvalue()
-        self.assertIn("Errors: 0, Warnings: 1", stdout_value)
+        self.assertIn("Errors: 0, Warnings: 2", stdout_value)
 
     def test_type_info(self) -> None:
         """Testing for type info inside the ast tool."""