rapydscript-ns 0.8.0

package/src/baselib-builtins.pyj

@@ -0,0 +1,279 @@
+# vim:fileencoding=utf-8
+# License: BSD
+# Copyright: 2015, Kovid Goyal <kovid at kovidgoyal.net>
+
+# globals: exports, console, ρσ_iterator_symbol, ρσ_kwargs_symbol, ρσ_arraylike, ρσ_list_contains
+
+def ρσ_bool(val):
+    return v'!!val'
+
+def ρσ_print(*args, **kwargs):
+    if v'typeof console' is 'object':
+        sep = kwargs.sep if kwargs.sep is not undefined else ' '
+        parts = [ρσ_str(a) for a in args]
+        console.log(parts.join(sep))
+
+def ρσ_int(val, base):
+    if jstype(val) is "number":
+        ans = val | 0
+    else:
+        ans = parseInt(val, base or 10)
+    if isNaN(ans):
+        raise ValueError('Invalid literal for int with base ' + (base or 10) + ': ' + val)
+    return ans
+
+def ρσ_float(val):
+    if jstype(val) is "number":
+        ans = val
+    else:
+        ans = parseFloat(val)
+    if isNaN(ans):
+        raise ValueError('Could not convert string to float: ' + arguments[0])
+    return ans
+
+def ρσ_arraylike_creator():
+    names = 'Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array'.split(' ')
+    if jstype(HTMLCollection) is 'function':
+        names = names.concat('HTMLCollection NodeList NamedNodeMap TouchList'.split(' '))
+    return def(x):
+        if Array.isArray(x) or v'typeof x' is 'string' or names.indexOf(Object.prototype.toString.call(x).slice(8, -1)) > -1:
+            return True
+        return False
+
+def options_object(f):
+    return def():
+        if v'typeof arguments[arguments.length - 1] === "object"':
+            arguments[arguments.length - 1][ρσ_kwargs_symbol] = True
+        return f.apply(this, arguments)
+
+def ρσ_id(x):
+    return x.ρσ_object_id
+
+def ρσ_dir(item):
+    # TODO: this isn't really representative of real Python's dir(), nor is it
+    # an intuitive replacement for "for ... in" loop, need to update this logic
+    # and introduce a different way of achieving "for ... in"
+    arr = []
+    for v'var i in item': arr.push(i)  # noqa:undef
+    return arr
+
+def ρσ_ord(x):
+    ans = x.charCodeAt(0)
+    if 0xD800 <= ans <= 0xDBFF:
+        second = x.charCodeAt(1)
+        if 0xDC00 <= second <= 0xDFFF:
+            return (ans - 0xD800) * 0x400 + second - 0xDC00 + 0x10000
+        raise TypeError('string is missing the low surrogate char')
+    return ans
+
+def ρσ_chr(code):
+    if code <= 0xFFFF:
+        return String.fromCharCode(code)
+    code -= 0x10000
+    return String.fromCharCode(0xD800+(code>>10), 0xDC00+(code&0x3FF))
+
+def ρσ_callable(x):
+    return v'typeof x === "function"'
+
+def ρσ_bin(x):
+    if jstype(x) is not 'number' or x % 1 is not 0:
+        raise TypeError('integer required')
+    ans = x.toString(2)
+    if ans[0] is '-':
+        ans = '-' + '0b' + ans[1:]
+    else:
+        ans = '0b' + ans
+    return ans
+
+def ρσ_hex(x):
+    if jstype(x) is not 'number' or x % 1 is not 0:
+        raise TypeError('integer required')
+    ans = x.toString(16)
+    if ans[0] is '-':
+        ans = '-' + '0x' + ans[1:]
+    else:
+        ans = '0x' + ans
+    return ans
+
+def ρσ_enumerate(iterable):
+    ans = v'{"_i":-1}'
+    ans[ρσ_iterator_symbol] = def():
+        return this
+    if ρσ_arraylike(iterable):
+        ans['next'] = def():
+                this._i += 1
+                if this._i < iterable.length:
+                    return v"{'done':false, 'value':[this._i, iterable[this._i]]}"
+                return v"{'done':true}"
+        return ans
+    if jstype(iterable[ρσ_iterator_symbol]) is 'function':
+        iterator = iterable.keys() if jstype(Map) is 'function' and v'iterable instanceof Map' else iterable[ρσ_iterator_symbol]()
+        ans['_iterator'] = iterator
+        ans['next'] = def():
+            r = this._iterator.next()
+            if r.done:
+                return v"{'done':true}"
+            this._i += 1
+            return v"{'done':false, 'value':[this._i, r.value]}"
+        return ans
+    return ρσ_enumerate(Object.keys(iterable))
+
+def ρσ_reversed(iterable):
+    if ρσ_arraylike(iterable):
+        ans = v'{"_i": iterable.length}'
+        ans['next'] = def():
+            this._i -= 1
+            if this._i > -1:
+                return v"{'done':false, 'value':iterable[this._i]}"
+            return v"{'done':true}"
+        ans[ρσ_iterator_symbol] = def():
+            return this
+        return ans
+    raise TypeError('reversed() can only be called on arrays or strings')
+
+def ρσ_iter(iterable):
+    # Generate a JavaScript iterator object from iterable
+    if jstype(iterable[ρσ_iterator_symbol]) is 'function':
+        return iterable.keys() if jstype(Map) is 'function' and v'iterable instanceof Map' else iterable[ρσ_iterator_symbol]()
+    if ρσ_arraylike(iterable):
+        ans = v'{"_i":-1}'
+        ans[ρσ_iterator_symbol] = def():
+            return this
+        ans['next'] = def():
+            this._i += 1
+            if this._i < iterable.length:
+                return v"{'done':false, 'value':iterable[this._i]}"
+            return v"{'done':true}"
+        return ans
+    return ρσ_iter(Object.keys(iterable))
+
+def ρσ_range_next(step, length):
+    this._i += step
+    this._idx += 1
+    if this._idx >= length:
+        this._i, this._idx = this.__i, -1
+        return v"{'done':true}"
+    return v"{'done':false, 'value':this._i}"
+
+def ρσ_range(start, stop, step):
+    if arguments.length <= 1:
+        stop = start or 0
+        start = 0
+    step = arguments[2] or 1
+    length = Math.max(Math.ceil((stop - start) / step), 0)
+    ans = v'{start:start, step:step, stop:stop}'
+    ans[ρσ_iterator_symbol] = def():
+        it = v'{"_i": start - step, "_idx": -1}'
+        it.next = ρσ_range_next.bind(it, step, length)
+        it[ρσ_iterator_symbol] = def():
+            return this
+        return it
+    ans.count = def(val):
+        if not this._cached:
+            this._cached = list(this)
+        return this._cached.count(val)
+    ans.index = def(val):
+        if not this._cached:
+            this._cached = list(this)
+        return this._cached.index(val)
+    ans.__len__ = def():
+        return length
+    ans.__repr__ = def():
+        return f'range({start}, {stop}, {step})'
+    ans.__str__ = ans.toString = ans.__repr__
+    if jstype(Proxy) is 'function':
+        ans = new Proxy(ans, {
+            'get': def(obj, prop):
+                if jstype(prop) is 'string':
+                    iprop = parseInt(prop)
+                    if not isNaN(iprop):
+                        prop = iprop
+                if jstype(prop) is 'number':
+                    if not obj._cached:
+                        obj._cached = list(obj)
+                    return obj._cached[prop]
+                return obj[prop]
+        })
+    return ans
+
+def ρσ_getattr(obj, name, defval):
+    try:
+        ret = obj[name]
+    except TypeError:
+        if defval is undefined:
+            raise AttributeError('The attribute ' + name + ' is not present')
+        return defval
+    if ret is undefined and not v'(name in obj)':
+        if defval is undefined:
+            raise AttributeError('The attribute ' + name + ' is not present')
+        ret = defval
+    return ret
+
+def ρσ_setattr(obj, name, value):
+    obj[name] = value
+
+def ρσ_hasattr(obj, name):
+    return v'name in obj'
+
+ρσ_len = (def ():
+
+    def len(obj):
+        if ρσ_arraylike(obj): return obj.length
+        if jstype(obj.__len__) is 'function': return obj.__len__()
+        if v'obj instanceof Set' or v'obj instanceof Map': return obj.size
+        return Object.keys(obj).length
+
+    def len5(obj):
+        if ρσ_arraylike(obj): return obj.length
+        if jstype(obj.__len__) is 'function': return obj.__len__()
+        return Object.keys(obj).length
+
+    return len if v'typeof Set' is 'function' and v'typeof Map' is 'function' else len5
+)()
+
+def ρσ_get_module(name):
+    return ρσ_modules[name]
+
+def ρσ_pow(x, y, z):
+    ans = Math.pow(x, y)
+    if z is not undefined:
+        ans %= z
+    return ans
+
+def ρσ_type(x):
+    return x.constructor
+
+
+def ρσ_divmod(x, y):
+    if y is 0:
+        raise ZeroDivisionError('integer division or modulo by zero')
+    d = Math.floor(x / y)
+    return d, x - d * y
+
+
+def ρσ_max(*args, **kwargs):
+    if args.length is 0:
+        if kwargs.defval is not undefined:
+            return kwargs.defval
+        raise TypeError('expected at least one argument')
+    if args.length is 1:
+        args = args[0]
+    if kwargs.key:
+        args = [kwargs.key(x) for x in args]
+    if not Array.isArray(args):
+        args = list(args)
+    if args.length:
+        return this.apply(None, args)
+    if kwargs.defval is not undefined:
+        return kwargs.defval
+    raise TypeError('expected at least one argument')
+
+
+v'var abs = Math.abs, max = ρσ_max.bind(Math.max), min = ρσ_max.bind(Math.min), bool = ρσ_bool, type = ρσ_type'
+v'var float = ρσ_float, int = ρσ_int, arraylike = ρσ_arraylike_creator(), ρσ_arraylike = arraylike'
+v'var id = ρσ_id, get_module = ρσ_get_module, pow = ρσ_pow, divmod = ρσ_divmod'
+v'var dir = ρσ_dir, ord = ρσ_ord, chr = ρσ_chr, bin = ρσ_bin, hex = ρσ_hex, callable = ρσ_callable'
+v'var enumerate = ρσ_enumerate, iter = ρσ_iter, reversed = ρσ_reversed, len = ρσ_len'
+v'var range = ρσ_range, getattr = ρσ_getattr, setattr = ρσ_setattr, hasattr = ρσ_hasattr'
+v'var ρσ_Ellipsis = Object.freeze({toString: function(){return "Ellipsis";}, __repr__: function(){return "Ellipsis";}})'
+v'var Ellipsis = ρσ_Ellipsis'