rapydscript-ns 0.8.0

package/test/dict_spread.pyj

@@ -0,0 +1,76 @@
+# vim:fileencoding=utf-8
+# Tests for dict merge literal {**d1, **d2}
+
+# Basic merge of two JS-object dicts
+d1 = {'a': 1, 'b': 2}
+d2 = {'c': 3, 'd': 4}
+merged = {**d1, **d2}
+assrt.equal(merged['a'], 1)
+assrt.equal(merged['b'], 2)
+assrt.equal(merged['c'], 3)
+assrt.equal(merged['d'], 4)
+
+# Later key wins (rightmost takes priority)
+da = {'x': 1}
+db = {'x': 99, 'y': 2}
+r = {**da, **db}
+assrt.equal(r['x'], 99)
+assrt.equal(r['y'], 2)
+
+# Mix of spread and literal key-value pairs
+base = {'a': 10, 'b': 20}
+result = {**base, 'c': 30}
+assrt.equal(result['a'], 10)
+assrt.equal(result['b'], 20)
+assrt.equal(result['c'], 30)
+
+# Literal key before spread (spread overrides)
+result2 = {'a': 0, **base}
+assrt.equal(result2['a'], 10)
+
+# Multiple spreads with interleaved key-value pairs
+x = {'x': 1}
+y = {'y': 2}
+z = {'z': 3}
+combined = {**x, 'mid': 99, **y, **z}
+assrt.equal(combined['x'], 1)
+assrt.equal(combined['mid'], 99)
+assrt.equal(combined['y'], 2)
+assrt.equal(combined['z'], 3)
+
+# Single spread only
+src = {'p': 7, 'q': 8}
+copy = {**src}
+assrt.equal(copy['p'], 7)
+assrt.equal(copy['q'], 8)
+
+# Empty dict spread
+empty = {}
+r2 = {**empty, 'k': 42}
+assrt.equal(r2['k'], 42)
+
+# Trailing comma allowed
+tc = {**d1,}
+assrt.equal(tc['a'], 1)
+
+# Python dict literals with dict_literals scoped flag
+def test_pydict_spread():
+    from __python__ import dict_literals, overload_getitem
+    pd1 = {'alpha': 1, 'beta': 2}
+    pd2 = {'gamma': 3}
+    merged_py = {**pd1, **pd2}
+    assrt.ok(isinstance(merged_py, dict))
+    assrt.equal(merged_py['alpha'], 1)
+    assrt.equal(merged_py['beta'], 2)
+    assrt.equal(merged_py['gamma'], 3)
+    # Key override in pydict
+    pd3 = {'alpha': 999}
+    overridden = {**pd1, **pd3}
+    assrt.equal(overridden['alpha'], 999)
+    assrt.equal(overridden['beta'], 2)
+    # Mix spread and literal
+    mixed = {**pd1, 'delta': 4}
+    assrt.equal(mixed['alpha'], 1)
+    assrt.equal(mixed['delta'], 4)
+
+test_pydict_spread()

package/test/docstrings.pyj

@@ -0,0 +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')

package/test/elementmaker_test.pyj

@@ -0,0 +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'}})

package/test/ellipsis.pyj

@@ -0,0 +1,49 @@
+# globals: assrt
+
+# Ellipsis is a singleton — two uses of ... reference the same object
+assrt.ok(... is ..., "... is ...")
+assrt.ok(... is Ellipsis, "... is Ellipsis")
+assrt.ok(Ellipsis is ..., "Ellipsis is ...")
+
+# Ellipsis is not null/undefined/false
+assrt.ok(... is not None, "... is not None")
+assrt.ok(... is not undefined, "... is not undefined")
+assrt.ok(... is not False, "... is not False")
+
+# str(...) should return 'Ellipsis'
+assrt.equal(str(...), 'Ellipsis', "str(...) == 'Ellipsis'")
+assrt.equal(str(Ellipsis), 'Ellipsis', "str(Ellipsis) == 'Ellipsis'")
+
+# Assignment and re-use
+e = ...
+assrt.ok(e is ..., "assigned ... is ...")
+assrt.ok(e is Ellipsis, "assigned ... is Ellipsis")
+
+# Ellipsis in a list
+lst = [1, ..., 3]
+assrt.ok(lst[1] is ..., "Ellipsis in list")
+
+# Ellipsis as function argument
+def identity(x):
+    return x
+
+assrt.ok(identity(...) is ..., "passing ... to function")
+
+# Ellipsis as return value
+def get_ellipsis():
+    return ...
+
+assrt.ok(get_ellipsis() is ..., "returning ...")
+
+# Ellipsis as function body placeholder (like pass)
+def placeholder():
+    ...
+
+placeholder()  # should not raise
+
+# Ellipsis used as dict value
+d = {'key': ...}
+assrt.ok(d['key'] is ..., "Ellipsis as dict value")
+
+# Ellipsis truthiness (should be truthy, like in Python)
+assrt.ok(..., "... is truthy")

package/test/functions.pyj

@@ -0,0 +1,151 @@
+# globals: assrt
+
+def nothing():
+    pass
+assrt.equal(nothing(), undefined)
+
+add = def(a, b):
+    return a+b
+def sub(a, b):
+    return a-b
+
+mul = None
+(def():
+    nonlocal mul
+    mul = def(a, b):
+        return a*b
+
+    div = def(a, b):  # noqa:unused-local
+        return a/b
+)()
+
+assrt.equal(add(1,2), 3)
+assrt.equal(sub(1,2), -1)
+assrt.equal(mul(2,2), 4)
+# for some reason input to throws must be of type block, hence the 'def' wrapper
+assrt.throws(
+    def():
+        div(6,3)  # noqa: undef
+    ,
+    /div is not defined/
+)
+
+arr = [8,4]
+assrt.equal(add(*arr), 12)
+assrt.ok(Array.isArray(arr))
+
+def sum(*args):
+    ttl = 0
+    for i in args:
+        ttl += i
+    return ttl
+assrt.equal(sum(1,2,3), 6)
+assrt.equal(sum(1,*[2,3]), 6)
+
+num = 4
+def():
+    nonlocal num
+    num = 5
+.call(this)
+
+assrt.equal(num, 5)
+
+x = "foo"
+y = 5
+def swap(x, y):
+    return y, x
+x, y = swap(x, y)
+assrt.equal(x, 5)
+assrt.equal(y, "foo")
+
+count = 0
+f, r = (def():
+    def fake_increment():
+        count += 1
+    def real_increment():
+        nonlocal count
+        count += 1
+    return fake_increment, real_increment
+).call(this)
+
+f()
+assrt.equal(count, 0)
+r()
+assrt.equal(count, 1)
+
+st = "this is a string"
+assrt.equal(jstype(st), v"typeof st")
+
+# testing inlined functions
+inlined = [
+    def(x): return x+1;, def(x): return x+2;,
+    def(x): return x+3
+    ,
+    def(x): return x+4
+]
+assrt.equal(inlined[0](1), 2)
+assrt.equal(inlined[1](1), 3)
+assrt.equal(inlined[2](1), 4)
+assrt.equal(inlined[3](1), 5)
+
+# decorators
+def makebold(fn):
+    def wrapped(arg):
+        return "<b>" + fn(arg) + "</b>"
+    return wrapped
+
+def makeitalic(fn):
+    def wrapped(arg):
+        return "<i>" + fn(arg) + "</i>"
+    return wrapped
+
+@makebold
+@makeitalic
+def hello(something):
+    return "hello " + something
+
+assrt.equal(hello("world"), "<b><i>hello world</i></b>")
+assrt.equal(hello.__module__, '__main__')
+assrt.equal(hello.__argnames__.length, 1)
+assrt.equal(hello.__argnames__[0], 'arg')
+
+
+def simple_wrapper(f):
+    f.test_attr = 'test'
+    return f
+
+
+@simple_wrapper
+def fw(x):
+    pass
+
+assrt.equal(fw.__module__, '__main__')
+assrt.equal(fw.__argnames__.length, 1)
+assrt.equal(fw.__argnames__[0], 'x')
+# just because something is a reserved keyword in RapydScript, doesn't mean other libraries won't attempt to use it
+# let's make sure we parse that correctly
+five = {}
+v"five.is = function(n) { return 5 == n };"
+assrt.ok(five.is(5))
+
+# function assignment via conditional
+foo = (def(): return 5;) if 0 else (def(): return 6;)
+bar = (def(): return 5;) if 0 < 1 else (def(): return 6;)
+baz = (def():
+    return 5
+) if 1 else (def():
+    return 6
+)
+assrt.equal(foo(), 6)
+assrt.equal(bar(), 5)
+assrt.equal(baz(), 5)
+
+def trailing_comma(a, b,):
+    return a + b
+assrt.equal(trailing_comma(1, 2), 3)
+assrt.equal(trailing_comma(1, 2,), 3)
+
+def return_string_with_newline():
+    return '''a
+b'''
+assrt.equal(return_string_with_newline(), 'a\nb')

package/test/generators.pyj

@@ -0,0 +1,41 @@
+# vim:fileencoding=utf-8
+# License: BSD
+# Copyright: 2015, Kovid Goyal <kovid at kovidgoyal.net>
+
+def g1():
+    yield 1
+    yield 2
+
+def g2():
+    for i in range(2):
+        yield from g1()
+
+def g3():
+    data = yield 1
+    yield data
+
+class A:
+
+    def __init__(self):
+        self.items = [1, 2, 3]
+
+    def __iter__(self):
+        for x in self.items:
+            yield x
+
+assrt.deepEqual([x for x in g1()], [1, 2])
+assrt.deepEqual([x for x in g2()], [1, 2, 1, 2])
+assrt.deepEqual([x for x in A()], [1, 2, 3])
+
+g = g3()
+assrt.equal(g.next().value, 1)
+assrt.equal(g.next('a').value, 'a')
+
+a = (x for x in range(3))
+assrt.deepEqual(list(a), [0, 1, 2])
+a = ([x, x**2] for x in range(3))
+assrt.deepEqual(list(a), [[0, 0], [1, 1], [2, 4]])
+assrt.deepEqual(list(x for x in range(3)), [0, 1, 2])
+def t(a, b):
+    assrt.deepEqual(list(a), list(b))
+t((x for x in range(1)), (y for y in range(1)))