rapydscript-ns 0.8.4 → 0.9.0

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])

package/test/format.pyj

@@ -0,0 +1,148 @@
+# vim:fileencoding=utf-8
+# License: BSD
+# Tests for __format__ dunder dispatch in format(), str.format(), and f-strings
+# globals: assrt
+
+ae = assrt.equal
+
+# ── Basic custom __format__ ───────────────────────────────────────────────────
+
+class Currency:
+    def __init__(self, amount):
+        self.amount = amount
+    def __str__(self):
+        return str(self.amount)
+    def __format__(self, spec):
+        if spec == 'usd':
+            return '$' + str(self.amount)
+        if spec == 'eur':
+            return '€' + str(self.amount)
+        return format(self.amount, spec)
+
+c = Currency(42)
+
+# format() builtin dispatches to __format__
+ae(format(c, 'usd'), '$42')
+ae(format(c, 'eur'), '€42')
+ae(format(c, '.2f'), '42.00')
+
+# str.format() dispatches to __format__
+ae(str.format('{:usd}', c), '$42')
+ae(str.format('{:eur}', c), '€42')
+ae(str.format('{:.2f}', c), '42.00')
+
+# f-strings dispatch to __format__
+ae(f'{c:usd}', '$42')
+ae(f'{c:eur}', '€42')
+ae(f'{c:.2f}', '42.00')
+
+# ── format() with empty spec calls __format__('') ────────────────────────────
+
+class Tagged:
+    def __init__(self, v):
+        self.v = v
+    def __str__(self):
+        return 'str:' + str(self.v)
+    def __format__(self, spec):
+        if not spec:
+            return 'fmt:' + str(self.v)
+        return 'fmt:' + format(self.v, spec)
+
+t = Tagged(7)
+ae(format(t), 'fmt:7')
+ae(format(t, ''), 'fmt:7')
+ae(str.format('{}', t), 'fmt:7')
+ae(f'{t}', 'fmt:7')
+
+# ── Default __format__ delegates to __str__ when spec is empty ────────────────
+
+class Simple:
+    def __str__(self):
+        return 'simple!'
+
+s = Simple()
+ae(format(s), 'simple!')
+ae(format(s, ''), 'simple!')
+ae(str.format('{}', s), 'simple!')
+ae(f'{s}', 'simple!')
+
+# ── Default __format__ raises TypeError for non-empty spec ───────────────────
+
+class Plain:
+    def __str__(self):
+        return 'plain'
+
+p = Plain()
+raised = False
+try:
+    format(p, 'd')
+except TypeError:
+    raised = True
+ae(raised, True)
+
+raised = False
+try:
+    str.format('{:d}', p)
+except TypeError:
+    raised = True
+ae(raised, True)
+
+# ── Inheritance: subclass inherits parent __format__ ─────────────────────────
+
+class Base:
+    def __format__(self, spec):
+        return 'base:' + spec
+
+class Child(Base):
+    pass
+
+child = Child()
+ae(format(child, 'x'), 'base:x')
+ae(str.format('{:x}', child), 'base:x')
+ae(f'{child:x}', 'base:x')
+
+# ── Subclass can override __format__ ─────────────────────────────────────────
+
+class Override(Base):
+    def __format__(self, spec):
+        return 'override:' + spec
+
+o = Override()
+ae(format(o, 'y'), 'override:y')
+ae(str.format('{:y}', o), 'override:y')
+
+# ── !r and !s transformers bypass __format__ ─────────────────────────────────
+
+class WithRepr:
+    def __repr__(self):
+        return 'MyRepr'
+    def __str__(self):
+        return 'MyStr'
+    def __format__(self, spec):
+        return 'MyFmt'
+
+wr = WithRepr()
+# With no transformer, __format__ is called
+ae(str.format('{}', wr), 'MyFmt')
+# !s applies str(), result is a string (no __format__)
+ae(str.format('{!s}', wr), 'MyStr')
+# !r applies repr()
+ae(str.format('{!r}', wr), 'MyRepr')
+
+# ── Multiple fields with __format__ ──────────────────────────────────────────
+
+class Qty:
+    def __init__(self, n):
+        self.n = n
+    def __str__(self):
+        return str(self.n)
+    def __format__(self, spec):
+        if spec == 'w':
+            words = ['zero', 'one', 'two', 'three', 'four', 'five']
+            return words[self.n] if self.n < len(words) else str(self.n)
+        return format(self.n, spec)
+
+a, b = Qty(1), Qty(2)
+ae(str.format('{:w} and {:w}', a, b), 'one and two')
+ae(f'{a:w} + {b:w}', 'one + two')
+ae(str.format('{0:d} + {1:d}', a, b), '1 + 2')

package/test/functions.pyj

@@ -1,151 +1,151 @@
-# globals: assrt
-
-def nothing():
-    pass
-assrt.equal(nothing(), undefined)
-
-add = def(a, b):
-    return a+b
-def sub(a, b):
-    return a-b
-
-mul = None
-(def():
-    nonlocal mul
-    mul = def(a, b):
-        return a*b
-
-    div = def(a, b):  # noqa:unused-local
-        return a/b
-)()
-
-assrt.equal(add(1,2), 3)
-assrt.equal(sub(1,2), -1)
-assrt.equal(mul(2,2), 4)
-# for some reason input to throws must be of type block, hence the 'def' wrapper
-assrt.throws(
-    def():
-        div(6,3)  # noqa: undef
-    ,
-    /div is not defined/
-)
-
-arr = [8,4]
-assrt.equal(add(*arr), 12)
-assrt.ok(Array.isArray(arr))
-
-def sum(*args):
-    ttl = 0
-    for i in args:
-        ttl += i
-    return ttl
-assrt.equal(sum(1,2,3), 6)
-assrt.equal(sum(1,*[2,3]), 6)
-
-num = 4
-def():
-    nonlocal num
-    num = 5
-.call(this)
-
-assrt.equal(num, 5)
-
-x = "foo"
-y = 5
-def swap(x, y):
-    return y, x
-x, y = swap(x, y)
-assrt.equal(x, 5)
-assrt.equal(y, "foo")
-
-count = 0
-f, r = (def():
-    def fake_increment():
-        count += 1
-    def real_increment():
-        nonlocal count
-        count += 1
-    return fake_increment, real_increment
-).call(this)
-
-f()
-assrt.equal(count, 0)
-r()
-assrt.equal(count, 1)
-
-st = "this is a string"
-assrt.equal(jstype(st), v"typeof st")
-
-# testing inlined functions
-inlined = [
-    def(x): return x+1;, def(x): return x+2;,
-    def(x): return x+3
-    ,
-    def(x): return x+4
-]
-assrt.equal(inlined[0](1), 2)
-assrt.equal(inlined[1](1), 3)
-assrt.equal(inlined[2](1), 4)
-assrt.equal(inlined[3](1), 5)
-
-# decorators
-def makebold(fn):
-    def wrapped(arg):
-        return "<b>" + fn(arg) + "</b>"
-    return wrapped
-
-def makeitalic(fn):
-    def wrapped(arg):
-        return "<i>" + fn(arg) + "</i>"
-    return wrapped
-
-@makebold
-@makeitalic
-def hello(something):
-    return "hello " + something
-
-assrt.equal(hello("world"), "<b><i>hello world</i></b>")
-assrt.equal(hello.__module__, '__main__')
-assrt.equal(hello.__argnames__.length, 1)
-assrt.equal(hello.__argnames__[0], 'arg')
-
-
-def simple_wrapper(f):
-    f.test_attr = 'test'
-    return f
-
-
-@simple_wrapper
-def fw(x):
-    pass
-
-assrt.equal(fw.__module__, '__main__')
-assrt.equal(fw.__argnames__.length, 1)
-assrt.equal(fw.__argnames__[0], 'x')
-# just because something is a reserved keyword in RapydScript, doesn't mean other libraries won't attempt to use it
-# let's make sure we parse that correctly
-five = {}
-v"five.is = function(n) { return 5 == n };"
-assrt.ok(five.is(5))
-
-# function assignment via conditional
-foo = (def(): return 5;) if 0 else (def(): return 6;)
-bar = (def(): return 5;) if 0 < 1 else (def(): return 6;)
-baz = (def():
-    return 5
-) if 1 else (def():
-    return 6
-)
-assrt.equal(foo(), 6)
-assrt.equal(bar(), 5)
-assrt.equal(baz(), 5)
-
-def trailing_comma(a, b,):
-    return a + b
-assrt.equal(trailing_comma(1, 2), 3)
-assrt.equal(trailing_comma(1, 2,), 3)
-
-def return_string_with_newline():
-    return '''a
-b'''
-assrt.equal(return_string_with_newline(), 'a\nb')
+# globals: assrt
+
+def nothing():
+    pass
+assrt.equal(nothing(), undefined)
+
+add = def(a, b):
+    return a+b
+def sub(a, b):
+    return a-b
+
+mul = None
+(def():
+    nonlocal mul
+    mul = def(a, b):
+        return a*b
+
+    div = def(a, b):  # noqa:unused-local
+        return a/b
+)()
+
+assrt.equal(add(1,2), 3)
+assrt.equal(sub(1,2), -1)
+assrt.equal(mul(2,2), 4)
+# for some reason input to throws must be of type block, hence the 'def' wrapper
+assrt.throws(
+    def():
+        div(6,3)  # noqa: undef
+    ,
+    /div is not defined/
+)
+
+arr = [8,4]
+assrt.equal(add(*arr), 12)
+assrt.ok(Array.isArray(arr))
+
+def sum(*args):
+    ttl = 0
+    for i in args:
+        ttl += i
+    return ttl
+assrt.equal(sum(1,2,3), 6)
+assrt.equal(sum(1,*[2,3]), 6)
+
+num = 4
+def():
+    nonlocal num
+    num = 5
+.call(this)
+
+assrt.equal(num, 5)
+
+x = "foo"
+y = 5
+def swap(x, y):
+    return y, x
+x, y = swap(x, y)
+assrt.equal(x, 5)
+assrt.equal(y, "foo")
+
+count = 0
+f, r = (def():
+    def fake_increment():
+        count += 1
+    def real_increment():
+        nonlocal count
+        count += 1
+    return fake_increment, real_increment
+).call(this)
+
+f()
+assrt.equal(count, 0)
+r()
+assrt.equal(count, 1)
+
+st = "this is a string"
+assrt.equal(jstype(st), v"typeof st")
+
+# testing inlined functions
+inlined = [
+    def(x): return x+1;, def(x): return x+2;,
+    def(x): return x+3
+    ,
+    def(x): return x+4
+]
+assrt.equal(inlined[0](1), 2)
+assrt.equal(inlined[1](1), 3)
+assrt.equal(inlined[2](1), 4)
+assrt.equal(inlined[3](1), 5)
+
+# decorators
+def makebold(fn):
+    def wrapped(arg):
+        return "<b>" + fn(arg) + "</b>"
+    return wrapped
+
+def makeitalic(fn):
+    def wrapped(arg):
+        return "<i>" + fn(arg) + "</i>"
+    return wrapped
+
+@makebold
+@makeitalic
+def hello(something):
+    return "hello " + something
+
+assrt.equal(hello("world"), "<b><i>hello world</i></b>")
+assrt.equal(hello.__module__, '__main__')
+assrt.equal(hello.__argnames__.length, 1)
+assrt.equal(hello.__argnames__[0], 'arg')
+
+
+def simple_wrapper(f):
+    f.test_attr = 'test'
+    return f
+
+
+@simple_wrapper
+def fw(x):
+    pass
+
+assrt.equal(fw.__module__, '__main__')
+assrt.equal(fw.__argnames__.length, 1)
+assrt.equal(fw.__argnames__[0], 'x')
+# just because something is a reserved keyword in RapydScript, doesn't mean other libraries won't attempt to use it
+# let's make sure we parse that correctly
+five = {}
+v"five.is = function(n) { return 5 == n };"
+assrt.ok(five.is(5))
+
+# function assignment via conditional
+foo = (def(): return 5;) if 0 else (def(): return 6;)
+bar = (def(): return 5;) if 0 < 1 else (def(): return 6;)
+baz = (def():
+    return 5
+) if 1 else (def():
+    return 6
+)
+assrt.equal(foo(), 6)
+assrt.equal(bar(), 5)
+assrt.equal(baz(), 5)
+
+def trailing_comma(a, b,):
+    return a + b
+assrt.equal(trailing_comma(1, 2), 3)
+assrt.equal(trailing_comma(1, 2,), 3)
+
+def return_string_with_newline():
+    return '''a
+b'''
+assrt.equal(return_string_with_newline(), 'a\nb')