rapydscript-ns 0.8.0

package/test/classes.pyj

@@ -0,0 +1,452 @@
+# globals: assrt
+
+# empty classes are allowed
+class Blank:
+    pass
+blank = Blank()
+assrt.ok(isinstance(blank, Blank))
+
+# basic class
+class Human:
+
+    HAIRS = 23
+
+    def __init__(self, name):
+        self.name = name
+
+    def greet(self):
+        return "Hello, I'm " + self.name
+
+    @staticmethod
+    def getTypicalWeight():
+        return "150"
+
+    @staticmethod
+    def with_arg(x):
+        return x
+
+
+# don't have to declare __init__, it either gets inherited or stays empty
+# isinstance correctly sees inheritance
+class Friend(Human):
+    def greet(self):
+        return "Yo, it's me, " + self.name
+
+    def nickname(self, name):
+        self.name = name
+
+# __init__ doesn't have to come first
+# can call methods of other classes
+class OldFriend(Friend):
+    def how_long(self):
+        return "I've known you for " + self.duration + " years"
+    def get_bound_method(self):
+        return self.how_long.bind(self)
+    def __init__(self, name, duration):
+        self.duration = duration
+        Friend.__init__(self, name)
+
+bob = Human("Bob")
+assrt.equal(bob.greet(), "Hello, I'm Bob")
+assrt.equal(Human.greet(bob), "Hello, I'm Bob")
+assrt.equal(Human.getTypicalWeight(), "150") # static method recognition
+assrt.equal(Human.with_arg(3), 3) # static method with arg
+assrt.equal(Human.HAIRS, 23)
+
+joe = Friend("Joe")
+assrt.equal(joe.greet(), "Yo, it's me, Joe")
+assrt.ok(isinstance(joe, Friend))
+assrt.ok(isinstance(joe, Human))
+
+angela = OldFriend("Angela", 8)
+assrt.equal(angela.greet(), "Yo, it's me, Angela")
+assrt.equal(angela.how_long(), "I've known you for 8 years")
+
+# test that function stays bound
+bound = angela.get_bound_method()
+assrt.equal(bound(), angela.how_long())
+
+# function methods
+assrt.deepEqual(dir(angela).sort(), [
+    'HAIRS',
+    "__init__",
+    '__repr__',
+    '__str__',
+    "constructor",
+    "duration",
+    "get_bound_method",
+    "greet",
+    "how_long",
+    "name",
+    "nickname",
+])
+
+# test that binding works in relation to the actual class, not the parent
+angela.nickname("Angie")
+assrt.equal(angela.greet(), "Yo, it's me, Angie")
+
+dude = None
+(def fake_module():
+    # test that we can declare classes inside other blocks
+    # test that we can call methods of classes we didn't inherit from
+    nonlocal dude
+    class Stranger(Human):
+        def greet(self):
+            return Friend.greet(self)
+    dude = Stranger("some guy")
+)()
+assrt.equal(dude.greet(), "Yo, it's me, some guy")
+# also test that classes declared this way are not globally scoped (while normal ones are)
+assrt.throws(
+    def():
+        Friend("another friend")
+        Stranger("another guy")  # noqa:undef
+    ,
+    /Stranger is not defined/
+)
+
+# attributes
+assrt.ok(hasattr(dude, "greet"))
+assrt.equal(getattr(dude, "greet").bind(dude)(), "Yo, it's me, some guy") # function stays bound after binding
+assrt.equal(hasattr(dude, "stuff"), False)
+setattr(dude, "stuff", True)
+assrt.ok(hasattr(dude, "stuff"))
+
+# native classes and methods
+st = String("test")
+assrt.equal(st, "test")
+assrt.equal(st.toUpperCase(), "TEST")
+assrt.equal(String.toUpperCase(st), "TEST")
+assrt.equal(String.fromCharCode(65), "A") # static method recognition
+
+# now we test RapydScript's ability to insert 'new' operator correctly
+assrt.ok(String('a') != 'a')   # string literal vs string object
+assrt.ok((String)('a') == 'a') # string literal vs string literal
+assrt.ok(String.call(this, 'a') == 'a') # string literal via static method on string
+
+# self consistency
+class Counter:
+    def __init__(s, n=0):
+        s.count = n # first arg becomes 'self'
+    def getIncrementer(self):
+        return def():
+            self.count += 1
+c = Counter(5)
+inc = c.getIncrementer()
+inc()
+assrt.equal(c.count, 6)
+
+# nested classes
+# not yet fully implemented
+#class Molecule:
+#   class Atom:
+#       def __init__(self, element):
+#           self.element = element
+#
+#   def __init__(self, elements):
+#       self.structure = []
+#       for e in elements:
+#           self.structure.push(Molecule.Atom(e))
+#
+#water = Molecule(['H', "H", 'O'])
+#assrt.equal(len(water.structure), 3)
+#assrt.equal(water.structure[0].element, 'H')
+#for atom in water.structure:
+#   assrt.ok(isinstance(atom, Molecule.Atom))
+
+# starargs and method decorators
+def negate(fn):
+    def wrapped(*args):
+        return -fn(*args)
+    return wrapped
+
+def add_pi(cls):
+    cls.prototype.pi = 3.14
+    return cls
+
+@add_pi
+class Math:
+    def sum(s, *args):
+        # fakearg simply tests that offsets work correctly
+        ttl = 0
+        for i in args:
+            ttl += i
+        return ttl
+    def concatSum(s, string, *nums):
+        return string + s.sum(*nums)
+    @negate
+    def plus(s, a, b):
+        return a+b
+
+m = Math()
+assrt.equal(m.sum(1,2,3), 6)
+assrt.equal(m.sum(1,*[2,3]), 6)
+assrt.equal(m.concatSum("foo", 1, 2, 5), "foo8")
+assrt.equal(m.plus(2, 5), -7)
+assrt.equal(m.pi, 3.14)
+
+
+class CV():
+
+    a = b = 1
+    c = a + b
+    if True:
+        d = 1
+    else:
+        d = 2
+
+    def one(self):
+        return 1
+    two = one
+
+c = CV()
+assrt.deepEqual([c.a, c.b, c.c, c.d], [1, 1, 2, 1])
+assrt.equal(c.one(), c.two())
+
+
+class Properties:
+
+    def __init__(self):
+        self._a = 19
+        assrt.equal(self.a, 19)
+
+    @property
+    def a(self):
+        return self._a
+
+    @a.setter
+    def a(self, val):
+        self._a = val
+
+    @property
+    def b(self):
+        return 1
+
+    def c(self):
+        return self.a
+
+class A:
+    @property
+    def val(self):
+        return 'a'
+
+    @property
+    def parent(self):
+        return 'parent'
+
+class B(A):
+    @property
+    def val(self):
+        return 'b'
+
+
+p = Properties()
+assrt.equal(p._a, p.a)
+p.a = 11
+assrt.equal(11, p.a)
+assrt.equal(p.c(), p.a)
+assrt.equal(p.b, 1)
+assrt.throws(
+    def():
+        p.b = 2
+)
+p = B()
+assrt.equal(p.val, 'b')
+assrt.equal(p.parent, 'parent')
+assrt.equal(id(p), id(p))
+assrt.notEqual(id(p), id(B()))
+
+class Context:
+
+    val = 1
+
+    def __enter__(self):
+        self.val = 2
+        return self
+
+    def __exit__(self):
+        self.val = 3
+        return True
+
+with Context() as c:
+    assrt.eq(c.val, 2)
+assrt.equal(c.val, 3)
+
+with Context() as d:
+    assrt.equal(d.val, 2)
+    raise Exception('error')
+assrt.equal(d.val, 3)
+
+class Throws:
+
+    def __enter__(self):
+        pass
+
+    def __exit__(self):
+        pass
+
+assrt.throws(
+    def ():
+        with Throws():
+            raise Exception('error')
+    , Exception
+)
+
+class X:
+
+    def __init__(self):
+        self.a = 3
+
+class Y(X):
+    pass
+
+class Z(Y):
+    pass
+
+assrt.equal(Z().a, X().a)
+assrt.ok(repr(Z()).indexOf('<__main__.Z') == 0)
+assrt.ok(str(Z()).indexOf('<__main__.Z') == 0)
+
+from __python__ import bound_methods
+
+class U:
+
+    def __init__(self, a):
+        self.a = a
+
+    def val(self):
+        return self.a
+
+u = U(3)
+f = u.val
+assrt.equal(f(), u.val())
+
+class U2(U):
+
+    def val(self):
+        return self.a * 2
+
+u = U2(3)
+f = u.val
+assrt.equal(f(), 6)
+
+class M1:
+
+    def f1(self):
+        return 'M1-f1'
+
+    def f3(self):
+        return 'M1-f3'
+
+class M0:
+
+    def f0(self):
+        return 'M0-f0'
+
+class M2(M0):
+
+    @property
+    def prop(self):
+        return self._p or 'prop'
+
+    @prop.setter
+    def prop(self, val):
+        self._p = val
+
+    def f1(self):
+        return 'M2-f1'
+
+    def f2(self):
+        return 'M2-f2'
+
+    def f3(self):
+        return 'M2-f3'
+
+class Child(M1, M2):
+
+    def f3(self):
+        return 'Child-f3'
+
+c = Child()
+assrt.equal(c.f0(), 'M0-f0')
+assrt.equal(c.f1(), 'M1-f1')
+assrt.equal(c.f2(), 'M2-f2')
+assrt.equal(c.f3(), 'Child-f3')
+assrt.equal(c.prop, 'prop')
+c.prop = 1
+assrt.equal(c.prop, 1)
+assrt.ok(isinstance(c, Child))
+assrt.ok(isinstance(c, M1))
+assrt.ok(isinstance(c, M2))
+assrt.ok(isinstance(c, M0))
+
+
+class B1:
+
+    def __init__(self):
+        self.b1 = 1
+
+    def one(self):
+        return self.two()
+
+    def two(self):
+        return self.b1
+
+class B2(B1):
+
+    def __init__(self):
+        self.b2 = 2
+        B1.__init__(self)
+
+    def two(self):
+        return self.b2
+assrt.equal(B2().two(), 2)
+assrt.equal(B2().b1, 1)
+
+
+class Cvar:
+    a = b = 0
+    def __init__(self):
+        Cvar.a += 1
+
+    def inc(self):
+        Cvar.a += 1
+
+    def val(self):
+        return Cvar.a
+
+    def incb(self):
+        Cvar.b += 1
+        return Cvar.b
+
+assrt.equal(Cvar.a, 0)
+c = Cvar()
+assrt.equal(Cvar.a, 1)
+c.inc()
+assrt.equal(Cvar.a, 2)
+assrt.equal(Cvar().val(), 3)
+assrt.equal(Cvar().incb(), 1)
+assrt.equal(Cvar().incb(), 2)
+
+class anon_func_in_class:
+
+    f = def():
+        func_var = 1
+        return func_var
+
+    def func_var(self):
+        pass
+
+assrt.equal(jstype(anon_func_in_class.prototype.func_var), 'function')
+anon_func_in_class.prototype.f()
+assrt.equal(jstype(anon_func_in_class.prototype.func_var), 'function')
+
+
+def decorate(cls):
+    assrt.equal(cls.prototype.somevar, 1)
+    return cls
+
+
+@decorate
+class decorated:
+    somevar = 1

package/test/collections.pyj

@@ -0,0 +1,152 @@
+# globals: assrt
+# ARRAYS
+
+# immutables
+a = [4,5,6,7]
+
+# mutables
+class Item:
+    pass
+i0 = Item()
+i1 = Item()
+i2 = Item()
+b = [i0, i1]
+assrt.ok(i0 != i1)
+
+# access and slicing
+i = -1
+assrt.equal(len(a), 4)
+assrt.equal(a[-1], 7)
+assrt.equal(a[i], a[-1])
+assrt.equal(a[-2], 6)
+assrt.deepEqual(a[1:3], [5,6])
+assrt.deepEqual(a[:3], [4,5,6])
+assrt.deepEqual(a[2:], [6,7])
+assrt.ok(7 in a)
+assrt.ok(i1 in b)
+assrt.ok(i2 not in b)
+assrt.ok(b == b.copy())
+assrt.ok([1] in [[1], [2]])
+assrt.ok([3] not in [[1], [2]])
+
+if jstype(Symbol) is 'function':
+    ss = Symbol('s')
+    sym = {ss:1}
+    assrt.equal(sym[ss], 1)
+def keyf():
+    return 1
+assrt.equal({keyf():2}[keyf()], 2)
+
+# assignment
+a[-1] = 9
+assrt.equal(a[-1], 9)
+s = [0,1,2,3,4]
+s[:2] = [8, 9]
+assrt.deepEqual(s, [8,9,2,3,4])
+s[1:2] = [5]
+assrt.deepEqual(s, [8,5,2,3,4])
+s[-2:] = [1,2]
+assrt.deepEqual(s, [8,5,2,1,2])
+
+# extended slices
+b = list(range(11))
+s = 'abcde'
+assrt.deepEqual(b[::2], [0, 2, 4, 6, 8, 10])
+assrt.deepEqual(b[::-1], list(range(10,-1,-1)))
+assrt.deepEqual(b[7:0:-1], [7, 6, 5, 4, 3, 2, 1])
+assrt.deepEqual(b[7:1:-2], [7, 5, 3])
+assrt.equal(s[::2], 'ace')
+assrt.equal(s[::-1], 'edcba')
+assrt.equal(s[4:0:-1], 'edcb')
+assrt.equal(s[4:1:-2], 'ec')
+
+# sorting
+a = [2,1,3]
+a.pysort(key=def(x):return 0;)
+assrt.deepEqual(a, [2,1,3])  # stable sort
+a.pysort(reverse=True)
+assrt.deepEqual(a, [3,2,1])
+a.pysort()
+assrt.deepEqual(a, [1,2,3])
+
+# misc interface
+a = [1,2,3]
+assrt.equal(a.pypop(), 3)
+assrt.deepEqual(a, [1,2])
+assrt.equal(a.pypop(0), 1)
+assrt.deepEqual(a, [2])
+
+# strings
+assrt.ok("tes" in "this is a test")
+
+one = "one"
+two = "two"
+one, two = two, one
+[x, y, z] = 'x', 'y', 'z'
+assrt.equal(one, "two")
+assrt.equal(two, "one")
+assrt.equal(x, 'x')
+assrt.equal(y, 'y')
+assrt.equal(z, 'z')
+
+
+# DICTIONARIES
+d0 = {'a':'b','c':2, 'd':		'd',}
+d1 = {
+	'foo': 1,
+	"bar": "baz",
+	"fun1": def():
+		return 5
+	,
+	'fun2': def(c):
+		return c+1
+}
+d2 = dict([[1,2], [2,3]], a='b')
+
+# access
+assrt.ok('foo' in d1)
+assrt.equal(d0.a, d0['a'])
+assrt.equal(d1['fun1'](), 5)
+assrt.equal(d1.fun2(3), 4)
+assrt.equal(len(d0), 3)
+assrt.equal(d2.get(1), 2)
+assrt.equal(d2.get('a'), 'b')
+assrt.deepEqual(d2.popitem(), ['a', 'b'])
+
+# assignment
+d1["bar"] += "!"
+assrt.equal(d1.bar, "baz!")
+
+# nested comparisons
+x = 3
+assrt.ok(1 < x <= 3)
+assrt.ok(1 < x*x > 3)
+assrt.ok(1 < (x+=1) < 5) # check that only one increment occurs
+assrt.equal(x, 4)
+
+# list comprehensions
+e0 = [i*i for i in [0,1,2,3]]
+e1 = [x+y for x, y in enumerate(range(5,0,-1))]
+e2 = [e0+1 for e0 in range(6) if e0%3]
+assrt.deepEqual(e0, [0,1,4,9])
+assrt.deepEqual(e1, [5,5,5,5,5])
+assrt.deepEqual(e2, [2,3,5,6])
+hash = {
+    "foo": 1,
+    "bar": 1,
+    "baz": 1,
+}
+assrt.deepEqual(Object.keys(hash), [k for k in hash])
+
+a = {1:2}
+b = {2:1}
+assrt.ok(a != b)
+b = a
+assrt.ok(a == b)
+b = {1:2}
+assrt.ok(a == b)
+assrt.ok(v'{1:2}' == v'{1:2}')
+
+# iterating over TypedArrays
+assrt.deepEqual(list(Uint8Array(2)), [0, 0])
+assrt.deepEqual(list(Int32Array([1,-1])), [1,-1])

package/test/decorators.pyj

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