rapydscript-ns 0.9.2 → 0.9.3

package/test/parenthesized_with.pyj

@@ -0,0 +1,141 @@
+# globals: assrt
+# vim:fileencoding=utf-8
+#
+# parenthesized_with.pyj
+# Tests for Python 3.10+ parenthesized `with` statement.
+
+ae  = assrt.equal
+ok  = assrt.ok
+
+# ── Helper context manager ────────────────────────────────────────────────────
+
+class _CM:
+    def __init__(self, name, log):
+        self.name = name
+        self.log = log
+
+    def __enter__(self):
+        self.log.push('enter:' + self.name)
+        return self
+
+    def __exit__(self, *args):
+        self.log.push('exit:' + self.name)
+        return False
+
+# ── 1. Single clause, alias inside parens ─────────────────────────────────────
+
+_log1 = []
+with (_CM('a', _log1) as cm):
+    _log1.push('body')
+ae(_log1[0], 'enter:a')
+ae(_log1[1], 'body')
+ae(_log1[2], 'exit:a')
+
+# ── 2. Single clause, no alias ────────────────────────────────────────────────
+
+_log2 = []
+
+class _SimpleCM:
+    def __init__(self, log):
+        self.log = log
+    def __enter__(self):
+        self.log.push('entered')
+        return self
+    def __exit__(self):
+        self.log.push('exited')
+
+with (_SimpleCM(_log2)):
+    _log2.push('body')
+ae(_log2[0], 'entered')
+ae(_log2[1], 'body')
+ae(_log2[2], 'exited')
+
+# ── 3. Multi-clause, LIFO exit order ──────────────────────────────────────────
+
+_log3 = []
+with (_CM('a', _log3) as a, _CM('b', _log3) as b):
+    _log3.push('body')
+ae(_log3[0], 'enter:a')
+ae(_log3[1], 'enter:b')
+ae(_log3[2], 'body')
+ae(_log3[3], 'exit:b')  # LIFO: b exits before a
+ae(_log3[4], 'exit:a')
+
+# ── 4. Trailing comma ─────────────────────────────────────────────────────────
+
+_log4 = []
+with (_CM('x', _log4) as x,):
+    _log4.push('body')
+ae(_log4[0], 'enter:x')
+ae(_log4[1], 'body')
+ae(_log4[2], 'exit:x')
+
+# ── 5. Multi-line form ────────────────────────────────────────────────────────
+
+_log5 = []
+with (
+    _CM('p', _log5) as p,
+    _CM('q', _log5) as q,
+):
+    _log5.push('body')
+ae(_log5[0], 'enter:p')
+ae(_log5[1], 'enter:q')
+ae(_log5[2], 'body')
+ae(_log5[3], 'exit:q')
+ae(_log5[4], 'exit:p')
+
+# ── 6. __enter__ return value assigned to alias ───────────────────────────────
+
+class _ValCM:
+    def __init__(self, val):
+        self.val = val
+    def __enter__(self):
+        return self.val
+    def __exit__(self):
+        pass
+
+with (_ValCM(99) as v):
+    ae(v, 99)
+
+# ── 7. Exception suppression via __exit__ ─────────────────────────────────────
+
+class _SuppressCM:
+    def __enter__(self):
+        return self
+    def __exit__(self, *args):
+        return True  # suppress any exception
+
+_raised = False
+with (_SuppressCM()):
+    raise Error('suppressed')
+_raised = True
+ok(_raised)
+
+# ── 8. Exception propagation (unsuppressed) ──────────────────────────────────
+
+_caught = False
+try:
+    with (_CM('err', []) as _ignored):
+        raise Error('propagated')
+except Exception as _e:
+    _caught = True
+ok(_caught)
+
+# ── 9. Non-parenthesized form still works (regression) ───────────────────────
+
+_log9 = []
+with _CM('r', _log9) as r, _CM('s', _log9) as s:
+    _log9.push('body')
+ae(_log9[0], 'enter:r')
+ae(_log9[3], 'exit:s')
+ae(_log9[4], 'exit:r')
+
+# ── 10. Parenthesized expression (not parenthesized-with) still works ─────────
+
+_log10 = []
+_cm10 = _CM('t', _log10)
+with (_cm10) as t:
+    _log10.push('body')
+ae(_log10[0], 'enter:t')
+ae(_log10[1], 'body')
+ae(_log10[2], 'exit:t')

package/test/python_compat.pyj

@@ -235,7 +235,7 @@ strings()
 ae('  hello  '.strip(), 'hello')
 ae('hello world'.upper(), 'HELLO WORLD')
 
-# ── 15. strings() leaves replace() as JS version; split() defaults to ' ' ─────
+# ── 15. strings() patches replace(); split() defaults to ' ' ──────────────────
 # (strings() is active from section 14 above)
 # Python str.split() with no args: splits on any whitespace, strips leading/trailing.
 # RapydScript .split() with no args: transpiles to .split(" ") — splits on single space.
@@ -248,11 +248,9 @@ ade(str.split('a  b c'), ['a', 'b', 'c'])
 ade('a  b'.split(), ['a', '', 'b'])   # double space → empty token between
 ade('a b'.split(' '), ['a', 'b'])     # explicit ' ' separator still works
 
-# Python str.replace() vs JS String.prototype.replace():
-# Python replaces ALL occurrences by default.
-# JS .replace() with a string pattern only replaces the FIRST occurrence.
+# str.replace() and String.prototype.replace() both use Python semantics (replace all).
 ae(str.replace('aaa', 'a', 'b'), 'bbb')     # Python: replaces all
-ae('aaa'.replace('a', 'b'), 'baa')           # JS: replaces only first
+ae('aaa'.replace('a', 'b'), 'bbb')           # also replaces all (pythonized)
 
 # ── 16. Method binding — not automatic ──────────────────────────────────────
 # Python: bound methods carry a reference to self.

package/test/python_modulo.pyj

@@ -0,0 +1,76 @@
+# globals: assrt
+# vim:fileencoding=utf-8
+#
+# python_modulo.pyj
+# Tests for Python-style modulo: result takes the sign of the divisor.
+# python_modulo defaults to True; no __python__ import needed.
+
+ae = assrt.equal
+ok = assrt.ok
+
+# ── Positive operands ────────────────────────────────────────────────────────
+ae(7 % 3, 1)
+ae(0 % 5, 0)
+ae(6 % 3, 0)
+
+# ── Negative dividend ────────────────────────────────────────────────────────
+ae(-7 % 3, 2)
+ae(-1 % 3, 2)
+ae(-6 % 3, 0)
+
+# ── Negative divisor ─────────────────────────────────────────────────────────
+ae(7 % -3, -2)
+ae(1 % -3, -2)
+ae(6 % -3, 0)
+
+# ── Both negative ────────────────────────────────────────────────────────────
+ae(-7 % -3, -1)
+ae(-1 % -3, -1)
+ae(-6 % -3, 0)
+
+# ── Floats ───────────────────────────────────────────────────────────────────
+ae(-7.5 % 2, 0.5)
+ae(7.5 % -2, -0.5)
+ae(2.5 % 1, 0.5)
+
+# ── Booleans (treated as numbers) ────────────────────────────────────────────
+ae(5 % True, 0)
+ae(False % 3, 0)
+
+# ── Augmented `%=` ───────────────────────────────────────────────────────────
+x = -7
+x %= 3
+ae(x, 2)
+
+y = 7
+y %= -3
+ae(y, -2)
+
+z = -7
+z %= -3
+ae(z, -1)
+
+# ── Inside expressions ───────────────────────────────────────────────────────
+ae((-7 % 3) + 10, 12)
+ae(((-10) % 3) * 2, 4)
+
+# ── Variables (not just literals) ────────────────────────────────────────────
+a = -7
+b = 3
+ae(a % b, 2)
+
+# ── BigInt (Python semantics already worked; regression guard) ───────────────
+ae(BigInt(-7) % BigInt(3), BigInt(2))
+ae(BigInt(7) % BigInt(-3), BigInt(-2))
+
+# ── Custom __mod__ wins over numeric path ────────────────────────────────────
+# python_modulo routes through ρσ_op_mod_ns which dispatches __mod__/__rmod__
+# even without overload_operators.
+class Mod:
+    def __init__(self, v):
+        self.v = v
+    def __mod__(self, other):
+        return 'mod-' + self.v + '-' + other
+
+m = Mod('a')
+ae(m % 'b', 'mod-a-b')

package/test/python_modulo_off.pyj

@@ -0,0 +1,21 @@
+# globals: assrt
+# vim:fileencoding=utf-8
+#
+# python_modulo_off.pyj
+# Tests for opting out of Python-style modulo via no_python_modulo.
+# With the flag off, `%` emits raw JS modulo (sign of dividend).
+
+from __python__ import no_python_modulo
+
+ae = assrt.equal
+
+# JS modulo: result takes the sign of the dividend.
+ae(-7 % 3, -1)   # Python would give 2
+ae(7 % -3, 1)    # Python would give -2
+ae(-7 % -3, -1)  # same as Python here
+ae(7 % 3, 1)     # positive case identical
+
+# Augmented `%=` follows the same flag.
+x = -7
+x %= 3
+ae(x, -1)        # Python would give 2

package/test/repl.pyj

@@ -1,121 +1,121 @@
-# globals: compiler_dir
-stdout = []
-def clear():
-    stdout.length = 0
-
-class FakeConsole:
-
-    def log(self):
-        Array.prototype.slice.call(arguments).forEach(def (arg):
-            stdout.push((arg or '').toString())
-        )
-        stdout.push('\n')
-
-    def error(self):
-        Array.prototype.slice.call(arguments).forEach(def (arg):
-            stdout.push((arg or '').toString())
-        )
-        stdout.push('\n')
-
-class FakeReadline:
-
-    def __init__(self):
-        self.listeners = {}
-        self._prompt = ''
-
-    def setPrompt(self, prompt):
-        self._prompt = prompt
-
-    def write(self, data):
-        stdout.push(data)
-
-    def clearLine(self):
-        pass
-
-    def on(self, event, callback):
-        self.listeners[event] = callback
-        return self
-
-    def prompt(self):
-        stdout.push(self._prompt)
-
-    def send_line(self, text):
-        self.listeners['line'](text)
-
-repl = require('./repl')
-rl = FakeReadline()
-
-send_line = rl.send_line.bind(rl)
-
-def send_text(text):
-    for line in text.split('\n'):
-        send_line(line)
-
-def check(text, output):
-    send_text(text)
-    eq(output, stdout[0])
-    clear()
-
-def check_in(text, output):
-    send_text(text)
-    assrt.ok(output in stdout, output + ' not in ' + stdout)
-    clear()
-
-def check_not_in(text, output):
-    send_text(text)
-    assrt.ok(output not in stdout)
-    clear()
-
-readline = {
-    'createInterface': def(options):
-        rl.completer = options.completer
-        return rl
-}
-repl({'lib_path':compiler_dir, 'console':FakeConsole(), 'readline':readline, 'terminal':False, 'show_js':False, 'histfile':False})
-eq = assrt.equal
-eq('>>> ', stdout[-1])
-clear()
-check('1', '1')
-check_in('if 1:\n  2\n  \n  ', '2')
-check_not_in('if 1:\n  2\n ', '2')
-check_in('1 +\n1\n\n', '2')
-check('max(1, 2)', '2')
-send_text(
-'''
-class A:
-
-    def __init__(self, a):
-        self. a = a
-
-
-''')
-clear()
-check_in('b = A(1)\nb.a', '1')
-check_in('c = A(2)\nc.a', '2')
-send_text('from __python__ import dict_literals\nd={1:1}')
-check_in('isinstance(d, dict)', 'true')
-send_text('from __python__ import no_dict_literals\nd={1:1}')
-check_in('isinstance(d, dict)', 'false')
-# Test completions
-def completions(line):
-    return rl.completer(line)[0]
-
-def check_completions():
-    items = completions(arguments[0])
-    for x in Array.prototype.slice.call(arguments, 1):
-        assrt.ok(items and x in items, x + ' not in completions for: ' + arguments[0])
-
-check_completions('', 'return', 'A')
-check_completions('Array.', 'isArray', 'apply')
-send_text('x = ""\ny = []'), clear()
-check_completions('x.', 'substr', 'trim')
-check_completions('y.', 'concat', 'push')
-check_completions('x.sl', 'slice')
-send_text('y = {"x":1}'), clear()
-check_completions('y.', 'x')
-
-# Test docstrings
-clear()
-send_text('def ds():\n "xxx"\n\n')
-clear()
-check('ds.__doc__', "'xxx'")
+# globals: compiler_dir
+stdout = []
+def clear():
+    stdout.length = 0
+
+class FakeConsole:
+
+    def log(self):
+        Array.prototype.slice.call(arguments).forEach(def (arg):
+            stdout.push((arg or '').toString())
+        )
+        stdout.push('\n')
+
+    def error(self):
+        Array.prototype.slice.call(arguments).forEach(def (arg):
+            stdout.push((arg or '').toString())
+        )
+        stdout.push('\n')
+
+class FakeReadline:
+
+    def __init__(self):
+        self.listeners = {}
+        self._prompt = ''
+
+    def setPrompt(self, prompt):
+        self._prompt = prompt
+
+    def write(self, data):
+        stdout.push(data)
+
+    def clearLine(self):
+        pass
+
+    def on(self, event, callback):
+        self.listeners[event] = callback
+        return self
+
+    def prompt(self):
+        stdout.push(self._prompt)
+
+    def send_line(self, text):
+        self.listeners['line'](text)
+
+repl = require('./repl')
+rl = FakeReadline()
+
+send_line = rl.send_line.bind(rl)
+
+def send_text(text):
+    for line in text.split('\n'):
+        send_line(line)
+
+def check(text, output):
+    send_text(text)
+    eq(output, stdout[0])
+    clear()
+
+def check_in(text, output):
+    send_text(text)
+    assrt.ok(output in stdout, output + ' not in ' + stdout)
+    clear()
+
+def check_not_in(text, output):
+    send_text(text)
+    assrt.ok(output not in stdout)
+    clear()
+
+readline = {
+    'createInterface': def(options):
+        rl.completer = options.completer
+        return rl
+}
+repl({'lib_path':compiler_dir, 'console':FakeConsole(), 'readline':readline, 'terminal':False, 'show_js':False, 'histfile':False})
+eq = assrt.equal
+eq('>>> ', stdout[-1])
+clear()
+check('1', '1')
+check_in('if 1:\n  2\n  \n  ', '2')
+check_not_in('if 1:\n  2\n ', '2')
+check_in('1 +\n1\n\n', '2')
+check('max(1, 2)', '2')
+send_text(
+'''
+class A:
+
+    def __init__(self, a):
+        self. a = a
+
+
+''')
+clear()
+check_in('b = A(1)\nb.a', '1')
+check_in('c = A(2)\nc.a', '2')
+send_text('from __python__ import dict_literals\nd={1:1}')
+check_in('isinstance(d, dict)', 'true')
+send_text('from __python__ import no_dict_literals\nd={1:1}')
+check_in('isinstance(d, dict)', 'false')
+# Test completions
+def completions(line):
+    return rl.completer(line)[0]
+
+def check_completions():
+    items = completions(arguments[0])
+    for x in Array.prototype.slice.call(arguments, 1):
+        assrt.ok(items and x in items, x + ' not in completions for: ' + arguments[0])
+
+check_completions('', 'return', 'A')
+check_completions('Array.', 'isArray', 'apply')
+send_text('x = ""\ny = []'), clear()
+check_completions('x.', 'substr', 'trim')
+check_completions('y.', 'concat', 'push')
+check_completions('x.sl', 'slice')
+send_text('y = {"x":1}'), clear()
+check_completions('y.', 'x')
+
+# Test docstrings
+clear()
+send_text('def ds():\n "xxx"\n\n')
+clear()
+check('ds.__doc__', "'xxx'")

package/test/scoped_flags.pyj

@@ -1,76 +1,76 @@
-# vim:fileencoding=utf-8
-# License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
-
-a = {1:1}
-assrt.ok(not isinstance(a, dict))
-
-from __python__ import dict_literals, overload_getitem
-a = {1:1}
-assrt.ok(isinstance(a, dict))
-assrt.equal(a[1], 1)
-a[2] = 2
-assrt.equal(a[2], 2)
-a[2] += 4
-assrt.equal(a[2], 6)
-assrt.deepEqual(list(a.keys()), [1, 2])
-from __python__ import no_dict_literals, no_overload_getitem
-
-
-a = {1:1}
-assrt.ok(not isinstance(a, dict))
-
-def f():
-    from __python__ import dict_literals
-    a = {1:1}
-    assrt.ok(isinstance(a, dict))
-
-a = {1:1}
-assrt.ok(not isinstance(a, dict))
-
-class S:
-    from __python__ import bound_methods
-
-    def __init__(self):
-        self.a = 3
-
-    def val(self):
-        return self.a if self else None
-
-f = S().val
-assrt.equal(f(), S().val())
-
-class U:
-
-    def __init__(self):
-        self.a = 3
-
-    def val(self):
-        return self.a if self else None
-
-f = U().val
-assrt.equal(f(), None)
-
-class C:
-
-    def __init__(self):
-        self.a = 3
-
-    def uval1(self):
-        return self.a if self else None
-
-    from __python__ import bound_methods
-
-    def bval(self):
-        return self.a
-
-    from __python__ import no_bound_methods
-
-    def uval2(self):
-        return self.a if self else None
-
-c = C()
-u1, u2 = c.uval1, c.uval2
-f = c.bval
-assrt.equal(u1(), None)
-assrt.equal(u2(), None)
-assrt.equal(f(), 3)
+# vim:fileencoding=utf-8
+# License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
+
+a = {1:1}
+assrt.ok(not isinstance(a, dict))
+
+from __python__ import dict_literals, overload_getitem
+a = {1:1}
+assrt.ok(isinstance(a, dict))
+assrt.equal(a[1], 1)
+a[2] = 2
+assrt.equal(a[2], 2)
+a[2] += 4
+assrt.equal(a[2], 6)
+assrt.deepEqual(list(a.keys()), [1, 2])
+from __python__ import no_dict_literals, no_overload_getitem
+
+
+a = {1:1}
+assrt.ok(not isinstance(a, dict))
+
+def f():
+    from __python__ import dict_literals
+    a = {1:1}
+    assrt.ok(isinstance(a, dict))
+
+a = {1:1}
+assrt.ok(not isinstance(a, dict))
+
+class S:
+    from __python__ import bound_methods
+
+    def __init__(self):
+        self.a = 3
+
+    def val(self):
+        return self.a if self else None
+
+f = S().val
+assrt.equal(f(), S().val())
+
+class U:
+
+    def __init__(self):
+        self.a = 3
+
+    def val(self):
+        return self.a if self else None
+
+f = U().val
+assrt.equal(f(), None)
+
+class C:
+
+    def __init__(self):
+        self.a = 3
+
+    def uval1(self):
+        return self.a if self else None
+
+    from __python__ import bound_methods
+
+    def bval(self):
+        return self.a
+
+    from __python__ import no_bound_methods
+
+    def uval2(self):
+        return self.a if self else None
+
+c = C()
+u1, u2 = c.uval1, c.uval2
+f = c.bval
+assrt.equal(u1(), None)
+assrt.equal(u2(), None)
+assrt.equal(f(), 3)

package/test/str.pyj

@@ -221,3 +221,17 @@ ae('{{}}'.format(), '{}')
 ae('{x}}}'.format(x=1), '1}')
 a = 1
 ae(f'{{ {a} }}', '{ 1 }')
+
+# str.replace — Python semantics (replace all by default)
+ae('bbb', 'aaa'.replace('a', 'b'))
+ae('hello world', 'hello earth'.replace('earth', 'world'))
+ae('baa', 'aaa'.replace('a', 'b', 1))
+ae('bba', 'aaa'.replace('a', 'b', 2))
+ae('aaa', 'aaa'.replace('a', 'b', 0))
+ae('aaa', 'aaa'.replace('x', 'y'))
+ae('', 'aaa'.replace('a', ''))
+ae('xbxbxb', 'ababab'.replace('a', 'x'))
+ae('a$b$c', 'a-b-c'.replace('-', '$'))
+# negative count replaces all (same as omitting count)
+ae('bbb', 'aaa'.replace('a', 'b', -1))
+ae('bbb', 'aaa'.replace('a', 'b', -99))