rapydscript-ns 0.8.2 → 0.8.4

package/src/baselib-internal.pyj

@@ -1,7 +1,7 @@
 # vim:fileencoding=utf-8
 # License: BSD
 
-# globals: exports, console, ρσ_iterator_symbol, ρσ_kwargs_symbol, ρσ_arraylike, ρσ_list_contains, ρσ_list_constructor, ρσ_str, ρσ_int, ρσ_float
+# globals: exports, console, ρσ_iterator_symbol, ρσ_kwargs_symbol, ρσ_arraylike, ρσ_list_contains, ρσ_list_constructor, ρσ_str, ρσ_int, ρσ_float, ρσ_slice
 
 def ρσ_eslice(arr, step, start, end):
     if jstype(arr) is 'string' or v'arr instanceof String':
@@ -87,6 +87,14 @@ def ρσ_extends(child, parent):
     child.prototype.constructor = child
     Object.setPrototypeOf(child, parent)
 
+def ρσ_object_new(cls):
+    return v'Object.create(cls.prototype)'
+
+def ρσ_new(parent, cls):
+    if parent and jstype(parent.__new__) is 'function':
+        return parent.__new__.apply(parent, v'Array.prototype.slice.call(arguments, 1)')
+    return v'Object.create(cls.prototype)'
+
 ρσ_in = (def ():
     if jstype(Map) is 'function' and jstype(Set) is 'function':
         return def(val, arr):
@@ -131,15 +139,23 @@ def ρσ_Iterable(iterable):
             ans = Object.create(None)
             ans[ρσ_kwargs_symbol] = True
             for v'var i = 0; i < arguments.length; i++':
-                Object.assign(ans, arguments[i])
+                arg = arguments[i]
+                if v'arg && arg.jsmap && typeof arg.jsmap.forEach === "function"':
+                    v'arg.jsmap.forEach(function(v, k) { ans[k] = v; })'
+                else:
+                    Object.assign(ans, arg)
             return ans
     return def():
         ans = Object.create(None)
         ans[ρσ_kwargs_symbol] = True
         for v'var i = 0; i < arguments.length; i++':
-            keys = Object.keys(arguments[i])
-            for v'var j = 0; j < keys.length; j++':
-                ans[keys[j]] = arguments[i][keys[j]]
+            arg = arguments[i]
+            if v'arg && arg.jsmap && typeof arg.jsmap.forEach === "function"':
+                v'arg.jsmap.forEach(function(v, k) { ans[k] = v; })'
+            else:
+                keys = Object.keys(arg)
+                for v'var j = 0; j < keys.length; j++':
+                    ans[keys[j]] = arg[keys[j]]
         return ans
 )()
 
@@ -177,8 +193,15 @@ def ρσ_interpolate_kwargs_constructor(apply, f, supplied_args):
     return this
 
 def ρσ_getitem(obj, key):
+    if v'typeof obj === "function"' and obj.__class_getitem__:
+        return obj.__class_getitem__(key)
     if obj.__getitem__:
         return obj.__getitem__(key)
+    if v'typeof ρσ_slice !== "undefined" && key instanceof ρσ_slice':
+        return ρσ_eslice(obj,
+            v'(key.step  !== null && key.step  !== undefined) ? key.step  : 1',
+            v'(key.start !== null && key.start !== undefined) ? key.start : undefined',
+            v'(key.stop  !== null && key.stop  !== undefined) ? key.stop  : undefined')
     if jstype(key) is 'number' and key < 0:
         key += obj.length
     return obj[key]
@@ -186,6 +209,10 @@ def ρσ_getitem(obj, key):
 def ρσ_setitem(obj, key, val):
     if obj.__setitem__:
         obj.__setitem__(key, val)
+    elif v'typeof ρσ_slice !== "undefined" && key instanceof ρσ_slice':
+        ρσ_splice(obj, val,
+            v'(key.start !== null && key.start !== undefined) ? key.start : 0',
+            v'(key.stop  !== null && key.stop  !== undefined) ? key.stop  : obj.length')
     else:
         if jstype(key) is 'number' and key < 0:
             key += obj.length
@@ -195,6 +222,11 @@ def ρσ_setitem(obj, key, val):
 def ρσ_delitem(obj, key):
     if obj.__delitem__:
         obj.__delitem__(key)
+    elif v'typeof ρσ_slice !== "undefined" && key instanceof ρσ_slice':
+        ρσ_delslice(obj,
+            v'(key.step  !== null && key.step  !== undefined) ? key.step  : 1',
+            v'(key.start !== null && key.start !== undefined) ? key.start : undefined',
+            v'(key.stop  !== null && key.stop  !== undefined) ? key.stop  : undefined')
     elif jstype(obj.splice) is 'function':
         obj.splice(key, 1)
     else:
@@ -339,6 +371,21 @@ def ρσ_op_rshift(a, b):
     if b is not None and jstype(b.__rrshift__) is 'function': return b.__rrshift__(a)
     return a >> b
 
+# List-concatenation helpers (always available, no overload_operators required).
+# ρσ_list_add: used for the + operator; creates a new list when both sides are arrays.
+# NOTE: the fallback uses v'a + b' (verbatim JS) to avoid recursive self-compilation.
+def ρσ_list_add(a, b):
+    if Array.isArray(a) and Array.isArray(b):
+        return ρσ_list_constructor(a.concat(b))
+    return v'a + b'
+
+# ρσ_list_iadd: used for +=; extends a in-place when both sides are arrays (Python semantics).
+def ρσ_list_iadd(a, b):
+    if Array.isArray(a) and Array.isArray(b):
+        v'Array.prototype.push.apply(a, b)'
+        return a
+    return v'a + b'
+
 # Unary operator overloading helpers
 def ρσ_op_neg(a):
     if a is not None and jstype(a.__neg__) is 'function': return a.__neg__()
@@ -429,3 +476,75 @@ def ρσ_instanceof():
                         break
                     cls = p.constructor
     return False
+
+# ── Attribute-dunder support (__getattr__ / __setattr__ / __delattr__ / __getattribute__) ──
+# We use a JavaScript Proxy to intercept attribute access/assignment/deletion on class instances
+# that define any of the four attribute dunders.
+
+# Cache the JS Proxy constructor with a ρσ_ name to avoid collisions with user-defined 'Proxy' classes.
+ρσ_JS_Proxy = v'typeof Proxy === "function" ? Proxy : null'
+
+# Symbol (or fallback string key) used to retrieve the raw underlying target from a wrapped proxy.
+ρσ_proxy_target_symbol = v'typeof Symbol === "function" ? Symbol("ρσ_proxy_target") : "__ρσ_proxy_target__"'
+
+ρσ_attr_proxy_handler = {
+    'get': def(target, prop, receiver):
+        # Always expose the raw target via the sentinel key (used by ρσ_object_* helpers).
+        if prop is ρσ_proxy_target_symbol:
+            return target
+        # Pass through JS symbols (Symbol.iterator, Symbol.toPrimitive, etc.) unchanged.
+        if jstype(prop) is 'symbol':
+            return v'Reflect.get(target, prop, receiver)'
+        # __getattribute__ overrides every attribute lookup (except itself, to avoid infinite recursion).
+        if jstype(target.__getattribute__) is 'function' and prop is not '__getattribute__':
+            try:
+                return target.__getattribute__.call(receiver, prop)
+            except AttributeError:
+                # AttributeError from __getattribute__ → try __getattr__ fallback.
+                if jstype(target.__getattr__) is 'function':
+                    return target.__getattr__.call(receiver, prop)
+                raise
+        # Normal property lookup via prototype chain.
+        val = v'Reflect.get(target, prop, receiver)'
+        # __getattr__ is only called when the attribute is genuinely missing.
+        if val is undefined and jstype(target.__getattr__) is 'function' and not v'(prop in target)':
+            return target.__getattr__.call(receiver, prop)
+        return val
+    ,
+    'set': def(target, prop, value, receiver):
+        if jstype(target.__setattr__) is 'function':
+            target.__setattr__.call(receiver, prop, value)
+            return True
+        # Pass 'target' as receiver (not proxy) to avoid infinite recursion through the Proxy set trap.
+        return v'Reflect.set(target, prop, value, target)'
+    ,
+    'deleteProperty': def(target, prop):
+        if jstype(target.__delattr__) is 'function':
+            # deleteProperty has no receiver; pass target as 'this'.
+            # Inside __delattr__, use ρσ_object_delattr(self, name) for a direct delete.
+            target.__delattr__.call(target, prop)
+            return True
+        return v'Reflect.deleteProperty(target, prop)'
+}
+
+def ρσ_object_setattr(obj, name, value):
+    # Bypass __setattr__ and set directly on the underlying object.
+    # Use this inside __setattr__ to avoid infinite recursion (like object.__setattr__ in Python).
+    target = obj[ρσ_proxy_target_symbol]
+    if target is undefined:
+        target = obj
+    v'target[name] = value'
+
+def ρσ_object_getattr(obj, name):
+    # Bypass __getattribute__ and read directly from the underlying object.
+    target = obj[ρσ_proxy_target_symbol]
+    if target is undefined:
+        target = obj
+    return target[name]
+
+def ρσ_object_delattr(obj, name):
+    # Bypass __delattr__ and delete directly from the underlying object.
+    target = obj[ρσ_proxy_target_symbol]
+    if target is undefined:
+        target = obj
+    v'delete target[name]'

package/src/baselib-itertools.pyj

@@ -1,97 +1,97 @@
-# vim:fileencoding=utf-8
-# License: BSD
-# Copyright: 2015, Kovid Goyal <kovid at kovidgoyal.net>
-
-# globals: ρσ_iterator_symbol, ρσ_bool
-
-def sum(iterable, start):
-    if Array.isArray(iterable):
-        return iterable.reduce(
-            def(prev, cur): return prev+cur
-            ,
-            start or 0
-        )
-    ans = start or 0
-    iterator = iter(iterable)
-    r = iterator.next()
-    while not r.done:
-        ans += r.value
-        r = iterator.next()
-    return ans
-
-def map():
-    iterators = new Array(arguments.length - 1)
-    func = arguments[0]  # noqa: unused-local
-    args = new Array(arguments.length - 1)  # noqa: unused-local
-    for v'var i = 1; i < arguments.length; i++':
-        iterators[i - 1] = iter(arguments[i])  # noqa:undef
-    ans = v"{'_func':func, '_iterators':iterators, '_args':args}"
-    ans[ρσ_iterator_symbol] = def():
-        return this
-    ans['next'] = def():
-        for v'var i = 0; i < this._iterators.length; i++':
-            r = this._iterators[i].next()
-            if r.done:
-                return v"{'done':true}"
-            this._args[i] = r.value  # noqa:undef
-        return v"{'done':false, 'value':this._func.apply(undefined, this._args)}"
-    return ans
-
-def filter(func_or_none, iterable):
-    func = ρσ_bool if func_or_none is None else func_or_none  # noqa: unused-local
-    ans = v"{'_func':func, '_iterator':ρσ_iter(iterable)}"
-    ans[ρσ_iterator_symbol] = def():
-        return this
-    ans['next'] = def():
-        r = this._iterator.next()
-        while not r.done:
-            if this._func(r.value):
-                return r
-            r = this._iterator.next()
-        return v"{'done':true}"
-    return ans
-
-def zip():
-    iterators = new Array(arguments.length)
-    for v'var i = 0; i < arguments.length; i++':
-        iterators[i] = iter(arguments[i])  # noqa:undef
-    ans = v"{'_iterators':iterators}"
-    ans[ρσ_iterator_symbol] = def():
-        return this
-    ans['next'] = def():
-        args = new Array(this._iterators.length)
-        for v'var i = 0; i < this._iterators.length; i++':
-            r = this._iterators[i].next()
-            if r.done:
-                return v"{'done':true}"
-            args[i] = r.value  # noqa:undef
-        return v"{'done':false, 'value':args}"
-    return ans
-
-def any(iterable):
-    if Array.isArray(iterable) or jstype(iterable) is 'string':
-        for v'var i = 0; i < iterable.length; i++':
-            if iterable[i]:  # noqa:undef
-                return True
-        return False
-    iterator = iter(iterable)
-    r = iterator.next()
-    while not r.done:
-        if r.value:
-            return True
-        r = iterator.next()
-    return False
-
-def all(iterable):
-    if Array.isArray(iterable) or jstype(iterable) is 'string':
-        for v'var i = 0; i < iterable.length; i++':
-            if not iterable[i]:  # noqa:undef
-                return False
-        return True
-    iterator = iter(iterable)
-    r = iterator.next()
-    while not r.done:
-        if not r.value:
-            return False
-        r = iterator.next()
-    return True
+# vim:fileencoding=utf-8
+# License: BSD
+# Copyright: 2015, Kovid Goyal <kovid at kovidgoyal.net>
+
+# globals: ρσ_iterator_symbol, ρσ_bool
+
+def sum(iterable, start):
+    if Array.isArray(iterable):
+        return iterable.reduce(
+            def(prev, cur): return prev+cur
+            ,
+            start or 0
+        )
+    ans = start or 0
+    iterator = iter(iterable)
+    r = iterator.next()
+    while not r.done:
+        ans += r.value
+        r = iterator.next()
+    return ans
+
+def map():
+    iterators = new Array(arguments.length - 1)
+    func = arguments[0]  # noqa: unused-local
+    args = new Array(arguments.length - 1)  # noqa: unused-local
+    for v'var i = 1; i < arguments.length; i++':
+        iterators[i - 1] = iter(arguments[i])  # noqa:undef
+    ans = v"{'_func':func, '_iterators':iterators, '_args':args}"
+    ans[ρσ_iterator_symbol] = def():
+        return this
+    ans['next'] = def():
+        for v'var i = 0; i < this._iterators.length; i++':
+            r = this._iterators[i].next()
+            if r.done:
+                return v"{'done':true}"
+            this._args[i] = r.value  # noqa:undef
+        return v"{'done':false, 'value':this._func.apply(undefined, this._args)}"
+    return ans
+
+def filter(func_or_none, iterable):
+    func = ρσ_bool if func_or_none is None else func_or_none  # noqa: unused-local
+    ans = v"{'_func':func, '_iterator':ρσ_iter(iterable)}"
+    ans[ρσ_iterator_symbol] = def():
+        return this
+    ans['next'] = def():
+        r = this._iterator.next()
+        while not r.done:
+            if this._func(r.value):
+                return r
+            r = this._iterator.next()
+        return v"{'done':true}"
+    return ans
+
+def zip():
+    iterators = new Array(arguments.length)
+    for v'var i = 0; i < arguments.length; i++':
+        iterators[i] = iter(arguments[i])  # noqa:undef
+    ans = v"{'_iterators':iterators}"
+    ans[ρσ_iterator_symbol] = def():
+        return this
+    ans['next'] = def():
+        args = new Array(this._iterators.length)
+        for v'var i = 0; i < this._iterators.length; i++':
+            r = this._iterators[i].next()
+            if r.done:
+                return v"{'done':true}"
+            args[i] = r.value  # noqa:undef
+        return v"{'done':false, 'value':args}"
+    return ans
+
+def any(iterable):
+    if Array.isArray(iterable) or jstype(iterable) is 'string':
+        for v'var i = 0; i < iterable.length; i++':
+            if iterable[i]:  # noqa:undef
+                return True
+        return False
+    iterator = iter(iterable)
+    r = iterator.next()
+    while not r.done:
+        if r.value:
+            return True
+        r = iterator.next()
+    return False
+
+def all(iterable):
+    if Array.isArray(iterable) or jstype(iterable) is 'string':
+        for v'var i = 0; i < iterable.length; i++':
+            if not iterable[i]:  # noqa:undef
+                return False
+        return True
+    iterator = iter(iterable)
+    r = iterator.next()
+    while not r.done:
+        if not r.value:
+            return False
+        r = iterator.next()
+    return True

package/src/baselib-str.pyj

@@ -774,6 +774,29 @@ define_str_func('zfill', def(width):
     return string
 )
 
+define_str_func('expandtabs', def(tabsize):
+    if tabsize is undefined:
+        tabsize = 8
+    string = this
+    ans = ''
+    col = 0
+    for v'var i = 0; i < string.length; i++':
+        ch = string[i]  # noqa:undef
+        if ch is '\t':
+            if tabsize > 0:
+                spaces = tabsize - (col % tabsize)
+                ans += v'new Array(spaces + 1).join(" ")'
+                col += spaces
+            # tabsize <= 0: tab adds no spaces, col stays
+        elif ch is '\n' or ch is '\r':
+            ans += ch
+            col = 0
+        else:
+            ans += ch
+            col += 1
+    return ans
+)
+
 ρσ_str.uchrs = def(string, with_positions):
     # Return iterator over unicode chars in string. Will yield the unicode
     # replacement char U+FFFD for broken surrogate pairs
@@ -829,4 +852,12 @@ define_str_func('zfill', def(width):
 ρσ_str.whitespace   = ' \t\n\r\x0b\x0c'
 
 v'define_str_func = undefined'
-v'var str = ρσ_str, repr = ρσ_repr'
+def ρσ_format(value, spec):
+    if value is not None and value is not undefined and v'typeof value.__format__ === "function"':
+        return value.__format__(spec if spec is not undefined else '')
+    if spec is undefined or spec is '':
+        return ρσ_str(value)
+    return str.format('{:' + spec + '}', value)
+
+ρσ_str.__name__ = 'str'
+v'var str = ρσ_str, repr = ρσ_repr, format = ρσ_format'

package/src/compiler.pyj

@@ -1,36 +1,36 @@
-# vim:fileencoding=utf-8
-# License: BSD
-# Copyright: 2015, Kovid Goyal <kovid at kovidgoyal.net>
-# globals: console
-
-from utils import DefaultsError, string_template
-from errors import ImportError, SyntaxError
-from tokenizer import ALL_KEYWORDS, IDENTIFIER_PAT, tokenizer
-from parse import parse, NATIVE_CLASSES, compile_time_decorators
-from output.stream import OutputStream
-from output.codegen import generate_code
-from output.treeshake import tree_shake
-
-generate_code()  # create the print methods on the AST nodes
-
-# The following allows this module to be used from a pure javascript, require()
-# based environment like Node.js
-if jstype(exports) is 'object':
-    exports.DefaultsError = DefaultsError
-    exports.parse = parse
-    exports.compile_time_decorators = compile_time_decorators
-    exports.OutputStream = OutputStream
-    exports.string_template = string_template  # noqa:undef
-    # Needed for REPL and linter
-    exports.ALL_KEYWORDS = ALL_KEYWORDS
-    exports.IDENTIFIER_PAT = IDENTIFIER_PAT
-    exports.NATIVE_CLASSES = NATIVE_CLASSES
-    exports.ImportError = ImportError
-    exports.SyntaxError = SyntaxError
-    exports.tokenizer = tokenizer
-    exports.tree_shake = tree_shake
-    # Magic! Export all the AST_* nodes
-    ast = ρσ_modules['ast']
-    for ast_node in ast:
-        if ast_node.substr(0, 4) is 'AST_':
-            exports[ast_node] = ast[ast_node]  # noqa:undef
+# vim:fileencoding=utf-8
+# License: BSD
+# Copyright: 2015, Kovid Goyal <kovid at kovidgoyal.net>
+# globals: console
+
+from utils import DefaultsError, string_template
+from errors import ImportError, SyntaxError
+from tokenizer import ALL_KEYWORDS, IDENTIFIER_PAT, tokenizer
+from parse import parse, NATIVE_CLASSES, compile_time_decorators
+from output.stream import OutputStream
+from output.codegen import generate_code
+from output.treeshake import tree_shake
+
+generate_code()  # create the print methods on the AST nodes
+
+# The following allows this module to be used from a pure javascript, require()
+# based environment like Node.js
+if jstype(exports) is 'object':
+    exports.DefaultsError = DefaultsError
+    exports.parse = parse
+    exports.compile_time_decorators = compile_time_decorators
+    exports.OutputStream = OutputStream
+    exports.string_template = string_template  # noqa:undef
+    # Needed for REPL and linter
+    exports.ALL_KEYWORDS = ALL_KEYWORDS
+    exports.IDENTIFIER_PAT = IDENTIFIER_PAT
+    exports.NATIVE_CLASSES = NATIVE_CLASSES
+    exports.ImportError = ImportError
+    exports.SyntaxError = SyntaxError
+    exports.tokenizer = tokenizer
+    exports.tree_shake = tree_shake
+    # Magic! Export all the AST_* nodes
+    ast = ρσ_modules['ast']
+    for ast_node in ast:
+        if ast_node.substr(0, 4) is 'AST_':
+            exports[ast_node] = ast[ast_node]  # noqa:undef

package/src/errors.pyj

@@ -1,30 +1,30 @@
-# vim:fileencoding=utf-8
-# License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
-from __python__ import hash_literals
-
-class SyntaxError(Error):
-
-    def __init__(self, message, filename, line, col, pos, is_eof):
-        self.stack = Error().stack
-        self.message = message
-        self.line = line
-        self.col = col
-        self.pos = pos
-        self.is_eof = is_eof
-        self.filename = filename
-        # The "standard" form for these error attributes
-        self.lineNumber = line
-        self.fileName = filename
-
-    def toString(self):
-        ans = self.message + " (line: " + self.line + ", col: " + self.col + ", pos: " + self.pos + ")"
-        if self.filename:
-            ans = self.filename + ':' + ans
-        if self.stack:
-            ans += "\n\n" + self.stack
-        return ans
-
-
-class ImportError(SyntaxError):
-    pass
-
+# vim:fileencoding=utf-8
+# License: BSD Copyright: 2016, Kovid Goyal <kovid at kovidgoyal.net>
+from __python__ import hash_literals
+
+class SyntaxError(Error):
+
+    def __init__(self, message, filename, line, col, pos, is_eof):
+        self.stack = Error().stack
+        self.message = message
+        self.line = line
+        self.col = col
+        self.pos = pos
+        self.is_eof = is_eof
+        self.filename = filename
+        # The "standard" form for these error attributes
+        self.lineNumber = line
+        self.fileName = filename
+
+    def toString(self):
+        ans = self.message + " (line: " + self.line + ", col: " + self.col + ", pos: " + self.pos + ")"
+        if self.filename:
+            ans = self.filename + ':' + ans
+        if self.stack:
+            ans += "\n\n" + self.stack
+        return ans
+
+
+class ImportError(SyntaxError):
+    pass
+