rapydscript-ns 0.9.3 → 0.9.4

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/functions.pyj

@@ -1,151 +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')
+# 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

@@ -1,41 +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)))
+# 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)))