rapydscript-ns 0.9.3 → 0.9.4

package/test/annotations.pyj

@@ -1,80 +1,80 @@
-def add(a: int, b: float):
-    return a + b
-
-assrt.ok(add.__annotations__)
-assrt.equal(add.__annotations__['a'], int)
-assrt.equal(add.__annotations__['b'], float)
-assrt.equal(add.__annotations__['return'], undefined)
-
-def sum(ls: list) -> int:
-    pass
-
-assrt.ok(not (sum.__annotations__ == undefined))
-assrt.deepEqual(sum.__annotations__, {
-    'ls': list,
-    'return': int
-})
-
-def optional(a:int=10):
-    return a
-
-assrt.ok(not (optional.__annotations__ == undefined))
-assrt.equal(optional.__annotations__.a, int)
-assrt.equal(optional.__defaults__.a, 10)
-
-def otherexpr(a:3+4) -> [1, 2]:
-    pass
-
-assrt.ok(not (otherexpr.__annotations__ == undefined))
-assrt.equal(otherexpr.__annotations__['a'], 7)
-assrt.deepEqual(otherexpr.__annotations__['return'], [1, 2])
-
-def basic(x:float):
-    pass
-
-assrt.deepEqual(basic.__annotations__, {
-    'x': float
-})
-
-def kwstarargs(*args:list, **kwargs:dict) -> int:
-    pass
-
-assrt.equal(kwstarargs.__annotations__['return'], int)
-
-def nothing():
-    pass
-
-assrt.ok(nothing.__annotations__ == undefined)
-assrt.throws(def():
-    nothing.__annotations__['return']
-)
-
-test = def(x: int):
-    pass
-
-assrt.deepEqual(test.__annotations__, {
-    'x': int
-})
-
-anonreturn = def() -> 'test':
-    pass
-
-assrt.equal(anonreturn.__annotations__['return'], 'test')
-
-assrt.equal(def asexpr(a: int):
-    a
-.__annotations__['a'], int)
-
-assrt.deepEqual(def(a: int) -> float:
-    a + 10.0
-.__annotations__, {
-    'a': int,
-    'return': float
-})
-
-class A:
-
-    def f(self, a : int, b: 'x') -> float:
-        pass
-
-assrt.deepEqual(A.prototype.f.__annotations__, {'a':int, 'b':'x', 'return': float})
+def add(a: int, b: float):
+    return a + b
+
+assrt.ok(add.__annotations__)
+assrt.equal(add.__annotations__['a'], int)
+assrt.equal(add.__annotations__['b'], float)
+assrt.equal(add.__annotations__['return'], undefined)
+
+def sum(ls: list) -> int:
+    pass
+
+assrt.ok(not (sum.__annotations__ == undefined))
+assrt.deepEqual(sum.__annotations__, {
+    'ls': list,
+    'return': int
+})
+
+def optional(a:int=10):
+    return a
+
+assrt.ok(not (optional.__annotations__ == undefined))
+assrt.equal(optional.__annotations__.a, int)
+assrt.equal(optional.__defaults__.a, 10)
+
+def otherexpr(a:3+4) -> [1, 2]:
+    pass
+
+assrt.ok(not (otherexpr.__annotations__ == undefined))
+assrt.equal(otherexpr.__annotations__['a'], 7)
+assrt.deepEqual(otherexpr.__annotations__['return'], [1, 2])
+
+def basic(x:float):
+    pass
+
+assrt.deepEqual(basic.__annotations__, {
+    'x': float
+})
+
+def kwstarargs(*args:list, **kwargs:dict) -> int:
+    pass
+
+assrt.equal(kwstarargs.__annotations__['return'], int)
+
+def nothing():
+    pass
+
+assrt.ok(nothing.__annotations__ == undefined)
+assrt.throws(def():
+    nothing.__annotations__['return']
+)
+
+test = def(x: int):
+    pass
+
+assrt.deepEqual(test.__annotations__, {
+    'x': int
+})
+
+anonreturn = def() -> 'test':
+    pass
+
+assrt.equal(anonreturn.__annotations__['return'], 'test')
+
+assrt.equal(def asexpr(a: int):
+    a
+.__annotations__['a'], int)
+
+assrt.deepEqual(def(a: int) -> float:
+    a + 10.0
+.__annotations__, {
+    'a': int,
+    'return': float
+})
+
+class A:
+
+    def f(self, a : int, b: 'x') -> float:
+        pass
+
+assrt.deepEqual(A.prototype.f.__annotations__, {'a':int, 'b':'x', 'return': float})

package/test/baselib.pyj

@@ -159,6 +159,29 @@ a.sort()
 assrt.deepEqual(a, [1,2,3,4])
 a.sort(reverse=True)
 assrt.deepEqual(a, [4,3,2,1])
+
+# sort: a positional two-argument function is treated as a comparator
+assrt.deepEqual(sorted([3, 1, 2, 10], def(x, y): return x - y;), [1, 2, 3, 10])
+assrt.deepEqual(sorted([3, 1, 2, 10], def(x, y): return y - x;), [10, 3, 2, 1])
+sort_cmp = [5, 2, 8, 1]
+sort_cmp.sort(def(x, y): return x - y;)
+assrt.deepEqual(sort_cmp, [1, 2, 5, 8])
+# a one-argument function is still a key function
+assrt.deepEqual(sorted([3, 1, 2], key=def(x): return -x;), [3, 2, 1])
+# comparator path keeps ties in their original order (stable)
+assrt.deepEqual(sorted([[1, 'a'], [1, 'b'], [0, 'c']], def(p, q): return p[0] - q[0];),
+                [[0, 'c'], [1, 'a'], [1, 'b']])
+
+# sort: custom objects are ordered via their __lt__ method
+class SortOrd:
+    def __init__(self, v):
+        self.v = v
+    def __lt__(self, other):
+        return self.v < other.v
+ord_asc = sorted([SortOrd(3), SortOrd(1), SortOrd(2)])
+assrt.deepEqual([ord_asc[0].v, ord_asc[1].v, ord_asc[2].v], [1, 2, 3])
+ord_desc = sorted([SortOrd(3), SortOrd(1), SortOrd(2)], reverse=True)
+assrt.deepEqual([ord_desc[0].v, ord_desc[1].v, ord_desc[2].v], [3, 2, 1])
 assrt.deepEqual(a, a.slice())
 assrt.ok(a is not a.slice())
 assrt.ok(a.slice().extend is not undefined)

package/test/chainmap.pyj

@@ -0,0 +1,185 @@
+# globals: assrt
+# vim:fileencoding=utf-8
+#
+# chainmap.pyj
+# Tests for collections.ChainMap.
+
+from __python__ import overload_getitem
+from collections import ChainMap
+
+ae  = assrt.equal
+ade = assrt.deepEqual
+ok  = assrt.ok
+
+# ── 1. construction and lookup — first map wins ───────────────────────────────
+
+defaults = {'color': 'red', 'user': 'guest', 'depth': 1}
+overrides = {'user': 'admin'}
+cm = ChainMap(overrides, defaults)
+
+ae(cm['user'], 'admin')      # found in first map
+ae(cm['color'], 'red')       # falls through to second map
+ae(cm['depth'], 1)
+ae(len(cm), 3)               # unique keys across all maps
+
+# ── 2. empty construction uses a single empty dict ────────────────────────────
+
+empty = ChainMap()
+ae(len(empty), 0)
+ae(empty.maps.length, 1)
+
+# ── 3. missing key raises KeyError ────────────────────────────────────────────
+
+_err = False
+try:
+    cm['missing']
+except KeyError:
+    _err = True
+ok(_err, 'missing key raises KeyError')
+
+# ── 4. writes, deletes and updates affect only the first map ──────────────────
+
+cm['depth'] = 99
+ae(cm['depth'], 99)          # shadows the value in defaults
+ae(defaults['depth'], 1)     # underlying map untouched
+ae(overrides['depth'], 99)   # written to the first map
+
+cm['user'] = 'root'
+ae(cm['user'], 'root')
+
+del cm['user']
+ae(cm['user'], 'guest')      # first-map entry removed; falls through again
+
+_del_err = False
+try:
+    del cm['color']          # 'color' lives in the second map, not the first
+except KeyError:
+    _del_err = True
+ok(_del_err, 'deleting a key absent from the first map raises KeyError')
+
+# ── 5. membership, get, and iteration ─────────────────────────────────────────
+
+ok('color' in cm)
+ok('user' in cm)
+ok('nope' not in cm)
+ae(cm.get('color'), 'red')
+ae(cm.get('nope'), None)
+ae(cm.get('nope', 'fallback'), 'fallback')
+
+m1 = {'a': 1, 'b': 2}
+m2 = {'c': 3}
+ordered = ChainMap(m1, m2)
+ade(list(ordered), ['c', 'a', 'b'])     # Python order: later maps first
+ade(ordered.keys(), ['c', 'a', 'b'])
+ade(ordered.values(), [3, 1, 2])
+ade(ordered.items(), [['c', 3], ['a', 1], ['b', 2]])
+
+_seen = []
+for k in ordered:
+    _seen.push(k)
+ade(_seen, ['c', 'a', 'b'])
+
+# ── 6. maps attribute, new_child and parents ──────────────────────────────────
+
+base = ChainMap({'x': 1})
+child = base.new_child({'x': 2, 'y': 3})
+ae(child['x'], 2)            # child's own map shadows the parent
+ae(child['y'], 3)
+ae(base['x'], 1)             # parent unchanged
+ae(child.maps.length, 2)
+
+# new_child() with no argument adds a fresh empty map
+fresh = base.new_child()
+ae(fresh.maps.length, 2)
+ae(len(fresh), 1)
+fresh['z'] = 7
+ae(fresh['z'], 7)
+ok('z' not in base)
+
+# parents drops the first map
+parents = child.parents
+ae(parents['x'], 1)
+ae(parents.maps.length, 1)
+
+# ── 7. copy is shallow — first map cloned, rest shared ────────────────────────
+
+src = ChainMap({'a': 1}, {'b': 2})
+dup = src.copy()
+dup['a'] = 100
+ae(src['a'], 1)              # first map was cloned
+dup['c'] = 9                 # writes to the cloned first map
+ok('c' not in src)
+ae(dup['b'], 2)              # tail maps are shared
+
+# ── 8. pop, popitem, clear, setdefault, update ────────────────────────────────
+
+p = ChainMap({'a': 1, 'b': 2}, {'c': 3})
+ae(p.pop('a'), 1)
+ok('a' not in p.maps[0])
+ae(p.pop('missing', 'dflt'), 'dflt')
+
+_pop_err = False
+try:
+    p.pop('c')               # 'c' is not in the first map
+except KeyError:
+    _pop_err = True
+ok(_pop_err, 'pop of a key absent from the first map raises KeyError')
+
+pi = ChainMap({'only': 42})
+ade(pi.popitem(), ['only', 42])
+ae(len(pi.maps[0]), 0)
+
+sd = ChainMap({'a': 1}, {'b': 2})
+ae(sd.setdefault('a', 999), 1)       # existing key — unchanged
+ae(sd.setdefault('new', 5), 5)       # missing key — inserted into first map
+ae(sd['new'], 5)
+ae(sd.setdefault('b', 0), 2)         # found in tail map — not copied forward
+ok('b' not in sd.maps[0])
+
+up = ChainMap({'a': 1}, {'b': 2})
+up.update({'a': 10, 'd': 4})
+ae(up['a'], 10)
+ae(up['d'], 4)
+up.update(e=5)
+ae(up['e'], 5)
+up.update([['f', 6]])
+ae(up['f'], 6)
+
+cl = ChainMap({'a': 1, 'b': 2}, {'c': 3})
+cl.clear()
+ae(len(cl.maps[0]), 0)
+ae(cl['c'], 3)               # tail map survives clear()
+
+# ── 9. nested ChainMap as a member map ────────────────────────────────────────
+
+inner = ChainMap({'a': 1}, {'b': 2})
+outer = ChainMap({'c': 3}, inner)
+ae(outer['a'], 1)
+ae(outer['b'], 2)
+ae(outer['c'], 3)
+ok('a' in outer)
+ae(len(outer), 3)
+
+# ── 10. equality ──────────────────────────────────────────────────────────────
+
+ok(ChainMap({'a': 1}, {'b': 2}) == ChainMap({'a': 1}, {'b': 2}))
+ok(ChainMap({'a': 1}) == {'a': 1})
+ok(not (ChainMap({'a': 1}) == ChainMap({'a': 2})))
+ok(not (ChainMap({'a': 1}) == {'a': 1, 'b': 2}))
+
+# ── 11. repr ──────────────────────────────────────────────────────────────────
+
+# RapydScript's repr() quotes strings with double quotes (as Counter/OrderedDict do)
+ae(ChainMap({'a': 1}, {'b': 2}).__repr__(), 'ChainMap({"a": 1}, {"b": 2})')
+
+# ── 12. dynamic — changes to underlying maps are visible ──────────────────────
+
+live = {'k': 'v1'}
+dyn = ChainMap({}, live)
+ae(dyn['k'], 'v1')
+live['k'] = 'v2'
+ae(dyn['k'], 'v2')           # ChainMap reflects the mutation
+live['extra'] = 'x'
+ok('extra' in dyn)
+
+print('chainmap tests passed')

package/test/decorators.pyj

@@ -1,77 +1,77 @@
-# vim:fileencoding=utf-8
-# License: BSD Copyright: 2015, Kovid Goyal <kovid at kovidgoyal.net>
-
-def double(f):
-    return def (x):
-        return 2 * f(x)
-
-def triple(f):
-    return def(x):
-        return 3 * f(x)
-
-@double
-def half(x):
-    return x // 2
-
-@double
-def f1(x):
-    return x
-
-@double
-@triple
-def f2(x):
-    return x
-
-def append_one(f):
-    return def(x):
-        ans = f(x)
-        ans.push(1)
-        return ans
-
-def append_two(f):
-    return def(x):
-        ans = f(x)
-        ans.push(2)
-        return ans
-
-@append_two
-@append_one
-def f3():
-    return []
-
-o = {'double':double}
-
-@o.double
-def f4():
-    return 1
-
-assrt.equal(2, half(2))
-assrt.equal(4, f1(2))
-assrt.equal(12, f2(2))
-assrt.equal(2, f4())
-assrt.deepEqual([1, 2], f3())
-
-def multiply(amt):
-
-    def wrapper(f):
-        return def ():
-            return amt * f()
-
-    return wrapper
-
-@multiply(2)
-def two():
-    return 1
-
-@multiply(3)
-def three():
-    return 1
-
-@multiply(2)
-@multiply(2)
-def four():
-    return 1
-
-assrt.equal(2, two())
-assrt.equal(3, three())
-assrt.equal(4, four())
+# vim:fileencoding=utf-8
+# License: BSD Copyright: 2015, Kovid Goyal <kovid at kovidgoyal.net>
+
+def double(f):
+    return def (x):
+        return 2 * f(x)
+
+def triple(f):
+    return def(x):
+        return 3 * f(x)
+
+@double
+def half(x):
+    return x // 2
+
+@double
+def f1(x):
+    return x
+
+@double
+@triple
+def f2(x):
+    return x
+
+def append_one(f):
+    return def(x):
+        ans = f(x)
+        ans.push(1)
+        return ans
+
+def append_two(f):
+    return def(x):
+        ans = f(x)
+        ans.push(2)
+        return ans
+
+@append_two
+@append_one
+def f3():
+    return []
+
+o = {'double':double}
+
+@o.double
+def f4():
+    return 1
+
+assrt.equal(2, half(2))
+assrt.equal(4, f1(2))
+assrt.equal(12, f2(2))
+assrt.equal(2, f4())
+assrt.deepEqual([1, 2], f3())
+
+def multiply(amt):
+
+    def wrapper(f):
+        return def ():
+            return amt * f()
+
+    return wrapper
+
+@multiply(2)
+def two():
+    return 1
+
+@multiply(3)
+def three():
+    return 1
+
+@multiply(2)
+@multiply(2)
+def four():
+    return 1
+
+assrt.equal(2, two())
+assrt.equal(3, three())
+assrt.equal(4, four())

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