rapydscript-ns 0.8.4 → 0.9.1

package/test/docstrings.pyj

@@ -1,39 +1,39 @@
-# vim:fileencoding=utf-8
-# License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
-# globals: ρσ_module_doc__
-
-import _import_one
-
-def f():
-    " A basic docstring "
-    pass
-
-assrt.equal(f.__doc__, 'A basic docstring')
-assrt.equal(_import_one.__doc__, 'Module level ds1\n\nModule level ds2\nline2\n\nModule level ds 3')
-
-def g():
-    '''
-    A more complex docstring:
-        xxx
-            yyyy
-
-    the end
-    '''
-    pass
-
-assrt.equal(g.__doc__, 'A more complex docstring:\n    xxx\n        yyyy\n\nthe end')
-
-class D:
-    ' Docstring for a class '
-
-    def method(self):
-        'ds for a method'
-        pass
-
-assrt.equal(D().__doc__, 'Docstring for a class')
-assrt.equal(D().method.__doc__, 'ds for a method')
-
-x = def():
-    'xxx'
-
-assrt.equal(x.__doc__, 'xxx')
+# vim:fileencoding=utf-8
+# License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
+# globals: ρσ_module_doc__
+
+import _import_one
+
+def f():
+    " A basic docstring "
+    pass
+
+assrt.equal(f.__doc__, 'A basic docstring')
+assrt.equal(_import_one.__doc__, 'Module level ds1\n\nModule level ds2\nline2\n\nModule level ds 3')
+
+def g():
+    '''
+    A more complex docstring:
+        xxx
+            yyyy
+
+    the end
+    '''
+    pass
+
+assrt.equal(g.__doc__, 'A more complex docstring:\n    xxx\n        yyyy\n\nthe end')
+
+class D:
+    ' Docstring for a class '
+
+    def method(self):
+        'ds for a method'
+        pass
+
+assrt.equal(D().__doc__, 'Docstring for a class')
+assrt.equal(D().method.__doc__, 'ds for a method')
+
+x = def():
+    'xxx'
+
+assrt.equal(x.__doc__, 'xxx')

package/test/elementmaker_test.pyj

@@ -1,45 +1,45 @@
-# vim:fileencoding=utf-8
-# License: BSD Copyright: 2015, Kovid Goyal <kovid at kovidgoyal.net>
-# globals: assrt
-
-from elementmaker import E
-
-eq = assrt.equal
-
-def dummy_elem_eq(a, b):
-    eq(jstype(a), jstype(b))
-    if (jstype(a) == 'string'):
-        eq(a, b)
-        return
-    eq(a.attributes.length, b.attributes.length)
-    eq(a.children.length, b.children.length)
-    eq(a.name, b.name)
-    for attr in a.attributes:
-        eq(a[attr], b[attr])
-    for i, child in enumerate(a.children):
-        dummy_elem_eq(child, b.children[i])
-
-q = E.div('text', id='1', class_='c', data_x='x')
-dummy_elem_eq(q, {'name':'div', 'children':['text'], 'attributes':{'id':'1', 'class':'c', 'data-x': 'x'}})
-
-q = E.div(
-        E.span('a'),
-        E.span('b'),
-        E.a(),
-        id='1',
-        boolean_attr=True,
-    )
-dummy_elem_eq(q, {'name':'div', 'children':[
-    {
-        'name':'span',
-        'children':['a'], 'attributes': {}
-    },
-    {
-        'name':'span',
-        'children':['b'], 'attributes': {}
-    },
-    {
-        'name':'a',
-        'children':[], 'attributes': {}
-    },
-], 'attributes':{'id':'1', 'boolean-attr':'boolean-attr'}})
+# vim:fileencoding=utf-8
+# License: BSD Copyright: 2015, Kovid Goyal <kovid at kovidgoyal.net>
+# globals: assrt
+
+from elementmaker import E
+
+eq = assrt.equal
+
+def dummy_elem_eq(a, b):
+    eq(jstype(a), jstype(b))
+    if (jstype(a) == 'string'):
+        eq(a, b)
+        return
+    eq(a.attributes.length, b.attributes.length)
+    eq(a.children.length, b.children.length)
+    eq(a.name, b.name)
+    for attr in a.attributes:
+        eq(a[attr], b[attr])
+    for i, child in enumerate(a.children):
+        dummy_elem_eq(child, b.children[i])
+
+q = E.div('text', id='1', class_='c', data_x='x')
+dummy_elem_eq(q, {'name':'div', 'children':['text'], 'attributes':{'id':'1', 'class':'c', 'data-x': 'x'}})
+
+q = E.div(
+        E.span('a'),
+        E.span('b'),
+        E.a(),
+        id='1',
+        boolean_attr=True,
+    )
+dummy_elem_eq(q, {'name':'div', 'children':[
+    {
+        'name':'span',
+        'children':['a'], 'attributes': {}
+    },
+    {
+        'name':'span',
+        'children':['b'], 'attributes': {}
+    },
+    {
+        'name':'a',
+        'children':[], 'attributes': {}
+    },
+], 'attributes':{'id':'1', 'boolean-attr':'boolean-attr'}})

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