rapydscript-ns 0.8.2 → 0.8.4

package/test/regexp.pyj

@@ -1,55 +1,55 @@
-# vim:fileencoding=utf-8
-# License: BSD
-# Copyright: 2015, Kovid Goyal <kovid at kovidgoyal.net>
-
-# Test the re module
-import re
-s = "Isaac Newton, physicist"
-c = re.search("(\\w+) (\\w+)", s)
-assrt.equal(c.group(1), 'Isaac')
-assrt.equal(c.group(2), 'Newton')
-c = re.match("(\\w+) (\\w+)", s)
-assrt.equal(c.group(1), 'Isaac')
-assrt.equal(c.start(1), 0)
-assrt.equal(c.end(1), c.group(1).length)
-assrt.equal(c.start(2), c.group(1).length + 1)
-assrt.equal(c.group(2), 'Newton')
-m = re.search('a(b)cd', 'abc abcd')
-assrt.equal(m.group(1), 'b')
-assrt.equal(m.start(1), m.string.lastIndexOf('b'))
-assrt.deepEqual(re.split('\\s', s), ['Isaac', 'Newton,', 'physicist'])
-assrt.deepEqual(re.findall('s[a-z]', s), ['sa', 'si', 'st'])
-assrt.deepEqual([m.group() for m in re.finditer('s[a-z]', s)], ['sa', 'si', 'st'])
-assrt.deepEqual(re.findall(/s[a-z]/, s), ['sa', 'si', 'st'])
-assrt.equal(re.sub('[A-Z]', '_', s), '_saac _ewton, physicist')
-assrt.equal(re.sub('[A-Z]', '_', s, count=1), '_saac Newton, physicist')
-assrt.equal(re.search('a[.]b', 'axb'), None)
-assrt.equal(re.search(r'a\.b', 'axb'), None)
-assrt.equal(re.search('a[.]b', 'axb', flags=re.D), None)
-assrt.equal(re.search('.+', 'a\nb').group(), 'a')
-assrt.equal(re.search('.+', 'a\nb', flags=re.D).group(), 'a\nb')
-assrt.equal(re.search('(?s).+', 'a\nb').group(), 'a\nb')
-assrt.equal(re.sub('a(b)', r'xx', 'ab'), r'xx')
-assrt.equal(re.sub('a(b)', r'\\1', 'ab'), r'\1')
-assrt.equal(re.sub('a(b)', r'\\\1', 'ab'), r'\b')
-assrt.equal(re.sub('a(b)', r'\g<1>', 'ab'), r'b')
-assrt.equal(re.sub('a(b)', def(m):return m.group(1);, 'ab'), r'b')
-assrt.equal(']', re.match('[]]', ']').group())
-
-assrt.throws(def():re.search(r'(?(1)a|b)b', 'ab');, re.error)
-
-# Test lookbehind assertions
-assrt.equal('acdb', re.sub(r'(?<=a)b', 'c', 'abdb'))
-
-# Test named groups
-assrt.equal('aa', re.sub(r'(?P<a>a)b', r'\g<a>\1', 'ab'))
-assrt.equal('bb', re.sub(r'(?P<a>a)(?P=a)', r'bb', 'aa'))
-assrt.equal('ab', re.sub(r'(.)(?P<a>a)', r'\g<a>\1', 'ba'))
-assrt.deepEqual({'a':'a', 'b':'b'}, re.search(r'(?P<a>a)(?P<b>b)', 'ab').groupdict())
-
-# Test verbose mode literals
-assrt.equal(re.search(///
-    a
-    .  # anything
-    b
-    ///, ' axb').group(), 'axb')
+# vim:fileencoding=utf-8
+# License: BSD
+# Copyright: 2015, Kovid Goyal <kovid at kovidgoyal.net>
+
+# Test the re module
+import re
+s = "Isaac Newton, physicist"
+c = re.search("(\\w+) (\\w+)", s)
+assrt.equal(c.group(1), 'Isaac')
+assrt.equal(c.group(2), 'Newton')
+c = re.match("(\\w+) (\\w+)", s)
+assrt.equal(c.group(1), 'Isaac')
+assrt.equal(c.start(1), 0)
+assrt.equal(c.end(1), c.group(1).length)
+assrt.equal(c.start(2), c.group(1).length + 1)
+assrt.equal(c.group(2), 'Newton')
+m = re.search('a(b)cd', 'abc abcd')
+assrt.equal(m.group(1), 'b')
+assrt.equal(m.start(1), m.string.lastIndexOf('b'))
+assrt.deepEqual(re.split('\\s', s), ['Isaac', 'Newton,', 'physicist'])
+assrt.deepEqual(re.findall('s[a-z]', s), ['sa', 'si', 'st'])
+assrt.deepEqual([m.group() for m in re.finditer('s[a-z]', s)], ['sa', 'si', 'st'])
+assrt.deepEqual(re.findall(/s[a-z]/, s), ['sa', 'si', 'st'])
+assrt.equal(re.sub('[A-Z]', '_', s), '_saac _ewton, physicist')
+assrt.equal(re.sub('[A-Z]', '_', s, count=1), '_saac Newton, physicist')
+assrt.equal(re.search('a[.]b', 'axb'), None)
+assrt.equal(re.search(r'a\.b', 'axb'), None)
+assrt.equal(re.search('a[.]b', 'axb', flags=re.D), None)
+assrt.equal(re.search('.+', 'a\nb').group(), 'a')
+assrt.equal(re.search('.+', 'a\nb', flags=re.D).group(), 'a\nb')
+assrt.equal(re.search('(?s).+', 'a\nb').group(), 'a\nb')
+assrt.equal(re.sub('a(b)', r'xx', 'ab'), r'xx')
+assrt.equal(re.sub('a(b)', r'\\1', 'ab'), r'\1')
+assrt.equal(re.sub('a(b)', r'\\\1', 'ab'), r'\b')
+assrt.equal(re.sub('a(b)', r'\g<1>', 'ab'), r'b')
+assrt.equal(re.sub('a(b)', def(m):return m.group(1);, 'ab'), r'b')
+assrt.equal(']', re.match('[]]', ']').group())
+
+assrt.throws(def():re.search(r'(?(1)a|b)b', 'ab');, re.error)
+
+# Test lookbehind assertions
+assrt.equal('acdb', re.sub(r'(?<=a)b', 'c', 'abdb'))
+
+# Test named groups
+assrt.equal('aa', re.sub(r'(?P<a>a)b', r'\g<a>\1', 'ab'))
+assrt.equal('bb', re.sub(r'(?P<a>a)(?P=a)', r'bb', 'aa'))
+assrt.equal('ab', re.sub(r'(.)(?P<a>a)', r'\g<a>\1', 'ba'))
+assrt.deepEqual({'a':'a', 'b':'b'}, re.search(r'(?P<a>a)(?P<b>b)', 'ab').groupdict())
+
+# Test verbose mode literals
+assrt.equal(re.search(///
+    a
+    .  # anything
+    b
+    ///, ' axb').group(), 'axb')

package/test/repl.pyj

@@ -1,121 +1,121 @@
-# globals: compiler_dir
-stdout = []
-def clear():
-    stdout.length = 0
-
-class FakeConsole:
-
-    def log(self):
-        Array.prototype.slice.call(arguments).forEach(def (arg):
-            stdout.push((arg or '').toString())
-        )
-        stdout.push('\n')
-
-    def error(self):
-        Array.prototype.slice.call(arguments).forEach(def (arg):
-            stdout.push((arg or '').toString())
-        )
-        stdout.push('\n')
-
-class FakeReadline:
-
-    def __init__(self):
-        self.listeners = {}
-        self._prompt = ''
-
-    def setPrompt(self, prompt):
-        self._prompt = prompt
-
-    def write(self, data):
-        stdout.push(data)
-
-    def clearLine(self):
-        pass
-
-    def on(self, event, callback):
-        self.listeners[event] = callback
-        return self
-
-    def prompt(self):
-        stdout.push(self._prompt)
-
-    def send_line(self, text):
-        self.listeners['line'](text)
-
-repl = require('./repl')
-rl = FakeReadline()
-
-send_line = rl.send_line.bind(rl)
-
-def send_text(text):
-    for line in text.split('\n'):
-        send_line(line)
-
-def check(text, output):
-    send_text(text)
-    eq(output, stdout[0])
-    clear()
-
-def check_in(text, output):
-    send_text(text)
-    assrt.ok(output in stdout, output + ' not in ' + stdout)
-    clear()
-
-def check_not_in(text, output):
-    send_text(text)
-    assrt.ok(output not in stdout)
-    clear()
-
-readline = {
-    'createInterface': def(options):
-        rl.completer = options.completer
-        return rl
-}
-repl({'lib_path':compiler_dir, 'console':FakeConsole(), 'readline':readline, 'terminal':False, 'show_js':False, 'histfile':False})
-eq = assrt.equal
-eq('>>> ', stdout[-1])
-clear()
-check('1', '1')
-check_in('if 1:\n  2\n  \n  ', '2')
-check_not_in('if 1:\n  2\n ', '2')
-check_in('1 +\n1\n\n', '2')
-check('max(1, 2)', '2')
-send_text(
-'''
-class A:
-
-    def __init__(self, a):
-        self. a = a
-
-
-''')
-clear()
-check_in('b = A(1)\nb.a', '1')
-check_in('c = A(2)\nc.a', '2')
-send_text('from __python__ import dict_literals\nd={1:1}')
-check_in('isinstance(d, dict)', 'true')
-send_text('from __python__ import no_dict_literals\nd={1:1}')
-check_in('isinstance(d, dict)', 'false')
-# Test completions
-def completions(line):
-    return rl.completer(line)[0]
-
-def check_completions():
-    items = completions(arguments[0])
-    for x in Array.prototype.slice.call(arguments, 1):
-        assrt.ok(items and x in items, x + ' not in completions for: ' + arguments[0])
-
-check_completions('', 'return', 'A')
-check_completions('Array.', 'isArray', 'apply')
-send_text('x = ""\ny = []'), clear()
-check_completions('x.', 'substr', 'trim')
-check_completions('y.', 'concat', 'push')
-check_completions('x.sl', 'slice')
-send_text('y = {"x":1}'), clear()
-check_completions('y.', 'x')
-
-# Test docstrings
-clear()
-send_text('def ds():\n "xxx"\n\n')
-clear()
-check('ds.__doc__', "'xxx'")
+# globals: compiler_dir
+stdout = []
+def clear():
+    stdout.length = 0
+
+class FakeConsole:
+
+    def log(self):
+        Array.prototype.slice.call(arguments).forEach(def (arg):
+            stdout.push((arg or '').toString())
+        )
+        stdout.push('\n')
+
+    def error(self):
+        Array.prototype.slice.call(arguments).forEach(def (arg):
+            stdout.push((arg or '').toString())
+        )
+        stdout.push('\n')
+
+class FakeReadline:
+
+    def __init__(self):
+        self.listeners = {}
+        self._prompt = ''
+
+    def setPrompt(self, prompt):
+        self._prompt = prompt
+
+    def write(self, data):
+        stdout.push(data)
+
+    def clearLine(self):
+        pass
+
+    def on(self, event, callback):
+        self.listeners[event] = callback
+        return self
+
+    def prompt(self):
+        stdout.push(self._prompt)
+
+    def send_line(self, text):
+        self.listeners['line'](text)
+
+repl = require('./repl')
+rl = FakeReadline()
+
+send_line = rl.send_line.bind(rl)
+
+def send_text(text):
+    for line in text.split('\n'):
+        send_line(line)
+
+def check(text, output):
+    send_text(text)
+    eq(output, stdout[0])
+    clear()
+
+def check_in(text, output):
+    send_text(text)
+    assrt.ok(output in stdout, output + ' not in ' + stdout)
+    clear()
+
+def check_not_in(text, output):
+    send_text(text)
+    assrt.ok(output not in stdout)
+    clear()
+
+readline = {
+    'createInterface': def(options):
+        rl.completer = options.completer
+        return rl
+}
+repl({'lib_path':compiler_dir, 'console':FakeConsole(), 'readline':readline, 'terminal':False, 'show_js':False, 'histfile':False})
+eq = assrt.equal
+eq('>>> ', stdout[-1])
+clear()
+check('1', '1')
+check_in('if 1:\n  2\n  \n  ', '2')
+check_not_in('if 1:\n  2\n ', '2')
+check_in('1 +\n1\n\n', '2')
+check('max(1, 2)', '2')
+send_text(
+'''
+class A:
+
+    def __init__(self, a):
+        self. a = a
+
+
+''')
+clear()
+check_in('b = A(1)\nb.a', '1')
+check_in('c = A(2)\nc.a', '2')
+send_text('from __python__ import dict_literals\nd={1:1}')
+check_in('isinstance(d, dict)', 'true')
+send_text('from __python__ import no_dict_literals\nd={1:1}')
+check_in('isinstance(d, dict)', 'false')
+# Test completions
+def completions(line):
+    return rl.completer(line)[0]
+
+def check_completions():
+    items = completions(arguments[0])
+    for x in Array.prototype.slice.call(arguments, 1):
+        assrt.ok(items and x in items, x + ' not in completions for: ' + arguments[0])
+
+check_completions('', 'return', 'A')
+check_completions('Array.', 'isArray', 'apply')
+send_text('x = ""\ny = []'), clear()
+check_completions('x.', 'substr', 'trim')
+check_completions('y.', 'concat', 'push')
+check_completions('x.sl', 'slice')
+send_text('y = {"x":1}'), clear()
+check_completions('y.', 'x')
+
+# Test docstrings
+clear()
+send_text('def ds():\n "xxx"\n\n')
+clear()
+check('ds.__doc__', "'xxx'")

package/test/scoped_flags.pyj

@@ -1,76 +1,76 @@
-# vim:fileencoding=utf-8
-# License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
-
-a = {1:1}
-assrt.ok(not isinstance(a, dict))
-
-from __python__ import dict_literals, overload_getitem
-a = {1:1}
-assrt.ok(isinstance(a, dict))
-assrt.equal(a[1], 1)
-a[2] = 2
-assrt.equal(a[2], 2)
-a[2] += 4
-assrt.equal(a[2], 6)
-assrt.deepEqual(list(a.keys()), [1, 2])
-from __python__ import no_dict_literals, no_overload_getitem
-
-
-a = {1:1}
-assrt.ok(not isinstance(a, dict))
-
-def f():
-    from __python__ import dict_literals
-    a = {1:1}
-    assrt.ok(isinstance(a, dict))
-
-a = {1:1}
-assrt.ok(not isinstance(a, dict))
-
-class S:
-    from __python__ import bound_methods
-
-    def __init__(self):
-        self.a = 3
-
-    def val(self):
-        return self.a if self else None
-
-f = S().val
-assrt.equal(f(), S().val())
-
-class U:
-
-    def __init__(self):
-        self.a = 3
-
-    def val(self):
-        return self.a if self else None
-
-f = U().val
-assrt.equal(f(), None)
-
-class C:
-
-    def __init__(self):
-        self.a = 3
-
-    def uval1(self):
-        return self.a if self else None
-
-    from __python__ import bound_methods
-
-    def bval(self):
-        return self.a
-
-    from __python__ import no_bound_methods
-
-    def uval2(self):
-        return self.a if self else None
-
-c = C()
-u1, u2 = c.uval1, c.uval2
-f = c.bval
-assrt.equal(u1(), None)
-assrt.equal(u2(), None)
-assrt.equal(f(), 3)
+# vim:fileencoding=utf-8
+# License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
+
+a = {1:1}
+assrt.ok(not isinstance(a, dict))
+
+from __python__ import dict_literals, overload_getitem
+a = {1:1}
+assrt.ok(isinstance(a, dict))
+assrt.equal(a[1], 1)
+a[2] = 2
+assrt.equal(a[2], 2)
+a[2] += 4
+assrt.equal(a[2], 6)
+assrt.deepEqual(list(a.keys()), [1, 2])
+from __python__ import no_dict_literals, no_overload_getitem
+
+
+a = {1:1}
+assrt.ok(not isinstance(a, dict))
+
+def f():
+    from __python__ import dict_literals
+    a = {1:1}
+    assrt.ok(isinstance(a, dict))
+
+a = {1:1}
+assrt.ok(not isinstance(a, dict))
+
+class S:
+    from __python__ import bound_methods
+
+    def __init__(self):
+        self.a = 3
+
+    def val(self):
+        return self.a if self else None
+
+f = S().val
+assrt.equal(f(), S().val())
+
+class U:
+
+    def __init__(self):
+        self.a = 3
+
+    def val(self):
+        return self.a if self else None
+
+f = U().val
+assrt.equal(f(), None)
+
+class C:
+
+    def __init__(self):
+        self.a = 3
+
+    def uval1(self):
+        return self.a if self else None
+
+    from __python__ import bound_methods
+
+    def bval(self):
+        return self.a
+
+    from __python__ import no_bound_methods
+
+    def uval2(self):
+        return self.a if self else None
+
+c = C()
+u1, u2 = c.uval1, c.uval2
+f = c.bval
+assrt.equal(u1(), None)
+assrt.equal(u2(), None)
+assrt.equal(f(), 3)

package/test/slice.pyj

@@ -0,0 +1,105 @@
+# globals: assrt
+# vim:fileencoding=utf-8
+#
+# slice.pyj — tests for the slice() builtin class.
+# Subscript read/write via a slice object (lst[s], lst[s]=val) requires
+# overload_getitem so that the compiler routes [] through ρσ_getitem.
+
+from __python__ import overload_getitem
+
+ae  = assrt.equal
+ade = assrt.deepEqual
+ok  = assrt.ok
+
+# ── Construction forms ────────────────────────────────────────────────────────
+
+s1 = slice(5)
+ae(s1.start, None)
+ae(s1.stop,  5)
+ae(s1.step,  None)
+
+s2 = slice(2, 8)
+ae(s2.start, 2)
+ae(s2.stop,  8)
+ae(s2.step,  None)
+
+s3 = slice(1, 9, 2)
+ae(s3.start, 1)
+ae(s3.stop,  9)
+ae(s3.step,  2)
+
+# None values preserved
+sn = slice(None, None, -1)
+ae(sn.start, None)
+ae(sn.stop,  None)
+ae(sn.step,  -1)
+
+# ── indices() ─────────────────────────────────────────────────────────────────
+
+ade(s2.indices(10), [2, 8, 1])
+ade(slice(None, None, 1).indices(5), [0, 5, 1])
+ade(slice(-3, -1).indices(10), [7, 9, 1])
+ade(slice(None, None, -1).indices(5), [4, -1, -1])
+ade(slice(0, 100).indices(10), [0, 10, 1])   # stop clamped to length
+ade(slice(-100, 5).indices(10), [0, 5, 1])   # start clamped to 0
+
+# ── repr / str ────────────────────────────────────────────────────────────────
+
+ae(str(slice(1, 5, None)), 'slice(1, 5, None)')
+ae(str(slice(None, 5, 2)), 'slice(None, 5, 2)')
+ae(str(slice(None, None, None)), 'slice(None, None, None)')
+
+# ── Equality ──────────────────────────────────────────────────────────────────
+
+ok(slice(1, 5) == slice(1, 5))
+ok(not (slice(1, 5) == slice(1, 6)))
+ok(not (slice(1, 5) == slice(0, 5)))
+ok(slice(1, 5, 2) == slice(1, 5, 2))
+ok(not (slice(1, 5, 2) == slice(1, 5, 3)))
+
+# ── isinstance ────────────────────────────────────────────────────────────────
+
+ok(isinstance(slice(1, 5), slice))
+ok(not isinstance(42, slice))
+ok(not isinstance([1, 2, 3], slice))
+
+# ── List subscript read ───────────────────────────────────────────────────────
+
+lst = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+ade(lst[slice(2, 5)],    [2, 3, 4])
+ade(lst[slice(0, 6, 2)], [0, 2, 4])
+ade(lst[slice(None, 4)], [0, 1, 2, 3])
+ade(lst[slice(None)],    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+
+# Negative step
+ade(lst[slice(5, 1, -1)],        [5, 4, 3, 2])
+ade(lst[slice(None, None, -1)],  [9, 8, 7, 6, 5, 4, 3, 2, 1, 0])
+ade(lst[slice(9, 0, -2)],        [9, 7, 5, 3, 1])
+
+# ── String subscript read ─────────────────────────────────────────────────────
+
+s = 'hello'
+ae(s[slice(1, 4)],        'ell')
+ae(s[slice(None, None, -1)], 'olleh')
+ae(s[slice(0, 5, 2)],     'hlo')
+
+# ── List subscript write ──────────────────────────────────────────────────────
+
+a = [0, 1, 2, 3, 4]
+a[slice(1, 3)] = [10, 20]
+ade(a, [0, 10, 20, 3, 4])
+
+b = [0, 1, 2, 3, 4]
+b[slice(0, 2)] = [99]
+ade(b, [99, 2, 3, 4])
+
+# ── List subscript delete ─────────────────────────────────────────────────────
+
+c = [0, 1, 2, 3, 4]
+del c[slice(1, 3)]
+ade(c, [0, 3, 4])
+
+d = [0, 1, 2, 3, 4]
+del d[slice(0, 1)]
+ade(d, [1, 2, 3, 4])

package/test/str.pyj

@@ -98,6 +98,31 @@ test_throws(IndexError, '{1} {2}', 1)
 test_throws(ValueError, '{1')
 test_interpolation()
 
+# Test format() builtin
+ae('3.14', format(3.14159, '.2f'))
+ae('  42', format(42, '>4d'))
+ae('42  ', format(42, '<4d'))
+ae(' 42 ', format(42, '^4d'))
+ae('0042', format(42, '04d'))
+ae('2a', format(42, 'x'))
+ae('0b101010', format(42, '#b'))
+ae('hello', format('hello'))
+ae('42', format(42))
+ae('None', format(None))
+ae('hello     ', format('hello', '<10'))
+ae('     hello', format('hello', '>10'))
+ae('  hello   ', format('hello', '^10'))
+ae('1.23e+2', format(123.456, '.2e').toLowerCase())
+ae('hello', format('hello world', '.5'))
+
+class FormattableNum:
+    def __init__(self, n):
+        self.n = n
+    def __format__(self, spec):
+        return 'FN:' + format(self.n, spec)
+
+ae('FN:042', format(FormattableNum(42), '03d'))
+
 # Test miscellaneous services
 ae('Abc', str.capitalize('aBC'))
 ae(' 1 ', str.center('1', 3))

package/test/unit/fixtures/fibonacci_expected.js

@@ -30,7 +30,7 @@ var fib = memoize((function() {
         } else if ((n === 1 || typeof n === "object" && ρσ_equals(n, 1))) {
             return 1;
         } else {
-            return fib(n - 1) + fib(n - 2);
+            return ρσ_list_add(fib(n - 1), fib(n - 2));
         }
     };
     if (!ρσ_anonfunc.__argnames__) Object.defineProperties(ρσ_anonfunc, {