jaclang 0.7.16__py3-none-any.whl → 0.7.18__py3-none-any.whl

jaclang/settings.py

@@ -14,10 +14,8 @@ class Settings:
     filter_sym_builtins: bool = True
     ast_symbol_info_detailed: bool = False
     pass_timer: bool = False
-
-    # Import configuration
-    py_raise: bool = False
-    py_raise_deep: bool = False
+    collect_py_dep_debug: bool = False
+    print_py_raised_ast: bool = False
 
     # Formatter configuration
     max_line_length: int = 88

jaclang/tests/fixtures/access_checker.jac

@@ -1,19 +1,14 @@
-obj :priv BankAccount {
-    has account_no: int;
-    can register() {
-        print(f"{self.account_no} has been registered.");
-    }
-}
-can :priv privmethod() {
-    return "private method";
-}
-can :priv overide_check() {
-    return "inside access_check";
-}
-glob :priv b=1;
-glob :priv p=0;
+
+obj :pub  ModulePublObj {}
+obj :priv ModulePrivObj {}
+
+glob :pub  module_publ_glob:int = 0;
+glob :priv module_priv_glob:int = 0;
+
 with entry {
-    public = BankAccount(123);
-    public.register();
-    privmethod();
+    ModulePrivObj(); # <-- okey.
+    ModulePublObj(); # <-- okey.
+
+    module_publ_glob; # <-- okey.
+    module_priv_glob; # <-- okey.
 }

jaclang/tests/fixtures/access_modifier.jac

@@ -1,49 +1,104 @@
 include:jac access_checker;
-obj Animal {
-    has :pub species: str;
 
-    can :priv introduce() {
-        return "Hello, I am " + self.species + ". ";
-    }
+obj SomeObj {
+    obj :pub     InnerPublObj {}
+    obj :priv    InnerPrivObj {}
+    obj :protect InnerProtObj {}
+
+    enum :pub     InnerPublEnum { FOO = "FOO" }
+    enum :priv    InnerPrivEnum { BAR = "BAR" }
+    enum :protect InnerProtEnum { BAZ = "BAZ" }
 
+    can :pub     publ_ability() -> None {}
+    can :priv    priv_ability() -> None {}
+    can :protect prot_ability() -> None {}
 
+    has :pub     publ_attrib:int = 0;
+    has :priv    priv_attrib:int = 0;
+    has :protect prot_attrib:int = 0;
 }
 
-obj Dog: Animal: {
-    has :pub breed: str;
 
-    can init(breed: str) {
-        super.init("Dog");
-        self.breed = breed;
-    }
+obj BaseClass {
+    has :pub     publ_attrib:int = 0;
+    has :priv    priv_attrib:int = 0;
+    has :protect prot_attrib:int = 0;
 
-    can :pub bark() {
-        return "Woof! Woof!";
+    can do_base() -> None {
+        self.publ_attrib; # <-- okey.
+        self.priv_attrib; # <-- okey.
+        self.prot_attrib; # <-- okey.
     }
+}
 
-    can :pub makeSound() {
-        return "The dog says: " + super.introduce();
+
+obj DrivedClass1 :BaseClass: {
+    can do_driv1() -> None {
+        self.publ_attrib; # <-- okey.
+        self.priv_attrib; # <-- not okey.
+        self.prot_attrib; # <-- okey.
     }
-        obj Body {
-        has :pub s: str="22";
+}
+
+
+# Check if the protect works from inherited chain.
+obj DrivedClass2 :BaseClass: {
+    can do_driv2() -> None {
+        self.publ_attrib; # <-- okey.
+        self.priv_attrib; # <-- not okey.
+        self.prot_attrib; # <-- okey.
     }
 }
-can :priv overide_check() {
-    return "inside access_modifier";
+
+
+
+obj :pub Chain1 {
+    has :priv priv_val:int = 0; # <-- the private in the chain.
+}
+
+obj :pub Chain2 {
+    has :pub chain1:Chain1 = Chain1();
+}
+
+obj :pub Chain3 {
+    has :pub chain2:Chain2 = Chain2();
 }
-glob :priv a=2, c=7, m="hi";
+
+
 with entry {
-     myDog  = Dog(breed= "Golden Retriever");
-
-    print( " Name: " + myDog.species );
-    print( " Breed: " + myDog.breed );
-    print( myDog.introduce() );
-    print( myDog.bark() );
-    b=myDog.Body("33");
-    print(a);
-    account = BankAccount(3333);
-    print(privmethod());
-    print(overide_check());
-    print(b);
-    print(p);
+    SomeObj.InnerPublObj; # <-- okey.
+    SomeObj.InnerPrivObj; # <-- not okey.
+    SomeObj.InnerProtObj; # <-- not okey.
+
+    SomeObj.InnerPublEnum; # <-- okey.
+    SomeObj.InnerPrivEnum; # <-- not okey.
+    SomeObj.InnerProtEnum; # <-- not okey.
+
+    some_obj = SomeObj();
+
+    some_obj.InnerPublObj; # <-- okey.
+    some_obj.InnerPrivObj; # <-- not okey.
+    some_obj.InnerProtObj; # <-- not okey.
+
+    some_obj.InnerPublEnum; # <-- okey.
+    some_obj.InnerPrivEnum; # <-- not okey.
+    some_obj.InnerProtEnum; # <-- not okey.
+
+    some_obj.publ_attrib; # <-- okey.
+    some_obj.priv_attrib; # <-- not okey.
+    some_obj.prot_attrib; # <-- not okey.
+
+    some_obj.publ_ability(); # <-- okey.
+    some_obj.priv_ability(); # <-- not okey.
+    some_obj.prot_ability(); # <-- not okey.
+
+    chain3: Chain3 = Chain3();
+    chain3.chain2.chain1;          # <-- okey.
+    chain3.chain2.chain1.priv_val; # <-- not okey.
+
+    access_checker.ModulePublObj(); # <-- okey.
+    access_checker.ModulePrivObj(); # <-- not okey.
+
+    access_checker.module_priv_glob; # <-- okey.
+    access_checker.module_priv_glob; # <-- not okey.
 }

jaclang/tests/fixtures/baddy.jac

@@ -0,0 +1,3 @@
+can speak {
+    HasFault();
+}

jaclang/tests/fixtures/bar.jac

@@ -0,0 +1,34 @@
+# Define a simple node type called `Item`
+node Item {
+    has value: int = 0;
+}
+
+# Define an edge type called `Link`
+edge Link {}
+
+# Define the `bar` walker
+walker bar_walk {
+    has count: int = 0;
+
+    # Start walking from the root node or an Item node
+    can start with `root | Item entry {
+        here ++> Item();
+        if self.count < 5 {
+            visit [-->];
+        } else {
+            "Created 5 items." |> print;
+            disengage;
+        }
+    }
+
+    # Walk over Item nodes and update their values
+    can walk with Item entry {
+        here.value = self.count;
+        f"Item value: {here.value}" |> print;
+        self.count += 1;
+        visit [-->] else {
+            "Finished walking over all items." |> print;
+            disengage;
+        }
+    }
+}

jaclang/tests/fixtures/builtin_dotgen.jac

@@ -31,6 +31,7 @@ with entry{
     print(d2.count('a(val')==19,d2.count('#F5E5FF')==2 ,'Edge1' not in d2,d2.count('GenericEdge')==42);
     print(d3.count('a(val')==6,d3.count("GenericEdge")==5,d3.count('#F5E5FF')==1);
     print(d4.count("a(val")==25,d4.count("GenericEdge")==66,d4.count('#FFF0F')==3);
+    print(d5.count("Edge1(val=6)")==2, d5.count("GenericEdge()")==24);
     # print(l3<l2);
     # print(d1);
     # print(d2);

jaclang/tests/fixtures/edge_node_walk.jac

@@ -37,7 +37,7 @@ edge Edge_c {
 
 with entry {
     print(root spawn creator());
-    print(root._jac_.gen_dot());
+    print(root.__jac__.gen_dot());
     print([root-:Edge_a:->]);
     print([root-:Edge_c:->]);
     print([root-:Edge_a:->-:Edge_b:->]);

jaclang/tests/fixtures/edge_ops.jac

@@ -22,7 +22,7 @@ edge MyEdge {
             for j=0 to j<3 by j+=1  {
                 end +:MyEdge:val=random.randint(1, 15), val2=random.randint(1, 5):+> node_a(value=j + 10);
             }
-            print([(i.val, i.val2) for i in end._jac_.edges if isinstance(i, MyEdge)]);
+            print([(arch.val, arch.val2) for i in end.__jac__.edges if isinstance(arch := i.architype, MyEdge)]);
         }
     }
     for i=0 to i<3 by i+=1  {

jaclang/tests/fixtures/edges_walk.jac

@@ -30,7 +30,7 @@ edge Edge_c{
 
 with entry{
     print(root spawn creator());
-    print(root._jac_.gen_dot());
+    print(root.__jac__.gen_dot());
     print([root -:Edge_a:->]);
     print([root -:Edge_c:->]);
     print([root -:Edge_a:-> -:Edge_b:->]);

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/game1.jac

@@ -1,5 +1,5 @@
 import:py random;
-import:py from typing { Tuple }
+import:py from typing, Tuple;
 
 obj Button {
     can is_pressed(pos: tuple, pressed: str) -> bool {

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/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/objref.jac

@@ -0,0 +1,12 @@
+node MyNode {
+    has value: int = 0;
+}
+
+with entry {
+    root ++> (x:=MyNode());
+    obj_id = jid(x);
+    myobj = &obj_id;
+    print(obj_id);
+    print(myobj);
+    print("valid:", myobj == x);
+}

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"""

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/test_cli.py

@@ -98,17 +98,14 @@ class JacCliTests(TestCase):
 
     def test_jac_test_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
-        cli.test(self.fixture_abs_path("err.jac"))
+        cli.test(self.fixture_abs_path("baddy.jac"))
         sys.stdout = sys.__stdout__
         sys.stderr = sys.__stderr__
         stdout_value = captured_output.getvalue()
-        # print(stdout_value)
-        path_to_file = self.fixture_abs_path("err.test.jac")
+        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:
@@ -147,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()
@@ -165,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."""