rapydscript-ns 0.8.3 → 0.9.0

package/test/comparison_ops.pyj

@@ -0,0 +1,173 @@
+from __python__ import overload_operators
+
+# ── helpers ──────────────────────────────────────────────────────────────────
+
+def _raises(fn, exc_type):
+    """Return True if fn() raises exc_type, False otherwise."""
+    try:
+        fn()
+    except exc_type:
+        return True
+    return False
+
+# ── 1. Numeric comparisons (should still work correctly) ─────────────────────
+
+assert 1 < 2
+assert not (2 < 1)
+assert 2 > 1
+assert not (1 > 2)
+assert 1 <= 1
+assert 2 <= 3
+assert not (3 <= 2)
+assert 3 >= 3
+assert 3 >= 2
+assert not (2 >= 3)
+
+# ── 2. String comparisons ────────────────────────────────────────────────────
+
+assert 'abc' < 'abd'
+assert 'abc' <= 'abc'
+assert 'z' > 'a'
+assert 'abc' >= 'abc'
+assert not ('b' < 'a')
+
+# ── 3. List lexicographic ordering ───────────────────────────────────────────
+
+# First differing element determines order
+assert [1, 2] < [1, 3]
+assert not ([1, 3] < [1, 2])
+
+# Prefix rule: shorter list with equal prefix is smaller
+assert [1, 2] < [1, 2, 0]
+assert not ([1, 2, 0] < [1, 2])
+
+# First element dominates
+assert [2] > [1, 99]
+assert not ([1, 99] > [2])
+
+# Equal lists
+assert [1, 2] <= [1, 2]
+assert [1, 2] >= [1, 2]
+assert not ([1, 2] < [1, 2])
+assert not ([1, 2] > [1, 2])
+
+# Empty lists
+assert [] < [1]
+assert [] <= []
+assert [1] > []
+assert not ([] > [])
+
+# ── 4. Nested list lexicographic ordering ────────────────────────────────────
+
+assert [[1, 2], [3]] < [[1, 2], [4]]
+assert [[1], [2]] < [[1], [2], []]
+
+# ── 5. Bool operands (bool is int in Python) ─────────────────────────────────
+
+assert not (True < True)
+assert False < True
+assert True > False
+assert True >= True
+
+# ── 6. Custom __lt__ / __le__ / __gt__ / __ge__ dispatch ────────────────────
+
+class Vec:
+    def __init__(self, x):
+        self.x = x
+    def __lt__(self, other):
+        return self.x < other.x
+    def __le__(self, other):
+        return self.x <= other.x
+    def __gt__(self, other):
+        return self.x > other.x
+    def __ge__(self, other):
+        return self.x >= other.x
+
+v1 = Vec(1)
+v2 = Vec(2)
+v3 = Vec(2)
+
+assert v1 < v2
+assert not (v2 < v1)
+assert v2 > v1
+assert not (v1 > v2)
+assert v1 <= v2
+assert v2 <= v3
+assert v2 >= v3
+assert v2 >= v1
+assert not (v1 >= v2)
+
+# ── 7. Reflected dunder dispatch ─────────────────────────────────────────────
+# When left has no __gt__, Python calls right.__lt__
+
+class LtOnly:
+    """Only defines __lt__; reflected ops depend on the right-hand operand."""
+    def __init__(self, x):
+        self.x = x
+    def __lt__(self, other):
+        return self.x < other.x
+
+a = LtOnly(1)
+b = LtOnly(2)
+
+assert a < b        # a.__lt__(b)
+assert b > a        # b.__gt__ absent → ρσ_op_gt falls back → ρσ_op_lt(a, b) → a.__lt__(b)
+
+# ── 8. TypeError for incompatible types ──────────────────────────────────────
+
+assert _raises(def(): return 1 < 'x';, TypeError)
+assert _raises(def(): return 'x' < 1;, TypeError)
+assert _raises(def(): return [1] < 1;, TypeError)
+assert _raises(def(): return 1 < [1];, TypeError)
+assert _raises(def(): return 1 > 'x';, TypeError)
+assert _raises(def(): return 1 <= 'x';, TypeError)
+assert _raises(def(): return 1 >= 'x';, TypeError)
+
+# ── 9. TypeError message contains operator symbol ────────────────────────────
+
+def _err_msg(fn):
+    try:
+        fn()
+    except TypeError as e:
+        return str(e)
+    return ''
+
+msg = _err_msg(def(): return 1 < 'x';)
+assert "'<'" in msg, msg
+assert 'int' in msg, msg
+assert 'str' in msg, msg
+
+msg = _err_msg(def(): return 1 > [1];)
+assert "'>'" in msg, msg
+
+msg = _err_msg(def(): return 1 <= {};)
+assert "'<='" in msg, msg
+
+msg = _err_msg(def(): return 1 >= {};)
+assert "'>='" in msg, msg
+
+# ── 10. Chained comparisons with overloaded ops ───────────────────────────────
+
+assert 1 < 2 < 3
+assert not (1 < 2 < 2)
+assert 3 > 2 > 1
+assert 1 <= 1 <= 2
+assert [1] < [2] < [3]
+assert [3] > [2] > [1]
+
+# Mixed direction chain
+assert 1 < 2 > 0
+assert not (1 < 2 > 3)
+
+# ── 11. Chained comparison: middle expression evaluated once ─────────────────
+
+counter = [0]
+def inc_and_return(val):
+    counter[0] += 1
+    return val
+
+# a < inc_and_return(b) < c  — middle must be evaluated exactly once
+assert 1 < inc_and_return(2) < 3
+assert counter[0] == 1, counter[0]
+
+print('All comparison_ops tests passed.')

package/test/dataclasses.pyj

@@ -0,0 +1,253 @@
+# globals: assrt
+# vim:fileencoding=utf-8
+#
+# dataclasses.pyj
+# Tests for the dataclasses standard library.
+
+ae  = assrt.equal
+ade = assrt.deepEqual
+ok  = assrt.ok
+
+from dataclasses import dataclass, field, fields, asdict, astuple, replace, is_dataclass, MISSING
+
+# ── 1. Basic @dataclass: __init__, __repr__, __eq__ ───────────────────────────
+
+@dataclass
+class _Point:
+    x: float
+    y: float
+
+p1 = _Point(1, 2)
+ae(p1.x, 1)
+ae(p1.y, 2)
+ae(repr(p1), '_Point(x=1, y=2)')
+ok(p1 == _Point(1, 2))
+ok(p1 is not _Point(1, 2))   # different instances
+ok(not (p1 == _Point(1, 9)))
+
+# ── 2. Default values ─────────────────────────────────────────────────────────
+
+@dataclass
+class _Config:
+    name: str
+    debug: bool = False
+    count: int = 0
+
+c1 = _Config('myapp')
+ae(c1.name, 'myapp')
+ok(c1.debug is False)
+ae(c1.count, 0)
+
+c2 = _Config('other', True, 5)
+ae(c2.name, 'other')
+ok(c2.debug is True)
+ae(c2.count, 5)
+
+# ── 3. Keyword arguments ──────────────────────────────────────────────────────
+
+c3 = _Config(name='test', debug=True)
+ae(c3.name, 'test')
+ok(c3.debug is True)
+ae(c3.count, 0)
+
+# ── 4. field() with default_factory ──────────────────────────────────────────
+
+@dataclass
+class _Container:
+    items: list = field(default_factory=list)
+    label: str = 'default'
+
+a = _Container()
+b = _Container()
+# Each instance gets its own list
+a.items.push(1)
+ae(a.items.length, 1)
+ae(b.items.length, 0)
+ae(a.label, 'default')
+
+d = _Container(label='custom')
+ae(d.label, 'custom')
+
+# ── 5. field() repr=False ─────────────────────────────────────────────────────
+
+@dataclass
+class _Hidden:
+    public: str
+    secret: str = field('s3cr3t', repr=False)
+
+h = _Hidden("visible")
+ae(repr(h), '_Hidden(public="visible")')
+ae(h.secret, 's3cr3t')
+
+# ── 6. field() init=False ─────────────────────────────────────────────────────
+
+@dataclass
+class _WithPostInit:
+    x: int
+    y: int
+    dist: int = field(init=False, repr=True)
+
+    def __post_init__(self):
+        this.dist = this.x + this.y
+
+w = _WithPostInit(3, 4)
+ae(w.x, 3)
+ae(w.y, 4)
+ae(w.dist, 7)
+
+# ── 7. fields() returns Field objects ────────────────────────────────────────
+
+fs = fields(_Point)
+ae(fs.length, 2)
+ae(fs[0].name, 'x')
+ae(fs[1].name, 'y')
+
+# Also works on an instance
+fs2 = fields(p1)
+ae(fs2.length, 2)
+ae(fs2[0].name, 'x')
+
+# ── 8. asdict() ───────────────────────────────────────────────────────────────
+
+@dataclass
+class _Inner:
+    value: int
+
+@dataclass
+class _Outer:
+    inner: object
+    tag: str
+
+d_obj = _Outer(_Inner(42), 'hello')
+d_dict = asdict(d_obj)
+ae(d_dict['tag'], 'hello')
+ae(d_dict['inner']['value'], 42)
+
+# ── 9. astuple() ──────────────────────────────────────────────────────────────
+
+pt = _Point(3, 4)
+t = astuple(pt)
+ae(t[0], 3)
+ae(t[1], 4)
+
+# ── 10. replace() ────────────────────────────────────────────────────────────
+
+p2 = _Point(1, 2)
+p3 = replace(p2, y=99)
+ae(p3.x, 1)
+ae(p3.y, 99)
+ae(p2.y, 2)          # original unchanged
+
+# ── 11. is_dataclass() ───────────────────────────────────────────────────────
+
+ok(is_dataclass(_Point))
+ok(is_dataclass(p1))
+ok(not is_dataclass(42))
+ok(not is_dataclass('hello'))
+ok(not is_dataclass({}))
+ok(not is_dataclass(None))
+
+# ── 12. @dataclass(order=True) ───────────────────────────────────────────────
+# Note: RapydScript's < / > operators do not dispatch to __lt__/__gt__, so
+# order=True is tested by calling the generated comparison methods directly.
+
+@dataclass(order=True)
+class _Version:
+    major: int
+    minor: int
+
+v1 = _Version(1, 0)
+v2 = _Version(1, 5)
+v3 = _Version(2, 0)
+
+ok(v1.__lt__(v2))
+ok(v2.__lt__(v3))
+ok(v3.__gt__(v1))
+ok(v1.__le__(v1))
+ok(v1.__ge__(v1))
+ok(v2.__ge__(v1))
+ok(not v1.__lt__(v1))
+
+# ── 13. @dataclass(frozen=True) ──────────────────────────────────────────────
+
+@dataclass(frozen=True)
+class _ImmutablePoint:
+    x: int
+    y: int
+
+ip = _ImmutablePoint(1, 2)
+ae(ip.x, 1)
+
+# Assigning to a frozen dataclass field raises an error (TypeError in JS,
+# since writable:false is enforced via Object.defineProperty).
+_frozen_error = None
+try:
+    ip.x = 99
+except Exception as e:
+    _frozen_error = str(e)
+ok(_frozen_error is not None)
+
+# ── 14. Inheritance ───────────────────────────────────────────────────────────
+
+@dataclass
+class _Base:
+    x: int
+    y: int = 0
+
+@dataclass
+class _Child(_Base):
+    z: str = 'default'
+
+ch = _Child(x=1, y=2, z='hi')
+ae(ch.x, 1)
+ae(ch.y, 2)
+ae(ch.z, 'hi')
+
+ch2 = _Child(10)
+ae(ch2.x, 10)
+ae(ch2.y, 0)
+ae(ch2.z, 'default')
+
+# repr shows all fields including inherited
+# (RapydScript repr() uses double quotes for strings, like JavaScript)
+r = repr(ch2)
+ok('x=10' in r)
+ok('y=0' in r)
+ok('z="default"' in r)
+
+# ── 15. MISSING sentinel ──────────────────────────────────────────────────────
+
+ae(repr(MISSING), 'MISSING')
+
+# ── 16. Multiple independent dataclasses ─────────────────────────────────────
+
+@dataclass
+class _A:
+    val: int = 1
+
+@dataclass
+class _B:
+    val: int = 2
+
+ok(_A().val is 1)
+ok(_B().val is 2)
+
+# ── 17. @dataclass as decorator factory (explicit parens, no args) ────────────
+
+@dataclass()
+class _Explicit:
+    name: str = 'x'
+
+ex = _Explicit()
+ae(ex.name, 'x')
+ae(repr(ex), '_Explicit(name="x")')
+
+# ── 18. Nested list field with asdict ────────────────────────────────────────
+
+@dataclass
+class _WithList:
+    numbers: list = field(default_factory=list)
+
+wl = _WithList([1, 2, 3])
+d2 = asdict(wl)
+ade(d2['numbers'], [1, 2, 3])

package/test/enum.pyj

@@ -0,0 +1,134 @@
+# globals: assrt
+# vim:fileencoding=utf-8
+#
+# enum.pyj
+# Tests for the enum standard library (from enum import Enum).
+
+ae  = assrt.equal
+ade = assrt.deepEqual
+ok  = assrt.ok
+
+from enum import Enum
+
+# ── 1. Basic member access: .name and .value ─────────────────────────────────
+# STATUS: ✓ WORKS
+
+class _Color(Enum):
+    RED   = 1
+    GREEN = 2
+    BLUE  = 3
+
+ae(_Color.RED.name,   'RED')
+ae(_Color.RED.value,  1)
+ae(_Color.GREEN.name,  'GREEN')
+ae(_Color.GREEN.value, 2)
+ae(_Color.BLUE.name,   'BLUE')
+ae(_Color.BLUE.value,  3)
+
+# ── 2. Member singletons (identity) ──────────────────────────────────────────
+# STATUS: ✓ WORKS
+
+ok(_Color.RED is _Color.RED)
+ok(_Color.RED is not _Color.GREEN)
+ok(_Color.GREEN is not _Color.BLUE)
+
+# ── 3. repr and str ──────────────────────────────────────────────────────────
+# STATUS: ✓ WORKS
+# Note: repr() for integer values uses the numeric representation.
+# The class name in repr/str reflects the actual JS constructor name.
+
+ae(repr(_Color.RED),   '<_Color.RED: 1>')
+ae(repr(_Color.GREEN), '<_Color.GREEN: 2>')
+ae(str(_Color.RED),    '_Color.RED')
+ae(str(_Color.BLUE),   '_Color.BLUE')
+
+# ── 4. isinstance checks ─────────────────────────────────────────────────────
+# STATUS: ✓ WORKS
+
+ok(isinstance(_Color.RED,   _Color))
+ok(isinstance(_Color.RED,   Enum))
+ok(isinstance(_Color.GREEN, _Color))
+ok(not isinstance(1, _Color))
+ok(not isinstance(1, Enum))
+
+# ── 5. Iteration via list() ───────────────────────────────────────────────────
+# STATUS: ✓ WORKS
+
+members = list(_Color)
+ae(len(members), 3)
+ae(members[0].name, 'RED')
+ae(members[1].name, 'GREEN')
+ae(members[2].name, 'BLUE')
+ae(members[0].value, 1)
+ae(members[1].value, 2)
+ae(members[2].value, 3)
+
+# ── 6. for loop iteration ─────────────────────────────────────────────────────
+# STATUS: ✓ WORKS
+
+_found_names = []
+for _m in _Color:
+    _found_names.push(_m.name)
+ade(_found_names, ['RED', 'GREEN', 'BLUE'])
+
+_found_values = []
+for _m in _Color:
+    _found_values.push(_m.value)
+ade(_found_values, [1, 2, 3])
+
+# ── 7. _member_names_ registry ───────────────────────────────────────────────
+# STATUS: ✓ WORKS
+
+ade(_Color._member_names_, ['RED', 'GREEN', 'BLUE'])
+
+# ── 8. String-valued enum ─────────────────────────────────────────────────────
+# STATUS: ✓ WORKS
+
+class _Direction(Enum):
+    NORTH = 'north'
+    SOUTH = 'south'
+    EAST  = 'east'
+    WEST  = 'west'
+
+ae(_Direction.NORTH.name,  'NORTH')
+ae(_Direction.NORTH.value, 'north')
+ae(_Direction.SOUTH.value, 'south')
+# RapydScript repr() wraps strings in double quotes (JS convention)
+ae(repr(_Direction.NORTH), '<_Direction.NORTH: "north">')
+ae(str(_Direction.EAST),   '_Direction.EAST')
+ae(len(list(_Direction)), 4)
+
+# ── 9. Enum subclass with extra methods ───────────────────────────────────────
+# STATUS: ✓ WORKS
+
+class _Status(Enum):
+    ACTIVE   = 1
+    INACTIVE = 0
+
+    def is_active(self):
+        return this is _Status.ACTIVE
+
+ok(_Status.ACTIVE.is_active())
+ok(not _Status.INACTIVE.is_active())
+
+# ── 10. Multiple Enum subclasses are independent ──────────────────────────────
+# STATUS: ✓ WORKS
+
+ae(len(list(_Color)),     3)
+ae(len(list(_Direction)), 4)
+ae(len(list(_Status)),    2)
+ok(_Color._member_names_ is not _Direction._member_names_)
+ok(_Color.RED is not _Status.ACTIVE)   # different classes, different members
+
+# ── 11. Members are not confused with plain class instances ───────────────────
+# STATUS: ✓ WORKS
+
+ok(isinstance(_Color.RED, _Color))
+ok(_Color.RED is _Color.RED)   # same object every time
+
+# ── 12. Values from _members_by_value_ lookup ────────────────────────────────
+# STATUS: ✓ WORKS
+
+ae(_Color._members_by_value_[1].name, 'RED')
+ae(_Color._members_by_value_[2].name, 'GREEN')
+ae(_Color._members_by_value_[3].name, 'BLUE')

package/test/eval_exec.pyj

@@ -0,0 +1,56 @@
+# vim:fileencoding=utf-8
+# globals: assrt
+
+ae  = assrt.equal
+ade = assrt.deepEqual
+ok  = assrt.ok
+
+# ── eval — basic expression evaluation ────────────────────────────────────────
+
+ae(eval("1 + 2"), 3)
+ae(eval("10 * 5"), 50)
+ae(eval("100 - 37"), 63)
+ae(eval('"hello" + " world"'), "hello world")
+ae(eval("Math.pow(2, 8)"), 256)
+ae(eval("True"), True)
+ae(eval("None"), None)
+
+# ── eval — with explicit globals dict ─────────────────────────────────────────
+
+ae(eval("x + y", {"x": 10, "y": 5}), 15)
+ae(eval("a * b", {"a": 3, "b": 4}), 12)
+ae(eval("n * n", {"n": 7}), 49)
+
+# ── eval — locals override globals ────────────────────────────────────────────
+
+ae(eval("x", {"x": 1}, {"x": 99}), 99)
+ae(eval("x + y", {"x": 10, "y": 20}, {"y": 1}), 11)
+
+# ── exec — always returns None ────────────────────────────────────────────────
+
+ae(exec("1 + 2"), None)
+ae(exec("_ignored = 42"), None)
+
+# ── exec — side effects via mutable objects in globals ────────────────────────
+
+log = []
+exec("log.push('hello')", {"log": log})
+ae(log[0], "hello")
+
+exec("log.push(1 + 2)", {"log": log})
+ae(log[1], 3)
+
+# exec with a function in globals
+out = []
+def _adder(a, b): out.push(a + b);
+exec("fn(10, 7)", {"fn": _adder, "out": out})
+ae(out[0], 17)
+
+# exec returns None even when globals/locals provided
+ae(exec("1 + 1", {"x": 5}), None)
+
+# ── exec — JS loop, mutation visible in caller ────────────────────────────────
+
+nums = []
+exec("for _i in range(4):\n    nums.append(_i * _i)", {"nums": nums})
+ade(nums, [0, 1, 4, 9])