rapydscript-ns 0.8.4 → 0.9.0

package/test/object.pyj

@@ -0,0 +1,64 @@
+# globals: assrt
+
+ae  = assrt.equal
+ade = assrt.deepEqual
+ok  = assrt.ok
+
+# ── Basic instantiation ───────────────────────────────────────────────────────
+
+o = object()
+ok(o is not None)
+ok(o is not undefined)
+
+# ── Sentinel pattern: each call returns a distinct instance ───────────────────
+
+s1 = object()
+s2 = object()
+ok(s1 is not s2)
+
+# ── isinstance ────────────────────────────────────────────────────────────────
+
+ok(isinstance(o, object))
+ok(isinstance(s1, object))
+ok(isinstance(s2, object))
+
+# ── repr / str ────────────────────────────────────────────────────────────────
+
+r = repr(o)
+ok(r.startsWith('<object object'))
+
+# ── hash: stable and distinct between instances ───────────────────────────────
+
+h1 = hash(s1)
+h2 = hash(s2)
+ok(jstype(h1) is 'number')
+ok(h1 is not h2)
+ae(hash(s1), h1)  # hash is stable across calls
+
+# ── Subclassing: class Foo(object) ────────────────────────────────────────────
+
+class Widget(object):
+    def __init__(self, name):
+        self.name = name
+
+    def greet(self):
+        return 'Hello, ' + self.name
+
+w = Widget('world')
+ok(isinstance(w, Widget))
+ok(isinstance(w, object))
+ae(w.greet(), 'Hello, world')
+
+# ── Multiple inheritance with object as one parent ────────────────────────────
+
+class Mixin:
+    def tag(self):
+        return 'mixin'
+
+class Combined(Mixin, object):
+    pass
+
+c = Combined()
+ok(isinstance(c, Combined))
+ok(isinstance(c, object))
+ae(c.tag(), 'mixin')

package/test/omit_function_metadata.pyj

@@ -1,20 +1,20 @@
-# globals: RapydScript
-
-# Test that omit_function_metadata flag suppresses __module__ and __argnames__
-code = 'def foo(a, b):\n    return a + b'
-ast = RapydScript.parse(code, {'filename': '<test>'})
-
-# Without flag: output should contain __module__ and __argnames__
-output_with = v'new RapydScript.OutputStream({"beautify": true, "omit_baselib": true})'
-ast.print(output_with)
-result_with = output_with.get()
-assrt.ok(result_with.indexOf('__module__') >= 0, '__module__ should appear in default output')
-assrt.ok(result_with.indexOf('__argnames__') >= 0, '__argnames__ should appear in default output')
-
-# With flag: output should not contain __module__, __argnames__, or Object.defineProperties
-output_without = v'new RapydScript.OutputStream({"beautify": true, "omit_baselib": true, "omit_function_metadata": true})'
-ast.print(output_without)
-result_without = output_without.get()
-assrt.ok(result_without.indexOf('__module__') is -1, '__module__ should not appear when omit_function_metadata is set')
-assrt.ok(result_without.indexOf('__argnames__') is -1, '__argnames__ should not appear when omit_function_metadata is set')
-assrt.ok(result_without.indexOf('Object.defineProperties') is -1, 'Object.defineProperties should not appear when omit_function_metadata is set')
+# globals: RapydScript
+
+# Test that omit_function_metadata flag suppresses __module__ and __argnames__
+code = 'def foo(a, b):\n    return a + b'
+ast = RapydScript.parse(code, {'filename': '<test>'})
+
+# Without flag: output should contain __module__ and __argnames__
+output_with = v'new RapydScript.OutputStream({"beautify": true, "omit_baselib": true})'
+ast.print(output_with)
+result_with = output_with.get()
+assrt.ok(result_with.indexOf('__module__') >= 0, '__module__ should appear in default output')
+assrt.ok(result_with.indexOf('__argnames__') >= 0, '__argnames__ should appear in default output')
+
+# With flag: output should not contain __module__, __argnames__, or Object.defineProperties
+output_without = v'new RapydScript.OutputStream({"beautify": true, "omit_baselib": true, "omit_function_metadata": true})'
+ast.print(output_without)
+result_without = output_without.get()
+assrt.ok(result_without.indexOf('__module__') is -1, '__module__ should not appear when omit_function_metadata is set')
+assrt.ok(result_without.indexOf('__argnames__') is -1, '__argnames__ should not appear when omit_function_metadata is set')
+assrt.ok(result_without.indexOf('Object.defineProperties') is -1, 'Object.defineProperties should not appear when omit_function_metadata is set')

package/test/python_compat.pyj

@@ -115,20 +115,22 @@ _a8 += [3, 4]
 ade(_a8, [1, 2, 3, 4])
 ade(_b8, [1, 2, 3, 4])  # _b8 still points to same object, now extended
 
-# ── 8. Ordering operators on lists — JS string coercion ──────────────────────
+# ── 8. Ordering operators on lists — behaviour depends on overload_operators ──
 # Python: [10] < [9] compares element-wise → False (10 > 9).
-# RapydScript: < coerces to string → '10' < '9' is True (char comparison).
-# This is a common gotcha: single-element lists with multi-digit numbers.
+# Without overload_operators (tested here): < falls through to JS string
+# coercion → '[10]' < '[9]' → True (char comparison on the first differing
+# digit: '1' < '9'). This is a common gotcha with multi-digit numbers.
+#
+# With overload_operators (the default when using rapydscript compile or the
+# web-repl), < dispatches through ρσ_op_lt which does lexicographic comparison
+# of list elements — matching Python semantics ([10] < [9] → False).
 
 # RapydScript lists have a Python-style __str__, so [10].toString() = '[10]'.
-# String compare of '[10]' vs '[9]': '[' = '[', then '1' < '9' → [10] < [9] is True.
-ok([10] < [9])       # True in RapydScript (string: '[10]' < '[9]')
-ae([9] < [10], False)  # False   (string: '[9]' > '[10]')
-
-# Compare: Python uses numeric element-wise ordering, so [10] > [9] (10 > 9).
-# RapydScript gives the opposite result for these specific values.
+# String compare of '[10]' vs '[9]': '[' = '[', then '1' < '9' → True.
+ok([10] < [9])       # True (string: '[10]' < '[9]') — no overload_operators
+ae([9] < [10], False)  # False (string: '[9]' > '[10]')
 
-# For correct numeric comparisons, compare elements explicitly:
+# Direct numeric comparison is always unambiguous:
 ok(10 > 9)           # direct numeric comparison always works
 
 # ── 9. List sort() — Python numeric sort (jssort() for JS lexicographic) ──────
@@ -233,18 +235,18 @@ strings()
 ae('  hello  '.strip(), 'hello')
 ae('hello world'.upper(), 'HELLO WORLD')
 
-# ── 15. strings() leaves split() and replace() as JS versions ─────────────────
+# ── 15. strings() leaves replace() as JS version; split() defaults to ' ' ─────
 # (strings() is active from section 14 above)
 # Python str.split() with no args: splits on any whitespace, strips leading/trailing.
-# JS String.prototype.split() with no args: returns the whole string in a 1-element array.
+# RapydScript .split() with no args: transpiles to .split(" ") — splits on single space.
 
 # Python semantics via str module:
 ade(str.split('a  b'), ['a', 'b'])    # Python split on any whitespace
 ade(str.split('a  b c'), ['a', 'b', 'c'])
 
-# After strings(), .split() is STILL the JS version (by design):
-ade('a  b'.split(), ['a  b'])         # JS: no-arg split = one-element array
-ade('a b'.split(' '), ['a', 'b'])     # JS split with separator still works
+# .split() with no args now defaults to splitting on ' ':
+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.

package/test/python_features.pyj

@@ -366,14 +366,41 @@ def _test_frozenset():
 _test_frozenset()
 
 # ── 17. int.bit_length() ─────────────────────────────────────────────────────
-# STATUS: ✗ NOT SUPPORTED — Number prototype does not have bit_length.
-#
-#  ae((255).bit_length(), 8)
+# STATUS: ✓ SUPPORTED — Number.prototype.bit_length added to baselib.
+
+def _test_int_bit_length():
+    ae((0).bit_length(), 0)
+    ae((1).bit_length(), 1)
+    ae((2).bit_length(), 2)
+    ae((3).bit_length(), 2)
+    ae((4).bit_length(), 3)
+    ae((255).bit_length(), 8)
+    ae((256).bit_length(), 9)
+    ae((1023).bit_length(), 10)
+    ae((1024).bit_length(), 11)
+    # Negative numbers: bit_length ignores sign (Python semantics)
+    ae((-1).bit_length(), 1)
+    ae((-5).bit_length(), 3)
+    ae((-255).bit_length(), 8)
+
+_test_int_bit_length()
 
 # ── 18. float.is_integer() ───────────────────────────────────────────────────
-# STATUS: ✗ NOT SUPPORTED — Number prototype does not have is_integer.
-#
-#  ae((1.0).is_integer(), True)
+# STATUS: ✓ SUPPORTED — Number.prototype.is_integer added to baselib.
+
+def _test_float_is_integer():
+    ae((1.0).is_integer(), True)
+    ae((1.5).is_integer(), False)
+    ae((0.0).is_integer(), True)
+    ae((-2.0).is_integer(), True)
+    ae((-2.5).is_integer(), False)
+    ae((1e10).is_integer(), True)
+    ae((1.0000000001).is_integer(), False)
+    # NaN and Infinity are not integers (JS literals)
+    ae(v'Infinity'.is_integer(), False)
+    ae(v'NaN'.is_integer(), False)
+
+_test_float_is_integer()
 
 # ── 19. dict | merge operator (Python 3.9+) ──────────────────────────────────
 # STATUS: ✓ WORKS — requires `from __python__ import overload_operators, dict_literals`
@@ -526,9 +553,20 @@ ae(g.next().value,    1)
 ae(g.next('hello').value, 'hello')
 
 # ── 27. zip(strict=True) ─────────────────────────────────────────────────────
-# STATUS: ✗ NOT SUPPORTED — zip() silently truncates to shortest.
+# STATUS: ✓ WORKS — equal-length iterables succeed; mismatched raise ValueError.
 
 ade(list(zip([1, 2], [3, 4])), [[1, 3], [2, 4]])  # basic zip still works
+ade(list(zip([1, 2], [3, 4], strict=True)), [[1, 3], [2, 4]])  # strict, equal lengths OK
+try:
+    list(zip([1, 2], [3], strict=True))
+    ae(True, False)  # should not reach here
+except ValueError:
+    pass  # expected: first iterable longer
+try:
+    list(zip([1], [3, 4], strict=True))
+    ae(True, False)  # should not reach here
+except ValueError:
+    pass  # expected: second iterable longer
 
 # ── 28. Walrus operator := ────────────────────────────────────────────────────
 # STATUS: ✓ WORKS — hoisting in if/while conditions; comprehension filter scope
@@ -874,11 +912,25 @@ ae(_c(), 2)
 ae(_c(), 3)
 
 # ── 42. Complex number literals 3+4j ─────────────────────────────────────────
-# STATUS: ✗ NOT SUPPORTED — no j suffix; no complex type.
-# SKIP:
-#   c = 3+4j
-#   ae(c.real, 3)
-#   ae(c.imag, 4)
+# STATUS: ✓ SUPPORTED — j suffix, complex() builtin, arithmetic, abs(), conjugate()
+def _test_complex():
+    from __python__ import overload_operators
+    c = 3+4j
+    ae(c.real, 3)
+    ae(c.imag, 4)
+    ae(abs(c), 5.0)
+    ade(c.conjugate(), complex(3, -4))
+    ade(c + complex(1, 2), complex(4, 6))
+    ade(c - complex(1, 1), complex(2, 3))
+    ade(c * complex(0, 1), complex(-4, 3))
+    ade(c / complex(1, 0), complex(3, 4))
+    ade(complex(5), complex(5, 0))
+    ade(complex(), complex(0, 0))
+    ae(repr(1j), '1j')
+    ae(repr(complex(3, -4)), '(3-4j)')
+    ade(1 + 2j, complex(1, 2))
+    ade(-1j, complex(0, -1))
+_test_complex()
 
 # ── 43. b'...' bytes literals ────────────────────────────────────────────────
 # STATUS: ✗ NOT SUPPORTED — no b prefix; no native bytes type.
@@ -940,8 +992,10 @@ ae(_c(), 3)
 # STATUS: ✗ NOT SUPPORTED — no attribute-lookup override.
 
 # ── 50. __format__ dunder ────────────────────────────────────────────────────
-# STATUS: ✓ WORKS — format(obj, spec) dispatches to obj.__format__(spec).
-#         Tested fully in test/str.pyj.
+# STATUS: ✓ WORKS — format(), str.format(), and f-strings all dispatch to
+#         obj.__format__(spec). Default __format__ auto-generated for classes.
+#         !r/!s/!a transformers bypass __format__ correctly.
+#         Tested fully in test/format.pyj.
 
 # ── 51. __class_getitem__ ────────────────────────────────────────────────────
 # STATUS: ✓ WORKS — Class[item] dispatches to __class_getitem__(cls, item).
@@ -1099,7 +1153,8 @@ _check_unhashable({'a': 1})
 
 # ── 55. format(value, spec) builtin ──────────────────────────────────────────
 # STATUS: ✓ WORKS — format(value, spec) is defined and dispatches to __format__.
-#         Tested fully in test/str.pyj.
+#         str.format() and f-strings also dispatch to __format__.
+#         Tested fully in test/format.pyj and test/str.pyj.
 #
 #   ae(format(3.14159, '.2f'), '3.14')
 

package/test/regexp.pyj

@@ -1,55 +1,83 @@
-# vim:fileencoding=utf-8
-# License: BSD
-# Copyright: 2015, Kovid Goyal <kovid at kovidgoyal.net>
-
-# Test the re module
-import re
-s = "Isaac Newton, physicist"
-c = re.search("(\\w+) (\\w+)", s)
-assrt.equal(c.group(1), 'Isaac')
-assrt.equal(c.group(2), 'Newton')
-c = re.match("(\\w+) (\\w+)", s)
-assrt.equal(c.group(1), 'Isaac')
-assrt.equal(c.start(1), 0)
-assrt.equal(c.end(1), c.group(1).length)
-assrt.equal(c.start(2), c.group(1).length + 1)
-assrt.equal(c.group(2), 'Newton')
-m = re.search('a(b)cd', 'abc abcd')
-assrt.equal(m.group(1), 'b')
-assrt.equal(m.start(1), m.string.lastIndexOf('b'))
-assrt.deepEqual(re.split('\\s', s), ['Isaac', 'Newton,', 'physicist'])
-assrt.deepEqual(re.findall('s[a-z]', s), ['sa', 'si', 'st'])
-assrt.deepEqual([m.group() for m in re.finditer('s[a-z]', s)], ['sa', 'si', 'st'])
-assrt.deepEqual(re.findall(/s[a-z]/, s), ['sa', 'si', 'st'])
-assrt.equal(re.sub('[A-Z]', '_', s), '_saac _ewton, physicist')
-assrt.equal(re.sub('[A-Z]', '_', s, count=1), '_saac Newton, physicist')
-assrt.equal(re.search('a[.]b', 'axb'), None)
-assrt.equal(re.search(r'a\.b', 'axb'), None)
-assrt.equal(re.search('a[.]b', 'axb', flags=re.D), None)
-assrt.equal(re.search('.+', 'a\nb').group(), 'a')
-assrt.equal(re.search('.+', 'a\nb', flags=re.D).group(), 'a\nb')
-assrt.equal(re.search('(?s).+', 'a\nb').group(), 'a\nb')
-assrt.equal(re.sub('a(b)', r'xx', 'ab'), r'xx')
-assrt.equal(re.sub('a(b)', r'\\1', 'ab'), r'\1')
-assrt.equal(re.sub('a(b)', r'\\\1', 'ab'), r'\b')
-assrt.equal(re.sub('a(b)', r'\g<1>', 'ab'), r'b')
-assrt.equal(re.sub('a(b)', def(m):return m.group(1);, 'ab'), r'b')
-assrt.equal(']', re.match('[]]', ']').group())
-
-assrt.throws(def():re.search(r'(?(1)a|b)b', 'ab');, re.error)
-
-# Test lookbehind assertions
-assrt.equal('acdb', re.sub(r'(?<=a)b', 'c', 'abdb'))
-
-# Test named groups
-assrt.equal('aa', re.sub(r'(?P<a>a)b', r'\g<a>\1', 'ab'))
-assrt.equal('bb', re.sub(r'(?P<a>a)(?P=a)', r'bb', 'aa'))
-assrt.equal('ab', re.sub(r'(.)(?P<a>a)', r'\g<a>\1', 'ba'))
-assrt.deepEqual({'a':'a', 'b':'b'}, re.search(r'(?P<a>a)(?P<b>b)', 'ab').groupdict())
-
-# Test verbose mode literals
-assrt.equal(re.search(///
-    a
-    .  # anything
-    b
-    ///, ' axb').group(), 'axb')
+# vim:fileencoding=utf-8
+# License: BSD
+# Copyright: 2015, Kovid Goyal <kovid at kovidgoyal.net>
+
+# Test the re module
+import re
+s = "Isaac Newton, physicist"
+c = re.search("(\\w+) (\\w+)", s)
+assrt.equal(c.group(1), 'Isaac')
+assrt.equal(c.group(2), 'Newton')
+c = re.match("(\\w+) (\\w+)", s)
+assrt.equal(c.group(1), 'Isaac')
+assrt.equal(c.start(1), 0)
+assrt.equal(c.end(1), c.group(1).length)
+assrt.equal(c.start(2), c.group(1).length + 1)
+assrt.equal(c.group(2), 'Newton')
+m = re.search('a(b)cd', 'abc abcd')
+assrt.equal(m.group(1), 'b')
+assrt.equal(m.start(1), m.string.lastIndexOf('b'))
+assrt.deepEqual(re.split('\\s', s), ['Isaac', 'Newton,', 'physicist'])
+assrt.deepEqual(re.findall('s[a-z]', s), ['sa', 'si', 'st'])
+assrt.deepEqual([m.group() for m in re.finditer('s[a-z]', s)], ['sa', 'si', 'st'])
+assrt.deepEqual(re.findall(/s[a-z]/, s), ['sa', 'si', 'st'])
+assrt.equal(re.sub('[A-Z]', '_', s), '_saac _ewton, physicist')
+assrt.equal(re.sub('[A-Z]', '_', s, count=1), '_saac Newton, physicist')
+assrt.equal(re.search('a[.]b', 'axb'), None)
+assrt.equal(re.search(r'a\.b', 'axb'), None)
+assrt.equal(re.search('a[.]b', 'axb', flags=re.D), None)
+assrt.equal(re.search('.+', 'a\nb').group(), 'a')
+assrt.equal(re.search('.+', 'a\nb', flags=re.D).group(), 'a\nb')
+assrt.equal(re.search('(?s).+', 'a\nb').group(), 'a\nb')
+assrt.equal(re.sub('a(b)', r'xx', 'ab'), r'xx')
+assrt.equal(re.sub('a(b)', r'\\1', 'ab'), r'\1')
+assrt.equal(re.sub('a(b)', r'\\\1', 'ab'), r'\b')
+assrt.equal(re.sub('a(b)', r'\g<1>', 'ab'), r'b')
+assrt.equal(re.sub('a(b)', def(m):return m.group(1);, 'ab'), r'b')
+assrt.equal(']', re.match('[]]', ']').group())
+
+assrt.throws(def():re.search(r'(?(1)a|b)b', 'ab');, re.error)
+
+# Test positive lookbehind assertions
+assrt.equal('acdb', re.sub(r'(?<=a)b', 'c', 'abdb'))
+
+# Test negative lookbehind assertions
+assrt.equal('accd', re.sub(r'(?<!a)b', 'c', 'acbd'))
+
+# Test variable-width lookbehind (ES2018+)
+assrt.equal('c', re.search(r'(?<=ab+)c', 'abbc').group())
+
+# Test fullmatch
+assrt.ok(re.fullmatch(r'\w+', 'hello') is not None)
+assrt.ok(re.fullmatch(r'\w+', 'hello world') is None)
+assrt.ok(re.fullmatch(r'\w+', '') is None)
+assrt.equal(re.fullmatch(r'(\w+)', 'hello').group(1), 'hello')
+assrt.ok(re.fullmatch(r'[a-z]+', 'hello') is not None)
+assrt.ok(re.fullmatch(r'[a-z]+', 'hello!') is None)
+
+# Test accurate group start/end positions (ES2022 'd' flag; falls back to heuristic)
+m = re.match(r'(a)(b)(c)', 'abc')
+assrt.equal(m.start(1), 0)
+assrt.equal(m.end(1), 1)
+assrt.equal(m.start(2), 1)
+assrt.equal(m.end(2), 2)
+assrt.equal(m.start(3), 2)
+assrt.equal(m.end(3), 3)
+
+# Test NOFLAG and S (DOTALL) aliases
+assrt.equal(re.NOFLAG, 0)
+assrt.equal(re.S, re.DOTALL)
+assrt.equal(re.search('.+', 'a\nb', flags=re.S).group(), 'a\nb')
+
+# Test named groups
+assrt.equal('aa', re.sub(r'(?P<a>a)b', r'\g<a>\1', 'ab'))
+assrt.equal('bb', re.sub(r'(?P<a>a)(?P=a)', r'bb', 'aa'))
+assrt.equal('ab', re.sub(r'(.)(?P<a>a)', r'\g<a>\1', 'ba'))
+assrt.deepEqual({'a':'a', 'b':'b'}, re.search(r'(?P<a>a)(?P<b>b)', 'ab').groupdict())
+
+# Test verbose mode literals
+assrt.equal(re.search(///
+    a
+    .  # anything
+    b
+    ///, ' axb').group(), 'axb')