rapydscript-ns 0.8.3 → 0.9.0

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/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/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,16 +992,31 @@ 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: ✗ NOT SUPPORTED — no generic subscript MyClass[T] syntax.
-# SKIP:
-#   class _Box:
-#       def __class_getitem__(cls, item):
-#           return cls
-#   ok(_Box[int] is _Box)
+# STATUS: ✓ WORKS — Class[item] dispatches to __class_getitem__(cls, item).
+#         Subclasses inherit __class_getitem__; cls is set to the calling class.
+
+class _Box51:
+    def __class_getitem__(cls, item):
+        return cls
+
+ok(_Box51[int] is _Box51)
+
+class _BoxNamed51:
+    def __class_getitem__(cls, item):
+        return cls.__name__ + '[' + str(item) + ']'
+
+ok(_BoxNamed51[42] == '_BoxNamed51[42]')
+
+class _BoxChild51(_BoxNamed51):
+    pass
+
+ok(_BoxChild51[99] == '_BoxChild51[99]')
 
 # ── 52. __init_subclass__ ────────────────────────────────────────────────────
 # STATUS: ✗ NOT SUPPORTED — no subclass hook.
@@ -1086,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

@@ -38,9 +38,37 @@ assrt.equal(']', re.match('[]]', ']').group())
 
 assrt.throws(def():re.search(r'(?(1)a|b)b', 'ab');, re.error)
 
-# Test lookbehind assertions
+# 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'))

package/test/tuples.pyj

@@ -0,0 +1,96 @@
+# globals: assrt
+# vim:fileencoding=utf-8
+#
+# tuples.pyj
+# Tests for tuple literal syntax: (a, b), (a,), and ().
+
+ae  = assrt.equal
+ade = assrt.deepEqual
+ok  = assrt.ok
+
+# ── 1. Empty tuple ────────────────────────────────────────────────────────────
+t = ()
+ok(Array.isArray(t))
+ae(t.length, 0)
+
+# ── 2. Single-element tuple with trailing comma ───────────────────────────────
+t1 = (42,)
+ok(Array.isArray(t1))
+ae(t1.length, 1)
+ae(t1[0], 42)
+
+t_str = ('hello',)
+ae(t_str[0], 'hello')
+
+# ── 3. Two-element tuple ──────────────────────────────────────────────────────
+t2 = (1, 2)
+ok(Array.isArray(t2))
+ae(t2.length, 2)
+ae(t2[0], 1)
+ae(t2[1], 2)
+
+# ── 4. Three-element tuple ────────────────────────────────────────────────────
+t3 = ('a', 'b', 'c')
+ae(t3.length, 3)
+ae(t3[0], 'a')
+ae(t3[1], 'b')
+ae(t3[2], 'c')
+
+# ── 5. Trailing comma on multi-element tuple ──────────────────────────────────
+t_trail = (10, 20, 30,)
+ae(t_trail.length, 3)
+ae(t_trail[0], 10)
+ae(t_trail[2], 30)
+
+# ── 6. Tuple in an expression context (return, assignment) ────────────────────
+def make_pair():
+    return (99, 100)
+
+p = make_pair()
+ae(p[0], 99)
+ae(p[1], 100)
+
+# ── 7. Tuple unpacking works the same as array unpacking ─────────────────────
+a, b = (10, 20)
+ae(a, 10)
+ae(b, 20)
+
+# ── 8. Nested tuples ─────────────────────────────────────────────────────────
+nested = ((1, 2), (3, 4))
+ae(nested.length, 2)
+ae(nested[0][0], 1)
+ae(nested[0][1], 2)
+ae(nested[1][0], 3)
+ae(nested[1][1], 4)
+
+# ── 9. Tuple as function argument ─────────────────────────────────────────────
+def first(t):
+    return t[0]
+
+ae(first((7, 8, 9)), 7)
+
+# ── 10. isinstance with tuple of types ────────────────────────────────────────
+ok(isinstance(42,    (int, str)))
+ok(isinstance('hi',  (int, str)))
+ok(not isinstance(3.14, (int, str)))
+
+# ── 11. Tuple expressions with complex elements ───────────────────────────────
+x = 5
+tup = (x + 1, x * 2, x if x > 0 else 0)
+ae(tup[0], 6)
+ae(tup[1], 10)
+ae(tup[2], 5)
+
+# ── 12. Parenthesised single expression is NOT a tuple ───────────────────────
+plain = (42)
+ae(plain, 42)
+ok(not Array.isArray(plain))
+
+# ── 13. Tuple used in for-loop unpacking ─────────────────────────────────────
+pairs = [(1, 'one'), (2, 'two'), (3, 'three')]
+result = []
+for num, name in pairs:
+    result.push(str(num) + ':' + name)
+ae(result[0], '1:one')
+ae(result[1], '2:two')
+ae(result[2], '3:three')